, 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 • <NAME>., <NAME>., and <NAME>. (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 • <NAME>., and <NAME>. (1972). Robust estimates, residuals, and outlier de-\n tection with multiresponse data. Biometrics, 81-124.\n • <NAME>., and <NAME>. (1985). Regression diagnostics: An expository treatment\n of outliers and influential cases. Sociological Methods and Research, 13(4), 510-542.\n • <NAME>., <NAME>., and <NAME>. (2019). Multivariate outlier detection based on a\n robust Mahalanobis distance with shrinkage estimators. arXiv preprint arXiv:1904.02596.\n • <NAME>. (1977). Detection of influential observation in linear regression. Technometrics,\n 19(1), 15-18.\n • <NAME>., and <NAME>. (1993). How to detect and handle outliers (Vol. 16). Asq\n Press.\n • <NAME>., <NAME>., <NAME>., and <NAME>. (2018). Detecting multivariate outliers: Use\n a robust variant of Mahalanobis distance. Journal of Experimental Social Psychology, 74,\n 150-156.\n • <NAME>., <NAME>., and <NAME>. (2008, December). Isolation forest. In 2008 Eighth\n IEEE International Conference on Data Mining (pp. 413-422). IEEE.\n • <NAME>., <NAME>., <NAME>., <NAME>., and <NAME>. (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 • <NAME>., and <NAME>. (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 <NAME> 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<NAME> (2007), pages\n 115-116).\nReferences\n • <NAME> et al. (2017): GLMM FAQ.\n • <NAME>., and <NAME>. (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\" (<NAME>, 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 • <NAME>., <NAME>., <NAME>., <NAME>., and <NAME>. (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 • <NAME>., and <NAME>. (2007). Data analysis using regression and multilevel/hierarchical\n models. Cambridge; New York: Cambridge University Press.\n • <NAME>., <NAME>., <NAME>., <NAME>., <NAME>., and <NAME>. (2014).\n Bayesian data analysis. (Third edition). CRC Press.\n • <NAME>., <NAME>., and <NAME>. (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 • <NAME>, <NAME>, <NAME>, <NAME>. Parsimonious Mixed Models. arXiv:1506.04967,\n June 2015.\n • <NAME>, <NAME>, <NAME>, <NAME>. Random effects structure for confirmatory hypothesis\n testing: Keep it maximal. Journal of Memory and Language, 68(3):255-278, April 2013.\n • <NAME>, <NAME>, <NAME>, <NAME>, <NAME>. 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 <NAME>., and <NAME>. (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 <NAME>., and <NAME>. 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 (<NAME>, 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 • <NAME>. (2010). Multilevel analysis: techniques and applications (2nd ed). New York:\n Routledge.\n • <NAME>., <NAME>., and <NAME>. (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 • <NAME>., and <NAME>. (2012). Multilevel and longitudinal modeling using Stata\n (3rd ed). College Station, Tex: Stata Press Publication.\n • <NAME>., and <NAME>. (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 • <NAME>., and <NAME>. (2006). Quantitative Methoden der Datenerhebung. In <NAME> and\n N. Döring, Forschungsmethoden und Evaluation. Springer: Berlin, Heidelberg: 137–293\n • <NAME>, <NAME> (2020). Deskriptivstatistische Itemanalyse und Testwertbestim-\n mung. In: <NAME>, <NAME>, 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 • <NAME>, <NAME> (2020). Deskriptivstatistische Itemanalyse und Testwertbestim-\n mung. In: <NAME>, <NAME>, 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 • <NAME>. 1910. Correlation calculated from faulty data. British Journal of Psychology (3):\n 271-295. doi:10.1111/j.20448295.1910.tb00206.x\n • <NAME>. 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 • <NAME>. (1994). Structural equation modeling with EQS and EQS/Windows. Thousand\n Oaks, CA: Sage Publications.\n • <NAME>., and <NAME>. (1973). The reliability coefficient for maximum likelihood factor\n analysis. Psychometrika, 38, 1-10.\n • <NAME>., and <NAME>. (2004). A beginner’s guide to structural equation mod-\n eling, Second edition. Mahwah, NJ: Lawrence Erlbaum Associates.\n • <NAME>., <NAME>, and <NAME> (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 • <NAME>. (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 <NAME>., <NAME>., <NAME>., and <NAME>. (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 • <NAME>. (1973) Information theory as an extension of the maximum likelihood principle.\n In: Second International Symposium on Information Theory, pp. 267-281. <NAME>.,\n <NAME>., <NAME>.\n • <NAME>., <NAME>. (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 <NAME>., and <NAME>. (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 • <NAME>. (1999). Postestimation Uncertainty in Limited Dependent Variable Models. Polit-\n ical Analysis, 8, 83–98.\n • <NAME>., and <NAME>. (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 <NAME>. (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 <NAME>., <NAME>., <NAME>., and <NAME>. (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 • <NAME>., <NAME>. (1989). Analysis of binary data (Vol. 32). Monographs on Statistics\n and Applied Probability.\n • <NAME>. (1990). R 2 measures based on Wald and likelihood ratio joint significance tests.\n The American Statistician, 44(3), 250-253.\n • <NAME>. (1986). Limited-dependent and qualitative variables in econometrics (No. 3).\n Cambridge university press.\n • <NAME>. (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 <NAME>. and <NAME>. (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 • <NAME>. (1987). Regression-based specification tests for the multinomial logit model.\n Journal of econometrics, 34(1-2), 63-82.\n • <NAME>. (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 <NAME>., <NAME>. (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, <NAME>. (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 • <NAME>. (2010). Multilevel analysis: techniques and applications (2nd ed). New York:\n Routledge.\n • <NAME>. (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 • <NAME>., and <NAME>. (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 • <NAME>., <NAME>., and <NAME>. (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 <NAME>. (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 <NAME>. (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 <NAME>. (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 • <NAME>. (1989). Likelihood ratio tests for model selection and non-nested hypotheses.\n Econometrica, 57, 307-333.\n • <NAME>., <NAME>., & <NAME>. (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<Option<T>>`, 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`: <NAME>’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<slab::Slab>`:\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<slab::Slab>` 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<Option<T>>`, 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`: <NAME>’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<slab::Slab>`:\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<slab::Slab>` 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 Pool<T, C = DefaultConfig>where\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<String> = 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<String> = 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<String> = 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<T> Pool<T>where\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<C: Config>() -> Pool<T, CReturns a new `Pool` with the provided configuration parameters.\n\n### impl<T, C> Pool<T, C>where\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) -> Option<RefMut<'_, T, C>Creates 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<String> = 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<Self>) -> Option<OwnedRefMut<T, C>Creates 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<T>` functions more or less identically to an owned\n`Box<T>`: 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<T>`, 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<Pool<String>> = 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<Pool<String>> = 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<String>,\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: 'static>(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet pool: Arc<Pool<String>> = 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<Pool<String>> = 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<Pool<String>> = 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<usizeCreates a new object in the pool with the provided initializer,\nreturning a key that may be used to access 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<String> = 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) -> Option<Ref<'_, T, C>Return 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<String> = 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<Self>, key: usize) -> Option<OwnedRef<T, C>Return 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<Pool<String>> = 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<String>,\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: 'static>(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet pool: Arc<Pool<String>> = 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<Pool<String>> = 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<String> = 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<String> = 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<T, C> Debug for Pool<T, C>where\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<T, C> Sync for Pool<T, C>where\n T: Sync + Clear + Default,\n C: Config,\n\nAuto Trait Implementations\n---\n\n### impl<T, C> RefUnwindSafe for Pool<T, C>where\n C: RefUnwindSafe,\n\n### impl<T, C> Unpin for Pool<T, C>where\n C: Unpin,\n\n### impl<T, C = DefaultConfig> !UnwindSafe for Pool<T, CBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<T, U> TryFrom<U> for Twhere\n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion.\n\nStruct sharded_slab::Slab\n===\n\n\n```\npub struct Slab<T, C: Config = DefaultConfig> { /* private fields */ }\n```\nA sharded slab.\n\nSee the crate-level documentation for details on using this type.\n\nImplementations\n---\n\n### impl<T> Slab<T#### pub fn new() -> Self\n\nReturns a new slab with the default configuration parameters.\n\n#### pub fn new_with_config<C: Config>() -> Slab<T, CReturns a new slab with the provided configuration parameters.\n\n### impl<T, C: Config> Slab<T, C#### pub const USED_BITS: usize = C::USED_BITS\n\nThe number of bits in each index which are used by the slab.\n\nIf other data is packed into the `usize` indices returned by\n`Slab::insert`, 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 slab’s parameters. By default, all bits are used; this can be changed by overriding the `Config::RESERVED_BITS` constant.\n\n#### pub fn insert(&self, value: T) -> Option<usizeInserts a value into the slab, returning the integer index at which that value was inserted. This index can then be used to access the entry.\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 slab = Slab::new();\n\nlet key = slab.insert(\"hello world\").unwrap();\nassert_eq!(slab.get(key).unwrap(), \"hello world\");\n```\n#### pub fn vacant_entry(&self) -> Option<VacantEntry<'_, T, C>Return 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<TRemoves the value associated with the given key from the slab, returning it.\n\nIf the slab does not contain a value for that key, `None` is returned instead.\n\nIf the value associated with the given key is currently being accessed by another thread, this method will block the current thread until the item is no longer accessed. If this is not desired, use\n`remove` instead.\n\n**Note**: This method blocks the calling thread by spinning until the currently outstanding references are released. Spinning for long periods of time can result in high CPU time and power consumption. Therefore,\n`take` should only be called when other references to the slot are expected to be dropped soon (e.g., when all accesses are relatively short).\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, returning it.\nassert_eq!(slab.take(key), Some(\"hello world\"));\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 only be removed when the other thread finishes\n// accessing it.\nassert_eq!(slab.take(key), Some(\"hello world\"));\n\nthread2.join().unwrap();\nassert!(!slab.contains(key));\n```\n#### pub fn get(&self, key: usize) -> Option<Entry<'_, T, C>Return 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<Self>, key: usize) -> Option<OwnedEntry<T, C>Return 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<Slab<&'static str>> = 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: 'static>(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet slab: Arc<Slab<&'static str>> = 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<Slab<&'static str>> = 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<T>`), elements will not be added or removed while the iteration is in progress.\n\nTrait Implementations\n---\n\n### impl<T: Debug, C: Config> Debug for Slab<T, C#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. \n\nReturns the “default value” for a type. \n---\n\n### impl<T, C> RefUnwindSafe for Slab<T, C>where\n C: RefUnwindSafe,\n\n### impl<T, C> Unpin for Slab<T, C>where\n C: Unpin,\n\n### impl<T, C = DefaultConfig> !UnwindSafe for Slab<T, CBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<T, U> TryFrom<U> for Twhere\n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion.{\"UniqueIter<'_, T, C>\":\"<h3>Notable traits for <code><a class=\\\"struct\\\" href=\\\"struct.UniqueIter.html\\\" title=\\\"struct sharded_slab::UniqueIter\\\">UniqueIter</a><'a, T, C></code></h3><pre><code><span class=\\\"where fmt-newline\\\">impl<'a, T, C: <a class=\\\"trait\\\" href=\\\"trait.Config.html\\\" title=\\\"trait sharded_slab::Config\\\">Config</a>> <a class=\\\"trait\\\" href=\\\"https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html\\\" title=\\\"trait core::iter::traits::iterator::Iterator\\\">Iterator</a> for <a class=\\\"struct\\\" href=\\\"struct.UniqueIter.html\\\" title=\\\"struct sharded_slab::UniqueIter\\\">UniqueIter</a><'a, T, C></span><span class=\\\"where fmt-newline\\\"> type <a href=\\\"https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\\\" class=\\\"associatedtype\\\">Item</a> = <a class=\\\"primitive\\\" href=\\\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\\\">&'a T</a>;</span>\"}\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<T: Clear> Clear for Mutex<T#### fn clear(&mut self)\n\n### impl<T> Clear for Vec<T#### fn clear(&mut self)\n\n### impl<K, V, S> Clear for HashMap<K, V, S>where\n K: Hash + Eq,\n S: BuildHasher,\n\n#### fn clear(&mut self)\n\n### impl<T> Clear for Option<T#### fn clear(&mut self)\n\n### impl<T> Clear for Box<T>where\n T: Clear,\n\n#### fn clear(&mut self)\n\n### impl Clear for String\n\n#### fn clear(&mut self)\n\n### impl<T, S> Clear for HashSet<T, S>where\n T: Hash + Eq,\n S: BuildHasher,\n\n#### fn clear(&mut self)\n\n### impl<T: Clear> Clear for RwLock<T#### fn clear(&mut self)\n\nImplementors\n---\n\nTrait sharded_slab::Config\n===\n\n\n```\npub trait Config: Sized {\n const MAX_THREADS: usize = 4_096usize;\n const MAX_PAGES: usize = 32usize;\n const INITIAL_PAGE_SIZE: usize = 32usize;\n const RESERVED_BITS: usize = 0usize;\n}\n```\nConfiguration parameters which can be overridden to tune the behavior of a slab.\n\nProvided Associated Constants\n---\n\n#### const MAX_THREADS: usize = 4_096usize\n\nThe maximum number of threads which can access the slab.\n\nThis value (rounded to a power of two) determines the number of shards in the slab. If a thread is created, accesses the slab, and then terminates,\nits shard may be reused and thus does not count against the maximum number of threads once the thread has terminated.\n\n#### const MAX_PAGES: usize = 32usize\n\nThe maximum number of pages in each shard in the slab.\n\nThis value, in combination with `INITIAL_PAGE_SIZE`, determines how many bits of each index are used to represent page addresses.\n\n#### const INITIAL_PAGE_SIZE: usize = 32usize\n\nThe size of the first page in each shard.\n\nWhen a page in a shard has been filled with values, a new page will be allocated that is twice as large as the previous page. Thus, the second page will be twice this size, and the third will be four times this size, and so on.\n\nNote that page sizes must be powers of two. If this value is not a power of two, it will be rounded to the next power of two.\n\n#### const RESERVED_BITS: usize = 0usize\n\nSets a number of high-order bits in each index which are reserved from user code.\n\nNote that these bits are taken from the generation counter; if the page address and thread IDs are configured to use a large number of bits,\nreserving additional bits will decrease the period of the generation counter. These should thus be used relatively sparingly, to ensure that generation counters are able to effectively prevent the ABA problem.\n\nImplementors\n---\n\n### impl Config for DefaultConfig\n\n#### const INITIAL_PAGE_SIZE: usize = 32usize\n\n#### const MAX_THREADS: usize = 4_096usize\n\n#### const MAX_PAGES: usize = 32usize\n\nModule sharded_slab::implementation\n===\n\nNotes on `sharded-slab`’s implementation and design.\n\nDesign\n---\n\nThe sharded slab’s design is strongly inspired by the ideas presented by Leijen, Zorn, and <NAME> in Mimalloc: Free List Sharding in Action. In this report, the authors present a novel design for a memory allocator based on a concept of *free list sharding*.\n\nMemory allocators must keep track of what memory regions are not currently allocated (“free”) in order to provide them to future allocation requests.\nThe term *free list* refers to a technique for performing this bookkeeping, where each free block stores a pointer to the next free block,\nforming a linked list. The memory allocator keeps a pointer to the most recently freed block, the *head* of the free list. To allocate more memory,\nthe allocator pops from the free list by setting the head pointer to the next free block of the current head block, and returning the previous head.\nTo deallocate a block, the block is pushed to the free list by setting its first word to the current head pointer, and the head pointer is set to point to the deallocated block. Most implementations of slab allocators backed by arrays or vectors use a similar technique, where pointers are replaced by indices into the backing array.\n\nWhen allocations and deallocations can occur concurrently across threads,\nthey must synchronize accesses to the free list; either by putting the entire allocator state inside of a lock, or by using atomic operations to treat the free list as a lock-free structure (such as a Treiber stack). In both cases, there is a significant performance cost — even when the free list is lock-free, it is likely that a noticeable amount of time will be spent in compare-and-swap loops. Ideally, the global synchronzation point created by the single global free list could be avoided as much as possible.\n\nThe approach presented by Leijen, Zorn, and <NAME> is to introduce sharding and thus increase the granularity of synchronization significantly.\nIn mimalloc, the heap is *sharded* so that each thread has its own thread-local heap. Objects are always allocated from the local heap of the thread where the allocation is performed. Because allocations are always done from a thread’s local heap, they need not be synchronized.\n\nHowever, since objects can move between threads before being deallocated,\n*deallocations* may still occur concurrently. Therefore, Leijen et al.\nintroduce a concept of *local* and *global* free lists. When an object is deallocated on the same thread it was originally allocated on, it is placed on the local free list; if it is deallocated on another thread, it goes on the global free list for the heap of the thread from which it originated. To allocate, the local free list is used first; if it is empty, the entire global free list is popped onto the local free list. Since the local free list is only ever accessed by the thread it belongs to, it does not require synchronization at all, and because the global free list is popped from infrequently, the cost of synchronization has a reduced impact. A majority of allocations can occur without any synchronization at all; and deallocations only require synchronization when an object has left its parent thread (a relatively uncommon case).\n\nImplementation\n---\n\nA slab is represented as an array of `MAX_THREADS` *shards*. A shard consists of a vector of one or more *pages* plus associated metadata.\nFinally, a page consists of an array of *slots*, head indices for the local and remote free lists.\n```\n┌─────────────┐\n│ shard 1 │\n│ │ ┌─────────────┐ ┌────────┐\n│ pages───────┼───▶│ page 1 │ │ │\n├─────────────┤ ├─────────────┤ ┌────▶│ next──┼─┐\n│ shard 2 │ │ page 2 │ │ ├────────┤ │\n├─────────────┤ │ │ │ │XXXXXXXX│ │\n│ shard 3 │ │ local_head──┼──┘ ├────────┤ │\n└─────────────┘ │ remote_head─┼──┐ │ │◀┘\n ... ├─────────────┤ │ │ next──┼─┐\n┌─────────────┐ │ page 3 │ │ ├────────┤ │\n│ shard n │ └─────────────┘ │ │XXXXXXXX│ │\n└─────────────┘ ... │ ├────────┤ │\n ┌─────────────┐ │ │XXXXXXXX│ │\n │ page n │ │ ├────────┤ │\n └─────────────┘ │ │ │◀┘\n └────▶│ next──┼───▶ ...\n ├────────┤\n │XXXXXXXX│\n └────────┘\n```\nThe size of the first page in a shard is always a power of two, and every subsequent page added after the first is twice as large as the page that preceeds it.\n```\npg.\n┌───┐ ┌─┬─┐\n│ 0 │───▶ │ │\n├───┤ ├─┼─┼─┬─┐\n│ 1 │───▶ │ │ │ │\n├───┤ ├─┼─┼─┼─┼─┬─┬─┬─┐\n│ 2 │───▶ │ │ │ │ │ │ │ │\n├───┤ ├─┼─┼─┼─┼─┼─┼─┼─┼─┬─┬─┬─┬─┬─┬─┬─┐\n│ 3 │───▶ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │\n└───┘ └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘\n```\nWhen searching for a free slot, the smallest page is searched first, and if it is full, the search proceeds to the next page until either a free slot is found or all available pages have been searched. If all available pages have been searched and the maximum number of pages has not yet been reached, a new page is then allocated.\n\nSince every page is twice as large as the previous page, and all page sizes are powers of two, we can determine the page index that contains a given address by shifting the address down by the smallest page size and looking at how many twos places necessary to represent that number,\ntelling us what power of two page size it fits inside of. We can determine the number of twos places by counting the number of leading zeros (unused twos places) in the number’s binary representation, and subtracting that count from the total number of bits in a word.\n\nThe formula for determining the page number that contains an offset is thus:\n\n```\nWIDTH - ((offset + INITIAL_PAGE_SIZE) >> INDEX_SHIFT).leading_zeros()\n```\nwhere `WIDTH` is the number of bits in a `usize`, and `INDEX_SHIFT` is\n\n```\nINITIAL_PAGE_SIZE.trailing_zeros() + 1;\n```\n\nModule sharded_slab::pool\n===\n\nA lock-free concurrent object pool.\n\nSee the `Pool` type’s documentation for details on the object pool API and how it differs from the `Slab` API.\n\nStructs\n---\n\n* OwnedRefAn owned guard that allows shared immutable access to an object in a pool.\n* OwnedRefMutAn owned guard that allows exclusive, mutable access to an object in a pool.\n* PoolA lock-free concurrent object pool.\n* RefA guard that allows access to an object in a pool.\n* RefMutA guard that allows exclusive mutable access to an object in a pool.\n\nStruct sharded_slab::DefaultConfig\n===\n\n\n```\npub struct DefaultConfig { /* private fields */ }\n```\nDefault slab configuration values.\n\nTrait Implementations\n---\n\n### impl Clone for DefaultConfig\n\n#### fn clone(&self) -> DefaultConfig\n\nReturns a copy of the value. Read more1.0.0 · source#### fn clone_from(&mut self, source: &Self)\n\nPerforms copy-assignment from `source`. \n\n#### const INITIAL_PAGE_SIZE: usize = 32usize\n\nThe size of the first page in each shard. \n\nThe maximum number of threads which can access the slab. \n\nThe maximum number of pages in each shard in the slab. \n\nSets a number of high-order bits in each index which are reserved from user code. \n\n#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. \n\nAuto Trait Implementations\n---\n\n### impl RefUnwindSafe for DefaultConfig\n\n### impl Send for DefaultConfig\n\n### impl Sync for DefaultConfig\n\n### impl Unpin for DefaultConfig\n\n### impl UnwindSafe for DefaultConfig\n\nBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<T> ToOwned for Twhere\n T: Clone,\n\n#### type Owned = T\n\nThe resulting type after obtaining ownership.#### fn to_owned(&self) -> T\n\nCreates owned data from borrowed data, usually by cloning. \n\nUses borrowed data to replace owned data, usually by cloning. \n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion.\n\nStruct sharded_slab::Entry\n===\n\n\n```\npub struct Entry<'a, T, C: Config = DefaultConfig> { /* private fields */ }\n```\nA handle that allows access to an occupied entry in a `Slab`.\n\nWhile the guard exists, it indicates to the slab that the item the guard references is currently being accessed. If the item is removed from the slab while a guard exists, the removal will be deferred until all guards are dropped.\n\nImplementations\n---\n\n### impl<'a, T, C: Config> Entry<'a, T, C#### pub fn key(&self) -> usize\n\nReturns the key used to access the guard.\n\nTrait Implementations\n---\n\n### impl<'a, T, C> Debug for Entry<'a, T, C>where\n T: Debug,\n C: Config,\n\n#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. \n\nThe resulting type after dereferencing.#### fn deref(&self) -> &Self::Target\n\nDereferences the value.### impl<'a, T, C: Config> Drop for Entry<'a, T, C#### fn drop(&mut self)\n\nExecutes the destructor for this type. \n T: PartialEq<T>,\n C: Config,\n\n#### fn eq(&self, other: &T) -> bool\n\nThis method tests for `self` and `other` values to be equal, and is used by `==`.1.0.0 · source#### fn ne(&self, other: &Rhs) -> bool\n\nThis method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.Auto Trait Implementations\n---\n\n### impl<'a, T, C = DefaultConfig> !RefUnwindSafe for Entry<'a, T, C### impl<'a, T, C = DefaultConfig> !Send for Entry<'a, T, C### impl<'a, T, C = DefaultConfig> !Sync for Entry<'a, T, C### impl<'a, T, C> Unpin for Entry<'a, T, C### impl<'a, T, C = DefaultConfig> !UnwindSafe for Entry<'a, T, CBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<T, U> TryFrom<U> for Twhere\n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion.\n\nStruct sharded_slab::OwnedEntry\n===\n\n\n```\npub struct OwnedEntry<T, C = DefaultConfig>where\n C: Config,{ /* private fields */ }\n```\nAn owned reference to an occupied entry in a `Slab`.\n\nWhile the guard exists, it indicates to the slab that the item the guard references is currently being accessed. If the item is removed from the slab while the guard exists, the removal will be deferred until all guards are dropped.\n\nUnlike `Entry`, which borrows the slab, an `OwnedEntry` clones the `Arc`\naround the slab. Therefore, it keeps the slab from being dropped until all such guards have been dropped. This means that an `OwnedEntry` may be held for an arbitrary lifetime.\n\nExamples\n---\n```\nuse std::sync::Arc;\n\nlet slab: Arc<Slab<&'static str>> = 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: 'static>(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet slab: Arc<Slab<&'static str>> = 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<Slab<&'static str>> = 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```\nImplementations\n---\n\n### impl<T, C> OwnedEntry<T, C>where\n C: Config,\n\n#### pub fn key(&self) -> usize\n\nReturns the key used to access this guard\n\nTrait Implementations\n---\n\n### impl<T, C> Debug for OwnedEntry<T, C>where\n T: Debug,\n C: Config,\n\n#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. \n C: Config,\n\n#### type Target = T\n\nThe resulting type after dereferencing.#### fn deref(&self) -> &Self::Target\n\nDereferences the value.### impl<T, C> Drop for OwnedEntry<T, C>where\n C: Config,\n\n#### fn drop(&mut self)\n\nExecutes the destructor for this type. \n T: PartialEq<T>,\n C: Config,\n\n#### fn eq(&self, other: &T) -> bool\n\nThis method tests for `self` and `other` values to be equal, and is used by `==`.1.0.0 · source#### fn ne(&self, other: &Rhs) -> bool\n\nThis method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.### impl<T, C> Send for OwnedEntry<T, C>where\n T: Sync,\n C: Config,\n\n### impl<T, C> Sync for OwnedEntry<T, C>where\n T: Sync,\n C: Config,\n\nAuto Trait Implementations\n---\n\n### impl<T, C = DefaultConfig> !RefUnwindSafe for OwnedEntry<T, C### impl<T, C> Unpin for OwnedEntry<T, C### impl<T, C = DefaultConfig> !UnwindSafe for OwnedEntry<T, CBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<T, U> TryFrom<U> for Twhere\n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion.\n\nStruct sharded_slab::UniqueIter\n===\n\n\n```\npub struct UniqueIter<'a, T, C: Config> { /* private fields */ }\n```\nAn exclusive fused iterator over the items in a `Slab`.\n\nTrait Implementations\n---\n\n### impl<'a, T: Debug, C: Debug + Config> Debug for UniqueIter<'a, T, C#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. \n\nThe type of the elements being iterated over.#### fn next(&mut self) -> Option<Self::ItemAdvances the iterator and returns the next value. \n &mut self\n) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where\n Self: Sized,\n\n🔬This is a nightly-only experimental API. (`iter_next_chunk`)Advances the iterator and returns an array containing the next `N` values. Read more1.0.0 · source#### fn size_hint(&self) -> (usize, Option<usize>)\n\nReturns the bounds on the remaining length of the iterator. Read more1.0.0 · source#### fn count(self) -> usizewhere\n Self: Sized,\n\nConsumes the iterator, counting the number of iterations and returning it. Read more1.0.0 · source#### fn last(self) -> Option<Self::Item>where\n Self: Sized,\n\nConsumes the iterator, returning the last element. \n Self: Sized,\n\nCreates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more1.0.0 · source#### fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where\n Self: Sized,\n U: IntoIterator<Item = Self::Item>,\n\nTakes two iterators and creates a new iterator over both in sequence. Read more1.0.0 · source#### fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where\n Self: Sized,\n U: IntoIterator,\n\n‘Zips up’ two iterators into a single iterator of pairs. \n Self: Sized,\n G: FnMut() -> Self::Item,\n\n🔬This is a nightly-only experimental API. (`iter_intersperse`)Creates a new iterator which places an item generated by `separator`\nbetween adjacent items of the original iterator. Read more1.0.0 · source#### fn map<B, F>(self, f: F) -> Map<Self, F>where\n Self: Sized,\n F: FnMut(Self::Item) -> B,\n\nTakes a closure and creates an iterator which calls that closure on each element. Read more1.21.0 · source#### fn for_each<F>(self, f: F)where\n Self: Sized,\n F: FnMut(Self::Item),\n\nCalls a closure on each element of an iterator. Read more1.0.0 · source#### fn filter<P>(self, predicate: P) -> Filter<Self, P>where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,\n\nCreates an iterator which uses a closure to determine if an element should be yielded. Read more1.0.0 · source#### fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where\n Self: Sized,\n F: FnMut(Self::Item) -> Option<B>,\n\nCreates an iterator that both filters and maps. Read more1.0.0 · source#### fn enumerate(self) -> Enumerate<Self>where\n Self: Sized,\n\nCreates an iterator which gives the current iteration count as well as the next value. Read more1.0.0 · source#### fn peekable(self) -> Peekable<Self>where\n Self: Sized,\n\nCreates an iterator which can use the `peek` and `peek_mut` methods to look at the next element of the iterator without consuming it. See their documentation for more information. Read more1.0.0 · source#### fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,\n\nCreates an iterator that `skip`s elements based on a predicate. Read more1.0.0 · source#### fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,\n\nCreates an iterator that yields elements based on a predicate. Read more1.57.0 · source#### fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where\n Self: Sized,\n P: FnMut(Self::Item) -> Option<B>,\n\nCreates an iterator that both yields elements based on a predicate and maps. Read more1.0.0 · source#### fn skip(self, n: usize) -> Skip<Self>where\n Self: Sized,\n\nCreates an iterator that skips the first `n` elements. Read more1.0.0 · source#### fn take(self, n: usize) -> Take<Self>where\n Self: Sized,\n\nCreates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner. Read more1.0.0 · source#### fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where\n Self: Sized,\n F: FnMut(&mut St, Self::Item) -> Option<B>,\n\nAn iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator. Read more1.0.0 · source#### fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where\n Self: Sized,\n U: IntoIterator,\n F: FnMut(Self::Item) -> U,\n\nCreates an iterator that works like map, but flattens nested structure. \n Self: Sized,\n F: FnMut(&[Self::Item; N]) -> R,\n\n🔬This is a nightly-only experimental API. (`iter_map_windows`)Calls the given function `f` for each contiguous window of size `N` over\n`self` and returns an iterator over the outputs of `f`. Like `slice::windows()`,\nthe windows during mapping overlap as well. Read more1.0.0 · source#### fn fuse(self) -> Fuse<Self>where\n Self: Sized,\n\nCreates an iterator which ends after the first `None`. Read more1.0.0 · source#### fn inspect<F>(self, f: F) -> Inspect<Self, F>where\n Self: Sized,\n F: FnMut(&Self::Item),\n\nDoes something with each element of an iterator, passing the value on. Read more1.0.0 · source#### fn by_ref(&mut self) -> &mut Selfwhere\n Self: Sized,\n\nBorrows an iterator, rather than consuming it. Read more1.0.0 · source#### fn collect<B>(self) -> Bwhere\n B: FromIterator<Self::Item>,\n Self: Sized,\n\nTransforms an iterator into a collection. \n E: Extend<Self::Item>,\n Self: Sized,\n\n🔬This is a nightly-only experimental API. (`iter_collect_into`)Collects all the items from an iterator into a collection. Read more1.0.0 · source#### fn partition<B, F>(self, f: F) -> (B, B)where\n Self: Sized,\n B: Default + Extend<Self::Item>,\n F: FnMut(&Self::Item) -> bool,\n\nConsumes an iterator, creating two collections from it. \n Self: Sized,\n P: FnMut(Self::Item) -> bool,\n\n🔬This is a nightly-only experimental API. (`iter_is_partitioned`)Checks if the elements of this iterator are partitioned according to the given predicate,\nsuch that all those that return `true` precede all those that return `false`. Read more1.27.0 · source#### fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere\n Self: Sized,\n F: FnMut(B, Self::Item) -> R,\n R: Try<Output = B>,\n\nAn iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more1.27.0 · source#### fn try_for_each<F, R>(&mut self, f: F) -> Rwhere\n Self: Sized,\n F: FnMut(Self::Item) -> R,\n R: Try<Output = ()>,\n\nAn iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more1.0.0 · source#### fn fold<B, F>(self, init: B, f: F) -> Bwhere\n Self: Sized,\n F: FnMut(B, Self::Item) -> B,\n\nFolds every element into an accumulator by applying an operation,\nreturning the final result. Read more1.51.0 · source#### fn reduce<F>(self, f: F) -> Option<Self::Item>where\n Self: Sized,\n F: FnMut(Self::Item, Self::Item) -> Self::Item,\n\nReduces the elements to a single one, by repeatedly applying a reducing operation. \n &mut self,\n f: F\n) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere\n Self: Sized,\n F: FnMut(Self::Item, Self::Item) -> R,\n R: Try<Output = Self::Item>,\n <R as Try>::Residual: Residual<Option<Self::Item>>,\n\n🔬This is a nightly-only experimental API. (`iterator_try_reduce`)Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. Read more1.0.0 · source#### fn all<F>(&mut self, f: F) -> boolwhere\n Self: Sized,\n F: FnMut(Self::Item) -> bool,\n\nTests if every element of the iterator matches a predicate. Read more1.0.0 · source#### fn any<F>(&mut self, f: F) -> boolwhere\n Self: Sized,\n F: FnMut(Self::Item) -> bool,\n\nTests if any element of the iterator matches a predicate. Read more1.0.0 · source#### fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,\n\nSearches for an element of an iterator that satisfies a predicate. Read more1.30.0 · source#### fn find_map<B, F>(&mut self, f: F) -> Option<B>where\n Self: Sized,\n F: FnMut(Self::Item) -> Option<B>,\n\nApplies function to the elements of iterator and returns the first non-none result. \n &mut self,\n f: F\n) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere\n Self: Sized,\n F: FnMut(&Self::Item) -> R,\n R: Try<Output = bool>,\n <R as Try>::Residual: Residual<Option<Self::Item>>,\n\n🔬This is a nightly-only experimental API. (`try_find`)Applies function to the elements of iterator and returns the first true result or the first error. Read more1.0.0 · source#### fn position<P>(&mut self, predicate: P) -> Option<usize>where\n Self: Sized,\n P: FnMut(Self::Item) -> bool,\n\nSearches for an element in an iterator, returning its index. Read more1.6.0 · source#### fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where\n B: Ord,\n Self: Sized,\n F: FnMut(&Self::Item) -> B,\n\nReturns the element that gives the maximum value from the specified function. Read more1.15.0 · source#### fn max_by<F>(self, compare: F) -> Option<Self::Item>where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Ordering,\n\nReturns the element that gives the maximum value with respect to the specified comparison function. Read more1.6.0 · source#### fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where\n B: Ord,\n Self: Sized,\n F: FnMut(&Self::Item) -> B,\n\nReturns the element that gives the minimum value from the specified function. Read more1.15.0 · source#### fn min_by<F>(self, compare: F) -> Option<Self::Item>where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Ordering,\n\nReturns the element that gives the minimum value with respect to the specified comparison function. Read more1.0.0 · source#### fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n Self: Sized + Iterator<Item = (A, B)>,\n\nConverts an iterator of pairs into a pair of containers. Read more1.36.0 · source#### fn copied<'a, T>(self) -> Copied<Self>where\n T: 'a + Copy,\n Self: Sized + Iterator<Item = &'a T>,\n\nCreates an iterator which copies all of its elements. Read more1.0.0 · source#### fn cloned<'a, T>(self) -> Cloned<Self>where\n T: 'a + Clone,\n Self: Sized + Iterator<Item = &'a T>,\n\nCreates an iterator which `clone`s all of its elements. \n Self: Sized,\n\n🔬This is a nightly-only experimental API. (`iter_array_chunks`)Returns an iterator over `N` elements of the iterator at a time. Read more1.11.0 · source#### fn sum<S>(self) -> Swhere\n Self: Sized,\n S: Sum<Self::Item>,\n\nSums the elements of an iterator. Read more1.11.0 · source#### fn product<P>(self) -> Pwhere\n Self: Sized,\n P: Product<Self::Item>,\n\nIterates over the entire iterator, multiplying all the elements \n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,\n\n🔬This is a nightly-only experimental API. (`iter_order_by`)Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. Read more1.5.0 · source#### fn partial_cmp<I>(self, other: I) -> Option<Ordering>where\n I: IntoIterator,\n Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n Self: Sized,\n\nLexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements.\nAs soon as an order can be determined, the evaluation stops and a result is returned. \n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,\n\n🔬This is a nightly-only experimental API. (`iter_order_by`)Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. Read more1.5.0 · source#### fn eq<I>(self, other: I) -> boolwhere\n I: IntoIterator,\n Self::Item: PartialEq<<I as IntoIterator>::Item>,\n Self: Sized,\n\nDetermines if the elements of this `Iterator` are equal to those of another. \n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,\n\n🔬This is a nightly-only experimental API. (`iter_order_by`)Determines if the elements of this `Iterator` are equal to those of another with respect to the specified equality function. Read more1.5.0 · source#### fn ne<I>(self, other: I) -> boolwhere\n I: IntoIterator,\n Self::Item: PartialEq<<I as IntoIterator>::Item>,\n Self: Sized,\n\nDetermines if the elements of this `Iterator` are not equal to those of another. Read more1.5.0 · source#### fn lt<I>(self, other: I) -> boolwhere\n I: IntoIterator,\n Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n Self: Sized,\n\nDetermines if the elements of this `Iterator` are lexicographically less than those of another. Read more1.5.0 · source#### fn le<I>(self, other: I) -> boolwhere\n I: IntoIterator,\n Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n Self: Sized,\n\nDetermines if the elements of this `Iterator` are lexicographically less or equal to those of another. Read more1.5.0 · source#### fn gt<I>(self, other: I) -> boolwhere\n I: IntoIterator,\n Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n Self: Sized,\n\nDetermines if the elements of this `Iterator` are lexicographically greater than those of another. Read more1.5.0 · source#### fn ge<I>(self, other: I) -> boolwhere\n I: IntoIterator,\n Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n Self: Sized,\n\nDetermines if the elements of this `Iterator` are lexicographically greater than or equal to those of another. \n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,\n\n🔬This is a nightly-only experimental API. (`is_sorted`)Checks if the elements of this iterator are sorted using the given comparator function. \n Self: Sized,\n F: FnMut(Self::Item) -> K,\n K: PartialOrd<K>,\n\n🔬This is a nightly-only experimental API. (`is_sorted`)Checks if the elements of this iterator are sorted using the given key extraction function. \n---\n\n### impl<'a, T, C> !RefUnwindSafe for UniqueIter<'a, T, C### impl<'a, T, C> !Send for UniqueIter<'a, T, C### impl<'a, T, C> !Sync for UniqueIter<'a, T, C### impl<'a, T, C> Unpin for UniqueIter<'a, T, C### impl<'a, T, C> !UnwindSafe for UniqueIter<'a, T, CBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<I> IntoIterator for Iwhere\n I: Iterator,\n\n#### type Item = <I as Iterator>::Item\n\nThe type of the elements being iterated over.#### type IntoIter = I\n\nWhich kind of iterator are we turning this into?const: unstable · source#### fn into_iter(self) -> I\n\nCreates an iterator from a value. \n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion.\n\nStruct sharded_slab::VacantEntry\n===\n\n\n```\npub struct VacantEntry<'a, T, C: Config = DefaultConfig> { /* private fields */ }\n```\nA handle to a vacant entry in a `Slab`.\n\n`VacantEntry` allows constructing values with the key that they will be assigned to.\n\nExamples\n---\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```\nImplementations\n---\n\n### impl<'a, T, C: Config> VacantEntry<'a, T, C#### pub fn insert(self, val: T)\n\nInsert a value in the entry.\n\nTo get the integer index at which this value will be inserted, use\n`key` prior to calling `insert`.\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 key(&self) -> usize\n\nReturn the integer index at which this entry will be inserted.\n\nA value stored in this entry will be associated with this key.\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```\nTrait Implementations\n---\n\n### impl<'a, T: Debug, C: Debug + Config> Debug for VacantEntry<'a, T, C#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. Read moreAuto Trait Implementations\n---\n\n### impl<'a, T, C = DefaultConfig> !RefUnwindSafe for VacantEntry<'a, T, C### impl<'a, T, C = DefaultConfig> !Send for VacantEntry<'a, T, C### impl<'a, T, C = DefaultConfig> !Sync for VacantEntry<'a, T, C### impl<'a, T, C> Unpin for VacantEntry<'a, T, C### impl<'a, T, C = DefaultConfig> !UnwindSafe for VacantEntry<'a, T, CBlanket Implementations\n---\n\n### impl<T> 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<T, U> Into<U> for Twhere\n U: From<T>,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From<T> for U` chooses to do.\n\n### impl<T, U> TryFrom<U> for Twhere\n U: Into<T>,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::ErrorPerforms the conversion.### impl<T, U> TryInto<U> for Twhere\n U: TryFrom<T>,\n\n#### type Error = <U as TryFrom<T>>::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::ErrorPerforms the conversion."}}},{"rowIdx":587,"cells":{"project":{"kind":"string","value":"pyramid-auth"},"source":{"kind":"string","value":"readthedoc"},"language":{"kind":"string","value":"Python"},"content":{"kind":"string","value":"pyramid_auth 0.4 documentation\n\n### Navigation\n\n* [pyramid_auth 0.4 documentation](index.html#document-index) »\n\npyramid_auth’s documentation\n===\n\nIntroduction[¶](#introduction)\n---\n\nThis is a plugin for pyramid which provides a simple authentication system. The idea was to use exising authentication’s policies to provide multiple support. Currently this plugin support cookie, remote_user and ldap policies.\n\nBy default the cookie and ldap policies generate the form and the urls automatically:\n* /login: display the login form\n* /logout: logout the user\n* /forbidden: the user is redirected to this page when he is logged but doesn’t have the right permission to see a page.\n\nIf you want to generate your own urls you can set the following parameter\n\npyramid_auth.no_routes\n\n> If set in your config, no routes will be added automatically. It’s usefull\n> when you use an API for authentication.\n\nNote\n\nIf you want to change the rendering of the template to include your design you can:\n\n* Create a template in the folder templates/auth of your project named base.mak. Each templates (login, forbidden) inherit from it.\n* Create the login.mak and/or forbidden.mak templates in the folder templates/auth to overwrite the default ones.\n\nCookie policy[¶](#cookie-policy)\n---\n\nThis policy uses pyramid.authentication.AuthTktAuthenticationPolicy. When a user wants to login, it displays a login/password form to process to the authentication.\n\n### Installation[¶](#installation)\n\nIn your .ini file add pyramid_auth to pyramid.includes like this:\n```\npyramid.includes =\n pyramid_auth\n ...\n```\nAlso you need to add pyramid_auth in setup.py in install_requires:\n```\ninstall_requires=[\n ...\n 'pyramid_auth'\n]\n```\n### Configuration[¶](#configuration)\n\nYou need to set some options in your .ini file. See this example for the required ones:\n```\npyramid_auth.policy = cookie pyramid_auth.cookie.secret = mysecret pyramid_auth.cookie.validate_function = validate_function\n```\n#### Options[¶](#options)\n\npyramid_auth.cookie.validate_function\n\n> Function to validate the credential. It can make some call in your DB or make some static verification. Here is a small example:\n> ```\n> def validate(request, login, password):\n> if login == 'Bob' and password == 'bobpwd':\n> return True\n> return False\n> ```\n> Required.\npyramid_auth.cookie.secret\n\n> The secret (a string) used for auth_tkt cookie signing.\n> Required.\n\npyramid_auth.cookie.callback\n\n> Default: None. A callback passed the userid and the\n> request, expected to return None if the userid doesn’t\n> exist or a sequence of principal identifiers (possibly empty) if\n> the user does exist. If callback is None, the userid\n> will be assumed to exist with no principals. Optional.\n\npyramid_auth.cookie.cookie_name\n\n> Default: auth_tkt. The cookie name used\n> (string). Optional.\n\npyramid_auth.cookie.secure\n\n> Default: False. Only send the cookie back over a secure\n> conn. Optional.\n\npyramid_auth.cookie.include_ip\n\n> Default: False. Make the requesting IP address part of\n> the authentication data in the cookie. Optional.\n> For IPv6 this option is not recommended. The mod_auth_tkt\n> specification does not specify how to handle IPv6 addresses, so using\n> this option in combination with IPv6 addresses may cause an\n> incompatible cookie. It ties the authentication ticket to that\n> individual’s IPv6 address.\npyramid_auth.cookie.timeout\n\n> Default: None. Maximum number of seconds which a newly\n> issued ticket will be considered valid. After this amount of\n> time, the ticket will expire (effectively logging the user\n> out). If this value is None, the ticket never expires.\n> Optional.\n\npyramid_auth.cookie.reissue_time\n\n> Default: None. If this parameter is set, it represents the number\n> of seconds that must pass before an authentication token cookie is\n> automatically reissued as the result of a request which requires\n> pyramid_auth. The duration is measured as the number of seconds\n> since the last auth_tkt cookie was issued and ‘now’. If this value is\n> 0, a new ticket cookie will be reissued on every request which\n> requires authentication.\n> A good rule of thumb: if you want auto-expired cookies based on\n> inactivity: set the timeout value to 1200 (20 mins) and set the\n> reissue_time value to perhaps a tenth of the timeout value\n> (120 or 2 mins). It’s nonsensical to set the timeout value lower\n> than the reissue_time value, as the ticket will never be reissued\n> if so. However, such a configuration is not explicitly prevented.\n> Optional.\npyramid_auth.cookie.max_age\n\n> Default: None. The max age of the auth_tkt cookie, in\n> seconds. This differs from timeout inasmuch as timeout\n> represents the lifetime of the ticket contained in the cookie,\n> while this value represents the lifetime of the cookie itself.\n> When this value is set, the cookie’s Max-Age and\n> Expires settings will be set, allowing the auth_tkt cookie\n> to last between browser sessions. It is typically nonsensical\n> to set this to a value that is lower than timeout or\n> reissue_time, although it is not explicitly prevented.\n> Optional.\n\npyramid_auth.cookie.path\n\n> Default: /. The path for which the auth_tkt cookie is valid.\n> May be desirable if the application only serves part of a domain.\n> Optional.\n\npyramid_auth.cookie.http_only\n\n> Default: False. Hide cookie from JavaScript by setting the\n> HttpOnly flag. Not honored by all browsers.\n> Optional.\n\npyramid_auth.cookie.wild_domain\n\n> Default: True. An auth_tkt cookie will be generated for the\n> wildcard domain. If your site is hosted as example.com this\n> will make the cookie available for sites underneath example.com\n> such as www.example.com.\n> Optional.\n\npyramid_auth.cookie.parent_domain\n\n> Default: False. An auth_tkt cookie will be generated for the\n> parent domain of the current site. For example if your site is\n> hosted under www.example.com a cookie will be generated for\n> .example.com. This can be useful if you have multiple sites\n> sharing the same domain. This option supercedes the wild_domain\n> option.\n> Optional.\n\npyramid_auth.cookie.domain\n\n> Default: None. If provided the auth_tkt cookie will only be\n> set for this domain. This option is not compatible with wild_domain\n> and parent_domain.\n> Optional.\n\npyramid_auth.cookie.hashalg\n\n> Default: sha512 (the literal string).\n> Any hash algorithm supported by Python’s hashlib.new() function\n> can be used as the hashalg.\n> Cookies generated by different instances of AuthTktAuthenticationPolicy\n> using different hashalg options are not compatible. Switching the\n> hashalg will imply that all existing users with a valid cookie will\n> be required to re-login.\n> Optional.\npyramid_auth.cookie.debug\n\n> Default: False. If debug is True, log messages to the\n> Pyramid debug logger about the results of various authentication\n> steps.\n> Optional.\nRemote_user policy[¶](#remote-user-policy)\n---\n\nThis policy uses pyramid.authentication.RemoteUserAuthenticationPolicy. The user is authenticated by the http server which provides in the environ a key with the login.\n\n### Installation[¶](#id1)\n\nIn your .ini file add pyramid_auth to pyramid.includes like this:\n```\npyramid.includes =\n pyramid_auth\n ...\n```\nAlso you need to add pyramid_auth in setup.py in install_requires:\n```\ninstall_requires=[\n ...\n 'pyramid_auth'\n]\n```\n### Configuration[¶](#id2)\n\nYou need to set some options in your .ini file. See this example for the required ones:\n```\npyramid_auth.policy = remote_user\n```\n#### Options[¶](#id3)\n\nenviron_key Default: REMOTE_USER. The key in the WSGI environ which provides the userid. Optional.\ncallback Default: None. A callback passed the userid and the request,\nexpected to return None if the userid doesn’t exist or a sequence of principal identifiers (possibly empty) representing groups if the user does exist. If callback is None, the userid will be assumed to exist with no group principals. Optional.\ndebug Default: False. If debug is True, log messages to the Pyramid debug logger about the results of various authentication steps. Optional.\n\nldap policy[¶](#ldap-policy)\n---\n\nThis policy uses pyramid_ldap. Basically the same logic than the cookie policy but we just validate the login/password with the ldap. As you will see in the configuration, it’s possible to get the ldap user’s groups. In this way, you will be able to set some permissions in your pyramid project according to the ldap configuration.\n\n### Installation[¶](#id4)\n\nYou need to have openldap header installed. For example on centos/fedora:\n```\nyum install openldap-devel\n```\nIn your .ini file add pyramid_ldap and pyramid_auth to pyramid.includes like this:\n```\npyramid.includes =\n pyramid_ldap\n pyramid_auth\n ...\n```\nWarning\n\nthe order is important, you need to include pyramid_ldap before pyramid_auth\n\nAlso you need to add pyramid_ldap and pyramid_auth in setup.py in install_requires:\n```\ninstall_requires=[\n ...\n 'pyramid_ldap'\n 'pyramid_auth'\n]\n```\nNote\n\npyramid_ldap is not installed in pyramid_auth since we don’t want to force the installation of ldap if we don’t want to use it!\n\n### Configuration[¶](#id5)\n\nYou need to set some options in your .ini file. See this example for the required ones:\n```\npyramid_auth.policy = ldap pyramid_auth.ldap.cookie.secret = mysecret pyramid_auth.ldap.setup.uri = http://ldap.lereskp.fr pyramid_auth.ldap.setup.passwd = myldappasswd\n\npyramid_auth.ldap.login.base_dn = CN=Users,DC=lereskp,DC=fr pyramid_auth.ldap.login.filter_tmpl = (sAMAccountName=$login)\n```\nIf you want to put some permissions according to the ldap groups, you have to give the parameters to be able to query the ldap:\n```\npyramid_auth.policy = ldap pyramid_auth.ldap.cookie.secret = mysecret pyramid_auth.ldap.setup.uri = http://ldap.lereskp.fr pyramid_auth.ldap.setup.passwd = myldappasswd\n\npyramid_auth.ldap.login.base_dn = CN=Users,DC=lereskp,DC=fr pyramid_auth.ldap.login.filter_tmpl = (sAMAccountName=$login)\n\npyramid_auth.ldap.groups.base_dn = CN=Users,DC=lereskp,DC=fr pyramid_auth.ldap.groups.filter_tmpl = (&(objectCategory=group)(member=$userdn))\n```\n#### Options[¶](#id6)\n\n##### Cookie[¶](#cookie)\n\npyramid_auth.ldap.cookie.secret\n\n> The secret (a string) used for auth_tkt cookie signing.\n> Required.\n\npyramid_auth.ldap.cookie.callback\n\n> Default: None. A callback passed the userid and the\n> request, expected to return None if the userid doesn’t\n> exist or a sequence of principal identifiers (possibly empty) if\n> the user does exist. If callback is None, the userid\n> will be assumed to exist with no principals. Optional.\n\npyramid_auth.ldap.cookie.cookie_name\n\n> Default: auth_tkt. The cookie name used\n> (string). Optional.\n\npyramid_auth.ldap.cookie.secure\n\n> Default: False. Only send the cookie back over a secure\n> conn. Optional.\n\npyramid_auth.ldap.cookie.include_ip\n\n> Default: False. Make the requesting IP address part of\n> the authentication data in the cookie. Optional.\n> For IPv6 this option is not recommended. The mod_auth_tkt\n> specification does not specify how to handle IPv6 addresses, so using\n> this option in combination with IPv6 addresses may cause an\n> incompatible cookie. It ties the authentication ticket to that\n> individual’s IPv6 address.\npyramid_auth.ldap.cookie.timeout\n\n> Default: None. Maximum number of seconds which a newly\n> issued ticket will be considered valid. After this amount of\n> time, the ticket will expire (effectively logging the user\n> out). If this value is None, the ticket never expires.\n> Optional.\n\npyramid_auth.ldap.cookie.reissue_time\n\n> Default: None. If this parameter is set, it represents the number\n> of seconds that must pass before an authentication token cookie is\n> automatically reissued as the result of a request which requires\n> authentication. The duration is measured as the number of seconds\n> since the last auth_tkt cookie was issued and ‘now’. If this value is\n> 0, a new ticket cookie will be reissued on every request which\n> requires authentication.\n> A good rule of thumb: if you want auto-expired cookies based on\n> inactivity: set the timeout value to 1200 (20 mins) and set the\n> reissue_time value to perhaps a tenth of the timeout value\n> (120 or 2 mins). It’s nonsensical to set the timeout value lower\n> than the reissue_time value, as the ticket will never be reissued\n> if so. However, such a configuration is not explicitly prevented.\n> Optional.\npyramid_auth.ldap.cookie.max_age\n\n> Default: None. The max age of the auth_tkt cookie, in\n> seconds. This differs from timeout inasmuch as timeout\n> represents the lifetime of the ticket contained in the cookie,\n> while this value represents the lifetime of the cookie itself.\n> When this value is set, the cookie’s Max-Age and\n> Expires settings will be set, allowing the auth_tkt cookie\n> to last between browser sessions. It is typically nonsensical\n> to set this to a value that is lower than timeout or\n> reissue_time, although it is not explicitly prevented.\n> Optional.\n\npyramid_auth.ldap.cookie.path\n\n> Default: /. The path for which the auth_tkt cookie is valid.\n> May be desirable if the application only serves part of a domain.\n> Optional.\n\npyramid_auth.ldap.cookie.http_only\n\n> Default: False. Hide cookie from JavaScript by setting the\n> HttpOnly flag. Not honored by all browsers.\n> Optional.\n\npyramid_auth.ldap.cookie.wild_domain\n\n> Default: True. An auth_tkt cookie will be generated for the\n> wildcard domain. If your site is hosted as example.com this\n> will make the cookie available for sites underneath example.com\n> such as www.example.com.\n> Optional.\n\npyramid_auth.ldap.cookie.parent_domain\n\n> Default: False. An auth_tkt cookie will be generated for the\n> parent domain of the current site. For example if your site is\n> hosted under www.example.com a cookie will be generated for\n> .example.com. This can be useful if you have multiple sites\n> sharing the same domain. This option supercedes the wild_domain\n> option.\n> Optional.\n\npyramid_auth.ldap.cookie.domain\n\n> Default: None. If provided the auth_tkt cookie will only be\n> set for this domain. This option is not compatible with wild_domain\n> and parent_domain.\n> Optional.\n\npyramid_auth.ldap.cookie.hashalg\n\n> Default: sha512 (the literal string).\n> Any hash algorithm supported by Python’s hashlib.new() function\n> can be used as the hashalg.\n> Cookies generated by different instances of AuthTktAuthenticationPolicy\n> using different hashalg options are not compatible. Switching the\n> hashalg will imply that all existing users with a valid cookie will\n> be required to re-login.\n> Optional.\npyramid_auth.ldap.cookie.debug\n\n> Default: False. If debug is True, log messages to the\n> Pyramid debug logger about the results of various authentication\n> steps.\n> Optional.\n##### Setup[¶](#setup)\n\npyramid_auth.ldap.setup.uri\n\n> ldap server uri. Required.\n\npyramid_auth.ldap.setup.bind\n\n> Default None. Bind that will be used to bind a connector. Optional.\n\npyramid_auth.ldap.setup.passwd\n\n> Default None. Password that will be used to bind a connector. Optional.\n\npyramid_auth.ldap.setup.size\n\n> Default 10. pool size. Optional.\n\npyramid_auth.ldap.setup.retry_max\n\n> Default 3. Number of attempts when a server is down. Optional.\n\npyramid_auth.ldap.setup.retry_delay\n\n> Default: .1. Delay in seconds before a retry. Optional.\n\npyramid_auth.ldap.setup.use_tls\n\n> Default False. Activate TLS when connecting. Optional.\n\npyramid_auth.ldap.setup.timeout\n\n> Default -1. Connector timeout. Optional.\n\npyramid_auth.ldap.setup.use_pool\n\n> Default True. Activates the pool. If False, will recreate a connector each time. Optional.\n\n##### Login[¶](#login)\n\npyramid_auth.ldap.login.base_dn\n\n> is the DN at which to begin the search.\n\npyramid_auth.ldap.login.filter_tmpl\n\n> is a string which can be used as an LDAP filter: it should contain the replacement value %(login)s.\n\npyramid_auth.ldap.login.scope\n\n> is any valid LDAP scope value (e.g. ldap.SCOPE_ONELEVEL).\n\npyramid_auth.ldap.login.cache_period\n\n> is the number of seconds to cache login search results; if it is 0, login search results will not be cached.\n\n##### Groups[¶](#groups)\n\npyramid_auth.ldap.groups.base_dn\n\n> is the DN at which to begin the search.\n\npyramid_auth.ldap.groups.filter_tmpl\n\n> is a string which can be used as an LDAP filter: it should contain the replacement value %(userdn)s.\n\nImportant\n\nIn pyramid_ldap userdn represent the user distinguished name. In pyramid_auth it represents the user uid. So you should make your filter_tmpl according to the user uid.\n\npyramid_auth.ldap.groups.scope\n\n> is any valid LDAP scope value (e.g. ldap.SCOPE_SUBTREE). cache_period is the number of seconds to cache groups search results; if it is 0, groups search results will not be cached.\n\n##### Extra[¶](#extra)\n\npyramid_auth.ldap.validate_function\n\n> Default: None. You can set a function to validate the ldap login/password it you want to be more specific. Optional.\n\npyramid_auth.ldap.callback\n\n> Default: None. A callback passed the userid and the\n> request to extend the groups found by the ldap groups query.\n> Optional.\n\n### Quick search\n\n Enter search terms or a module, class or function name.\n \n\n### Navigation\n\n* [pyramid_auth 0.4 documentation](index.html#document-index) »"}}},{"rowIdx":588,"cells":{"project":{"kind":"string","value":"MAd"},"source":{"kind":"string","value":"cran"},"language":{"kind":"string","value":"R"},"content":{"kind":"string","value":"Package ‘MAd’\n October 12, 2022\nType Package\nTitle Meta-Analysis with Mean Differences\nVersion 0.8-3\nDate 2022-08-07\nMaintainer <NAME> <<EMAIL>>\nDescription A collection of functions for conducting a meta-\n analysis with mean differences data. It uses recommended procedures as\n described in The Handbook of Research Synthesis and Meta-Analysis\n (Cooper, Hedges, & Valentine, 2009).\nDepends R (>= 2.10.1)\nSuggests metafor, ggplot2\nLicense GPL (>= 2)\nEncoding UTF-8\nURL https://www.acdelre.com\nNeedsCompilation no\nAuthor <NAME> [aut, cre] (<https://orcid.org/0000-0002-9571-7623>),\n <NAME> [aut] (<https://orcid.org/0000-0003-4324-5676>)\nRepository CRAN\nDate/Publication 2022-08-06 22:40:02 UTC\nR topics documented:\nMAd-packag... 2\nag... 7\nancova_to_d... 10\nancova_to_d... 11\natte... 12\ncompute_dg... 13\ncompute_d... 14\ncompute_g... 16\ndat.cooper15.... 17\ndat.cooperA... 17\ndat.hoy... 18\ndat.sim.e... 18\ndat.sim.fina... 18\ndat.sim.ra... 19\ndat.sim... 19\ndat.sim... 19\nd_to_... 20\nf.ancova_to_... 21\nfail_to_... 22\nf_to_... 23\nic... 24\nKapp... 26\nlor_to_... 27\nmaca... 28\nmacat... 30\nmare... 32\nmean_to_... 34\nmean_to_d... 35\nor_to_... 36\np.ancova_to_d... 37\np.ancova_to_d... 38\nplotca... 39\nplotco... 40\nPubBia... 41\np_to_d... 42\np_to_d... 43\nrobustS... 44\nr_from_ch... 45\nr_from_... 46\nr_from_d... 47\nr_from_... 48\nr_to_... 49\ntt.ancova_to_... 50\nt_to_... 51\nwgt... 52\n MAd-package Meta-Analysis with Mean Differences\nDescription\n The Mad package contains a variety of functions for conducting a mean differences meta-analysis\n using recommended procedures as described in The Handbook of Research Synthesis and Meta-\n Analysis (<NAME>, and Valentine, 2009). The goal in creating this package was to provide\n user-friendly functions to assist researchers in the process of conducting a meta-analysis, from the\n initial to final stages of their analytic endeavor. The meta-analyst can begin their project by using\n MAd functions to derive d (standardized mean differences) and g (unbiased d) from a variety of\n statistics/values reported in the primary studies (e.g., raw means and sd, t-test). Then, the analyst\n can aggregate all within-study effect sizes (while accounting for within-study correlations among\n outcome measures and eliminating any dependencies in the dataset), calculate omnibus effect sizes\n under a fixed and random effects model, and assess for significant moderators (categorical and\n continuous, single and multi-predictor models) in the dataset. Finally, the meta-analyst can use one\n of several user-friendly graphics functions to visually represent their data.\nDetails\n Package: MAd\n Type: Package\n Version: 0.8-2\n Date: 2014-12-23\n License: GPL-2\n LazyLoad: yes\n The MAd package has integrated functions to facilitate the meta-analytic process at nearly every\n analytical stage. There are five broad areas of analysis that the MAd package targets:\n 1. Computations to Calculate Mean Differences:\n There are a variety of functions to compute d (standardized mean difference) and g (unbiased d)\n from various designs reported in the primary studies. Most functions were derived from Boren-\n stein’s chapter in The Handbook of Research Synthesis and Meta-Analysis (Cooper, Hedges, &\n Valentine, 2009; pp. 228-234). For additional conversion formulas see the compute.es package:\n https://CRAN.R-project.org/package=compute.es\n 2. Within-Study Aggregation of Effect Sizes:\n This fuction will simultaneously aggregate all within-study effect sizes while taking into account\n the correlations among the within-study outcome measures (Gleser & Olkin 2009; Gleser & Olkin\n 2009; Hedges & Olkin, 1985; Rosenthal et al., 2006). The default imputed correlation between\n within-study effect sizes is set at .50 (Wampold et al., 1997) and will compute an aggregated effect\n size for each study. This default of .50 is adjustable and can vary between outcome types. This\n MAd aggregation function implements Gleser & Olkin (1994; 2009) and Borenstein et al. (2009)\n procedures for aggregating dependent effect sizes. To our knowledge, this is the first statistical\n package/program to explicitly utilize and automate this type of aggregation procedure, which has a\n dual effect of saving the researcher substantial time while improving the accuracy of their analyses.\n 3. Fixed and Random Effects Omnibus Analysis:\n This package contains all the relevant functions to calculate fixed and random effects omnibus\n effect sizes, outputting the omnibus (i.e., overall) effect size, variance, standard error, upper and\n lower confidence intervals, and the Q-statistic (heterogeneity test).\n 4. Moderator Analyses:\n There are user-friendly functions to compute fixed and random effects moderator analyses. These\n include single and multiple predictor models for both categorical and continuous moderator data.\n 5. Graphics:\n This package has a variety of functions visually representing data. This includes boxplots and\n meta-regression scatterplots.\n 6. Sample of Additional Functions:\n Export MA output to nicely formatted Word tables.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\n <NAME>., <NAME>., & <NAME>. (2009). The handbook of research synthesis and meta-\n analysis (2nd edition). New York: Russell Sage Foundation.\n Gleser & Olkin (1994). Stochastically dependent effect sizes. In <NAME>, & <NAME>, & J.\n C.(Eds.), The handbook of research synthesis (pp. 339-356). New York: Russell Sage Foundation.\n Gleser & Olkin (2009). Stochastically dependent effect sizes. In <NAME>, <NAME>, & <NAME>.\n Valentine (Eds.), The handbook of research synthesis and meta analysis (pp. 357-376). New York:\n Russell Sage Foundation.\n Viechtbauer, W (2010). metafor: Meta-Analysis Package for R. R package version 1.1-0. https://CRAN.R-\n project.org/package=metafor\n <NAME>., <NAME>., <NAME>., <NAME>., <NAME>., & <NAME>. (1997). A meta-\n analysis of outcome studies comparing bona fide psychotherapies: Empiricially, ’all must have\n prizes.’ Psychological Bulletin, 122(3), 203-215.\nSee Also\n compute.es package: https://CRAN.R-project.org/package=compute.es;\n metafor package: https://CRAN.R-project.org/package=metafor\nExamples\n ## EXAMPLES FOR EACH BROAD AREA\n # SAMPLE DATA:\n MA <- data.frame(id=factor(rep(1:5, 3)),\n measure=c(rep(\"dep\",5), rep(\"anx\",5), rep(\"shy\",5)),\n es=c(rnorm(5, 0.8, .2), rnorm(5, 0.5, .1), rnorm(5, 0.4, .1)),\n var.es=abs(rnorm(5*3,0.05, .03)),\n nT=round(rnorm(5*3, 30, 5),0),\n nC=round(rnorm(5*3, 30, 5),0),\n mod1=factor(rep(c(\"a\",\"b\",\"c\",\"d\",\"e\"),3)),\n mod2=rep(seq(20, 60, 10), 3))\n # 1. COMPUTE MEAN DIFFERENCE STATISTIC FROM\n # REPORTED STATS (GENERALLY FROM A PRIMARY STUDY):\n # suppose the primary study reported an log odds ratio for different\n # proportions between 2 groups. Then, running:\n lor_to_d(.9070,.0676)\n # reported log odds ratio (lor = .9070) and variance (.0676) will output the\n # standardized mean difference (d) and its variance (var.d) that can be used in\n # a meta-analysis.\n ## 2. ACCOUNT FOR DEPENDENCIES: WITHIN-STUDY EFFECT SIZES (ES):\n ## 2 EXAMPLES:\n # EXAMPLE 1: AGGREGATING EFFECT SIZES FOR A DATA FRAME\n # (MULTIPLE STUDIES AT LEAST SOME OF WHICH HAVE MULTIPLE DEPENDENT EFFECT SIZES)\n # EXAMPLE 2: AGGREGATING EFFECT SIZES FOR SINGLE STUDY WITH THREE OR MORE\n # EFFECT SIZES WHEN PAIRS OF DVS HAVE DIFFERENT CORRELATIONS\n ## EXAMPLE 1: MA IS A DATA FRAME CONTAINING MULTIPLE STUDIES (id),\n ## EACH WITH MULTIPLE EFFECT SIZES (CORRELATIONS BETWEEN ALL PAIRS OF DVS ARE r=.5.)\n # AGGREGATION PROCEDURE:\n # method=\"GO1\"; GLESER AND OLKIN (1994) PROCEDURE WHEN d IS COMPUTED\n # USING POOLED SD IN THE DENOMINATOR\n MA1 <- agg(id=id, es=es, var=var.es, n.1=nT, n.2=nC, cor = .5, method=\"GO1\", data=MA)\n MA1\n ## EXAMPLE 2: STUDY 1 COMPARES A TREATMENT AND CONTROL GROUP ON\n ## THREE OUTCOME MEASURES (DEPRESSION, ANXIETY, and SHYNESS).\n # THE CORRELATION AMONG THE THREE PAIRS OF DVS ARE r12=.5, r13=.2, and r23=.3.\n study1 <- data.frame( id=factor(rep(1, 3)),\n measure=c(\"dep\", \"anx\", \"shy\"),\n es=c(0.8, 0.5, 0.4),\n var.es=c(0.01, 0.02, 0.1),\n nT=rep(30, 3),\n nC=rep(30, 3))\n # ONE WOULD CONSTRUCT THE CORRELATION MATRIX AS FOLLOWS:\n cors <- matrix(c(1,.5,.2,\n .5,1,.3,\n .2,.3,1), nrow=3)\n # AGGREGATION PROCEDURE:\n # method=\"GO1\"; GLESER AND OLKIN (1994) PROCEDURE WHEN d\n # IS COMPUTED USING POOLED SD IN THE DENOMINATOR\n agg(id=id, es=es, var=var.es, n.1=nT, n.2=nC, cor=cors, method=\"GO1\", mod = NULL, data=study1)\n # where MA = data.frame with columns for id, es (standardized\n # mean difference), var.es (variance of es), n.1 (sample size of group\n # one), and n.2 (sample size of comparison group) with multiple rows per\n # study. Outputs an aggregated data.frame with 1 effect size per study.\n ## 3.OMNIBUS ANALYSIS\n # FIRST ADD MODERATORS TO THE AGGREGATED DATASET:\n MODS <- data.frame(id=1:5,\n mod1=factor(c(\"a\",\"b\",\"a\",\"b\",\"b\")),\n mod2=as.numeric(c(20, 30, 25, 35, 40)))\n MA2 <- merge(MA1, MODS, by='id')\n # Random Effects\n m0 <- mareg(es1~ 1, var = var1, method = \"REML\", data = MA2)\n # where MA = data.frame with columns for id, es (standardized\n # mean difference), var.es (variance of es), n.1 (sample size of group\n # one), and n.2 (sample size of comparison group).\n # view output:\n summary(m0)\n # 4. MODERATOR ANALYSIS:\n # Random Effects\n m1 <- mareg(es1~ mod1 + mod2 , var = var1, method = \"REML\", data = MA2)\n # view output:\n summary(m1)\n # 5. Graphics:\n ## Not run: plotcon(g = es1, var = var1, mod = mod1, data = MA2, method= \"random\",\n modname= \"Moderator\")\n ## End(Not run)\n # Additional Functions\n # Export MA output to nicely formatted Word tables.\n # install R2wd\n # install.packages('R2wd', dependencies = TRUE)\n # Export data to Word in formatted table\n # wd(m1, get = TRUE, new = TRUE)\n agg Aggregate Dependent Effect Sizes\nDescription\n This function will simultaneously aggregate all within-study effect sizes while taking into account\n the correlations among the within-study outcomes. The default correlation between outcome mea-\n sures is set at .50 (Wampold et al., 1997), and can be adjusted as needed. An aggregate effect size\n and its variance is computed for each study. This MAd aggregation function implements Gleser &\n Olkin (1994) and Borenstein et al. (2009) procedures for aggregating dependent effect sizes..\nUsage\n agg(id, es, var, n.1=NULL, n.2=NULL, method = \"BHHR\", cor = .50, mod=NULL, data)\nArguments\n id Study id with multiple rows of same id.\n es Effect size. Use Cohen’s d for GO1 and GO2 method and use Hedges g for\n BHHR method.\n var Variance of g.\n n.1 Sample size of group one. Only required if using method=’GO1’ or ’GO2’.\n n.2 Sample size of group two. Only required if using method=’GO1’ or ’GO2’.\n method ’BHHR’= Borenstein, et al. (2009) procedure.’GO1’= Gleser and Olkin (1994)\n procedure using pooled standard deviation (SD). ’GO2’= Gleser and Olkin (1994)\n procedure using group 2 SD (typically control group SD). Default is ’BHHR’.\n cor Estimated correlation among within-study outcome variables. Input should ei-\n ther be a fixed correlation (default is r=.5) or a correlation matrix to allow dif-\n ferent correlations between outcome types (in which case aggregation should\n typically be on one study at a time rather than the entire dataset–see examples\n below).\n mod To aggregate by id and one moderator. If there are multiple levels of a categorical\n moderator within study and one can in derive seperate effect size estimates for\n each level within and between studies. Default is NULL.\n data data.frame with above values.\nValue\n Outputs a data.frame with aggregated effect sizes and variances of effect sizes where each study\n is reduced to one row per study (unless aggregated by a moderator) by a weighted average formula.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\n <NAME>., <NAME>., & <NAME>. (2009). The handbook of research synthesis and meta-\n analysis (2nd edition). New York: Russell Sage Foundation.\n Gleser & Olkin (1994). Stochastically dependent effect sizes. In <NAME>, & <NAME>, & J.\n C.(Eds.), The handbook of research synthesis(pp. 339-356). New York: Russell Sage Foundation.\n Gleser & Olkin (2009). Stochastically dependent effect sizes. In <NAME>, <NAME>, & <NAME>.\n Valentine (Eds.), The handbook of research synthesis and meta analysis (pp. 357-377). New York:\n Russell Sage Foundation.\n Shadish & Haddock (2009). Analyzing effect sizes: Fixed-effects models. In <NAME>, <NAME>.\n Hedges, & <NAME> (Eds.), The handbook of research synthesis and meta analysis (pp. 257-\n 278). New York: Russell Sage Foundation.\nExamples\n ## 2 EXAMPLES:\n # EXAMPLE 1: Aggregating effect sizes for a data frame\n # (multiple studies at least some of which have multiple\n # effect sizes), assuming equal correlations (r=.5) between\n # pairs of DVs.\n # EXAMPLE 2: Aggregating effect sizes for a single study\n # with 3 or more effect sizes when pairs of DVs have\n # different correlations.\n # LOAD DATA (EXAMPLE DATA FROM HOYT & DEL RE, 2015 SIMULATION):\n data(dat.hoyt)\n ## EXAMPLE 1: dat.hoyt is a data frame with multiple studies identified\n ## by variable 'id'. Each study has multiple effect sizes based on\n ## multiple DVs. Correlations between all pairs of DVs are r=.5.\n # NOTE: Based on a simulation study by Hoyt & <NAME> (2015), it is\n # recommended that methods \"G01\" and \"G02\" (Gleser and Olkin)\n # should aggregate Cohen's d, without using Hedges & Olkin's\n # recommended bias correction. (Studies providing only a single\n # effect size should still be corrected for bias, after aggregation.)\n # Method \"BHHR\" should aggregate Hedges' g, after bias correction.\n # Option 1: method=\"BHHR\"; Borenstein et al. (2009) procedure.\n # Use with Hedges' g; can also be used with any other effect\n # size (e.g., z', LOR).\n agg(id=id, es=g, var=vg, cor=.5,\n method=\"BHHR\", mod=NULL, data=dat.hoyt)\n # Option 2: method=\"GO1\"; Gleser & Olkin (1994) procedure when\n # d is computed using pooled sd in denominator.\n agg(id=id, es=d, var=vd, n.1=n.T, n.2=n.C, cor = .5,\n method=\"GO1\", mod = NULL, data=dat.hoyt)\n # Option 3: method=\"GO2\"; Gleser & Olkin (1994) procedure when\n # d is computed using sd.2 (typically control group sd)\n # in denominator\n agg(id=id, es=d, var=vd, n.1=n.T, n.2=n.C, cor = .5,\n method=\"GO2\", mod = NULL, data=dat.hoyt)\n ## EXAMPLE 2: Single study comparing T and C group\n ## on three DVs: depression, anxiety, and shyness\n ## r12=.5; r13=.2; r23=.3\n data <- dat.hoyt[20:22,]\n # Step 1: Create the correlation matrix, based on r12, r13, and r23:\n cors <- matrix(c(1,.5,.2,\n .5,1,.3,\n .2,.3,1), nrow=3)\n # Step 2: Aggregate using agg() function.\n # Option 1: method=\"BHHR\"; Borenstein et al. (2009) procedure.\n # Use with Hedges' g; can also be used with any other effect\n # size (e.g., z', LOR).\n agg(id=id, es=g, var=vg, cor=cors,\n method=\"BHHR\", mod=NULL, data=data)\n # Option 2: method=\"GO1\"; Gleser & Olkin (1994) procedure when\n # d is computed using pooled sd in denominator.\n agg(id=id, es=d, var=vd, n.1=n.T, n.2=n.C, cor = cors,\n method=\"GO1\", mod = NULL, data=data)\n # Option 3: method=\"GO2\"; Gleser & Olkin (1994) procedure when\n # d is computed using sd.2 (typically control group sd)\n # in denominator\n agg(id=id, es=d, var=vd, n.1=n.T, n.2=n.C, cor = cors,\n method=\"GO2\", mod = NULL, data=data)\n ## Citation ##\n # <NAME>., & <NAME>, <NAME>. (2013). Comparison of methods for\n # aggregating dependent effect sizes in meta-analysis.\n # Manuscript submitted for publication.\n ancova_to_d1 ANCOVA F-statistic to d\nDescription\n Converts an ANCOVA F-statistic to d (standardized mean difference)\nUsage\n ancova_to_d1(m.1.adj, m.2.adj, sd.adj, n.1, n.2, R, q)\nArguments\n m.1.adj Adjusted mean of treatment group from ANCOVA.\n m.2.adj Adjusted mean of comparison group from ANCOVA.\n sd.adj Adjusted standard deviation.\n n.1 Treatment group sample size.\n n.2 Comparison group sample size.\n R Covariate outcome correlation or multiple correlation.\n q Number of covariates.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_d1, r_from_t\n ancova_to_d2 ANCOVA F-statistic to d II\nDescription\n Converts an ANCOVA F-statistic with pooled standard deviation to d (standardized mean differ-\n ence)\nUsage\n ancova_to_d2(m.1.adj, m.2.adj, s.pooled, n.1, n.2, R, q)\nArguments\n m.1.adj Adjusted mean of treatment group from ANCOVA.\n m.2.adj Adjusted mean of comparison group from ANCOVA.\n s.pooled Pooled standard deviation.\n n.1 Treatment group sample size.\n n.2 Comparison group sample size.\n R Covariate outcome correlation or multiple correlation.\n q number of covariates.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_d1, r_from_t\n atten Correction for Attenuation\nDescription\n Used to correct for attenuated effect sizes due to measurement unreliability.\nUsage\n atten(g, xx, yy, data)\nArguments\n g Hedges g (unbiased estimate of d) effect size.\n xx Column for reliability of predictor variable (\"independent variable\").\n yy Column for reliability of outcome variable (\"dependent variable\").\n data data.frame with the above values.\nValue\n A new column for g corrected for attenuation (g.corrected) will be added to the data, for those xx\n & yy columns with complete data.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n <NAME>., <NAME>. (2004). Methods of meta-analysis (2nd edition). Thousand Oaks, CA:\n Sage.\nExamples\n # Sample data:\n id<-c(1, 1:19)\n n<-c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n g<-c(.68,.56,.23,.64,.49,-.04,.49,.33,.58,.18,-.11,.27,.26,.40,.49,\n .51,.40,.34,.42,.16)\n var.g <- c(.08,.06,.03,.04,.09,.04,.009,.033,.0058,.018,.011,.027,.026,.0040,\n .049,.0051,.040,.034,.0042,.016)\n xx<-c(.88,.86,.83,.64,.89,.84,.89,.83,.99,.88,.81,.77,.86,.70,.79,\n .71,.80,.74,.82,.86) # Reliability of \"independent variable\"\n yy<-c(.99,.86,.83,.94,.89,.94,.89,.93,.99,.88,.81,.77,.86,.70,.79,\n .71,.80,.94,.92,.96) # Reliability of \"dependent variable\"\n df<-data.frame(id,n,g, var.g, xx,yy)\n # Example\n atten(g= g, xx = xx, yy = yy, data= df)\n compute_dgs Computes Vector of Standardized Mean Differences\nDescription\n Adds d & g (standardized mean difference) to a data.frame. Required inputs are: n.1 (sample size\n of group one), m.1 (raw post-mean value of group one), sd.1 (standard deviation of group one), n.2\n (sample size of group two), m.2 (raw post-mean value of group two), sd.2 (standard deviation of\n group two).\nUsage\n compute_dgs(n.1, m.1, sd.1 , n.2, m.2, sd.2, data, denom = \"pooled.sd\")\nArguments\n n.1 sample size of group one.\n m.1 raw post-mean value of group one.\n sd.1 standard deviation of group one.\n n.2 sample size of group two.\n m.2 raw post-mean value of group two.\n sd.2 standard deviation of group two.\n data data.frame with above values\n denom Value in the denominator to standardize the means by. pooled.sd will pool\n together both groups in deriving d. control.sd uses the standard deviation of\n group two (typically the control condition) to calculate d.\nValue\n d Standardized mean difference.\n var.d Variance of d.\n se.d Standard error of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n compute_ds, compute_gs\nExamples\n id <- c(1:20)\n n.1 <- c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n m.1 <- c(.68,.56,.23,.64,.49,.4,1.49,.53,.58,1.18,.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,.66)\n m.2 <- c(.38,.36,.23,.34,.29,.4,1.9,.33,.28,1.1,.111,.27,.21,.140,.149,\n .51,.140,.134,.42,.16)\n sd.1 <- c(.28,.26,.23,.44,.49,.34,.39,.33,.58,.38,.31,.27,.26,.40,\n .49,.51,.140,.134,.42,.46)\n sd.2 <- c(.28,.26,.23,.44,.49,.44,.39,.33,.58,.38,.51,.27,.26,.40,\n .49,.51,.140,.134,.142,.36)\n mod1 <- c(1,2,3,4,1,2,8,7,5,3,9,7,5,4,3,2,3,5,7,1)\n mod2 <- factor(c(rep(c(1,2,3,4),5)))\n dfs <- data.frame(id, n.1,m.1, sd.1, n.2, m.2, sd.2, mod1, mod2)\n # Example\n compute_dgs(n.1, m.1, sd.1, n.2, m.2, sd.2, data = dfs)\n compute_ds Computes Vector of Standardized Mean Differences\nDescription\n Adds d (standardized mean difference) to a data.frame. Required inputs are: n.1 (sample size of\n group one), m.1 (raw post-mean value of group one), sd.1 (standard deviation of group one), n.2\n (sample size of group two), m.2 (raw post-mean value of group two), sd.2 (standard deviation of\n group two).\nUsage\n compute_ds(n.1, m.1, sd.1 , n.2, m.2, sd.2 , data, denom = \"pooled.sd\")\nArguments\n n.1 sample size of group one.\n m.1 raw post-mean value of group one.\n sd.1 standard deviation of group one.\n n.2 sample size of group two.\n m.2 raw post-mean value of group two.\n sd.2 standard deviation of group two.\n data data.frame with values above.\n denom Value in the denominator to standardize the means by. pooled.sd will pool\n together both groups in deriving d. control.sd uses the standard deviation of\n group two (typically the control condition) to calculate d.\nValue\n d Standardized mean difference.\n var.d Variance of d.\n se.d Standard error of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n compute_ds, compute_dgs\nExamples\n id <- c(1:20)\n n.1 <- c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n m.1 <- c(.68,.56,.23,.64,.49,.4,1.49,.53,.58,1.18,.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,.66)\n m.2 <- c(.38,.36,.23,.34,.29,.4,1.9,.33,.28,1.1,.111,.27,.21,.140,.149,\n .51,.140,.134,.42,.16)\n sd.1 <- c(.28,.26,.23,.44,.49,.34,.39,.33,.58,.38,.31,.27,.26,.40,\n .49,.51,.140,.134,.42,.46)\n sd.2 <- c(.28,.26,.23,.44,.49,.44,.39,.33,.58,.38,.51,.27,.26,.40,\n .49,.51,.140,.134,.142,.36)\n mod1 <- c(1,2,3,4,1,2,8,7,5,3,9,7,5,4,3,2,3,5,7,1)\n mod2 <- factor(c(rep(c(1,2,3,4),5)))\n dfs <- data.frame(id, n.1,m.1, sd.1, n.2, m.2, sd.2, mod1, mod2)\n # Example\n compute_ds(n.1, m.1, sd.1, n.2, m.2, sd.2, data = dfs)\n compute_gs Converts Vector of Standardized Mean Differences\nDescription\n Adds g (unbiassed standardized mean difference) to a data.frame. Required inputs are: n.1 (sam-\n ple size of group one), sd.1 (standard deviation of group one), n.2 (sample size of group two).\nUsage\n compute_gs(d , var.d , n.1, n.2, data)\nArguments\n d Standardized mean difference (biased).\n var.d Variance of d.\n n.1 sample size of group one.\n n.2 sample size of group two.\n data data.frame with standardized mean difference, variance of d, sample size of\n group one, sample size of group two.\nValue\n g Unbiased standardized mean difference.\n var.g Variance of g.\n se.g Standard error of g.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n compute_ds, compute_dgs\nExamples\n id <- c(1:20)\n n.1 <- c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n m.1 <- c(.68,.56,.23,.64,.49,.4,1.49,.53,.58,1.18,.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,.66)\n m.2 <- c(.38,.36,.23,.34,.29,.4,1.9,.33,.28,1.1,.111,.27,.21,.140,.149,\n .51,.140,.134,.42,.16)\n sd.1 <- c(.28,.26,.23,.44,.49,.34,.39,.33,.58,.38,.31,.27,.26,.40,\n .49,.51,.140,.134,.42,.46)\n sd.2 <- c(.28,.26,.23,.44,.49,.44,.39,.33,.58,.38,.51,.27,.26,.40,\n .49,.51,.140,.134,.142,.36)\n mod1 <- c(1,2,3,4,1,2,8,7,5,3,9,7,5,4,3,2,3,5,7,1)\n mod2 <- factor(c(rep(c(1,2,3,4),5)))\n dfs <- data.frame(id, n.1,m.1, sd.1, n.2, m.2, sd.2, mod1, mod2)\n # Example\n # first compute d\n dfs2 <- compute_ds(n.1, m.1, sd.1, n.2, m.2, sd.2, data = dfs)\n # now, compute g\n compute_gs(d, var.d, n.1, n.2, dfs2)\n dat.cooper15.3 Data from Table 15.3 in The Handbook for Research Synthesis and\n Meta-Analysis (Cooper et al., 2009)\nDescription\n Data from Table 15.3 in The Handbook for Research Synthesis and Meta-Analysis (Cooper et al.,\n 2009)\n dat.cooperA2 Data from Table A2 in The Handbook for Research Synthesis and\n Meta-Analysis (Cooper et al., 2009)\nDescription\n Data from Table A2 in The Handbook for Research Synthesis and Meta-Analysis (Cooper et al.,\n 2009)\n dat.hoyt Subset of simulated data to demonstrate aggregation for dependent\n effect sizes\nDescription\n Subset of simulated data to demonstrate aggregation for dependent effect sizes. This data comes\n from: <NAME>., & <NAME>. (2013). Comparison of methods for aggregating dependent\n effect sizes in meta-analysis. Manuscript submitted for publication.\n dat.sim.es Subset of simulated psychotherapy treatment studies (k=8) with de-\n pendent effect sizes\nDescription\n This data set includes effect sizes for treatment vs control groups for a random subset of 8 simulated\n psychotherapy treatment studies (total population k = 1000). The known population standardized\n mean difference for outcome one is g = 0.50 and for outcome two g = 0.80. The data set also in-\n cludes two correlated study-level variables (i.e., moderators): treatment duration (dose) and average\n participant distress (stress).\n This data accompanies a tutorial for meta-analysis:\n <NAME>. (2015). A Practical Tutorial on Conducting Meta-Analysis in R. The Quantitative\n Methods for Psychology.\n dat.sim.final Final aggregated dataset of simulated psychotherapy treatment studies\n (k=8)\nDescription\n This data set includes aggregated effect sizes for treatment vs control groups for a random subset\n of 8 simulated psychotherapy treatment studies (total population k = 1000). The known population\n standardized mean difference for outcome one is g = 0.50 and for outcome two g = 0.80. The data\n set also includes two correlated study-level variables (i.e., moderators): treatment duration (dose)\n and average participant distress (stress).\n This data accompanies a tutorial for meta-analysis:\n <NAME>. (2015). A Practical Tutorial on Conducting Meta-Analysis in R. The Quantitative\n Methods for Psychology.\n dat.sim.raw Subset of simulated psychotherapy treatment studies (k=8) with means\n and SD\nDescription\n This data set includes means and standard deviations for treatment and control groups for a subset\n of k = 8 simulated psychotherapy treatment studies from a population of k = 1000 (see dat.sim1 and\n dat.sim2 for the k = 1000 studies for outcome 1 and 2, respectfully). Although effect sizes are not\n calculated in this dataset, the known population standardized mean difference for outcome one is\n d=0.50 and for outcome two g=0.80. The data set also includes two correlated study-level variables\n (i.e., moderators): treatment duration (dose) and average participant distress (stress).\n This data accompanies a tutorial for meta-analysis:\n <NAME>. (2015). A Practical Tutorial on Conducting Meta-Analysis in R. The Quantitative\n Methods for Psychology.\n dat.sim1 Simulated psychotherapy treatment studies for ’outcome one’\nDescription\n This data set includes 1000 simulated psychotherapy treatment studies. The population standardized\n mean difference for outcome one is d=0.50. The data set also includes two correlated study-level\n variables (i.e., moderators): treatment duration (dose) and average participant distress (stress).\n This data accompanies a tutorial for meta-analysis:\n <NAME>. (2015). A Practical Tutorial on Conducting Meta-Analysis in R. The Quantitative\n Methods for Psychology.\n dat.sim2 Simulated psychotherapy treatment studies for ’outcome two’\nDescription\n This data set includes 1000 simulated psychotherapy treatment studies. The population standardized\n mean difference for outcome two is d=0.80. The data set also includes two correlated study-level\n variables (i.e., moderators): treatment duration (dose) and average participant distress (stress).\n This data accompanies a tutorial for meta-analysis:\n <NAME>. (2015). A Practical Tutorial on Conducting Meta-Analysis in R. The Quantitative\n Methods for Psychology.\n d_to_g Standardized Mean Difference (d) Statistic to Unbiased Standardized\n Mean Difference (g)\nDescription\n Eliminates the small upward bias of d to provide an unbiased estimate of the population effect size\n parameter (g). This procedure will compute g for a single value of d.\nUsage\n d_to_g(d, var.d, n.1, n.2)\nArguments\n d Standardized mean difference statistic (d has a slight bias).\n var.d Variance of d.\n n.1 Sample size of treatment group.\n n.2 Sample size of comparison group.\nValue\n g Unbiased Standardized mean difference statistic.\n var.g Variance of g.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\n f.ancova_to_d ANCOVA F-statistic to Standardized Mean Difference (d)\nDescription\n Converts an ANCOVA F-statistic to d (standardized mean difference).\nUsage\n f.ancova_to_d(f, n.1, n.2, R, q)\nArguments\n f F-test value from ANCOVA.\n n.1 Treatment group sample size.\n n.2 Comparison group sample size.\n R Covariate outcome correlation or multiple correlation.\n q number of covariates.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n fail_to_d Failure groups to Standardized Mean Difference (d)\nDescription\n Converts number of ’failure’ groups reported in the primary study to standardized mean difference\n (d).\nUsage\n fail_to_d(B, D, n.1, n.0)\nArguments\n B Treatment failure.\n D Non-treatment failure.\n n.1 Treatment sample size.\n n.0 Control/comparison sample size.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n f_to_d F-test to Standardized Mean Difference (d)\nDescription\n Converts F-test value to standardized mean difference (d).\nUsage\n f_to_d(f, n.1, n.2)\nArguments\n f F-value reported in primary study.\n n.1 Sample size of treatment group.\n n.2 Sample size of comparison group.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n <NAME>. (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>.\n Valentine (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York:\n Russell Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_d1, r_from_t\n icc Intraclass correlation coefficient (ICC) for oneway and twoway mod-\n els\nDescription\n Computes single score or average score ICCs as an index of interrater reliability of quantitative\n data. Additionally, F-test and confidence interval are computed.\nUsage\n icc(ratings, model = c(\"oneway\", \"twoway\"),\n type = c(\"consistency\", \"agreement\"),\n unit = c(\"single\", \"average\"), r0 = 0, conf.level = 0.95)\nArguments\n ratings n*m matrix or dataframe, n subjects m raters.\n model a character string specifying if a oneway model (default) with row effects ran-\n dom, or a twoway model with column and row effects random should be applied.\n You can specify just the initial letter.\n type a character string specifying if ’\"consistency\"’ (default) or ’\"agreement\"’ be-\n tween raters should be estimated. If a ’\"oneway\"’ model is used, only ’\"consis-\n tency\"’ could be computed. You can specify just the initial letter.\n unit a character string specifying the unit of analysis: Must be one of single (de-\n fault) or average. You can specify just the initial letter.\n r0 specification of the null hypothesis r = r0. Note that a one sided test (H1: r > r0)\n is performed.\n conf.level confidence level of the interval.\nDetails\n This function was created by <NAME> for the irr package. For more details, see:\n http://rss.acs.unt.edu/Rdoc/library/irr/html/icc.html\n Details for the function:\n Missing data are omitted in a listwise way. When considering which form of ICC is appropriate for\n an actual set of data, one has take several decisions (Shrout & Fleiss, 1979):\n 1. Should only the subjects be considered as random effects (oneway model) or are subjects and\n raters randomly chosen from a bigger pool of persons (twoway model).\n 2. If differences in judges’ mean ratings are of interest, interrater agreement instead of consistency\n should be computed.\n 3. If the unit of analysis is a mean of several ratings, unit should be changed to average. In most\n cases, however, single values (unit = single) are regarded.\nValue\n A list with class icclist containing the following components:\n subjects the number of subjects examined.\n raters the number of raters.\n model a character string describing the selected model for the analysis.\n type a character string describing the selected type of interrater reliability.\n unit a character string describing the unit of analysis.\n icc.name a character string specifying the name of ICC according to McGraw & Wong\n (1996).\n value the intraclass correlation coefficient.\n r0 the specified null hypothesis.\n Fvalue the value of the F-statistic.\n df1 the numerator degrees of freedom.\n df2 the denominator degrees of freedom.\n p.value the p-value for a two-sided test.\n conf.level the confidence level for the interval.\n lbound the lower bound of the confidence interval.\n ubound the upper bound of the confidence interval.\nAuthor(s)\n <NAME>\nReferences\n <NAME>. (1966). The intraclass correlation coefficient as a measure of reliability. Psychological\n Reports, 19, 3-11.\n <NAME>., & <NAME>. (1996), Forming inferences about some intraclass correlation coeffi-\n cients. Psychological Methods, 1, 30-46.\n <NAME>., & <NAME>. (1979), Intraclass correlation: uses in assessing rater reliability. Psycho-\n logical Bulletin, 86, 420-428.\nExamples\n # sample data\n study <- c(1,1,2,2,3,3)\n rater <- c(rep(1:2,3))\n mod1 <- round(rnorm(6, 10, 1))\n mod2 <- c(5,5, 9, 9, 8, 8)\n mod3 <- c(10,10, 9, 9, 8, 8)\n w <-data.frame(study, rater, mod1, mod2, mod3)\n w\n # if data is in this format:\n # study rater mod1 mod2 mod3\n # 1 1 9 9 10\n # 1 2 11 8 10\n # 2 1 9 10 11\n # 2 2 9 10 11\n # 3 1 9 9 8\n # 3 2 12 9 8\n #\n # the data will need to be reshaped to be processed by the\n # icc function:\n long <- reshape(w, varying=colnames(w)[3:5], v.names=\"Code\",\n idvar=c('study', 'rater'), timevar=\"mods\", direction='long')\n wide <- reshape(long, idvar=c('mods', 'study'), timevar='rater')\n # icc function (created by <NAME> for the 'irr' package)\n icc(cbind(wide$Code.1, wide$Code.2), type= \"consistency\")\n Kappa Inter-Rater Agreement\nDescription\n Kappa coefficients for assessing inter-rater agreement between two coders (for categorical\n variables/moderators).\nUsage\n Kappa(rater1, rater2)\nArguments\n rater1 First rater of categorical variable to be analyzed. This vector needs to be in a\n separate column if in a data.frame.\n rater2 Second rater on same categorical variable to be analyzed. This vector needs to\n be in a separate column if in a data.frame.\nValue\n Kappa coefficients for inter-rater reliability (categorical variables).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nExamples\n # sample data\n study <- c(1,1,2,2,3,3) # study coded\n rater <- rep(1:2, 3) # 2 raters\n mod1 <- as.factor(round(rnorm(6, 10, 1))) # values coded for mod 1\n mod2 <- as.factor(round(rnorm(6, 10, 1)))\n mod3 <- as.factor(round(rnorm(6, 10, 1)))\n mod4 <- as.factor(round(rnorm(6, 10, 1)))\n mod5 <- as.factor(round(rnorm(6, 10, 1)))\n mod6 <- as.factor(round(rnorm(6, 10, 1)))\n w <-data.frame(study, rater,mod1, mod2, mod3, mod4, mod5, mod6)\n w\n # if data is in this format:\n # study rater mod1 mod2 mod3 mod4 mod5 mod6\n # 1 1 8 10 9 9 10 10\n # 1 2 10 11 10 10 13 12\n # 2 1 11 10 11 11 10 12\n # 2 2 13 10 10 11 12 9\n # 3 1 11 10 11 10 10 9\n # 3 2 10 10 11 9 10 11\n #\n # the data will need to be reshaped to be processed by the\n # Kappa function:\n long <- reshape(w, varying=colnames(w)[3:8], v.names=\"code\",\n idvar=c('study', 'rater'), timevar= 'mods', direction='long')\n wide <- reshape(long, idvar=c('mods', 'study'), timevar='rater')\n wide\n # running the function:\n Kappa(wide$code.1, wide$code.2)\n lor_to_d Log Odds Ratio to Standardized Mean Difference (d)\nDescription\n Converts a log odds ratio reported in the primary study to a standardized mean difference (d).\nUsage\n lor_to_d(lor, var.lor)\nArguments\n lor Log odds ratio reported in the primary study.\n var.lor Variance of the log odds ratio.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n macat Categorical Moderator Analysis\nDescription\n Computes single predictor categorical moderator analysis under a fixed or random effects model.\nUsage\n macat(g, var, mod, data, method= \"random\")\nArguments\n g Hedges g (unbiased estimate of d) effect size.\n var Vaiance of g.\n mod Categorical moderator variable used for moderator analysis.\n method Default is random. For fixed effects, use fixed.\n data data.frame with values above.\nDetails\n See Konstantopoulos & Hedges (2009; pp. 280-288) for the computations used in this function.\nValue\n mod Level of the categorical moderator.\n k Number of studies for each level of the moderator.\n estimate Mean effect size of each level of the moderator.\n ci.l Lower 95% confidence interval.\n ci.u Upper 95% confidence interval.\n z z-score (standardized value).\n p Significance level.\n var Variance of effect size.\n se Square root of variance.\n Q Q-statistic (measure of homogeneity).\n df Degrees of freedom for Q-statistic.\n p.h p-value for homogeneity within that level of the moderator.\n I2 Proportion of total variation in effect size that is due to heterogeneity rather than\n chance (see Shadish & Haddock, 2009; pp. 263).\n Q Q-statistic overall. Note: Whether fixed or random effects analyses are con-\n ducted, the Q statistic reported is for the fixed effect model. Therefore, Qb +\n Qw != Q in the random effects output.\n Qw Q-within (or error). Measure of within-group heterogeneity.\n Qw.df Degrees of freedom for Q-within.\n Qw.p Q-within p-value (for homogeneity).\n Qb Q-between (or model). Measure of model fit.\n Qb.df Degrees of freedom for Q-between.\n Qb.p Q-between p-value (for homogeneity). Qb and Qb.p provide the test of whether\n the moderator variable(s) account for significant variance among effect sizes.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Konstantopoulos & Hedges (2009). Analyzing effect sizes: Fixed-effects models. In <NAME>,\n <NAME>, & <NAME> (Eds.), The handbook of research synthesis and meta analysis (pp.\n 279-293). New York: Russell Sage Foundation.\n Shadish & Haddock (2009). Analyzing effect sizes: Fixed-effects models. In <NAME>, <NAME>, & <NAME> (Eds.), The handbook of research synthesis and meta analysis (pp. 257-\n 278). New York: Russell Sage Foundation.\nSee Also\n plotcat\nExamples\n id<-c(1:20)\n n.1<-c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n g <- c(.68,.56,.23,.64,.49,-.04,1.49,1.33,.58,1.18,-.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,1.16)\n var.g <- c(.08,.06,.03,.04,.09,.04,.009,.033,.0058,.018,.011,.027,.026,.0040,\n .049,.0051,.040,.034,.0042,.016)\n mod<-factor(c(rep(c(1,1,2,3),5)))\n df<-data.frame(id, n.1,n.2, g, var.g,mod)\n # Example\n # Random effects\n macat(g = g, var= var.g, mod = mod, data = df, method= \"random\")\n macatC Direct Categorical Moderator Comparison\nDescription\n Function for a planned comparison between two levels of a moderator under a fixed or random\n effects model.\nUsage\n macatC(x1, x2, g, var, mod, data, method= \"random\", type= \"post.hoc\")\nArguments\n x1 One level of categorical moderator.\n x2 Comparison level of same categorical moderator.\n g Hedges g (unbiased estimate of d) effect size.\n var Vaiance of g.\n mod Categorical moderator variable used for moderator analysis.\n method Default is random. For fixed effects, use fixed.\n type post.hoc assumes the comparison was not planned prior to conducting the meta\n analysis. The a priori option, planned, assumes the researcher planned to con-\n duct the analysis a priori. Default is post.hoc using the Scheffe post hoc statis-\n tical method.\n data data.frame with values above.\nDetails\n See Konstantopoulos & Hedges (2009; pp. 280-288) for the computations used in this function.\nValue\n diff Mean difference between the two levels.\n var.diff Variance of diff.\n p Significance level.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Konstantopoulos & Hedges (2009). Analyzing effect sizes: Fixed-effects models. In H. Cooper,\n L. V. Hedges, & <NAME> (Eds.), The handbook of research synthesis and meta analysis (pp.\n 279-293). New York: Russell Sage Foundation.\n Shadish & Haddock (2009). Analyzing effect sizes: Fixed-effects models. In <NAME>, <NAME>.\n Hedges, & <NAME> (Eds.), The handbook of research synthesis and meta analysis (pp. 257-\n 278). New York: Russell Sage Foundation.\nSee Also\n macat,\nExamples\n id<-c(1:20)\n n.1<-c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n g <- c(.68,.56,.23,.64,.49,-.04,1.49,1.33,.58,1.18,-.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,1.16)\n var.g <- c(.08,.06,.03,.04,.09,.04,.009,.033,.0058,.018,.011,.027,.026,.0040,\n .049,.0051,.040,.034,.0042,.016)\n mod<-factor(c(rep(c(1,1,2,3),5)))\n df<-data.frame(id, n.1,n.2, g, var.g,mod)\n # Example\n macatC(1, 2, g=g, var=var.g, mod=mod, data=df, method= \"random\",\n type= \"post.hoc\")\n mareg Meta-Regression\nDescription\n Meta-regression function for a single or multiple predictor model. This function is a wrapper for\n the rma() function in the metafor package (Viechtbauer, W, 2010). Please see http://CRAN.R-\n project.org/package=metafor for details or for more advanced functionality with the rma() function.\nUsage\n mareg(formula, var, data, method = \"REML\", subset, digits = 3, ...)\nArguments\n formula This is a formula based function, similar to other functions in R (e.g., lm), where\n the criterion variable (e.g., Hedges g in this case) is dependent on (’~’) the pre-\n dictor variables (e.g., moderators). The formula for two moderators would take\n this form: mareg(g ~ mod1 + mod2, var.g, data), where g is the criterion variable\n predicted by mod1 and mod2. The variance (var) of each g is var.g in this case.\n var Variance of g.\n data Aggregated data.frame (see agg function for setting up the dataset for these\n analyses) with id, g (unbiased standardized mean difference), var.g (variance of\n g) for each study.\n method Default is REML (Restricted-Maximal Likelihood), which is the standard random\n effects method. For fixed effects, use FE. Other options are specified in the\n metafor package manual (’rma’ function).\n subset an optional vector specifying a subset of observations to be used in the fitting\n process.\n digits Number of digits to output. Default is 3.\n ... Additional arguments to be passed to rma().\nDetails\n See <NAME> (2010). metafor: Meta-Analysis Package for R. R package version 1.1-0.\n for the details of the rma() function. http://CRAN.R-project.org/package=metafor\nValue\n estimate Meta-regression coefficient estimate.\n se Standard error of the estimate coefficient.\n z z-value.\n ci.l Lower 95% confidence interval.\n ci.u Upper 95% confidence interval.\n p p-value (significance level).\n QE Q-error. Measure of error in the model.\n QE.df Degrees of freedom for Q-error.\n QEp Q-error p-value (for homogeneity).\n QM Q-model. Measure of model fit.\n QM.df Degrees of freedom for Q-model.\n QMp Q-between p-value (for homogeneity). QM and QMp provide the test of whether\n the moderator variable(s) account for significant variance among effect sizes.\nReferences\n <NAME> (2010). metafor: Meta-Analysis Package for R. R package version 1.1-0.\n http://CRAN.R-project.org/package=metafor\nSee Also\n plotcon\nExamples\n # install metafor\n # install.packages('metafor', dependencies = TRUE)\n # Sample data\n data(dat.sim.final)\n # Examples\n # OMNIBUS\n m0 <- mareg(es~1, var=var, data=dat.sim.final)\n summary(m0)\n # META-REGRESSION\n m1 <- mareg(es~dose, var=var, data=dat.sim.final)\n summary(m1) # SINGLE MODERATOR\n m2 <- mareg(es~stress, var=var, data=dat.sim.final)\n summary(m2) # SINGLE MODERATOR\n m3 <- mareg(es~dose + stress, var=var, data=dat.sim.final)\n summary(m3) # MULTIPLE MODERATOR\n mean_to_d Means to Standardized Mean Difference\nDescription\n Converts raw mean scores reported in the primary study to a standardized mean difference (d).\nUsage\n mean_to_d(m.1, m.2, sd.1, sd.2, n.1, n.2)\nArguments\n m.1 Mean of group one.\n m.2 Mean of group two.\n sd.1 Standard deviation of group one.\n sd.2 Standard deviation of group two.\n n.1 Sample size of group one.\n n.2 Sample size of group two.\nValue\n d Standardized mean difference (d).\n var.d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2, tt.ancova_to_d,\n f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n mean_to_d2 Means with Pooled SD to Standardized Mean Difference\nDescription\n Converts raw mean scores with pooled standard deviation from the primary study to a standardized\n mean difference (d).\nUsage\n mean_to_d2(m.1, m.2, s.pooled, n.1, n.2)\nArguments\n m.1 Mean of group one.\n m.2 Mean of group two.\n s.pooled Pooled standard deviation.\n n.1 Sample size of group one.\n n.2 Sample size of group two.\nValue\n d Standardized mean difference (d).\n var.d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2, tt.ancova_to_d,\n f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n or_to_d Odds Ratio to Standardized Mean Difference (d)\nDescription\n Converts odds ratio reported in the primary study to standardized mean difference (d).\nUsage\n or_to_d(or)\nArguments\n or Odds ratio.\nValue\n d Standardized mean difference (d).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n p.ancova_to_d1 One-tailed p-value from ANCOVA to Standardized Mean Difference\n (d)\nDescription\n Converts a one-tailed p-value from ANCOVA reported in the primary study to a standardized mean\n difference (d)\nUsage\n p.ancova_to_d1(p, n.1, n.2, R, q)\nArguments\n p One-tailed p-value reported in primary study.\n n.1 Treatment group sample size.\n n.2 Comparison group sample size.\n R Covariate outcome correlation or multiple correlation.\n q number of covariates.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n p.ancova_to_d2 Two-tailed p-value from ANCOVA to Standardized Mean Difference\n (d)\nDescription\n Converts a two-tailed p-value from ANCOVA reported in the primary study to a standardized mean\n difference (d)\nUsage\n p.ancova_to_d2(p, n.1, n.2, R, q)\nArguments\n p Two-tailed p-value reported in primary study.\n n.1 Treatment group sample size.\n n.2 Comparison group sample size.\n R Covariate outcome correlation or multiple correlation.\n q number of covariates.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2, tt.ancova_to_d,\n f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n plotcat Categorical Moderator Graph\nDescription\n Outputs boxplot graphic for each level of the specified moderator.\nUsage\n plotcat(g, var, mod, data, modname=NULL, title=NULL, ...)\nArguments\n g Hedges g (unbiased estimate of d) effect size.\n var Vaiance of g.\n mod Categorical moderator variable used for moderator analysis.\n data data.frame with values above.\n modname Name of moderator to appear on x axis of plot. Default is NULL.\n title Plot title. Default is NULL.\n ... Additional arguments to be passed to ggplot.\nValue\n Boxplot graph with median, max, min, and outliers from a fixed or random effects categorical\n moderator analysis. Places jitter points (for each study) on the boxplots. The size of each point\n (representing a study in the analysis) are based on study weights where more precise studies have\n larger points. The ggplot2 package outputs the graphics.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n <NAME>., <NAME>., & <NAME>. (2009). The handbook of research synthesis and meta-\n analysis (2nd edition). New York: Russell Sage Foundation.\nSee Also\n macat, plotcon\nExamples\n id<-c(1, 1:19)\n n.1<-c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n g <- c(.68,.56,.23,.64,.49,-.04,1.49,1.33,.58,1.18,-.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,1.16)\n var.g <- c(.08,.06,.03,.04,.09,.04,.009,.033,.0058,.018,.011,.027,.026,.0040,\n .049,.0051,.040,.034,.0042,.016)\n mod<-factor(c(rep(c(1,1,2,3),5)))\n df<-data.frame(id, n.1,n.2, g, var.g,mod)\n # Example\n ## Not run: plotcat(g = g, var = var.g, mod = mod, data = df, method= \"random\",\n modname= \"Moderator\")\n ## End(Not run)\n plotcon Meta Regression Scatterplot\nDescription\n Outputs a scatterplot from a fixed or random effects meta regression (continuous and/or categorical).\nUsage\n plotcon(g, var, mod, data, method= \"random\", modname=NULL,\n title=NULL, ...)\nArguments\n g Hedges g (unbiased estimate of d) effect size.\n var Vaiance of g.\n mod Categorical moderator variable used for moderator analysis.\n method Default is random (Restricted-Maximal Likelihood), which is the standard ran-\n dom effects method. For fixed effects, use fixed.\n data data.frame with values above.\n modname Name of moderator to appear on x axis of plot. Default is NULL.\n title Plot title. Default is NULL.\n ... Additional arguments to be passed to ggplot.\nValue\n Scatterplot with fixed or random effects regression line with size of visual points based on study\n weights, where the more precise studies have larger points. The ggplot2 package outputs the rich\n graphics.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n <NAME>., <NAME>., & <NAME>. (2009). The handbook of research synthesis and meta\n analysis (2nd edition). New York: Russell Sage Foundation.\nSee Also\n mareg, plotcat\nExamples\n # SAMPLE DATA\n MA2 <-read.table(textConnection(\"\n id es1 var1 n.1 n.2 mod1 mod2\n 1 1 0.5695938 0.04906967 26 30 a 20\n 2 2 0.4123667 0.04362541 28 34 b 30\n 3 3 0.4084333 0.04458363 34 28 a 25\n 4 4 0.5014756 0.04186354 37 29 b 35\n 5 5 0.5540745 0.04339382 31 32 b 40\n 6 1 0.5695938 0.04906967 26 30 a 20\n 7 2 0.4123667 0.04362541 28 34 b 30\n 8 3 0.4084333 0.04458363 34 28 a 25\n 9 4 0.5014756 0.04186354 37 29 b 35\n 10 5 0.5540745 0.04339382 31 32 b 40\"))\n # EXAMPLE\n plotcon(es1, var1, mod2, data=MA2, method= \"fixed\", modname=\"NULL\",title=\"NULL\")\n PubBias Assess for Publication Bias\nDescription\n Assess for publication bias in the meta-analytic data\nUsage\n PubBias(data)\nArguments\n data data.frame having been analyzed by the weights function with id and z.score\n (standardized z-value).\nValue\n k Number of studies.\n Z Overall z-value for data set.\n k0 Number of studies needed to include with effect size = 0 (null) in order for the\n p > .05 (null hypothesis retained).\n k.per Number of missing studies for every observed study for the overall effect to be\n nullified.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Sutton, A. J. (2009). Publication bias. In <NAME>, <NAME>, & <NAME> (Eds.),\n The handbook of research synthesis and meta analysis (pp. 435-452). New York: Russell Sage\n Foundation.\nSee Also\n weights\n p_to_d1 One-tailed p-value to Standardized Mean Difference (d)\nDescription\n One-tailed p-value reported in the primary study to Standardized Mean Difference (d)\nUsage\n p_to_d1(p, n.1, n.2)\nArguments\n p One-tailed p-value reported in primary study.\n n.1 Sample size of treatment group.\n n.2 Sample size of comparison group.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d2, ancova_to_d1, ancova_to_d2, tt.ancova_to_d,\n f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n p_to_d2 Two-tailed p-value to Standardized Mean Difference (d)\nDescription\n One-tailed p-value reported in primary study to Standardized Mean Difference (d)\nUsage\n p_to_d2(p, n.1, n.2)\nArguments\n p Two-tailed p-value reported in primary study.\n n.1 Sample size of treatment group.\n n.2 Sample size of comparison group.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, ancova_to_d1, ancova_to_d2, tt.ancova_to_d,\n f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n robustSE Robust standard error\nDescription\n When the correlation between dependent effect sizes are unknown, one approach is to conduct the\n meta-analysis by assuming that the effect sizes are independent. Then, Hedges et al. (2010) robust\n standard error procedure can be calculated to adjust for dependence.\nUsage\n robustSE(model, cluster=NULL, CI=.95, digits=3)\nArguments\n model omnibus or moderator model object fitted from mareg() function.\n cluster Name of variable where the dependencies are present. This will typically be the\n variable for study id where length(unique(study_id))>1.\n CI Confidence interval. Defaults to .95.\n digits Number of digits to output. Defaults to 3.\nValue\n estimate Meta-regression coefficient estimate.\n se Adjusted Standard error of the estimate coefficient.\n t t-value.\n ci.l Adjusted Lower 95% confidence interval.\n ci.u Adjusted Upper 95% confidence interval.\n p p-value.\nAuthor(s)\n <NAME> with modifications by AC Del Re\nReferences\n <NAME>., <NAME>., & <NAME>. (2010). Robust variance estimation in meta-regression\n with dependent effect size estimates. Research Synthesis Methods, 1(1), 39-65. doi:10.1002/jrsm.5\n <NAME>. (2012). metaSEM: An R package for meta-analysis using structural equation\n modeling. Manuscript submitted for publication.\nSee Also\n mareg,\nExamples\n # install metafor\n # install.packages('metafor', dependencies = TRUE)\n # Sample data\n id<-c(1:20)\n n.1<-c(10,20,13,22,28,12,12,36,19,12,36,75,33,121,37,14,40,16,14,20)\n n.2 <- c(11,22,10,20,25,12,12,36,19,11,34,75,33,120,37,14,40,16,10,21)\n g <- c(.68,.56,.23,.64,.49,-.04,1.49,1.33,.58,1.18,-.11,1.27,.26,.40,.49,\n .51,.40,.34,.42,1.16)\n var.g <- c(.08,.06,.03,.04,.09,.04,.009,.033,.0058,.018,.011,.027,.026,.0040,\n .049,.0051,.040,.034,.0042,.016)\n mod<-factor(c(rep(c(1,1,2,3),5)))\n mods2<-c(rep(1:5,4))\n df<-data.frame(id, n.1,n.2, g, var.g,mod, mods2)\n # Examples\n # Adjusted SE\n robustSE(mareg(g~ mod + mods2, var = var.g, method = \"REML\", data = df))\n r_from_chi Chi-Squared to Correlation\nDescription\n Converting Chi-squared statistic (with 1 degree of freedom) reported in primary study to r\nUsage\n r_from_chi(chi.sq, n)\nArguments\n chi.sq Chi squared statistic from primary study.\n n Sample size in primary study.\nValue\n Computes correlation coefficient (r).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_d, r_from_d1, r_from_t\n r_from_d Correlation from Mean Difference\nDescription\n Converts d (mean difference) to r where n.tmt = n.comparison (see section 12.5.4, Borenstein, 2009;\n pp. 234).\nUsage\n r_from_d(d, var.d, a = 4)\nArguments\n d Mean difference statistic (d) reported in primary study.\n var.d Variance of d reported in primary study.\n a Used to compute correlation. Default is 4.\nValue\n Outputs a correlation coefficient (r).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In H. Cooper, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d1, r_from_t\n r_from_d1 Correlation from Mean Difference II\nDescription\n Converts d (mean difference) reported in primary study to r (correlation coefficient) where sample\n size of the treatment group is not equal to the sample size of the comparison group (see section\n 12.5.4, Borenstein, 2009; pp. 234).\nUsage\n r_from_d1(d, n.1, n.2, var.d)\nArguments\n d Mean difference statistic (d) reported in primary study.\n n.1 sample size of group one reported in primary study.\n n.2 sample size of group two reported in primary study.\n var.d variance of d reported in primary study.\nValue\n Computes a correlation coefficient (r).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_t\n r_from_t Correlation from t-test\nDescription\n Compute correlation from t-value reported in the primary study (see section 12.5.4, Borenstein,\n 2009; pp. 234).\nUsage\n r_from_t(t, n)\nArguments\n t t-statistic value reported in primary study.\n n Sample size reported in primary study.\nValue\n Outputs the correlation coefficient (r).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_d1,\n r_to_d Correlation (r) to Standardized Mean Difference (d)\nDescription\n Converts a correlation (r) to standardized mean difference (d).\nUsage\n r_to_d(r, N)\nArguments\n r Correlation coefficient.\n N Total sample size.\nValue\n d Standardized mean difference (d).\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_d1, r_from_t\n tt.ancova_to_d t-test Value from ANCOVA to Standardized Mean Difference (d)\nDescription\n Converts a t-test value from ANCOVA to a standardized mean difference (d)\nUsage\n tt.ancova_to_d(t, n.1, n.2, R, q)\nArguments\n t t-test value reported in primary study.\n n.1 Treatment group sample size.\n n.2 Comparison group sample size.\n R Covariate outcome correlation or multiple correlation.\n q number of covariates.\nValue\n d Standardized mean difference (d)\n var_d Variance of d\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, t_to_d, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or, prop_to_d,\n r_from_chi, r_from_d, r_from_d1, r_from_t\n t_to_d t-test Value to Standardized Mean Difference (d)\nDescription\n Converts a t-test value reported in the primary study to a standardized mean difference (d).\nUsage\n t_to_d(t, n.1, n.2)\nArguments\n t t-test value reported in primary study.\n n.1 Sample size of treatment group.\n n.2 Sample size of comparison group.\nValue\n d Standardized mean difference (d).\n var_d Variance of d.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>\nReferences\n Borenstein (2009). Effect sizes for continuous data. In <NAME>, <NAME>, & <NAME>\n (Eds.), The handbook of research synthesis and meta analysis (pp. 279-293). New York: Russell\n Sage Foundation.\nSee Also\n d_to_g, mean_to_d, mean_to_d2, f_to_d, p_to_d1, p_to_d2, ancova_to_d1, ancova_to_d2,\n tt.ancova_to_d, f.ancova_to_d, r_to_d, p.ancova_to_d1, p.ancova_to_d2, lor_to_d, prop_to_or,\n prop_to_d, r_from_chi, r_from_d, r_from_d1, r_from_t\n wgts Weights added to Meta Data\nDescription\n Adds weights to the meta-analysis data set.\nUsage\n wgts(g, var.g, data)\nArguments\n g Hedges g (unbiased standardized mean difference estimate).\n var.g Variance of g.\n data data.frame with values above.\nValue\n Adds fixed and random-effects weights and confidence intervals to meta data set.\nAuthor(s)\n <NAME> & <NAME>\n Maintainer: <NAME> <<EMAIL>>"}}},{"rowIdx":589,"cells":{"project":{"kind":"string","value":"@clack/prompts"},"source":{"kind":"string","value":"npm"},"language":{"kind":"string","value":"JavaScript"},"content":{"kind":"string","value":"`@clack/prompts`\n===\n\nEffortlessly build beautiful command-line apps 🪄 [Try the demo](https://stackblitz.com/edit/clack-prompts?file=index.js)\n\n---\n\n`@clack/prompts` is an opinionated, pre-styled wrapper around [`@clack/core`](https://www.npmjs.com/package/@clack/core).\n\n* 🤏 80% smaller than other options\n* 💎 Beautiful, minimal UI\n* ✅ Simple API\n* 🧱 Comes with `text`, `confirm`, `select`, `multiselect`, and `spinner` components\n\nBasics\n---\n\n### Setup\n\nThe `intro` and `outro` functions will print a message to begin or end a prompt session, respectively.\n```\nimport { intro, outro } from '@clack/prompts';\n\nintro(`create-my-app`);\n// Do stuff outro(`You're all set!`);\n```\n### Cancellation\n\nThe `isCancel` function is a guard that detects when a user cancels a question with `CTRL + C`. You should handle this situation for each prompt, optionally providing a nice cancellation message with the `cancel` utility.\n```\nimport { isCancel, cancel, text } from '@clack/prompts';\n\nconst value = await text(/* TODO */);\n\nif (isCancel(value)) {\n cancel('Operation cancelled.');\n process.exit(0);\n}\n```\nComponents\n---\n\n### Text\n\nThe text component accepts a single line of text.\n```\nimport { text } from '@clack/prompts';\n\nconst meaning = await text({\n message: 'What is the meaning of life?',\n placeholder: 'Not sure',\n initialValue: '42',\n validate(value) {\n if (value.length === 0) return `Value is required!`;\n },\n});\n```\n### Confirm\n\nThe confirm component accepts a yes or no answer. The result is a boolean value of `true` or `false`.\n```\nimport { confirm } from '@clack/prompts';\n\nconst shouldContinue = await confirm({\n message: 'Do you want to continue?',\n});\n```\n### Select\n\nThe select component allows a user to choose one value from a list of options. The result is the `value` prop of a given option.\n```\nimport { select } from '@clack/prompts';\n\nconst projectType = await select({\n message: 'Pick a project type.',\n options: [\n { value: 'ts', label: 'TypeScript' },\n { value: 'js', label: 'JavaScript' },\n { value: 'coffee', label: 'CoffeeScript', hint: 'oh no' },\n ],\n});\n```\n### Multi-Select\n\nThe `multiselect` component allows a user to choose many values from a list of options. The result is an array with all selected `value` props.\n```\nimport { multiselect } from '@clack/prompts';\n\nconst additionalTools = await multiselect({\n message: 'Select additional tools.',\n options: [\n { value: 'eslint', label: 'ESLint', hint: 'recommended' },\n { value: 'prettier', label: 'Prettier' },\n { value: 'gh-action', label: 'GitHub Action' },\n ],\n required: false,\n});\n```\n### Spinner\n\nThe spinner component surfaces a pending action, such as a long-running download or dependency installation.\n```\nimport { spinner } from '@clack/prompts';\n\nconst s = spinner();\ns.start('Installing via npm');\n// Do installation s.stop('Installed via npm');\n```\nUtilities\n---\n\n### Grouping\n\nGrouping prompts together is a great way to keep your code organized. This accepts a JSON object with a name that can be used to reference the group later. The second argument is an optional but has a `onCancel` callback that will be called if the user cancels one of the prompts in the group.\n```\nimport * as p from '@clack/prompts';\n\nconst group = await p.group(\n {\n name: () => p.text({ message: 'What is your name?' }),\n age: () => p.text({ message: 'What is your age?' }),\n color: ({ results }) =>\n p.multiselect({\n message: `What is your favorite color ${results.name}?`,\n options: [\n { value: 'red', label: 'Red' },\n { value: 'green', label: 'Green' },\n { value: 'blue', label: 'Blue' },\n ],\n }),\n },\n {\n // On Cancel callback that wraps the group\n // So if the user cancels one of the prompts in the group this function will be called\n onCancel: ({ results }) => {\n p.cancel('Operation cancelled.');\n process.exit(0);\n },\n }\n);\n\nconsole.log(group.name, group.age, group.color);\n```\nReadme\n---\n\n### Keywords\n\n* ask\n* clack\n* cli\n* command-line\n* command\n* input\n* interact\n* interface\n* menu\n* prompt\n* prompts\n* stdin\n* ui"}}},{"rowIdx":590,"cells":{"project":{"kind":"string","value":"doRedis"},"source":{"kind":"string","value":"cran"},"language":{"kind":"string","value":"R"},"content":{"kind":"string","value":"Package ‘doRedis’\n May 2, 2023\nType Package\nTitle 'Foreach' Parallel Adapter Using the 'Redis' Database\nVersion 3.0.2\nDate 2023-5-1\nAuthor <NAME> <<EMAIL>>\nMaintainer <NAME> <<EMAIL>>\nDescription Create and manage fault-\n tolerant task queues for the 'foreach' package using the 'Redis' key/value database.\nBugReports https://github.com/bwlewis/doRedis/issues\nDepends R (>= 3.0), foreach(>= 1.3.0), iterators(>= 1.0.0), utils\nImports redux, stats\nLicense GPL-2\nLazyLoad yes\nRoxygenNote 7.1.1\nNeedsCompilation yes\nRepository CRAN\nDate/Publication 2023-05-02 11:30:03 UTC\nR topics documented:\ndoRedis-packag... 2\n.doRedi... 2\njob... 3\nlogge... 3\nredisConnec... 4\nredisDelet... 4\nredisGe... 5\nredisSe... 5\nredisWorke... 6\nregisterDoRedi... 7\nremoveJo... 9\nremoveQueu... 9\nsetChunkSiz... 10\nsetExpor... 11\nsetFtinterva... 12\nsetPackage... 12\nsetProgres... 13\nstartLocalWorker... 13\ntask... 15\n doRedis-package A Redis parallel back end for foreach.\nDescription\n The doRedis package imlpements an elastic parallel back end for foreach using the Redis key/value\n database.\nSee Also\n registerDoRedis, startLocalWorkers\n .doRedis internal function called by foreach\nDescription\n internal function called by foreach\nUsage\n .doRedis(obj, expr, envir, data)\nArguments\n obj a foreach object\n expr the expression to evaluate\n envir the expression environment\n data a list of parameters from registerDoRedis\nValue\n the foreach result\n jobs List doRedis jobs\nDescription\n List doRedis jobs\nUsage\n jobs(queue = \"*\")\nArguments\n queue List jobs for the specified queue, or set to \"*\" to list jobs for all queues\nValue\n a data frame listing jobs by row with variables queue, id, user, host and time (submitted).\n logger Print a timestamped message to the standard error stream.\nDescription\n Use to help debug remote doRedis workers.\nUsage\n logger(msg)\nArguments\n msg a character message to print to the standard error stream\nValue\n The character message that was printed, decorated with time and system info.\n redisConnect Explicitly connect to a Redis server.\nDescription\n This function is normally not needed, use the redux package functions instead, or simply register-\n DoRedis.\nUsage\n redisConnect(host = \"localhost\", port = 6379L, password, ...)\nArguments\n host character Redis host name\n port integer Redis port number\n password optional character Redis password\n ... optional additional arguments for compatability with old rredis, ignored\nSee Also\n registerDoRedis, redisWorker, startLocalWorkers\n redisDelete A convenience function to delete a Redis key\nDescription\n A convenience function to delete a Redis key\nUsage\n redisDelete(key)\nArguments\n key (character or raw) Redis key name to delete\nValue\n Redis status message\nSee Also\n hiredis\n redisGet A convenience function to return an R value from a Redis key.\nDescription\n This function assumes the value associated with the Redis key is a serialized (binary) R value and\n unserializes it on return.\nUsage\n redisGet(key)\nArguments\n key (character or raw) Redis key name\nValue\n Unserialized R value.\nSee Also\n hiredis\n redisSet A convenience function to set an R value in a Redis key\nDescription\n This function serializes the val argument.\nUsage\n redisSet(key, val)\nArguments\n key (character or raw) Redis key name\n val R value to set\nValue\n Redis status message\nSee Also\n hiredis\n redisWorker Initialize a doRedis worker process.\nDescription\n The redisWorker function enrolls the current R session in one or more doRedis worker pools speci-\n fied by the work queue names. The worker loop takes over the R session until the work queue(s) are\n deleted, after which the worker loop exits after the linger period, or until the worker has processed\n iter tasks. Running workers also terminate after network activity with Redis remains inactive for\n longer than the timeout period set in the redisConnect function. That value defaults internally to\n 30 seconds in redisWorker. You can increase it by including a timeout=n argument value.\nUsage\n redisWorker(\n queue,\n host = \"localhost\",\n port = 6379,\n iter = Inf,\n linger = 30,\n log = stderr(),\n connected = FALSE,\n password = NULL,\n loglevel = 0,\n timelimit = 0,\n ...\n )\nArguments\n queue work queue name or a vector of queue names\n host Redis database host name or IP address\n port Redis database port number\n iter maximum number of tasks to process before exiting the worker loop\n linger timeout in seconds after which the work queue is deleted that the worker termi-\n nates\n log print messages to the specified file connection\n connected set to TRUE to reuse an existing open connection to Redis, otherwise establish a\n new one\n password optional Redis database password\n loglevel set to > 0 to increase verbosity in the log\n timelimit set to > 0 to specify a task time limit in seconds, after which worker processes\n are killed; beware that setting this value > 0 will terminate any R worker process\n if their task takes too long.\n ... Optional additional parameters passed to redisConnect\nValue\n NULL is invisibly returned.\nNote\n The worker connection to Redis uses a TCP timeout value of 30 seconds by default. That means\n that the worker will exit after about 30 seconds of inactivity. If you want the worker to remain active\n for longer periods, set the timeout option to a larger value.\n Use the linger option to instruct the worker to linger for up to the indicated number of seconds\n after the listening work queue has been removed. After at most that interval, the worker will exit\n after removing the queue.\nSee Also\n registerDoRedis, startLocalWorkers\n registerDoRedis Register the Redis back end for foreach.\nDescription\n The doRedis package imlpements a simple but flexible parallel back end for foreach that uses Redis\n for inter-process communication. The work queue name specifies the base name of a small set of\n Redis keys that the coordinator and worker processes use to exchange data.\nUsage\n registerDoRedis(\n queue,\n host = \"localhost\",\n port = 6379,\n password,\n ftinterval = 30,\n chunkSize = 1,\n progress = FALSE,\n ...\n )\nArguments\n queue A work queue name\n host The Redis server host name or IP address\n port The Redis server port number\n password An optional Redis database password\n ftinterval Default fault tolerance interval in seconds\n chunkSize Default iteration granularity, see setChunkSize\n progress (logical) Show progress bar for computations?\n ... Optional arguments passed to redisConnect\nDetails\n Back-end worker R processes advertise their availablility for work with the redisWorker function.\n The doRedis parallel back end tolerates faults among the worker processes and automatically re-\n submits failed tasks. It is also portable and supports heterogeneous sets of workers, even across\n operative systems. The back end supports dynamic pools of worker processes. New workers may\n be added to work queues at any time and can be used by running foreach computations.\nValue\n NULL is invisibly returned; this function is called for side effect of registering a foreach backend.\nNote\n All doRedis functions require access to a Redis database server (not included with this package).\n Worker processes default to same random number generator as the coordinator process by default\n with seeds set per iteration rather than per worker to yield reproducible output independent of\n the number of worker processes. The L’Ecuyer-CMRG RNG available from the parallel package\n is recommended when high-quality distributed pseudorandom numbers are needed. See package\n vignette for more details and additional options.\n Avoid using fork-based parallel functions within doRedis expressions. Use of mclapply and similar\n functions in the body of a doRedis foreach loop can result in worker faults.\nSee Also\n foreach, doRedis-package, setChunkSize, removeQueue\nExamples\n # Only run if a Redis server is running\n if (redux::redis_available()) {\n ## The example assumes that a Redis server is running on the local host\n ## and standard port.\n # 1. Start a single local R worker process\n startLocalWorkers(n=1, queue=\"jobs\", linger=1)\n # 2. Run a simple sampling approximation of pi:\n registerDoRedis(\"jobs\")\n pie = foreach(j=1:10, .combine=sum, .multicombine=TRUE) %dopar%\n 4 * sum((runif(1000000) ^ 2 + runif(1000000) ^ 2) < 1) / 10000000\n removeQueue(\"jobs\")\n print(pie)\n # Note that removing the work queue automatically terminates worker processes.\n }\n removeJob Remove Redis keys associated with one or more doRedis jobs\nDescription\n Remove Redis keys associated with one or more doRedis jobs\nUsage\n removeJob(job)\nArguments\n job Either a named character vector with \"queue\" and \"id\" entries corresponding to\n a doRedis job queue and job id, or a list with equal-length \"queue\" and \"id\"\n entries, or a data frame with \"queue\" and \"id\" entries, for example as returned\n by jobs.\nValue\n NULL is invisibly returned; this function is used for its side effect–in particular, removing all Redis\n keys associated with the specified job.\n removeQueue Remove a doRedis queue and delete all associated keys from Redis.\nDescription\n Removing a doRedis queue cleans up associated keys in the Redis database and signals to workers\n listening on the queue to terminate. Workers terminate after their timeout period after their work\n queue is deleted.\nUsage\n removeQueue(queue)\nArguments\n queue the doRedis queue name\nValue\n NULL is invisibly returned; this function is called for the side effect of removing Redis keys associ-\n ated with the specified queue.\nNote\n Workers listening for work on more than one queue will only terminate after all their queues have\n been deleted. See registerDoRedis for an example.\n setChunkSize Set the default granularity of distributed tasks.\nDescription\n A job is the collection of all tasks in a foreach loop. A task is a collection of loop iterations of at\n most size chunkSize. R workers are assigned work by task in blocks of at most chunkSize loop\n iterations per task. The default value is one iteration per task. Setting the default chunk size larger\n for shorter-running jobs can substantially improve performance. Setting this value too high can\n negatively impact load-balancing across workers, however.\nUsage\n setChunkSize(value = 1)\nArguments\n value positive integer chunk size setting\nValue\n value is invisibly returned; this value is called for its side effect.\nExamples\n # Only run if a Redis server is running\n if (redux::redis_available()) {\n # Start a single local R worker process\n startLocalWorkers(n=1, queue=\"jobs\", linger=1)\n # Register the work queue with the coordinator R process\n registerDoRedis(\"jobs\")\n # Compare verbose task submission output from...\n setChunkSize(1)\n foreach(j=1:4, .combine=c, .verbose=TRUE) %dopar% j\n # with the verbose task submission output from:\n setChunkSize(2)\n foreach(j=1:4, .combine=c, .verbose=TRUE) %dopar% j\n # Clean up\n removeQueue(\"jobs\")\n }\n setExport Manually add symbol names to the worker environment export list.\nDescription\n The setExport function lets users manually declare symbol names of corresponding objects that\n should be exported to workers.\nUsage\n setExport(names = c())\nArguments\n names A character vector of symbol names to export.\nDetails\n The foreach function includes a similar .export parameter.\n We provide this supplemental export option for users without direct access to the foreach function,\n for example, when foreach is used inside another package.\nValue\n The value of names is invisibly returned (this function is used ofr its side effect).\nExamples\n ## Not run:\n registerDoRedis(\"work queue\")\n startLocalWorkers(n=1, queue=\"work queue\", linger=1)\n f <- function() pi\n (foreach(1) %dopar% tryCatch(eval(call(\"f\")), error = as.character))\n # Returns the error converted to a message:\n # Error in eval(call(\"f\")) : task 1 failed - could not find function \"f\"\n # Manually export the symbol f:\n setExport(\"f\")\n (foreach(1) %dopar% eval(call(\"f\")))\n # Now f is found.\n removeQueue(\"work queue\")\n ## End(Not run)\n setFtinterval Set the fault tolerance check interval in seconds.\nDescription\n Failed tasks are automatically re-submitted to the work queue. The setFtinterval sets an upper\n bound on how frequently the system checks for failure. See the package vignette for discussion and\n examples.\nUsage\n setFtinterval(value = 30)\nArguments\n value positive integer number of seconds\nValue\n value is invisibly returned (this function is used for its side effect).\n setPackages Manually set package names in the worker environment package list.\nDescription\n The setPackages function lets users manually declare packages that R worker processes need to\n load before running their tasks.\nUsage\n setPackages(packages = c())\nArguments\n packages A character vector of package names.\nDetails\n The foreach function includes a similar .packages parameter.\n Defines a way to set the foreach .packages option for users without direct access to the foreach\n function, for example, when foreach is used inside another package.\nValue\n The value of packages is invisibly returned (this function is used for its side effect).\n setProgress Progress bar\nDescription\n Progress bar\nUsage\n setProgress(value = FALSE)\nArguments\n value if TRUE, display a text progress bar indicating status of the computation\nValue\n value is invisibly returned (this function is used for its side effect).\n startLocalWorkers Start one or more background R worker processes on the local system.\nDescription\n Use startLocalWorkers to start one or more doRedis R worker processes in the background. The\n worker processes are started on the local system using the redisWorker function.\nUsage\n startLocalWorkers(\n n,\n queue,\n host = \"localhost\",\n port = 6379,\n iter = Inf,\n linger = 30,\n log = stdout(),\n Rbin = paste(R.home(component = \"bin\"), \"R\", sep = \"/\"),\n password,\n ...\n )\nArguments\n n number of workers to start\n queue work queue name\n host Redis database host name or IP address\n port Redis database port number\n iter maximum number of tasks to process before exiting the worker loop\n linger timeout in seconds after which the work queue is deleted that the worker termi-\n nates\n log print messages to the specified file connection\n Rbin full path to the command-line R program\n password optional Redis database password\n ... optional additional parameters passed to the redisWorker function\nDetails\n Running workers self-terminate after a linger period if their work queues are deleted with the\n removeQueue function, or when network activity with Redis remains inactive for longer than the\n timeout period set in the redisConnect function. That value defaults internally to 3600 (one hour)\n in startLocalWorkers. You can increase it by including a timeout=n argument value.\nValue\n NULL is invisibly returned.\nSee Also\n registerDoRedis, redisWorker\nExamples\n # Only run if a Redis server is running\n if (redux::redis_available()) {\n ## The example assumes that a Redis server is running on the local host\n ## and standard port.\n # Start a single local R worker process\n startLocalWorkers(n=1, queue=\"R jobs\", linger=1)\n # Run a simple sampling approximation of pi:\n registerDoRedis(\"R jobs\")\n print(foreach(j=1:10, .combine=sum, .multicombine=TRUE) %dopar%\n 4 * sum((runif(1000000) ^ 2 + runif(1000000) ^ 2) < 1) / 10000000)\n # Clean up\n removeQueue(\"R jobs\")\n }\n tasks List running doRedis tasks\nDescription\n List running doRedis tasks\nUsage\n tasks(queue = \"*\", id = \"*\")\nArguments\n queue List jobs for the specified queue, or set to \"*\" to list jobs for all queues\n id List tasks for the specified job id, or set to \"*\" to list tasks for all job ids\nValue\n a data frame listing jobs by row with variables queue, id, user, coordinator, time, iter, host, pid (see\n Note)\nNote\n The returned values indicate\n 1. queue the doRedis queue name\n 2. id the doRedis job id\n 3. user the user running the job\n 4. coordinator the host name or I.P. address where the job was submitted (and the coordinator\n R process runs)\n 5. time system time on the worker node when the task was started\n 6. iter the loop iterations being run by the task\n 7. host the host name or I.P. address where the task is running\n 8. pid the process ID of the R worker running the task on host\n Tasks are listed until a key associated with them expires in Redis. Thus running tasks are not\n explicitly removed from the task list immediately when they terminate, but may linger on the list\n for a short while after (a few seconds)."}}},{"rowIdx":591,"cells":{"project":{"kind":"string","value":"carla"},"source":{"kind":"string","value":"readthedoc"},"language":{"kind":"string","value":"Markdown"},"content":{"kind":"string","value":"Welcome to the CARLA documentation.\n\nThis home page contains an index with a brief description of the different sections in the documentation. Feel free to read in whatever order preferred. In any case, here are a few suggestions for newcomers.\n\n* Install CARLA. Either follow the Quick start installation to get a CARLA release or make the build for a desired platform.\n * Start using CARLA. The section titled Foundations is an introduction to the most important concepts and the first steps tutorial shows you how to get started.\n * Check the API. there is a handy Python API reference to look up the classes and methods available.\n\nThe CARLA forum is available to post any doubts or suggestions that may arise during the reading.\n\nWarning\n Change the docs version to fit the CARLA version you are using. Use the panel in the bottom-right side of this window to change to previous versions. The Latest version points to documentation in the `dev` branch which may refer to features currently in development and not available in any packaged version of CARLA, as well general documentation improvements. \n\n## Getting started\n\n Introduction — What to expect from CARLA.Quick start package installation — Get the CARLA releases. First steps — Taking the first steps in CARLA. Building CARLA — How to build CARLA from source. \n\n## CARLA components\n\n Foundations — Overview of the fundamental building blocks of CARLA.Actors — Learn about actors and how to handle them. Maps — Discover the different maps and how do vehicles move around. Sensors and data — Retrieve simulation data using sensors. Traffic — An overview of the different options available to populate your scenes with traffic. 3rd party integrations — Integrations with 3rd party applications and libraries. Development — Information on how to develop custom features for CARLA. Custom assets — Information on how to develop custom assets \n\n## Resources\n\n Blueprint library — Blueprints provided to spawn actors.Python API — Classes and methods in the Python API. C++ reference — Classes and methods in CARLA C++. \n\n## CARLA ecosystem\n\n ROS bridge documentation — Brief overview of the ROS bridge and a link to the full documentationMathWorks — Overview of creating a map in RoadRunner. SUMO — Details of the co-simulation feature with SUMO. Scenic — How to use Scenic with CARLA to generate scenarios. Chrono — Details of the Chrono physics simulation integration with CARLA. OpenDrive — Details of the OpenDrive support in CARLA. PTV-Vissim — Details of the co-simulation feature with PTV-Vissim. RSS — Details of the Responsibility Sensitive Safety library integration with CARLA. AWS — Details of using RLlib to run CARLA as a distributed application on Amazon Web Services. ANSYS — Brief overview of how the Ansys Real Time Radar Model was integrated into CARLA. carlaviz — web visualizer — Plugin that listens the simulation and shows the scene and some simulation data in a web browser. \n\n## Contributing to CARLA\n\n Guidelines — Guidelines on contributing to the development of the CARLA simulator and its ecosystem.Coding standards — Details on the best coding practices when contributing to CARLA development. Documentation standard — Details on the documentation standards for CARLA docs. \n\n## Tutorials\n\nThere are numerous tutorials covering CARLA features with code and guidelines for varied use cases. Please check the tutorials page for help with your work.\n\n## Extended documentation\n\nThe pages above cover most of the core concepts and features of CARLA. There is additional documentation in the extended documentation section covering advanced features in more depth.\n\nThis document refers to the latest version of CARLA. For documentation of previous versions, select the required version in the bottom right hand corner where you see this button:\n\nCARLA is an open-source autonomous driving simulator. It was built from scratch to serve as a modular and flexible API to address a range of tasks involved in the problem of autonomous driving. One of the main goals of CARLA is to help democratize autonomous driving R&D, serving as a tool that can be easily accessed and customized by users. To do so, the simulator has to meet the requirements of different use cases within the general problem of driving (e.g. learning driving policies, training perception algorithms, etc.). CARLA is grounded on Unreal Engine to run the simulation and uses the OpenDRIVE standard (1.4 as today) to define roads and urban settings. Control over the simulation is granted through an API handled in Python and C++ that is constantly growing as the project does.\n\nIn order to smooth the process of developing, training and validating driving systems, CARLA evolved to become an ecosystem of projects, built around the main platform by the community. In this context, it is important to understand some things about how does CARLA work, so as to fully comprehend its capabilities.\n\n## The simulator\n\n The CARLA simulator consists of a scalable client-server architecture.The server is responsible for everything related with the simulation itself: sensor rendering, computation of physics, updates on the world-state and its actors and much more. As it aims for realistic results, the best fit would be running the server with a dedicated GPU, especially when dealing with machine learning. The client side consists of a sum of client modules controlling the logic of actors on scene and setting world conditions. This is achieved by leveraging the CARLA API (in Python or C++), a layer that mediates between server and client that is constantly evolving to provide new functionalities. \nThat summarizes the basic structure of the simulator. Understanding CARLA though is much more than that, as many different features and elements coexist within it. Some of these are listed hereunder, as to gain perspective on the capabilities of what CARLA can achieve.\n\n* Traffic manager. A built-in system that takes control of the vehicles besides the one used for learning. It acts as a conductor provided by CARLA to recreate urban-like environments with realistic behaviours.\n * Sensors. Vehicles rely on them to dispense information of their surroundings. In CARLA they are a specific kind of actor attached the vehicle and the data they receive can be retrieved and stored to ease the process. Currently the project supports different types of these, from cameras to radars, lidar and many more.\n * Recorder. This feature is used to reenact a simulation step by step for every actor in the world. It grants access to any moment in the timeline anywhere in the world, making for a great tracing tool.\n * ROS bridge and Autoware implementation. As a matter of universalization, the CARLA project ties knots and works for the integration of the simulator within other learning environments.\n * Open assets. CARLA facilitates different maps for urban settings with control over weather conditions and a blueprint library with a wide set of actors to be used. However, these elements can be customized and new can be generated following simple guidelines.\n * Scenario runner. In order to ease the learning process for vehicles, CARLA provides a series of routes describing different situations to iterate on. These also set the basis for the CARLA challenge, open for everybody to test their solutions and make it to the leaderboard.\n\n## The project\n\n CARLA grows fast and steady, widening the range of solutions provided and opening the way for the different approaches to autonomous driving. It does so while never forgetting its open-source nature. The project is transparent, acting as a white box where anybody is granted access to the tools and the development community. In that democratization is where CARLA finds its value.Talking about how CARLA grows means talking about a community of developers who dive together into the thorough question of autonomous driving. Everybody is free to explore with CARLA, find their own solutions and then share their achievements with the rest of the community. \nThis documentation will be a companion along the way. The next page contains Quick start instructions for those eager to install a CARLA release. There is also a build guide for Linux and Windows. This will make CARLA from repository and allow to dive full-length into its features.\n\nWelcome to CARLA.\n\nThis guide shows how to download and install the packaged version of CARLA. The package includes the CARLA server and two options for the client library. There are additional assets that can be downloaded and imported into the package. Advanced customization and development options that require use of the Unreal Engine editor are not available but these can be accessed by using the build version of CARLA for either Windows or Linux.\n\n* Before you begin\n * CARLA installation\n * Import additional assets\n * Install client library\n * Running CARLA\n * Updating CARLA\n * Follow-up\n\nThe following requirements should be fulfilled before installing CARLA:\n\n* System requirements. CARLA is built for Windows and Linux systems.\n * An adequate GPU. CARLA aims for realistic simulations, so the server needs at least a 6 GB GPU although we would recommend 8 GB. A dedicated GPU is highly recommended for machine learning.\n * Disk space. CARLA will use about 20 GB of space.\n * Python. Python is the main scripting language in CARLA. CARLA supports Python 2.7 and Python 3 on Linux, and Python 3 on Windows.\n * Pip. Some installation methods of the CARLA client library require pip or pip3 (depending on your Python version) version 20.3 or higher. To check your pip version:\n ```\n# For Python 3 pip3 -V # For Python 2 pip -V\n```\n\nIf you need to upgrade:\n\n```\n# For Python 3 pip3 install --upgrade pip # For Python 2 pip install --upgrade pip\n```\n\n* Two TCP ports and good internet connection. 2000 and 2001 by default. Make sure that these ports are not blocked by firewalls or any other applications.\n * Other requirements. CARLA requires some Python dependencies. Install the dependencies according to your operating system:\n\n### Windows\n\n```\npip3 install --user pygame numpy\n```\n\n### Linux\n\n```\npip install --user pygame numpy &&\npip3 install --user pygame numpy\n```\n\n## CARLA installation\n\nThere are two methods to download and install CARLA as a package:\n\nA) Download the Debian package.\n\nB) Download the package from GitHub.\n\n### A. Debian CARLA installation\n\nThe Debain package is available for both Ubuntu 18.04 and Ubuntu 20.04, however the officially supported platform is Ubuntu 18.04.\n\n1. Set up the Debian repository in the system:\n\n```\nsudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys <KEY>\n sudo add-apt-repository \"deb [arch=amd64] http://dist.carla.org/carla $(lsb_release -sc) main\"\n```\n\n 2. Install CARLA and check for the installation in the `/opt/` folder: \n\n```\nsudo apt-get update # Update the Debian package index\n sudo apt-get install carla-simulator # Install the latest CARLA version, or update the current installation\n cd /opt/carla-simulator # Open the folder where CARLA is installed\n```\n\nThis repository contains CARLA 0.9.10 and later versions. To install a specific version add the version tag to the installation command:\n\n```\napt-cache madison carla-simulator # List the available versions of Carla\n sudo apt-get install carla-simulator=0.9.10-1 # In this case, \"0.9.10\" refers to a CARLA version, and \"1\" to the Debian revision\n```\n\nTo install CARLA versions prior to 0.9.10, change to a previous version of the documentation using the panel in the bottom right corner of the window, and follow the old instructions.\n\n### B. Package installation\n\nThis repository contains different versions of CARLA. You will find options to download the current release with all the most recent fixes and features, previous releases and a nightly build with all the developmental fixes and features (the nightly build is the most unstable version of CARLA).\n\nThe package is a compressed file named CARLA_version.number. Download and extract the release file. It contains a precompiled version of the simulator, the Python API module and some scripts to be used as examples.\n\n## Import additional assets\n\nEach release has it's own additional package of extra assets and maps. This additional package includes the maps Town06, Town07, and Town10. These are stored separately to reduce the size of the build, so they can only be imported after the main package has been installed.\n\n1. Download the appropriate package for your desired version of CARLA.\n\n2. Extract the package:\n\nOn Linux:\n\n* move the package to the Import folder and run the following script to extract the contents:\n\n ./ImportAssets.sh\n```\n\nOn Windows:\n\n* Extract the contents directly in the root folder.\n\n## Install client library\n\n### CARLA versions prior to 0.9.12\n\n Previous versions of CARLA did not require the Python library to be installed, they came with an `.egg` file that was ready to use out of the box. CARLA versions 0.9.12+ change this behavior significantly; there are several options available to install the client library. If you are using a version of CARLA prior to 0.9.12, please select that version in the bottom right corner of the screen to see the relevant documentation. Otherwise, read on below about the available options in CARLA 0.9.12+. \n\n### CARLA 0.9.12+\n\nThere are several options available to install and use the CARLA client library:\n\n* .egg file\n * .whl file\n * Downloadable Python package\n\nRead more below about the requirements and limitations of each method before deciding which one to use. Please note that mixing the different methods can lead to incompatibilities, so use virtual environments when possible or uninstall a previously installed library before using a new one.\n A. .egg files\n\nCARLA provides\n `.egg` files in \n\nfor different Python versions that are ready to use out of the box. Each of the example scripts in `PythonAPI/examples` includes a code snippet that looks for this file automatically. In Linux, you may need to add this file to your `PYTHONPATH` . Read more about `.egg` files in CARLA here. \nIf you have previously installed the client library with\n `pip` , this will take precedence over the `.egg` file. You will need to uninstall the previous library first. \nB. .whl files\n\nCARLA provides\n `.whl` files for different Python versions. You will need to install the `.whl` file. The `.whl` file is found in \n\n. There is one file per supported Python version, indicated by the file name (e.g., carla-0.9.12-cp36-cp36m-manylinux_2_27_x86_64.whl indicates Python 3.6). \nIt is recommended to install the CARLA client library in a virtual environment to avoid conflicts when working with multiple versions.\n\nTo install the CARLA client library, run the following command, choosing the file appropriate to your desired Python version. You will need pip/pip3 version 20.3 or above. See the Before you begin section for how to check the version and upgrade pip/pip3:\n\nIf you previously installed the client library, you should uninstall the old one before installing the new one.\n\nC. Downloadable Python package\n\nThe CARLA client library can be downloaded from PyPi. This library is compatible with Python versions 2.7, 3.6, 3.7, and 3.8. To install it you will need pip/pip3 version 20.3 or above. See the Before you begin section for how to check the version and upgrade pip/pip3.\n\nIt is recommended to install the CARLA client library in a virtual environment to avoid conflicts when working with multiple versions.\n\nTo install the client library from PyPi, run the following command:\n\nThe PyPi download is suitable for use with CARLA packages only (i.e., not with a version built from source). Since the PyPi download only contains the client library, it is most useful in situations where you will be communicating with a remote CARLA server where you do not require downloading a full CARLA package.\n\n## Running CARLA\n\nThe method to start a CARLA server depends on the installation method you used and your operating system:\n\n* Debian installation:\n\n```\ncd /opt/carla-simulator/bin/\n\n* Linux package installation:\n\n* Windows package installation:\n\n CarlaUE4.exe\n```\n\n A window containing a view over the city will pop up. This is the spectator view. To fly around the city use the mouse and `WASD` keys, holding down the right mouse button to control the direction. \nThis is the server simulator which is now running and waiting for a client to connect and interact with the world. You can try some of the example scripts to spawn life into the city and drive a car:\n\n```\n# Terminal A \n cd PythonAPI\\examples\n\n python3 -m pip install -r requirements.txt # Support for Python2 is provided in the CARLA release packages\n\n python3 generate_traffic.py \n\n # Terminal B\n cd PythonAPI\\examples\n\n python3 manual_control.py\n```\n\n# Command-line options\n\nThere are some configuration options available when launching CARLA and they can be used as follows:\n\n```\n./CarlaUE4.sh -carla-rpc-port=3000\n```\n\n* \n `-carla-rpc-port=N` Listen for client connections at port `N` . Streaming port is set to `N+1` by default. * \n\n```\n-carla-streaming-port=N\n```\n\nSpecify the port for sensor data streaming. Use 0 to get a random unused port. The second port will be automatically set to `N+1` . * \n\n```\n-quality-level={Low,Epic}\n```\n\nChange graphics quality level. Find out more in rendering options. * List of Unreal Engine 4 command-line arguments. There are a lot of options provided by Unreal Engine however not all of these are available in CARLA.\n The script\n\nprovides more configuration options and should be run when the server has been started: \n\n```\n./config.py --no-rendering # Disable rendering\n ./config.py --map Town05 # Change map\n ./config.py --weather ClearNoon # Change weather\n\n ./config.py --help # Check all the available configuration options\n```\n\n## Updating CARLA\n\nThere is no way to update the packaged version of CARLA. When a new version is released, the repository is updated and you will need to delete the previous version and install the new version.\n\nIf you installed the client library using pip/pip3, you should uninstall it by running:\n\n```\n# Python 3\npip3 uninstall carla\n\n# Python 2\npip uninstall carla\n```\n\n## Follow-up\n\nBy now you should have a packaged version of CARLA up and running. If you came across any difficulties during the installation process, feel free to post in the CARLA forum or in the Discord channel.\n\nThe next step is to learn more about the core concepts in CARLA. Read the First steps section to start learning. You can also find all the information about the Python API classes and methods in the Python API reference.\n\nThe CARLA simulator is a comprehensive solution for producing synthetic training data for applications in autonomous driving (AD) and also other robotics applications. CARLA simulates a highly realistic environment emulating real world towns, cities and highways and the vehicles and other objects that occupy these driving spaces.\n\nThe CARLA simulator is further useful as an evaluation and testing environment. You can deploy the AD agents you have trained within the simulation to test and evaluate their performance and safety, all within the security of a simulated environment, with no risk to hardware or other road users.\n\nIn this tutorial, we will cover a standard workflow in CARLA, from launching the server and connecting the client, through to adding vehicles, sensors and generating training data to use for machine learning. This tutorial is meant to be light on details and go as efficiently as possible through the key steps in using CARLA to produce machine learning training data. For further details on each part of the workflow, such as the multitude of vehicles available in the blueprint library or the alternative types of sensors available, please consult the links in the text or browse the left menu.\n\n* Launching CARLA\n * Loading a map\n * Spectator navigation\n * Adding NPCs\n * Add sensors\n * Animate vehicles\n * Assign a vehicle as the Ego Vehicle\n * Choose your map\n * Choose your vehicles\n\n## Launching CARLA and connecting the client\n\nCARLA can be launched using the command line using the executable in Windows or the shell script in Linux. Follow the installation instructions for Linux and Windows then launch CARLA from the command line:\n\n```\ncd /carla/root\n./CarlaUE4.sh\n```\n\nTo manipulate CARLA through the Python API, we need to connect the Python client to the server through an open port. The client controls the simulator through the client and world objects Open a Python notebook or create a new script, then add the following code to the start of the script or the main function:\n\n```\nimport carla\nimport random\n\n# Connect to the client and retrieve the world object\nclient = carla.Client('localhost', 2000)\nworld = client.get_world()\n```\n\nThe client object serves to maintain the client's connection to the server and has a number of functions for applying commands and loading or exporting data. We can load an alternative map or reload the current one (resetting to initial state) using the client object.\n\nThe port can be chosen as any available port and is set to 2000 by default, you can also choose a host different from localhost by using a computer's IP address. This way, the CARLA server can be run on a networked machine, while the python client can be run from a personal computer. This is particularly useful for differentiating the GPU used for running the CARLA simulator and that used for neural network training, both of which can be highly demanding on graphics hardware.\n\nThe following presumes that CARLA is running in the default asynchronous mode. If you have engaged synchronous mode, some of the code in the following sections might not work as expected.\n\n## Loading a map\n\n In the CARLA API, the world object provides access to all elements of the simulation, including the map, objects within the map, such as buildings, traffic lights, vehicles and pedestrians. The CARLA server normally loads a default map (normally Town10). If you want to launch CARLA with an alternate map, use the `config.py` script: \n\n```\n./config.py --map Town05\n```\n\nWe can also use the world object to load a map from the client:\n\n```\nclient.load_world('Town05')\n```\n\nPlease find more information about CARLA maps here.\n\n## Spectator navigation\n\n The spectator is a view into the simulation. By default, the spectator opens in a new window when you run the CARLA server on a computer with a screen attached, unless you specify the `-RenderOffScreen` command line option. \nThe spectator is helpful to visualize your simulation. Using the spectator, you can familiarize yourself with the map you've loaded, and see the result of any changes you are making, such as adding vehicles, changing the weather, turning on/off various layers of the map and for debugging purposes.\n\nYou can fly the spectator around the world using the mouse to control the pitch and yaw of the spectator view and the QWE-ASD keys to move the spectator:\n\n* Q - move upwards (towards the top edge of the window)\n * \n\nE - move downwards (towards the lower edge of the window)\n * \n\nW - move forwards\n * S - move backwards\n * A - move left\n * D - move right\n\nLeft click and drag the mouse in the spectator window up and down to control pitch and left and right to control yaw.\n\nThe spectator and its properties can be accessed and manipulated through the Python API:\n\n```\n# Retrieve the spectator object\nspectator = world.get_spectator()\n\n# Get the location and rotation of the spectator through its transform\ntransform = spectator.get_transform()\n\nlocation = transform.location\nrotation = transform.rotation\n\n# Set the spectator with an empty transform\nspectator.set_transform(carla.Transform())\n# This will set the spectator at the origin of the map, with 0 degrees\n# pitch, yaw and roll - a good way to orient yourself in the map\n```\n\n## Adding NPCs\n\nNow we've loaded the map and the server is up and running we now need to populate our simulation with some vehicles to simulate a real environment with traffic and other road users or non-player characters (NPCs).\n\nTo spawn vehicles, first, we need to select the vehicles we want from the blueprint library.\n\n```\n# Get the blueprint library and filter for the vehicle blueprints\nvehicle_blueprints = world.get_blueprint_library().filter('*vehicle*')\n```\n\nNow we have the blueprints, we need to find some appropriate spots in the map to spawn our vehicles. Each CARLA map provides pre-defined spawn points spread evenly throughout the map on the roads for this purpose.\n\n```\n# Get the map's spawn points\nspawn_points = world.get_map().get_spawn_points()\n\n# Spawn 50 vehicles randomly distributed throughout the map \n# for each spawn point, we choose a random vehicle from the blueprint library\nfor i in range(0,50):\n world.try_spawn_actor(random.choice(vehicle_blueprints), random.choice(spawn_points))\n```\n\nNow we should also add a vehicle that will be the centerpoint of our simulation. To train an autonomous agent we need to simulate a the vehicle that it the autonomous agent will control. In CARLA parlance, we often refer to this vehicle as the \"Ego vehicle\".\n\n```\nego_vehicle = world.spawn_actor(random.choice(vehicle_blueprints), random.choice(spawn_points))\n```\n\nIn addition to vehicles, CARLA also provides pedestrians to add to simulations to simulate realistic driving scenarios. Vehicles and pedestrians are referred to as actors in the CARLA parlance, learn more about them here.\n\n## Add sensors\n\nModern autonomous vehicles understand and interpret their environment through an array of attached sensors. These sensors include things such as optical video cameras, optical flow cameras, LIDARs, RADARs and accelerometers. CARLA has models of numerous types of sensors built in to create training data for machine learning. The sensors can be attached to a vehicle, or they can be attached to a fixed point to model for example a CCTV camera.\n\nHere we will attach a standard camera sensor to the ego vehicle to record some video data:\n\n```\n# Create a transform to place the camera on top of the vehicle\ncamera_init_trans = carla.Transform(carla.Location(z=1.5))\n\n# We create the camera through a blueprint that defines its properties\ncamera_bp = world.get_blueprint_library().find('sensor.camera.rgb')\n\n# We spawn the camera and attach it to our ego vehicle\ncamera = world.spawn_actor(camera_bp, camera_init_trans, attach_to=ego_vehicle)\n```\n\n Once we have spawned the camera, we need to set it recording through the `listen()` method. The listen method takes as argument a callback that defines what to do with the data. You can either stream it to another program or save it to disk. \nWe will use a lambda function as a callback to save the data to disk:\n\n```\n# Start camera with PyGame callback\ncamera.listen(lambda image: image.save_to_disk('out/%06d.png' % image.frame))\n```\n\n This will save the data to the `out/` folder as a series of PNG image files named according to the simulation frame number. \nThere are a multitude of different types of sensors to choose from. Here you can delve deeper into the array of sensors available and how to use them.\n\n## Animate vehicles with traffic manager\n\nNow we've added our traffic and ego vehicle to the simulation and started recording camera data, we now need to set the vehicles in motion using the Traffic manager. The Traffic manager is a component of CARLA that controls vehicles to autonomously move around the roads of the map within the simulation, following the road conventions and behaving like real road users.\n We can find all the vehicles in the simulation using the `world.get_actors()` method, filtering for all the vehicles. We can then use the `set_autopilot()` method to hand over control of the vehicle to the Traffic Manager. \n\n```\nfor vehicle in world.get_actors().filter('*vehicle*'):\n vehicle.set_autopilot(True)\n```\n\nNow your simulation is running, with numerous vehicles driving around the map and a camera recording data from one of those vehicles. This data can then be used to feed a machine learning algorithm for training an autonomous driving agent. The Traffic manager has many functions for customising traffic behaviour, learn more here.\n\nThis is the most basic possible set up for a simulation, now you can go into further details deeper into documentation about the many extra sensors you can use to generate data, and the many other features of CARLA that can make your simulations more detailed and more realistic.\n\n## Assign a vehicle as the Ego Vehicle\n\nThe Ego Vehicle is an important concept to bear in mind when using CARLA. The Ego Vehicle refers to the vehicle that will be the focus of the simulation. In most CARLA use cases it's likely to be the vehicle to which you will attach your sensors and/or the vehicle that your autonomous driving machine learning stack will control. It is important because it serves as the basis for some simulation operations that help improve the efficiency of the simulation, like for example:\n\nLoading map tiles for Large Maps: Large Maps (like Town 12) are made up of tiles to that are only loaded when needed to improve CARLA performance. The position of the Ego Vehicle dictates which tiles are used. Only the tiles nearest the Ego Vehicle will be loaded.\n * \n\nHybrid Physics Mode: if your simulation contains a lot of vehicles controlled by the Traffic Manager, calculating physics for all of these vehicles is very computationally expensive. The Hybrid Physics Mode enables physics calculation to be limited to the vehicles in the vicinity of the Ego Vehicle, hence saving computing resources.\n To define the Ego Vehicle, you should set the `role_name` attribute of the vehicle carla.Actor object's blueprint when you are spawning your Ego Vehicle: \n\n```\nego_bp = world.get_blueprint_library().find('vehicle.lincoln.mkz_2020')\n\nego_bp.set_attribute('role_name', 'hero')\n\nego_vehicle = world.spawn_actor(ego_bp, random.choice(spawn_points))\n```\n\n## Choose your map\n\nCARLA comes loaded with several pre-made maps focused on providing a diversity of features. The maps present a range of environments such as urban, rural and residential. There are also differing architectural styles and also a multitude of different road layouts from unmarked rural roads to multi-lane highways. Browse the map guides in the catalogue or in the table below.\n\nYou can browse the available maps in your CARLA installation:\n\n```\nclient.get_available_maps()\n```\n\nThis will include maps that you have built yourself or imported.\n\nWhen you choose a map, load it like so:\n\n```\nclient.load_world('Town03_Opt')\n```\n\n## Choose your vehicles\n\nCARLA provides a library of vehicles to fill your simulation with traffic. Browse the vehicle models in the CARLA vehicle catalogue.\n\nYou can see all available vehicle blueprints by filtering the blueprint library.\n\n```\nfor bp in world.get_blueprint_library().filter('vehicle'):\n print(bp.id)\n```\n\nUsers can build CARLA from the source code for development purposes. This is recommended if you want to add extra features or capabilities to CARLA or if you want to use the Unreal Editor to create assets or manipulate maps.\n\nBuild instructions are available for Linux and Windows. You can also build CARLA in a Docker container for deployment in AWS, Azure or Google cloud services. Visit the CARLA GitHub and clone the repository.\n\n# Content authoring - maps\n\n# Content authoring - Maps\n\nCARLA comes with a generous compliment of assets for creating driving simulations out of the box. However, the real power of CARLA comes in its comprehensive extensibility, allowing users to create entirely custom environments populated with bespoke assets like buildings, benches, trash cans, statues, street lights and bus stops.\n\nIn this tutorial we will cover the process of creating a simple map for use with CARLA. We will use two software packages to create parts of the map. We will create the road network using RoadRunner and then add assets to the map through the Unreal Editor.\n\n* Prerequisites\n * Large maps\n * RoadRunner\n * Importing into CARLA\n * Importing assets\n * Traffic lights\n * Traffic signs\n * Materials\n * Road painter\n * Trees and vegetation\n\n## Prerequisites\n\nTo follow this guide, you will need to build CARLA from source, so that you may use the Unreal Editor. Follow the build instructions for your relevant operating system. You will also need a licensed copy of RoadRunner. You may also need a 3D modelling application such as Maya, 3DS Max or Blender to create 3D assets for your custom maps. You should ensure you have completed all the steps to build CARLA and ensure that the Unreal Editor is working, this could take some time to build the application. If you want to create 3D assets for your map, you should use an appropriate 3D design application such as Blender, Maya, 3DsMax or Modo.\n\nThe following text details the procedures for creating and decorating a standard map. From version 0.9.12, CARLA has the Large Maps functionality. Large maps are bigger in scale than standard maps, and can be up to 100 km2 in size. Large maps work in a slightly different way to standard maps, because of hardware limitations, even in high end graphics cards. Large maps are split up into tiles, and only the tiles needed immediately (i.e. those closest to the Ego vehicle) are loaded during the simulation. Other tiles sit dormant until the data is needed. This facilitates the highest performance for CARLA simulations. Most of the details that follow are similar when building a Large Map, but there are some additional steps. Please follow this guide to build a Large Map for CARLA.\n\n## Create a road network using RoadRunner\n\nOpen RoadRunner and create a new scene. Choose the Road Plan Tool and right click in the workspace to drop the first control point for the road. Click and drag elsewhere in the workspace to extend the road.\n\nFor the purpose of this tutorial we use a simple oval road with a junction in the middle. For building more advanced networks please refer to the roadrunner documentation.\n\n. Once you have created your desired road network, in the RoadRunner menu bar choose\n\n```\nFile > Export > Carla (.fbx, .xodr, .rrdata, .xml)\n```\n\nand export to an appropriate location. \nRoadRunner is the best application for creating custom maps. There are alternatives such as OpenStreetMap that focus on generating maps from real road maps.\n\n## TrueVision designer\n\nRoadRunner is a proprietary software that requires MATLAB. Some institutions like universities may have deals with MathWorks such that some users may be able to acquire a RoadRunner license. If you don't have budget for a license, a convenient open source alternative to RoadRunner is the TrueVision Designer. This app has many of the same features as RoadRunner and is useful if you cannot acquire a license for RoadRunner.\n\n## Importing your road network into CARLA\n\n The important export files needed for CARLA are the `.xodr` file and the `.fbx` file. Copy or move these files into the `Import` folder inside the root directory of the CARLA repository where you have built from source. Now open a terminal at the root of the CARLA source directory and run `make import` . This will import the road network into CARLA. You can now see your new map inside the Unreal Editor. Run `make launch` at the root of the CARLA source directory to launch the Unreal Editor. You will now see a new directory in the content browser named `map_package` . Within this directory in the location \n\n```\nContent > map_package > Maps > tutorial\n```\n\nyou will now find your new map. \nYou have now created the road network, the basis of your map.\n\n## Importing assets and adding them to the map\n\n Now we have the road network as the basis for our map, we now want to create some content for the map, such as buildings. These assets can be created using a 3D modelling application such as Autodesk Maya, 3DS Max, Blender or any other 3D application with the appropriate export options. It is important that, at a minimum, the application is capable of `.fbx` export. \nThere are several elements needed to create an asset in CARLA:\n\n* Mesh - a set of 3D coordinate vertices and the associated joining edges\n * UV map - a mapping of 3D vertices and edges to a 2D texture space to match textures with 3D locations\n * Texture - a 2D image defining the colors and patterns to appear on the surface of the 3D object\n * Normal map - a 2D image defining the directions of the normals on the surface of the object, to add 3D variations to the object's surface\n * ORM map - a map defining the regions of metallicity, roughness and ambient occlusion\n\nThe ORM map utilizes the channels of a standard RGBA encoded image to encode the map of metallic regions, roughness and ambient occlusion. As we define the map here, the red channel defines the metallic map, the green channel the roughness and the blue channel is the ambient occlusion. These maps (as well as the diffuse and normal maps) can be created using an application such as Adobe Substance 3D painter.\n Create a new folder in some appropriate location using the Unreal content browser. Within this folder you can either right click and select\n\n```\nImport to PATH/TO/FOLDER\n```\n\nnear the top of the context menu, or drag and drop files directly into the content browser. \nWe will import an FBX file containing the base mesh and the UV map, that we have exported from Blender.\n In the context menu, ensure that in the Mesh section `Import Normals` is selected\n for `Normal Import Method` and that in the Material section that \n\n```\nDo Not Create Material\n```\n\nis selected. Deselect `Import Textures` in the Materials section since we will import them manually. These choices would differ if you wanted to use some textures already embedded in your FBX file. Select `Import All` . Once the import has completed, double click on the imported asset that appears in the content browser to edit it. \nWe should now import the textures, the diffuse texture for the diffuse colors, the normal map and the ORM map.\n Open the ORM map by double clicking and deselect the `sRGB` option, to ensure the texture is correctly applied. Right click in the content browser and select `Material` from the menu. A new material will be created in the content browser. Double click to edit it. Shift select the textures you imported and drag them into the material edit window, you will now get 3 new nodes in the material node editor. \nNow connect the nodes according to the following rules:\n\n* Diffuse RGB --> Base Color\n * Normal RGB --> Normal\n * ORM R --> Ambient occlusion\n * ORM G --> Roughness\n * ORM B --> Metallic\n\nYour material node graph should now look similar to this:\n\nSave the material, then open the asset again and drag the material into the material slot. Your asset should now be fully textured.\n\nNow save the asset and it is ready for use in your map. You can now drag the asset from the content browser and place it into your map:\n\nNow you can save the map, using the \"Save Current\" option in the top left of the workspace and it is ready to use. Play the simulation.\n\nThis concludes the Map authorship guide. Now you know how to create a road network and import 3D assets for use in CARLA. You may now read how to package a map for use in CARLA standalone version\n\n## Traffic lights\n\nTo add traffic lights to your new map:\n 1. From the Content Browser, navigate to\n\n. You will find several different traffic light blueprints to choose from. \n2. Drag the traffic lights into the scene and position them in the desired location. Press the space bar on your keyboard to toggle between positioning, rotation, and scaling tools.\n 3. Adjust the `trigger volume` for each traffic light by selecting the BoxTrigger component in the Details panel and adjusting the values in the Transform section. This will determine the traffic light's area of influence. 4. For junctions, drag the `BP_TrafficLightGroup` actor into the level. Assign all the traffic lights in the junction to the traffic light group by adding them to the Traffic Lights array in the Details panel. \n5. Traffic light timing is only configurable through the Python API. See the documentation here for more information.\n Example: Traffic Signs, Traffic lights and Turn based stop.\n\n## Traffic signs\n\nTo add traffic signs to your new map:\n 1. From the Content Browser, navigate to\n\n```\nContent > Carla > Static > TrafficSign\n```\n\n. You will find several different traffic light blueprints to choose from. \n2. Drag the traffic lights into the scene and position them in the desired location. Press the space bar on your keyboard to toggle between positioning, rotation, and scaling tools.\n 3. Adjust the `trigger volume` for each traffic sign by selecting the BoxTrigger component in the Details panel and adjusting the values in the Transform section. This will determine the traffic light's area of influence. Not all traffic signs have a trigger volume. Those that do, include the yield, stop and speed limit signs. \n\n The CARLA content library has a multitude of useful materials ready to use to change the look of your maps. In your content browser, navigate to\n\n```\nCarla > Static > GenericMaterials\n```\n\n. In here you will find numerous materials you can use to alter the appearance of your map. \nYou can test the materials rapidly by drag and drop onto map elements:\n\n# Road Painter\n\nThe road painter is a tool that can be used to customize the appearance of the road, adding extra realism with additional textures, decals and meshes.\n\n## What is the road painter?\n\nThe Road Painter tool is a blueprint that uses OpenDRIVE information to paint roads quickly. It takes a master material and applies it to a render target of the road to use as a canvas. The master material is made up of a collection of materials that can be blended using brushes and applied as masks. There is no need to apply photometry techniques nor consider the UVs of the geometry.\n The road painter uses the OpenDRIVE information to paint the roads. Make sure that your `.xodr` file has the same name as your map for this to work correctly. \n\n## Establish the road painter, master material and render target\n\n 1. Create the `RoadPainter` actor. \n\n```\nContent > Carla > Blueprints > LevelDesign\n```\n\n. * Drag the\n `RoadPainter` into the scene. \n2. Create the Render Target.\n\n```\nContent > Carla > Blueprints > LevelDesign > RoadPainterAssets\n```\n\n. * Right-click on the\n `RenderTarget` file and select `Duplicate` . * Rename to\n\n. \n3. Create the master material instance.\n\n. * Right-click on\n `M_RoadMaster` and select Create Material Instance. * Rename to\n `Tutorial_RoadMaster` . \n4. Re-calibrate the Map Size (Cm) so that it is equal to the actual size of the map.\n\n* Select the\n `RoadPainter` actor in the scene. * Go to the Details panel and press the Z-Size button. You will see the value in Map Size (Cm) change.\n 5. Synchronize the map size between the `RoadPainter` and `Tutorial_RoadMaster` . \n\n* In the Content Browser, open\n `Tutorial_RoadMaster` . * Copy the value Map Size (Cm) from the previous step and paste it to Global Scalar Parameter Values -> Map units (CM) in the\n `Tutorial_RoadMaster` window. * Press save.\n\n6. Create the communication link between the road painter and the master material.\n The\n\nwill be the communication link between the road painter and `Tutorial_RoadMaster` . \n\n* In the\n `Tutorial_RoadMaster` window, apply the \n\nto Global Texture Parameter Values -> Texture Mask. * Save and close.\n * In the main editor window, select the road painter actor, go to the Details panel and apply the\n\nto Paint -> Render Target. \n\n## Prepare the master material\n\n The `Tutorial_RoadMaster` material you created holds the base material, extra material information, and parameters that will be applied via your \n\n. You can configure one base material and up to three additional materials. To configure the materials, double-click the `Tutorial_RoadMaster` file. In the window that appears, you can select and adjust the following values for each material according to your needs: \n\n* Brightness\n * Hue\n * Saturation\n * AO Intensity\n * NormalMap Intensity\n * Roughness Contrast\n * Roughness Intensity\n\nYou can change the textures for each material by selecting the following values and searching for a texture in the search box:\n\n* Diffuse\n * Normal\n * ORMH\n Explore some of the CARLA textures available in\n\n```\nGame > Carla > Static > GenericMaterials > Asphalt > Textures\n```\n\n### Paint the road\n\n1. Create the link between the road painter and the roads.\n\n* In the main editor window, search for\n `Road_Road` in the World Outliner search box. * Press\n `Ctrl + A` to select all the roads. * In the Details panel, go to the Materials section and apply\n `Tutorial_RoadMaster` to Element 0, Element 1, Element 2, and Element 3. \n2. Choose the material to customize.\n Each of the materials we added to `Tutorial_RoadMaster` are applied to the roads separately and application is configured with the Brush tool. To apply and customize a material: \n\n* Select the road painter actor\n * In the Details panel, select the material to work with in the Mask Color dropdown menu.\n\n3. Set the brush and stencil parameters.\n There are a variety of stencils to choose from in\n\n```\nGenericMaterials/RoadStencil/Alphas\n```\n\n. The stencil is used to paint the road according to your needs and can be adjusted using the following values: \n\n* Stencil size — Size of the brush.\n * Brush strength — Roughness of the outline.\n * Spacebeween Brushes — Distance between strokes.\n * Max Jitter — Size variation of the brush between strokes.\n * Stencil — The brush to use.\n * Rotation — Rotation applied to the stroke.\n 4. Apply each material to the desired portions of the road. \nChoose where to apply the selected material via the buttons in the Default section of the Details panel:\n\n* Paint all roads — Paint all the roads.\n * Paint by actor — Paint a specific, selected actor.\n * Paint over circle — Paint using a circular pattern, useful to provide variation.\n * Paint over square — Paint using a square pattern, useful to provide variation.\n\nThis section also contains options to erase the applied changes.\n\n* Clear all — Erase all the painted material.\n * Clear materials — Remove the currently active materials.\n * Clear material by actor — Remove the material closest to the selected actor.\n 5. Add decals and meshes. You can explore the available decals and meshes in\n\n. Add them to road painter by extending and adding to the Decals Spawn and Meshes Spawn arrays. For each one you can configure the following parameters: \n\n* Number of Decals/Meshes - The amount of each decal or mesh to paint.\n * Decal/Mesh Scale — Scale of the decal/mesh per axis.\n * Fixed Decal/Mesh Offset — Deviation from the center of the lane per axis.\n * Random Offset — Max deviation from the center of the lane per axis.\n * Decal/Mesh Random Yaw — Max random yaw rotation.\n * Decal/Mesh Min Scale — Minimum random scale applied to the decal/mesh.\n * Decal/Mesh Max Scale — Max random scale applied to the decal/mesh.\n Once you have configured your meshes and decals, spawn them by pressing `Spawn decals` and `Spawn meshes` . \nNote\n\nMake sure that meshes and decals do not have collisions enabled that can interfere with cars on the road and lower any bounding boxes to the level of the road.\n\n7. Experiment to get your desired appearance.\n\nExperiment with different materials, textures, settings, decals, and meshes to get your desired look. Below are some example images of how the appearance of the road changes during the process of painting each material.\n\n## Update the appearance of lane markings\n\nAfter you have painted the roads, you can update the appearance of the road markings by following these steps:\n\n1. Make a copy of the master material.\n\n. * Right-click on\n `Tutorial_RoadMaster` and select Create Material Instance. * Rename to\n\n. \n2. Configure the lane marking material.\n\n* In the Content Browser, double-click on\n\n. * In the Details panel, go to the Global Static Switch Parameter Values section and check the boxes on the left and right of LaneMark.\n * Go to the Texture section and check the boxes for LaneColor and Uv Size.\n * Choose your preferred color for the lane markings in LaneColor.\n * Save and close.\n\n3. Select the road marking meshes.\n\nDrag the material onto the lane markings you wish to color. Repeat the whole process for different colors of lane markings if required.\n\n## Trees and Vegetation\n\nThe CARLA content library has a comprehensive set of vegetation blueprints for you to add further realism to the off-road areas of your maps like sidewalks, parks, hillsides, fields and forrest.\n Navigate to the vegetation folder in the CARLA content library:\n\n```\nCarla > Static > Visitation\n```\n\n. You will find blueprints for multiple types of trees, bushes, shrubs. You can drag these elements into your map from the content browser. \n\n### Foliage tool\n\n A useful tool for trees and vegetation is the Unreal Engine foliage tool. Activate the tool by selecting the `mode` from the mode dropdown in the toolbar. Drag your desired foliage item into the box labeled `+ Drop Foliage Here` . Set an appropriate density in the density field, then paint into the map with your foliage item. \n\nContinue customizing your map using the tools and guides below:\n\n* Implement sub-levels in your map.\n * Add buildings with the procedural building tool.\n * Customize the weather\n * Customize the landscape with serial meshes. Once you have finished with the customization, you can generate the pedestrian navigation information.\n\nCARLA provides a comprehensive set of vehicles out of the box in the blueprint library. CARLA allows the user to expand upon this with custom vehicles for maximum extensibility.\n\n3D modelling of detailed vehicles is highly complex and requires a significant degree of skill. We therefore refer the reader to alternative sources of documentation on 3D modelling, since this is beyond the scope of this guide. There are, however, numerous sources of vehicle models in both free and proprietary online repositories. Hence the user has many options to turn to for creating custom vehicles for use in CARLA.\n\nThe key factors in preparing a custom vehicle for CARLA lie in rigging the vehicle armature and then importing into the Unreal Engine. After rigging and importing, blueprints need to be set for the car and the wheels. Then apply materials and add the glass parts of the vehicle. We will cover these steps in the following guide.\n\n* Modeling\n * Rigging\n * Import into Unreal Engine\n * Materials\n * Glass\n * Wheels\n * Lights\n\n## Modeling\n\nVehicles should have between 50,000 and 100,000 faces. We recommend triangulating the model prior to export as best practice. CARLA vehicles are modeled using the size and scale of actual cars as reference. Please ensure you pay careful attention to the units of your 3D application. Some work in centimeters while others work in meters.\n\n### Naming conventions\n\nFor ease and consistency we recommend that you divide the vehicle into the following parts and name them accordingly. Details specific to glass and lights will be covered in later sections:\n * Bodywork: The metallic part of the vehicle. This material is changed to Unreal Engine material. Logos and details can be added but, to be visible, they must be painted in a different color by using the alpha channels in the Unreal Engine editor.\n * Glass_Ext: A layer of glass that allows visibility from the outside to the inside of the vehicle.\n * Glass_Int: A layer of glass that allows visibility from the inside to the outside of the vehicle.\n * Lights: Headlights, indicator lights, etc.\n * LightGlass_Ext: A layer of glass that allows visibility from the outside to the inside of the light.\n * LightGlass_Int: A layer of glass that allows visibility from the inside to the outside of the light.\n * LicensePlate: A rectangular plane of 29x12 cm. You can use the CARLA provided\n `.fbx` for best results, download it here. The texture will be assigned automatically in Unreal Engine. * Interior: Any other details that don't fit in the above sections can go into Interior.\n Materials should be named using the format `M_CarPart_CarName` , e.g, `M_Bodywork_Mustang` . Textures should be named using the format `T_CarPart_CarName` , e.g, `T_Bodywork_Mustang` . Textures should be sized as 2048x2048. \n\n## Rigging the vehicle using an armature\n\nTo look realistic within the simulation, the car needs to have rotating and wheels, the front pair of which can turn with steering inputs. Therefore to prepare a vehicle for CARLA, an armature needs to be rigged to the car to identify the wheels and allow their movement.\n\n### Import\n\nImport or model the vehicle model mesh in your 3D modelling application. In this guide we will use Blender 3D. Ensure that the wheels are separable from the main body. Each wheel must be accessible as a distinct object.\n\nIt is important to ensure that the vehicle faces in the positive X direction, so the hood and windshield should be facing towards positive X. The car should also be oriented such that the floor to roof direction is in the positive Z direction. The wheels should be just grazing the X-Y plane and the origin should be situated where you would expect the vehicle's center of mass to be in the X-Y plane (not in the Z plane though).\n\n### Add an armature\n\nNow add an armature to the center of the vehicle, ensure the object is properly centered, the root of the armature bone should be set at the origin. Switch to edit mode and rotate the armature 90 around the x axis.\n Now select the armature and add 4 more bones. Each of these bones needs to be located such that the root of the bone coincides with the centre of the each wheel. This can be achieved by locating the 3D cursor at the center of each wheel in edit mode. Select one of the wheels in object mode, select a vertex, press A to select all vertices then `Shift+S` and select `Cursor to selected` . This will locate the cursor in the center of the wheel. Then, in object mode, select the armature, switch to edit mode, select a bone and choose `Selection to cursor` . Your bone will now coincide with the wheel. Rotate each bone such that it lines up with the base of the armature. \nFor each wheel, it is recommended to name the bone according to the wheel it needs to be coupled to, this will help in identification later when you need to assign vertex groups to each bone.\n\n### Parenting\n\n Now select all the parts of the body and all 4 wheels using shift or control in the project outliner, then control select the armature you have created (this order is important, it won't work if you select these in reverse order). Press `Ctrl+p` and select `With empty groups` to bind the mesh to the armature. Now you have parented the mesh to the armature, you now need to assign each wheel to its respective bone. Select a wheel either in the outliner or the editor. Switch to edit mode, and select all the vertices of the wheel (shortcut - `a` ). \n\n### Assigning car parts to bones\n\n Select the mesh tab of the properties (the green triangle). Inside the vertex groups tab of the mesh properties panel, you should now see the bones of your armature. Select the bone corresponding to the wheel you are editing and select `Assign` . Once you have rigged the wheels, rig all other parts of the vehicle to the base bone. Once you have assigned all of the mesh parts to the armature you can test if it works by selecting the armature and moving to pose mode and moving the relevant bones. The vehicle base bone should move the whole vehicle, while the wheel bones should each move and rotate their respective wheels. Ensure to undo any posing you might do with `Ctrl+Z` . \n\n### Blender UE4 vehicle rigging add-on\n\nThere is a very useful add on for blender for rigging a vehicle for import into CARLA that helps streamline the above steps. Please see the add-on webpage for instructions.\n\n### Export\n\n Now we will export our rigged model into FBX format for import into Unreal Engine. Select `Export > FBX (.fbx)` from the File menu. In the `Object Types` section of the `Include` panel, shift select the `Armature` and `Mesh` options. In the `Transform` panel. Change `Forward` to `X Forward` and change `Up` to `Z Up` . This is important to ensure the vehicle is oriented correctly in the Unreal Engine. In the `Armature` section uncheck `Add Leaf Bones` and uncheck `Bake Animation` . \n\n## Importing into unreal engine\n\n Launch the Unreal Editor with the `make launch` command from the CARLA root directory (the one where you have built CARLA from source). Open a content browser, set up an appropriate directory and right click and select `Import to ....` . Choose the FBX file that you previously exported from Blender (or another 3D modelling application). Import with default settings. \n\n### Setting the physics asset\n\nYou will now have 3 things in your content browser directory, the mesh, the skeleton and the physics asset. Double click on the physics asset to adjust it.\n First, select the main body, in the `Details` menu on the right, change the `Linear Damping` to 0.0 in the `Physics` section, check \n\n```\nSimulation Generates Hit Events\n```\n\nin the `Collision` section and change the `Primitive Type` from `Capsule` to `Box` in the `Body Creation` section. Then press `Regenerate bodies` . The capsule will now change to a rectangular box. Then select the wheels. Now select all the wheels (in the `Skeleton Tree` section on the left). Change `Linear Damping` to 0.0, set `Physics Type` to `Kinematic` , set `Collision Response` to `Disabled` and select the `Primitive Type` as `Sphere` . Press `Re-generate Bodies` once more. \n\n### Creating the animation\n\n In the content browser directory where you have your new vehicle asset, right click and choose\n\n```\nAnimation > Animation Blueprint\n```\n\n. In the popup that opens, search for `VehicleAnimInstance` in the `Parent Class` section and for the `Target Skeleton` search for the skeleton corresponding to your new vehicle, you should be able to see the name in your content browser. After selecting these two things press OK. This will create a new animation blueprint for your vehicle. To simplify things, we can copy the animation from another vehicle. In a second content browser, open\n\nand choose any vehicle. Open the animation blueprint of your chosen vehicle and then copy all nodes that are not the `Output pose` node from this into your new animation blueprint. Connect the nodes by dragging a new connection between the final node to the output node. Press compile and the animation blueprint is now set. \n\n### Creating the blueprint\n\n Navigate with your content browser into\n\nor a similar vehicle. In here you will find a set of blueprints set up for the 4 wheels. Copy these into the directory containing your own vehicle and rename them to ensure you can distinguish them later. You can set up your own custom wheels if you prefer, please refer to the later wheels section Right click in the content browser directory where your new vehicle assets are and chose `Blueprint Class` . Search in the `All Classes` menu for `BaseVehiclePawn` and choose this class. Name the blueprint and open it. Select `Mesh` in the `Components` tab on the left and then drag the vehicle mesh into the Mesh section on the right hand side. In `Anim Class` search for the animation corresponding to your new vehicle that you set up in the previous step. Next, select `Vehicle Movement` in the `Components` menu of the blueprint class and in the right `Details` menu navigate to the `Vehicle Setup` section. Now for each wheel, find the relevant wheel blueprint that you previously copied and renamed for the `Wheel Class` attribute. Do the same for each wheel. Compile and save. Now navigate to\n\nand double click this to open the Vehicle Factory. Select the `Vehicles` node and expand the `Vehicles` item in the `Default value` section on the right hand side. \nPress the plus icon to add your new vehicle. Scroll down to the last entry and expand it, it should be empty. Name the make and model of your vehicle and under the class section find your blueprint class that you created in the previous section. Leave the number of wheels as 4 and put the generation as 2. Compile and save. Do a global save for safety and you are now..ready to run your vehicle in a simulation.\n Press play in the unreal toolbar to run the simulation. Once it is running, open a terminal and run the `manual_control.py` script with the filter option to specify your new vehicle model: \n\n```\npython manual_control.py --filter my_vehicle_make\n```\n\nAs it is, the vehicle currently has no textures or colors applied. The next step is to apply materials to give your vehicle a finish like a real road vehicle.\n\nOnce you have your vehicle imported as a basic asset with the mesh and blueprints laid out, you now want to add materials to your vehicle to facilitate photorealistic rendering in the Unreal Engine, for maximum fidelity in your machine learning training data.\n\nThe Unreal Editor boasts a comprehensive materials workflow that facilitates the creation of highly realistic materials. This does, however, add a significant degree of complexity to the process. For this reason, CARLA is provided with a large library of material prototypes for you to use without having to start from scratch.\n\n### Applying a material to your vehicle\n\n CARLA provides a prototype material for replicating the glossy finish of vehicles that can mimic numerous different types of vehicle paint jobs and features. Open Unreal editor and in the content browser, locate the material in\n\n```\nContent > Carla > Static > GenericMaterials > 00_MastersOpt\n```\n\n. The basic material is called `M_CarPaint_Master` . Right click on this material and choose \n\n```\nCreate Material Instance\n```\n\nfrom the context material. Name it and move it into the folder where your new vehicle content is stored. \nIn the Unreal Editor, move the spectator to a point near the floor and drag the skeletal mesh of the vehicle from the content browser into the scene, the body of your vehicle will now appear there.\n Now, in the details panel on the right hand side, drag your new material instance into the `Element 0` position of the `Materials` section. You will see the bodywork take on a new grey, glossy material property. \nDouble click on the material in the content browser and we can start editing the parameters. There are a numerous parameters here that alter various properties that are important to mimic real world car paint jobs. The most important parameters are the following:\n\n# Color\n\nThe color settings govern the overall color of the car. The base color is simply the primary color of the car this will govern the overall color:\n\n# Clear coat\n\nThe clear coat settings govern the appearance of the finish and how it reacts to light. The roughness uses a texture to apply imperfections to the vehicle surface, scattering light more with higher values to create a matte look. Subtle adjustments and low values are recommended for a realistic look. Generally, car paint jobs are smooth and reflective, however, this effect might be used more generously to model specialist matte finishes of custom paint jobs.\n An important parameter to govern the \"shininess\" or \"glossiness\" of your car is the `Clear Coat Intensity` . High values close to 1 will make the coat shiny and glossy. \n\n# Orange peel\n\nFinishes on real cars (particularly on mass produced cars for the general market) tend to have imperfections that appear as slight ripples in the paint. The orange peel effect mimics this and makes cars look more realistic.\n\n# Flakes\n\n Some cars have paint jobs that include flakes of other material, such as metals or ceramics, to give the car a `metallic` or `pearlescant` appearance, adding extra glints and reflections that react in an attractive way to light. The flakes parameters allows CARLA to mimic this. To mimic metallic finishes, it would be \n\n# Dust\n\nCars often accumulate grease and dust on the body that adds additional texture to the paint, affecting the way it reflects the light. The dust parameters allow you to add patches of disruption to the coat to mimic foreign materials sticking to the paint.\n\n## Glass\n\nCreating realistic glass in CARLA requires some tricks to capture the real refractive and reflective behavior of glass used in motor vehicles. The CARLA garage vehicles have 4 layers of meshes for the glass, with 2 different materials. The layers are separated by a few millimeters and there are separate materials for the interior and exterior facing glass layers to ensure that the glass looks realistic from both inside and outside the vehicle.\n\nThere are 2 layers of glass for the appearance of the vehicle from outside and 2 layers for the appearance of glass from the interior of the vehicle. What makes glass look like glass is the reflections coming from both surfaces of the glass that makes a very subtle doubling of the reflection.\n\n### Glass meshes\n\nHere we see the glass parts attached to the main bodywork (not the doors or other moving parts) of the Lincoln.\n\nIf we separate the constituent mesh parts, we can see that the glass profile is separated into 4 different layers.\n\nThe 4 layers are separated into 2 groups, the exterior layers, with normals facing out of the vehicle and the interior layers, with mesh normals facing into the vehicle interior. The following diagram demonstrates\n\nOnce you have created your mesh layers, import them in the content browser into the Unreal Editor in the folder where you have stored your vehicle.\n\nShift select the 4 glass layers and drag them into the map so you can see them.\n\n### Glass material\n\n Double click the external layer of the glass, then navigate in a second content browser window to\n\nand find the `Glass` material. Drag the glass material to the material slot of the mesh item. Repeat this process for each layer of the glass. \nThe glass will now be transparent, but with reflectivity that reflects nearby objects and light sources. You should also check the interior glass, ensure there is a proper glass effect there.\n\n### Single layer glass\n\nFor a quicker way to produce the glass parts of vehicles, the only critical part is the outermost glass layer. You can apply the glass material to this in Unreal Editor and get a result that might be suitable to your needs, however, views from inside the vehicle (i.e. if you instantiate a camera on the dashboard or behind the steering wheel) will seem to have no glass (no refraction or reflection). We recommend the above process to produce maximally realistic glass.\n\nNow you have created the blueprint, added meshes, completed rigging, created materials for the paint finish and the glass, you should have a very realistic looking vehicle.\n\n## Wheels\n\nIf you copied the wheels when you were creating the blueprint, this might suit your purposes if your vehicle is very similar to vehicles that are already in the CARLA library. However, if your vehicle has non-standard wheel dimensions or grip characteristics, you should follow this section to set up your wheel blueprints to best match the physical characteristics of your vehicle's wheels.\n\nFor the wheels of CARLA vehicles, we need to set up a blueprint class for each wheel to deal with the mechanics and collision properties. You will set up 4 blueprint classes, we recommend the following prefixes or suffixes to identify the wheels:\n\n* RRW - Rear Right Wheel\n * RLW - Rear Left Wheel\n * FRW - Front Right Wheel\n * FLW - Front Left Wheel\n\n### Wheel blueprint\n\nInside the folder where you have your new vehicle, right click and choose to create a new blueprint class. Search for\n\nDouble click on the blueprint to adjust it:\n\n### Collision mesh\n\n Firstly, the default cylinder used for the collision mesh has a high polygon count, so we should replace this with a low polygon version. In the content browser locate the `CollisionWheel` mesh inside \n\n. Drag it onto the `Collision Mesh` slot in the details panel of the blueprint. This will improve performance without any noticeable deficit to physics simulation. \n\n### Tire configuration\n\n Next, we set the tire configuration. Inside\n\nlocate the `CommonTireConfig` configuration and drag it onto the `Tire Config` section of the blueprint. If you double click on the Tire Config in the blueprint, you can adjust the Friction Scale, you can modify the behavior of the vehicle's road handling. By default it is set at 3.5, a value suitable for most vehicle use cases. However, if you wish to model for example a racing vehicle with slick tires, this would be the appropriate parameter to adjust. \n\n### Wheel dimensions\n\n Next, in your 3D application, measure the diameter of your wheel. In Blender, the dimensions can be viewed in the properties panel opened by pressing `n` in object mode. Now plug these numbers into the `Wheel` section of the blueprint.Take care to remember to half the diameter for the radius and also that Unreal Editor works in units of centimeters. For the wheel mass, we recommend looking for specifications on the internet, find the right tire model or a similar one to estimate the correct mass (in kilograms). \n\n```\nAffected by handbrake\n```\n\nshould be checked for both rear wheels. `Steer angle` should be set to the maximum intended steer angle for both front wheels and set to zero for both rear wheels. \n\n### Suspension characteristics\n\nThe default values here provide a reasonable starting point. View this guide to set suspension characteristics appropriate to your vehicle type.\n\n## Lights\n\nThe last element to complete a realistic vehicle for CARLA is the lights, headlights, brake lights, blinkers etc. In your 3D modelling application, you should model some shapes that resemble the lights of the vehicle you are replicating. This would be flat discs or flat cuboid structures for most headlights. Some vehicles may also have strips of LEDs.\n\n### UV map\n\nThe different types of lights (headlights, blinkers, brake lights, etc.) are distinguished using a texture. You need to create a UV map in your 3D modelling application and position the lights to match up with the relevant region of the texture.\n\n### Importing\n\nImport the light mesh into the Unreal Editor- After importing the light mesh:\n\n* Drag the mesh item(s) into the Mesh (VehicleMesh) (Inherited) hierarchy in the Components panel.\n * Select the extra meshes in the hierarchy and search for\n `Collision` in the Details panel. * Set Collision Presets to\n `NoCollision` . * Select any lights meshes in the hierarchy. Search for\n `Tag` in the Details panel and add the tag `emissive` .\n\nThis page introduces the fundamental concepts required to understand how the CARLA server and client operate and communicate through the API. CARLA operates using a server-client architecture, whereby the CARLA server runs the simulation and instructions are sent to it by the client(s). The client code communicates with the server using the API. To use the Python API you must install the module through PIP:\n\n```\npip install carla-simulator # Python 2\npip3 install carla-simulator # Python 3\n```\n\nAlso make sure to import the CARLA package in your python scripts:\n `import carla` \n\n* World and client\n * Syncrhonous and asyncrhonous mode\n * Recorder\n\n## World and client\n\n### Client\n\nThe client is the module the user runs to ask for information or changes in the simulation. A client runs with an IP and a specific port. It communicates with the server via terminal. There can be many clients running at the same time. Advanced multiclient managing requires thorough understanding of CARLA and synchrony.\n\nSet up the client using the CARLA client object:\n\n```\nclient = carla.Client('localhost', 2000)\n```\n\n This sets up the client to communicate with a CARLA server running on `localhost` , the local machine. Alternatively, the IP address of a network machine can be used if running the client on a separate machine. The second argument is the port number. By default, the CARLA server will run on port 2000, you can alter this in the settings when you launch CARLA if necessary. \nThe client object can be used for a number of functions including loading new maps, recording the simulation and initialising the traffic manager:\n\n```\nclient.load_world('Town07')\n\nclient.start_recorder('recording.log')\n```\n\n### World\n\nThe world is an object representing the simulation. It acts as an abstract layer containing the main methods to spawn actors, change the weather, get the current state of the world, etc. There is only one world per simulation. It will be destroyed and substituted for a new one when the map is changed.\n\nThe world object is retrieved using the client object:\n\n```\nworld = client.get_world()\n```\n\nThe world object can be used to access objects within the simulation, such as weather, vehicles, traffic lights, buildings and the map using its many methods:\n\n```\nlevel = world.get_map()\n\nweather = world.get_weather()\n\n## Synchronous and asynchronous mode\n\nCARLA has a client-server architecture. The server runs the simulation. The client retrieves information and requests changes in the simulation. This section deals with communication between client and server.\n\nBy default, CARLA runs in asynchronous mode.\n\nEssentially, in asynchronous mode the CARLA server runs as fast as it can. Client requests are handled on the fly. In synchronous mode the client, running your Python code, takes the reigns and tells the server when to update.\n\nAsynchronous mode is an appropriate mode to run CARLA if you are experimenting or setting up a simulation, so you can fly around the map with the spectator as you place your actors. When you want to start producing training data or deploying an agent within the simulation, it is advised that you use the synchronous mode since this will give you more control and predictability.\n\nRead more about synchronous and asynchronous modes.\n\nIn a multiclient architecture, only one client should tick. The server reacts to every tick received as if it came from the same client. Many client ticks will make the create inconsistencies between server and clients.\n\n### Setting synchronous mode\n\nChanging between synchronous and asynchronous mode is just a matter of a boolean state.\n\n```\nsettings = world.get_settings()\nsettings.synchronous_mode = True # Enables synchronous mode\nsettings.fixed_delta_seconds = 0.05\nworld.apply_settings(settings)\n```\n\nIf synchronous mode is enabled, and there is a Traffic Manager running, this must be set to sync mode too. Read this to learn how to do it.\n To disable synchronous mode just set the variable to `False` or use the script \n\n```\ncd PythonAPI/util && python3 config.py --no-sync # Disables synchronous mode\n```\n\nSynchronous mode cannot be enabled using the script, only disabled. Enabling the synchronous mode makes the server wait for a client tick. Using this script, the user cannot send ticks when desired.\n\n### Using synchronous mode\n\nThe synchronous mode becomes specially relevant with slow client applications, and when synchrony between different elements, such as sensors, is needed. If the client is too slow and the server does not wait, there will be an overflow of information. The client will not be able to manage everything, and it will be lost or mixed. On a similar tune, with many sensors and asynchrony, it would be impossible to know if all the sensors are using data from the same moment in the simulation.\n\nThe following fragment of code extends the previous one. The client creates a camera sensor, stores the image data of the current step in a queue, and ticks the server after retrieving it from the queue. A more complex example regarding several sensors can be found here.\n\n```\nsettings = world.get_settings()\nsettings.synchronous_mode = True\nworld.apply_settings(settings)\n\ncamera = world.spawn_actor(blueprint, transform)\nimage_queue = queue.Queue()\ncamera.listen(image_queue.put)\n\nwhile True:\n world.tick()\n image = image_queue.get()\n```\n\nData coming from GPU-based sensors, mostly cameras, is usually generated with a delay of a couple of frames. Synchrony is essential here.\n\nThe world has asynchrony methods to make the client wait for a server tick, or do something when it is received.\n\n```\n# Wait for the next tick and retrieve the snapshot of the tick.\nworld_snapshot = world.wait_for_tick()\n\n# Register a callback to get called every time we receive a new snapshot.\nworld.on_tick(lambda world_snapshot: do_something(world_snapshot))\n```\n\n## Recorder\n\nThe recorder enables all data required to reproduce a previous simulation to be saved into a file. The data includes details like the position and speed of vehicles, the state of traffic lights, the position and speed of pedestrians and the position of the sun and weather conditions. The data gets recorded into a binary file that can be loaded at a later time by the carla server to exactly reproduce the simulation.\n\nActors are updated on every frame according to the data contained in the recorded file. Actors in the current simulation that appear in the recording will be either moved or re-spawned to emulate it. Those that do not appear in the recording will continue their way as if nothing happened.\n\nBy the end of the playback, vehicles will be set to autopilot, but pedestrians will stop.\n\nThe recorder file includes information regarding many different elements.\n\n* Actors — creation and destruction, bounding and trigger boxes.\n * Traffic lights — state changes and time settings.\n * Vehicles — position and orientation, linear and angular velocity, light state, and physics control.\n * Pedestrians — position and orientation, and linear and angular velocity.\n * Lights — Light states from buildings, streets, and vehicles.\n\n### Recording\n\n To start recording there is only need for a file name. Using `\\` , `/` or `:` characters in the file name will define it as an absolute path. If no path is detailed, the file will be saved in `CarlaUE4/Saved` . \n\n```\nclient.start_recorder(\"/home/carla/recording01.log\")\n```\n\n By default, the recorder is set to store only the necessary information to play the simulation back. In order to save all the information previously mentioned, the argument `additional_data` has to be configured when starting the recording. \n\n```\nclient.start_recorder(\"/home/carla/recording01.log\", True)\n```\n\nAdditional data includes: linear and angular velocity of vehicles and pedestrians, traffic light time settings, execution time, actors' trigger and bounding boxes, and physics controls for vehicles.\n\nTo stop the recording, the call is also straightforward.\n\n```\nclient.stop_recorder()\n```\n\nAs an estimate, 1h recording with 50 traffic lights and 100 vehicles takes around 200MB in size.\n\n### Simulation playback\n\nA playback can be started at any point during a simulation. Besides the path to the log file, this method needs some parameters.\n\n```\nclient.replay_file(\"recording01.log\", start, duration, camera)\n```\n\nParameter | Description | Notes |\n | --- | --- | --- |\n | Recording time in seconds to start the simulation at. | If positive, time will be considered from the beginning of the recording. |\n | Seconds to playback. 0 is all the recording. | By the end of the playback, vehicles will be set to autopilot and pedestrians will stop. |\n | ID of the actor that the camera will focus on. | Set it to |\n\n### Recorder file format\n\nThe recorder saves all of the data in a custom binary file format specified in [this document]\n\n## Rendering\n\nCARLA offers a number of options regarding rendering quality and efficiency. At the most basic level, CARLA offers two quality options to enable operation on both high and low spec hardware with the best results:\n\n### Epic mode\n\n```\n./CarlaUE4.sh -quality-level=Epic\n```\n\nEpic mode screenshot\n\n### Low mode\n\n```\n./CarlaUE4.sh -quality-level=Low\n```\n\nLow mode screenshot\n\nCARLA also offers options to suspend rendering or render offscreen, to enable simulations to be recorded or run more efficiently.\n\nMore details on rendering options can be found here.\n\nActors in CARLA are the elements that perform actions within the simulation, and they can affect other actors. Actors in CARLA includes vehicles and walkers and also sensors, traffic signs, traffic lights and the spectator. It is crucial to have full understanding on how to operate on them.\n\nThis section will cover spawning, destruction, types, and how to manage them. However, the possibilities are almost endless. Experiment, take a look at the tutorials in this documentation and share doubts and ideas in the CARLA forum.\n\n* Blueprints\n * Actor life cycle\n * Types of actors\n\n## Blueprints\n\nThese layouts allow the user to smoothly incorporate new actors into the simulation. They are already-made models with animations and a series of attributes. Some of these are modifiable and others are not. These attributes include, among others, vehicle color, amount of channels in a lidar sensor, a walker's speed, and much more.\n\nAvailable blueprints are listed in the blueprint library, along with their attributes. Vehicle and walker blueprints have a generation attribute that indicates if they are a new (gen 2) or old (gen 1) asset.\n\n### Managing the blueprint library\n\nThe carla.BlueprintLibrary class contains a list of carla.ActorBlueprint elements. It is the world object who can provide access to it.\n\nBlueprints have an ID to identify them and the actors spawned with it. The library can be read to find a certain ID, choose a blueprint at random, or filter results using a wildcard pattern.\n\n```\n# Find a specific blueprint.\ncollision_sensor_bp = blueprint_library.find('sensor.other.collision')\n# Choose a vehicle blueprint at random.\nvehicle_bp = random.choice(blueprint_library.filter('vehicle.*.*'))\n```\n\nBesides that, each carla.ActorBlueprint has a series of carla.ActorAttribute that can be get and set.\n\n```\nis_bike = [vehicle.get_attribute('number_of_wheels') == 2]\nif(is_bike)\n vehicle.set_attribute('color', '255,0,0')\n```\n\nSome of the attributes cannot be modified. Check it out in the blueprint library.\n\nAttributes have an carla.ActorAttributeType variable. It states its type from a list of enums. Also, modifiable attributes come with a list of recommended values.\n\n```\nfor attr in blueprint:\n if attr.is_modifiable:\n blueprint.set_attribute(attr.id, random.choice(attr.recommended_values))\n```\n\nUsers can create their own vehicles. Check the Tutorials (assets) to learn on that. Contributors can add their new content to CARLA.\n\n## Actor life cycle\n\nThis section mentions different methods regarding actors. The Python API provides for commands to apply batches of the most common ones, in just one frame.\n\nThe world object is responsible of spawning actors and keeping track of these. Spawning only requires a blueprint, and a carla.Transform stating a location and rotation for the actor.\n\nThe world has two different methods to spawn actors.\n\n* \n `spawn_actor()` raises an exception if the spawning fails. * \n `try_spawn_actor()` returns `None` if the spawning fails. \n\n```\ntransform = Transform(Location(x=230, y=195, z=40), Rotation(yaw=180))\nactor = world.spawn_actor(blueprint, transform)\n```\n\nImportant\n CARLA uses the Unreal Engine coordinates system. Remember that `carla.Rotation` constructor is defined as `(pitch, yaw, roll)` , that differs from Unreal Engine Editor `(roll, pitch, yaw)` . \nThe actor will not be spawned in case of collision at the specified location. No matter if this happens with a static object or another actor. It is possible to try avoiding these undesired spawning collisions.\n\n```\nmap.get_spawn_points()\n```\n\nfor vehicles. Returns a list of recommended spawning points. \n\n```\nworld.get_random_location()\n```\n\nfor walkers. Returns a random point on a sidewalk. This same method is used to set a goal location for walkers. \n\n```\nspawn_point = carla.Transform()\nspawn_point.location = world.get_random_location_from_navigation()\n```\n\nAn actor can be attached to another one when spawned. Actors follow the parent they are attached to. This is specially useful for sensors. The attachment can be rigid (proper to retrieve precise data) or with an eased movement according to its parent. It is defined by the helper class carla.AttachmentType.\n\nThe next example attaches a camera rigidly to a vehicle, so their relative position remains fixed.\n\n```\ncamera = world.spawn_actor(camera_bp, relative_transform, attach_to=my_vehicle, carla.AttachmentType.Rigid)\n```\n\nWhen spawning attached actors, the transform provided must be relative to the parent actor.\n\nOnce spawned, the world object adds the actors to a list. This can be easily searched or iterated on.\n\n```\nactor_list = world.get_actors()\n# Find an actor by id.\nactor = actor_list.find(id)\n# Print the location of all the speed limit signs in the world.\nfor speed_sign in actor_list.filter('traffic.speed_limit.*'):\n print(speed_sign.get_location())\n```\n\n### Handling\n\ncarla.Actor mostly consists of get() and set() methods to manage the actors around the map.\n\n```\nprint(actor.get_acceleration())\nprint(actor.get_velocity())\n\nlocation = actor.get_location()\nlocation.z += 10.0\nactor.set_location(location)\n```\n\nThe actor's physics can be disabled to freeze it in place.\n\n```\nactor.set_simulate_physics(False)\n```\n\nBesides that, actors also have tags provided by their blueprints. These are mostly useful for semantic segmentation sensors.\n\nMost of the methods send requests to the simulator asynchronously. The simulator has a limited amount of time each update to parse them. Flooding the simulator with set() methods will accumulate a significant lag.\n\n### Destruction\n\nActors are not destroyed when a Python script finishes. They have to explicitly destroy themselves.\n\n```\ndestroyed_sucessfully = actor.destroy() # Returns True if successful\n```\n\nDestroying an actor blocks the simulator until the process finishes.\n\n## Types of actors\n\n### Sensors\n\nSensors are actors that produce a stream of data. They have their own section, 4th. Sensors and data. For now, let's just take a look at a common sensor spawning cycle.\n\nThis example spawns a camera sensor, attaches it to a vehicle, and tells the camera to save the images generated to disk.\n\n```\ncamera_bp = blueprint_library.find('sensor.camera.rgb')\ncamera = world.spawn_actor(camera_bp, relative_transform, attach_to=my_vehicle)\ncamera.listen(lambda image: image.save_to_disk('output/%06d.png' % image.frame))\n```\n\n* Sensors have blueprints too. Setting attributes is crucial.\n * Most of the sensors will be attached to a vehicle to gather information on its surroundings.\n * Sensors listen to data. When data is received, they call a function described with a Lambda expression (6.14 in the link provided).\n\n### Spectator\n\nPlaced by Unreal Engine to provide an in-game point of view. It can be used to move the view of the simulator window. The following example would move the spectator actor, to point the view towards a desired vehicle.\n\n```\nspectator = world.get_spectator()\ntransform = vehicle.get_transform()\nspectator.set_transform(carla.Transform(transform.location + carla.Location(z=50),\ncarla.Rotation(pitch=-90)))\n```\n\n### Traffic signs and traffic lights\n\nOnly stops, yields and traffic lights are considered actors in CARLA so far. The rest of the OpenDRIVE signs are accessible from the API as carla.Landmark. Their information is accessible using these instances, but they do no exist in the simulation as actors. Landmarks are explained more in detail in the following step, 3rd. Maps and navigation.\n\nWhen the simulation starts, stop, yields and traffic light are automatically generated using the information in the OpenDRIVE file. None of these can be found in the blueprint library and thus, cannot be spawned.\n\nCARLA maps do not have traffic signs nor lights in the OpenDRIVE file. These are manually placed by developers.\n\nTraffic signs are not defined in the road map itself, as explained in the following page. Instead, they have a carla.BoundingBox to affect vehicles inside of it.\n\n```\n#Get the traffic light affecting a vehicle\nif vehicle_actor.is_at_traffic_light():\n traffic_light = vehicle_actor.get_traffic_light()\n```\n\n Traffic lights are found in junctions. They have their unique ID, as any actor, but also a `group` ID for the junction. To identify the traffic lights in the same group, a `pole` ID is used. \nThe traffic lights in the same group follow a cycle. The first one is set to green while the rest remain frozen in red. The active one spends a few seconds in green, yellow and red, so there is a period of time where all the lights are red. Then, the next traffic light starts its cycle, and the previous one is frozen with the rest.\n\nThe state of a traffic light can be set using the API. So does the seconds spent on each state. Possible states are described with carla.TrafficLightState as a series of enum values.\n\n```\n#Change a red traffic light to green\nif traffic_light.get_state() == carla.TrafficLightState.Red:\n traffic_light.set_state(carla.TrafficLightState.Green)\n traffic_light.set_set_green_time(4.0)\n```\n\nVehicles will only be aware of a traffic light if the light is red.\n\n### Vehicles\n\ncarla.Vehicle is a special type of actor. It incorporates special internal components that simulate the physics of wheeled vehicles. This is achieved by applying four types of different controls:\n\n* carla.VehicleControl provides input for driving commands such as throttle, steering, brake, etc.\n\n```\nvehicle.apply_control(carla.VehicleControl(throttle=1.0, steer=-1.0))\n```\n\ncarla.VehiclePhysicsControl defines physical attributes of the vehicle and contains two more controllers:\n\n* carla.GearPhysicsControl which controls the gears.\n * carla.WheelPhysicsControl which provides specific control over each wheel.\n\n```\nvehicle.apply_physics_control(carla.VehiclePhysicsControl(max_rpm = 5000.0, center_of_mass = carla.Vector3D(0.0, 0.0, 0.0), torque_curve=[[0,400],[5000,400]]))\n```\n\nVehicles have a carla.BoundingBox encapsulating them. This bounding box allows physics to be applied to the vehicle and enables collisions to be detected.\n\n```\nbox = vehicle.bounding_box\n print(box.location) # Location relative to the vehicle.\n print(box.extent) # XYZ half-box extents in meters.\n```\n\nThe physics of vehicle wheels can be improved by enabling the sweep wheel collision parameter. The default wheel physics uses single ray casting from the axis to the floor for each wheel but when sweep wheel collision is enabled, the full volume of the wheel is checked against collisions. It can be enabled as such:\n\n```\nphysics_control = vehicle.get_physics_control()\n physics_control.use_sweep_wheel_collision = True\n vehicle.apply_physics_control(physics_control)\n```\n\nVehicles include other functionalities unique to them:\n\n* Autopilot mode will subscribe a vehicle to the Traffic Manager to simulate real urban conditions. This module is hard-coded, not based on machine learning.\n\n```\nvehicle.set_autopilot(True)\n```\n\n* Vehicle lights have to be turned on and off by the user. Each vehicle has a set of lights listed in carla.VehicleLightState. Not all vehicles have lights integrated. At the time of writing, vehicles with integrated lights are as follows:\n\n* Bikes: All bikes have a front and back position light.\n * Motorcycles: Yamaha and Harley Davidson models.\n * Cars: Audi TT, Chevrolet Impala, both Dodge police cars, Dodge Charger, Audi e-tron, Lincoln 2017 and 2020, Mustang, Tesla Model 3, Tesla Cybertruck, Volkswagen T2 and the Mercedes C-Class.\n\nThe lights of a vehicle can be retrieved and updated anytime using the methods carla.Vehicle.get_light_state and carla.Vehicle.set_light_state. These use binary operations to customize the light setting.\n\n```\n# Turn on position lights\ncurrent_lights = carla.VehicleLightState.NONE\ncurrent_lights |= carla.VehicleLightState.Position\nvehicle.set_light_state(current_lights)\n```\n\n### Walkers\n\ncarla.Walker work in a similar way as vehicles do. Control over them is provided by controllers.\n\n* carla.WalkerControl moves the pedestrian around with a certain direction and speed. It also allows them to jump.\n * carla.WalkerBoneControl provides control over the 3D skeleton. This tutorial explains how to control it.\n\nWalkers can be AI controlled. They do not have an autopilot mode. The carla.WalkerAIController actor moves around the actor it is attached to.\n\n```\nwalker_controller_bp = world.get_blueprint_library().find('controller.ai.walker')\nworld.SpawnActor(walker_controller_bp, carla.Transform(), parent_walker)\n```\n\nNote\n The AI controller is bodiless and has no physics. It will not appear on scene. Also, location `(0,0,0)` relative to its parent will not cause a collision. \nEach AI controller needs initialization, a goal and, optionally, a speed. Stopping the controller works in the same manner.\n\n```\nai_controller.start()\nai_controller.go_to_location(world.get_random_location_from_navigation())\nai_controller.set_max_speed(1 + random.random()) # Between 1 and 2 m/s (default is 1.4 m/s).\n...\nai_controller.stop()\n```\n\nWhen a walker reaches the target location, they will automatically walk to another random point. If the target point is not reachable, walkers will go to the closest point from their current location.\n\nA snipet in carla.Client uses batches to spawn a lot of walkers and make them wander around.\n\nTo destroy AI pedestrians, stop the AI controller and destroy both, the actor, and the controller.\n\nThat is a wrap as regarding actors in CARLA. The next step takes a closer look into the map, roads and traffic in CARLA.\n\nKeep reading to learn more or visit the forum to post any doubts or suggestions that have come to mind during this reading.\n\nAfter discussing about the world and its actors, it is time to put everything into place and understand the map and how do the actors navigate it.\n\n* The map\n * Navigation in CARLA\n * CARLA maps\n * Custom maps\n\n## The map\n\nA map includes both the 3D model of a town and its road definition. A map's road definition is based on an OpenDRIVE file, a standarized, annotated road definition format. The way the OpenDRIVE standard 1.4 defines roads, lanes, junctions, etc. determines the functionality of the Python API and the reasoning behind decisions made.\n\nThe Python API acts as a high level querying system to navigate these roads. It is constantly evolving to provide a wider set of tools.\n\n### Changing the map\n\nTo change the map, the world has to change too. The simulation will be recreated from scratch. You can either restart with the same map in a new world or you can change both the map and the world:\n\n* \n `reload_world()` creates a new instance of the world with the same map. * \n `load_world()` changes the current map and creates a new world. \n\n```\nworld = client.load_world('Town01')\n```\n\n Each map has a `name` attribute that matches the name of the currently loaded city, e.g. Town01. To get a list of the available maps: \n\n```\nprint(client.get_available_maps())\n```\n\n### Landmarks\n\nTraffic signs defined in the OpenDRIVE file are translated to CARLA as landmark objects that can be queried from the API. The following methods and classes can be used to manipulate and work with landmark objects:\n\n* \n `carla.Landmark` objects represent OpenDRIVE signals. The attributes and methods of this class describe the landmark and its area of influence. \n\n```\ncarla.LandmarkOrientation\n```\n\nstates the orientation of the landmark with regard to the road's geometry definition. * \n `carla.LandmarkType` contains common landmark types to facilitate translation to OpenDRIVE types. * \n `carla.Waypoint` can get landmarks located a certain distance ahead of it. The landmark type to get can be specified. * \n `carla.Map` retrieves sets of landmarks. It can return all landmarks in the map, or those which have a common ID, type or group. * \n `carla.World` acts as intermediary between landmarks and the `carla.TrafficSign` and `carla.TrafficLight` that represent them in the simulation. \n\n```\nmy_waypoint.get_landmarks(200.0,True)\n```\n\n### Waypoints\n\n A `carla.Waypoint` is a 3D-directed point in the CARLA world corresponding to an OpenDRIVE lane. Everything related to waypoints happens on the client-side; communication with the server is only needed once to get the map object containing the waypoint information. Each waypoint contains a `carla.Transform` which states its location on the map and the orientation of the lane containing it. The variables `road_id` , `section_id` , `lane_id` and `s` correspond to the OpenDRIVE road. The `id` of the waypoint is constructed from a hash combination of these four values. \nNote\n Waypoints closer than 2cm within the same road share the same `id` . \nA waypoint holds information about the lane containing it. This information includes the lane's left and right lane markings, a boolean to determine if it's inside a junction, the lane type, width, and lane changing permissions.\n\n```\n# Access lane information from a waypoint\ninside_junction = waypoint.is_junction()\nwidth = waypoint.lane_width\nright_lm_color = waypoint.right_lane_marking.color\n```\n\n### Lanes\n\n The lane types defined by OpenDRIVE standard 1.4 are translated to the API in `carla.LaneType` as a series of enum values. The lane markings surrounding a lane are accessed through `carla.LaneMarking` . Lane markings are defined by a series of variables: \n\n* color:\n\n```\ncarla.LaneMarkingColor\n```\n\nare enum values that define the marking's color. * lane_change:\n `carla.LaneChange` states if the lane permits turning left, right, both or none. * type:\n\n```\ncarla.LaneMarkingType\n```\n\nare enum values that define the type of marking according to the OpenDRIVE standard. * width: defines the marking's thickness.\n\nThe below example shows to get information about the lane type, lane markings, and lane change permissions at a specific waypoint:\n\n```\n# Get the lane type of the waypoint\nlane_type = waypoint.lane_type\n\n# Get the type of lane marking on the left.\nleft_lanemarking_type = waypoint.left_lane_marking.type()\n\n# Get available lane changes for this waypoint.\nlane_change = waypoint.lane_change\n```\n\n### Junctions\n\n A `carla.Junction` represents an OpenDRIVE junction. This class encompasses a junction with a bounding box to identify lanes or vehicles within it. The `carla.Junction` class contains the `get_waypoints` method which returns a pair of waypoints for every lane within the junction. Each pair is located at the start and end points of the junction boundaries. \n\n```\nwaypoints_junc = my_junction.get_waypoints()\n```\n\n### Environment Objects\n\nEvery object on a CARLA map has a set of associated variables which can be found here. Included in these variables is a unique ID that can be used to toggle that object's visibility on the map. You can use the Python API to fetch the IDs of each environment object based on their semantic tag:\n\n```\n# Get the buildings in the world\n world = client.get_world()\n env_objs = world.get_environment_objects(carla.CityObjectLabel.Buildings)\n\n # Access individual building IDs and save in a set\n building_01 = env_objs[0]\n building_02 = env_objs[1]\n objects_to_toggle = {building_01.id, building_02.id}\n\n # Toggle buildings off\n world.enable_environment_objects(objects_to_toggle, False)\n # Toggle buildings on\n world.enable_environment_objects(objects_to_toggle, True)\n```\n\nSee an example of distinct objects being toggled:\n\n## Navigation in CARLA\n\n Navigation in CARLA is managed via the Waypoint API, a combination of methods from `carla.Waypoint` and `carla.Map` . \nThe client must initially communicate with the server to retrieve the map object containing the waypoint information. This is only required once, all subsequent queries are performed on the client side.\n\n### Navigating through waypoints\n\nThe Waypoint API exposes methods that allow waypoints to connect to each other and construct a path along a road for vehicles to navigate:\n\n* \n `next(d)` creates a list of waypoints within an approximate distance, `d` , in the direction of the lane. The list contains one waypoint for each possible deviation. * \n `previous(d)` creates a list of waypoints waypoint within an approximate distance, `d` , in the opposite direction of the lane. The list contains one waypoint for each possible deviation. * \n\n```\nnext_until_lane_end(d)\n```\n\n```\nprevious_until_lane_start(d)\n```\n\nreturn a list of waypoints a distance `d` apart. The lists go from the current waypoint to the end and beginning of its lane, respectively. * \n `get_right_lane()` and `get_left_lane()` return the equivalent waypoint in an adjacent lane, if one exists. A lane change maneuver can be made by finding the next waypoint to the one on its right/left lane, and moving to it. \n\n```\n# Find next waypoint 2 meters ahead.\nwaypoint = waypoint.next(2.0)\n```\n\n### Generating map navigation\n\n The client needs to make a request to the server to get the `.xodr` map file and parse it to a `carla.Map` object. This only needs to be done once. \nTo get the map object:\n\n```\nmap = world.get_map()\n```\n\n The map object contains recommended spawn points for the creation of vehicles. You can get a list of these spawn points, each one containing a `carla.Transform` , using the method below. Bear in mind that the spawn points may be occupied already, resulting in failed creation of vehicles due to collisions. \n\n You can get started with waypoints by getting the closest waypoint to a specific location or to a particular `road_id` , `lane_id` and `s` value in the map's OpenDRIVE definition: \n\n```\n# Nearest waypoint in the center of a Driving or Sidewalk lane.\nwaypoint01 = map.get_waypoint(vehicle.get_location(),project_to_road=True, lane_type=(carla.LaneType.Driving | carla.LaneType.Sidewalk))\n\n#Nearest waypoint but specifying OpenDRIVE parameters. \nwaypoint02 = map.get_waypoint_xodr(road_id,lane_id,s)\n```\n\nThe below example shows how to generate a collection of waypoints to visualize the city lanes. This will create waypoints all over the map, for every road and lane. All of them will approximately 2 meters apart:\n\n```\nwaypoint_list = map.generate_waypoints(2.0)\n```\n\nTo generate a minimal graph of road topology, use the example below. This will return a list of pairs (tuples) of waypoints. The first element in each pair connects with the second element and both define the start and end points of each lane in the map. More information on this method is found in the PythonAPI.\n\n```\nwaypoint_tuple_list = map.get_topology()\n```\n\n The example below converts a `carla.Transform` to geographical latitude and longitude coordinates, in the form of a `carla.GeoLocation` : \n\n```\nmy_geolocation = map.transform_to_geolocation(vehicle.transform)\n```\n\nUse the following example to save road information in OpenDRIVE format to disk:\n\n```\ninfo_map = map.to_opendrive()\n```\n\n## CARLA maps\n\nThere are eight towns in the CARLA ecosystem and each of those towns have two kinds of map, non-layered and layered. Layers refer to the grouped objects within a map and consist of the following:\n\n* NONE\n * Buildings\n * Decals\n * Foliage\n * Ground\n * ParkedVehicles\n * Particles\n * Props\n * StreetLights\n * Walls\n * All\n\n### Non-layered maps\n\nNon-layered maps are shown in the table below (click the town name to see an overhead image of the layout). All of the layers are present at all times and cannot be toggled on or off in these maps. Up until CARLA 0.9.11, these were the only kinds of map available.\n\nUsers can customize a map or even create a new map to be used in CARLA.\n\n### Layered maps\n\n The layout of layered maps is the same as non-layered maps but it is possible to toggle off and on the layers of the map. There is a minimum layout that cannot be toggled off and consists of roads, sidewalks, traffic lights and traffic signs. Layered maps can be identified by the suffix `_Opt` , for example, `Town01_Opt` . With these maps it is possible to load and unload layers via the Python API: \n\n```\n# Load layered map for Town 01 with minimum layout plus buildings and parked vehicles\n world = client.load_world('Town01_Opt', carla.MapLayer.Buildings | carla.MapLayer.ParkedVehicles)\n\n # Toggle all buildings off\n world.unload_map_layer(carla.MapLayer.Buildings)\n\n # Toggle all buildings on \n world.load_map_layer(carla.MapLayer.Buildings)\n```\n\nSee an example of all layers being loaded and unloaded in sequence:\n\n## Custom maps\n\nCARLA is designed to be extensible and highly customisable for specialist applications. Therefore, in addition to the many maps and assets already avaiable in CARLA out of the box, it is possible to create and import new maps, road networks and assets to populate bespoke environments in a CARLA simulation. The following documents detail the steps needed to build and integrate custom maps:\n\nSensors are actors that retrieve data from their surroundings. They are crucial to create learning environment for driving agents.\n\nThis page summarizes everything necessary to start handling sensors. It introduces the types available and a step-by-step guide of their life cycle. The specifics for every sensor can be found in the sensors reference.\n\n* Sensors step-by-step\n * Types of sensors\n * Sensors reference\n\n## Sensors step-by-step\n\nThe class carla.Sensor defines a special type of actor able to measure and stream data.\n\n* What is this data? It varies a lot depending on the type of sensor. All the types of data are inherited from the general carla.SensorData.\n * When do they retrieve the data? Either on every simulation step or when a certain event is registered. Depends on the type of sensor.\n * How do they retrieve the data? Every sensor has a\n `listen()` method to receive and manage the data. \nDespite their differences, all the sensors are used in a similar way.\n\n### Setting\n\nAs with every other actor, find the blueprint and set specific attributes. This is essential when handling sensors. Their attributes will determine the results obtained. These are detailed in the sensors reference.\n\nThe following example sets a dashboard HD camera.\n\n```\n# Find the blueprint of the sensor.\nblueprint = world.get_blueprint_library().find('sensor.camera.rgb')\n# Modify the attributes of the blueprint to set image resolution and field of view.\nblueprint.set_attribute('image_size_x', '1920')\nblueprint.set_attribute('image_size_y', '1080')\nblueprint.set_attribute('fov', '110')\n# Set the time in seconds between sensor captures\nblueprint.set_attribute('sensor_tick', '1.0')\n```\n\n `attachment_to` and `attachment_type` , are crucial. Sensors should be attached to a parent actor, usually a vehicle, to follow it around and gather the information. The attachment type will determine how its position is updated regarding said vehicle. \n\n* Rigid attachment. Movement is strict regarding its parent location. This is the proper attachment to retrieve data from the simulation.\n * SpringArm attachment. Movement is eased with little accelerations and decelerations. This attachment is only recommended to record videos from the simulation. The movement is smooth and \"hops\" are avoided when updating the cameras' positions.\n * SpringArmGhost attachment. Like the previous one but without doing the collision test, so the camera or sensor could cross walls or other geometries.\n\n```\ntransform = carla.Transform(carla.Location(x=0.8, z=1.7))\nsensor = world.spawn_actor(blueprint, transform, attach_to=my_vehicle)\n```\n\nWhen spawning with attachment, location must be relative to the parent actor.\n\n### Listening\n\n Every sensor has a `listen()` method. This is called every time the sensor retrieves data. The argument `callback` is a lambda function. It describes what should the sensor do when data is retrieved. This must have the data retrieved as an argument. \n\n```\n# do_something() will be called each time a new image is generated by the camera.\nsensor.listen(lambda data: do_something(data))\n\n...\n\n# This collision sensor would print everytime a collision is detected. \ndef callback(event):\n for actor_id in event:\n vehicle = world_ref().get_actor(actor_id)\n print('Vehicle too close: %s' % vehicle.type_id)\n\nsensor02.listen(callback)\n```\n\n### Data\n\nMost sensor data objects have a function to save the information to disk. This will allow it to be used in other environments.\n\nSensor data differs a lot between sensor types. Take a look at the sensors reference to get a detailed explanation. However, all of them are always tagged with some basic information.\n\nSensor data attribute | Type | Description |\n | --- | --- | --- |\n | int | Frame number when the measurement took place. |\n | double | Timestamp of the measurement in simulation seconds since the beginning of the episode. |\n | carla.Transform | World reference of the sensor at the time of the measurement. |\n\nImportant\n `is_listening` is a sensor attribute that enables/disables data listening at will. `sensor_tick` is a blueprint attribute that sets the simulation time between data received. \n\n## Types of sensors\n\n### Cameras\n\nTake a shot of the world from their point of view. For cameras that return carla.Image, you can use the helper class carla.ColorConverter to modify the image to represent different information.\n\nSensor | Output | Overview |\n | --- | --- | --- |\nDepth | carla.Image | Renders the depth of the elements in the field of view in a gray-scale map. |\nRGB | carla.Image | Provides clear vision of the surroundings. Looks like a normal photo of the scene. |\nOptical Flow | carla.Image | Renders the motion of every pixel from the camera. |\nSemantic segmentation | carla.Image | Renders elements in the field of view with a specific color according to their tags. |\nInstance segmentation | carla.Image | Renders elements in the field of view with a specific color according to their tags and a unique object ID. |\nDVS | carla.DVSEventArray | Measures changes of brightness intensity asynchronously as an event stream. |\n\n### Detectors\n\nRetrieve data when the object they are attached to registers a specific event.\n\n* Retrieve data when triggered.\n\nSensor | Output | Overview |\n | --- | --- | --- |\nCollision | carla.CollisionEvent | Retrieves collisions between its parent and other actors. |\nLane invasion | carla.LaneInvasionEvent | Registers when its parent crosses a lane marking. |\nObstacle | carla.ObstacleDetectionEvent | Detects possible obstacles ahead of its parent. |\n\n### Other\n\nDifferent functionalities such as navigation, measurement of physical properties and 2D/3D point maps of the scene.\n\nSensor | Output | Overview |\n | --- | --- | --- |\nGNSS | carla.GNSSMeasurement | Retrieves the geolocation of the sensor. |\nIMU | carla.IMUMeasurement | Comprises an accelerometer, a gyroscope, and a compass. |\nLIDAR | carla.LidarMeasurement | A rotating LIDAR. Generates a 4D point cloud with coordinates and intensity per point to model the surroundings. |\nRadar | carla.RadarMeasurement | 2D point map modelling elements in sight and their movement regarding the sensor. |\nRSS | carla.RssResponse | Modifies the controller applied to a vehicle according to safety checks. This sensor works in a different manner than the rest, and there is specific RSS documentation for it. |\nSemantic LIDAR | carla.SemanticLidarMeasurement | A rotating LIDAR. Generates a 3D point cloud with extra information regarding instance and semantic segmentation. |\n\nThat is a wrap on sensors and how do these retrieve simulation data.\n\nThus concludes the introduction to CARLA. However there is yet a lot to learn.\n\n* Continue learning. There are some advanced features in CARLA: rendering options, traffic manager, the recorder, and some more. This is a great moment to learn more about them.\n\n* Experiment freely. Take a look at the References section of this documentation. It contains detailed information on the classes in the Python API, sensors, code snippets and much more.\n\n* Give your two cents. Any doubts, suggestions and ideas are welcome in the forum.\n\nTraffic simulation is integral to the accurate and efficient training and testing of autonomous driving stacks. CARLA provides a number of different options to simulate traffic and specific traffic scenarios. This section is an overview of the options available to help decide which is the best fit for your use case.\n\n## Traffic Manager\n\n Traffic Manager is a module within CARLA that controls certain vehicles in a simulation from the client side. Vehicles are registered to Traffic Manager via the\n\n```\ncarla.Vehicle.set_autopilot\n```\n\nmethod or `command.SetAutopilot` class. Control of each vehicle is managed through a cycle of distinct stages which each run on a different thread. \nUseful for:\n\n* Populating a simulation with realistic urban traffic conditions.\n * Customizing traffic behaviours to set specific learning circumstances.\n * Developing phase-related functionalities and data structures while improving computational efficiency.\n\n## Scenario Runner and OpenScenario\n\nScenario Runner provides predefined traffic scenarios out of the box and also allows users to define their own scenarios using either Python or the OpenSCENARIO 1.0 standard.\n\nThe primary use of OpenSCENARIO is the description of complex maneuvers that involve multiple vehicles. Users can see which features of OpenSCENARIO are supported by Scenario Runner here. These features include Maneuvers, Actions, Conditions, Stories and the Storyboard.\n\nScenario Runner has to be installed separately from the main CARLA package.\n\n* Creating complex traffic scenarios and routes to prepare AD agents for evaluation in the CARLA leaderboard.\n * Defining bespoke metrics that can be run against recordings of the scenario simulation, foregoing the need to run simulations repeatedly.\n\n## Scenic\n\nScenic is a domain-specific probabilistic programming language for modeling the environments of cyber-physical systems like robots and autonomous cars. Scenic provides an specialized domain to facilitate execution of Scenic scripts on the CARLA simulator.\n\nScenic scenario definitions are easy to read and construct. A tutorial to create a simple scenario is provided here.\n\n* Generating multiple, diverse scenarios with a single scenario definition.\n * Defining probabilistic policies for dynamic agents to take actions over time in response to the state of the world.\n\n## SUMO\n\nSUMO is an open source, microscopic, multi-modal traffic simulation. In SUMO, each vehicle is modelled explicitly, has its own route, and moves individually through the network. Simulations are deterministic by default but there are various options for introducing randomness.\n\nCARLA provides a co-simulation feature with SUMO that allows distribution of tasks between the two simulators. Vehicles can be spawned in CARLA through SUMO, and managed by SUMO much as the Traffic Manager would do.\n\n* Exploitation of the capabilities of both CARLA and SUMO in one package.\n\nIf you have any doubts about the different options available to simulate traffic in CARLA, feel free to post in the forum or in Discord.\n\nCARLA is open source and designed to be highly extensible. This allows users to create custom functionality or content to suit specialized applications or specific needs. The following tutorials detail how to achieve specific development aims with the CARLA codebase:\n\n* Make release\n * Upgrading content\n * Create semantic tags\n * Create new sensor\n * Preformance benchmarking\n * Recorder file format\n * Collision boundaries\n\n## Make a release\n\nIf you want to develop your own fork of CARLA and publish releases of your code, follow this guide.\n\n## Upgrading content\n\nOur content resides on a separate Git LFS repository. As part of our build system, we generate and upload a package containing the latest version of this content tagged with the current date and commit. Regularly, we upgrade the CARLA repository with a link to the latest version of the content package. Please follow these instructions to upgrade content.\n\n## Create semantic tags\n\nCARLA has a set of semantic tags already defined suitable for most use cases. However, if you need additional classes you can add them as detailed in this guide\n\n## Creating a new sensor\n\nYou can modify CARLA's C++ code to create new sensors for your custom use cases. Please find the details here\n\n## Benchmarking performance\n\nCARLA has a benchmarking script to help with benchmarking performance on your system. Find the full details here\n\n## Recorder binary file format\n\nDetails on the binary file format for the recorder can be found here\n\n## Generating collision boundaries\n\nDetails on generating more accurate collision boundaries for vehicles can be found in this guide\n\nCARLA has a wealth of assets available out of the box including full towns and cities with road networks, buildings and infrastructure, vehicles and pedestrians to populate your simulations. However, for many applications, you may want to add your own assets and CARLA is fully capable of loading new assets created entirely by the user for maximum extensability.\n\nThe following documentation details numerous techniques for creating your own assets and adding them to CARLA.\n\n## Adding props\n\nProps are the assets populating the scene, other than the roads and vehicles. That includes streetlights, buildings, trees, and much more. The simulator can ingest new props anytime in a simple process. This is really useful to create customized environments in a map. This document demonstrates how to create and include custom props.\n\n## Adding vehicles\n\nVehicles are the bread and butter of CARLA. They serve to simulate other road users and act as a virtual emulation of the vehicle that an autonomous agent is built to control. CARLA has a large, growing library of vehicles out of the box, but for specialised applications, CARLA is capable of loading custom designed vehicles. This document details how to create and import custom vehicles.\n\n## Packaging assets\n\nIt is a common practice in CARLA to manage assets with standalone packages. Keeping them aside allows to reduce the size of the build. These asset packages can be easily imported into a CARLA package anytime. They also become really useful to easily distribute assets in an organized way. This document demonstrates how to package assets for use in CARLA.\n\n## Custom materials\n\nThe CARLA team prepares every asset to run under certain default settings. However, users that work in a build from source can modify these to best suit their needs. This document demonstrates how to achieve this.\n\n This reference contains all the details the Python API. To consult a previous reference for a specific CARLA release, change the documentation version using the panel in the bottom right corner.This will change the whole documentation to a previous state. Remember that the latest version is the `dev` branch and may show features not available in any packaged versions of CARLA. \n\n## carla.AckermannControllerSettings\n\nManages the settings of the Ackermann PID controller.\n\n* speed_kp (float)\nProportional term of the speed PID controller. * speed_ki (float)\nIntegral term of the speed PID controller. * speed_kd (float)\nDerivative term of the speed PID controller. * accel_kp (float)\nProportional term of the acceleration PID controller. * accel_ki (float)\nIntegral term of the acceleration PID controller. * accel_kd (float)\nDerivative term of the acceleration PID controller. \n\n* __init__(self, speed_kp=0.15, speed_ki=0.0, speed_kd=0.25, accel_kp=0.01, accel_ki=0.0, accel_kd=0.01)\n\n* \n `speed_kp` (float) * \n `speed_ki` (float) * \n `speed_kd` (float) * \n `accel_kp` (float) * \n `accel_ki` (float) * \n `accel_kd` (float) * Parameters:\n\n* __eq__(self, other=carla.AckermannControllerSettings)\n * __ne__(self, other=carla.AckermannControllerSettings)\n * __str__(self)\n\n## carla.Actor\n\nCARLA defines actors as anything that plays a role in the simulation or can be moved around. That includes: pedestrians, vehicles, sensors and traffic signs (considering traffic lights as part of these). Actors are spawned in the simulation by carla.World and they need for a carla.ActorBlueprint to be created. These blueprints belong into a library provided by CARLA, find more about them here.\n\n* attributes (dict)\nA dictionary containing the attributes of the blueprint this actor was based on. * id (int)\nIdentifier for this actor. Unique during a given episode. * type_id (str)\nThe identifier of the blueprint this actor was based on, e.g. `vehicle.ford.mustang` . * is_alive (bool)\nReturns whether this object was destroyed using this actor handle. * is_active (bool)\nReturns whether this actor is active (True) or not (False). * is_dormant (bool)\nReturns whether this actor is dormant (True) or not (False) - the opposite of is_active. * parent (carla.Actor)\nActors may be attached to a parent actor that they will follow around. This is said actor. * semantic_tags (list(int))\nA list of semantic tags provided by the blueprint listing components for this actor. E.g. a traffic light could be tagged with `Pole` and `TrafficLight` . These tags are used by the semantic segmentation sensor. Find more about this and other sensors here. * actor_state (carla.ActorState)\nReturns the carla.ActorState, which can identify if the actor is Active, Dormant or Invalid. * bounding_box (carla.BoundingBox)\nBounding box containing the geometry of the actor. Its location and rotation are relative to the actor it is attached to. \n\n* add_angular_impulse(self, angular_impulse)\nApplies an angular impulse at the center of mass of the actor. This method should be used for instantaneous torques, usually applied once. Use add_torque() to apply rotation forces over a period of time. \n\n* \n `impulse` (carla.Vector3D - N*s) - Impulse vector in global coordinates. * Parameters:\n * add_torque(self, torque)\nApplies a torque at the center of mass of the actor. This method should be used for torques that are applied over a certain period of time. Use add_angular_impulse() to apply a torque that only lasts an instant. \n\n* \n `torque` (carla.Vector3D - degrees) - Torque vector in global coordinates. * Parameters:\n * destroy(self)\nTells the simulator to destroy this actor and returns True if it was successful. It has no effect if it was already destroyed. \n\n* Return: bool\n * Warning: This method blocks the script until the destruction is completed by the simulator.\n * disable_constant_velocity(self)\nDisables any constant velocity previously set for a carla.Vehicle actor. * enable_constant_velocity(self, velocity)\nSets a vehicle's velocity vector to a constant value over time. The resulting velocity will be approximately the `velocity` being set, as with set_target_velocity(). \n\n* \n `velocity` (carla.Vector3D - m/s) - Velocity vector in local space. * Note: Only carla.Vehicle actors can use this method.\n * Warning: Enabling a constant velocity for a vehicle managed by the Traffic Manager may cause conflicts. This method overrides any changes in velocity by the TM.\n * Parameters:\n\n* get_acceleration(self)\nReturns the actor's 3D acceleration vector the client recieved during last tick. The method does not call the simulator. \n\n* Return: carla.Vector3D - m/s2\n * get_angular_velocity(self)\nReturns the actor's angular velocity vector the client recieved during last tick. The method does not call the simulator. \n\n* Return: carla.Vector3D - deg/s\n * get_location(self)\nReturns the actor's location the client recieved during last tick. The method does not call the simulator. \n\n* Return: carla.Location - meters\n * Setter: carla.Actor.set_location\n * get_transform(self)\nReturns the actor's transform (location and rotation) the client recieved during last tick. The method does not call the simulator. \n\n* Return: carla.Transform\n * Setter: carla.Actor.set_transform\n * get_velocity(self)\nReturns the actor's velocity vector the client recieved during last tick. The method does not call the simulator. \n\n* Return: carla.Vector3D - m/s\n * get_world(self)\nReturns the world this actor belongs to. \n\n* set_enable_gravity(self, enabled)\nEnables or disables gravity for the actor. Default is True. \n\n* \n `enabled` (bool) * Parameters:\n * set_location(self, location)\nTeleports the actor to a given location. \n\n* \n `location` (carla.Location - meters) * Getter: carla.Actor.get_location\n * Parameters:\n * set_simulate_physics(self, enabled=True)\nEnables or disables the simulation of physics on this actor. \n\n* \n `enabled` (bool) * Parameters:\n * set_target_angular_velocity(self, angular_velocity)\nSets the actor's angular velocity vector. This is applied before the physics step so the resulting angular velocity will be affected by external forces such as friction. \n\n* \n `angular_velocity` (carla.Vector3D - deg/s) * Parameters:\n * set_target_velocity(self, velocity)\nSets the actor's velocity vector. This is applied before the physics step so the resulting angular velocity will be affected by external forces such as friction. \n\n* \n `velocity` (carla.Vector3D) * Parameters:\n * set_transform(self, transform)\nTeleports the actor to a given transform (location and rotation). \n\n* \n `transform` (carla.Transform) * Getter: carla.Actor.get_transform\n * Parameters:\n\n## carla.ActorAttribute\n\nCARLA provides a library of blueprints for actors that can be accessed as carla.BlueprintLibrary. Each of these blueprints has a series of attributes defined internally. Some of these are modifiable, others are not. A list of recommended values is provided for those that can be set.\n\n* id (str)\nThe attribute's name and identifier in the library. * is_modifiable (bool)\nIt is True if the attribute's value can be modified. * recommended_values (list(str))\nA list of values suggested by those who designed the blueprint. * type (carla.ActorAttributeType)\nThe attribute's parameter type. \n\n* as_bool(self)\nReads the attribute as boolean value. * as_color(self)\nReads the attribute as carla.Color. * as_float(self)\nReads the attribute as float. * as_int(self)\nReads the attribute as int. * as_str(self)\nReads the attribute as string. \n\n* __bool__(self)\n * __eq__(self, other=bool / int / float / str / carla.Color / carla.ActorAttribute)\nReturns true if this actor's attribute and `other` are the same. \n\n* Return: bool\n * __float__(self)\n * __int__(self)\n * __ne__(self, other=bool / int / float / str / carla.Color / carla.ActorAttribute)\nReturns true if this actor's attribute and `other` are different. \n\n* Return: bool\n * __nonzero__(self)\nReturns true if this actor's attribute is not zero or null. \n\n* Return: bool\n * __str__(self)\n\n## carla.ActorAttributeType\n\nCARLA provides a library of blueprints for actors in carla.BlueprintLibrary with different attributes each. This class defines the types those at carla.ActorAttribute can be as a series of enum. All this information is managed internally and listed here for a better comprehension of how CARLA works.\n\n## carla.ActorBlueprint\n\nCARLA provides a blueprint library for actors that can be consulted through carla.BlueprintLibrary. Each of these consists of an identifier for the blueprint and a series of attributes that may be modifiable or not. This class is the intermediate step between the library and the actor creation. Actors need an actor blueprint to be spawned. These store the information for said blueprint in an object with its attributes and some tags to categorize them. The user can then customize some attributes and eventually spawn the actors through carla.World.\n\n* id (str)\nThe identifier of said blueprint inside the library. E.g. \n\n```\nwalker.pedestrian.0001\n```\n\n. * tags (list(str))\nA list of tags each blueprint has that helps describing them. E.g. \n\n```\n['0001', 'pedestrian', 'walker']\n```\n\n* has_attribute(self, id)\nReturns True if the blueprint contains the attribute `id` . \n\n* \n `id` (str) - e.g. `gender` would return True for pedestrians' blueprints. * Return: bool\n * Parameters:\n * has_tag(self, tag)\nReturns True if the blueprint has the specified `tag` listed. \n\n* \n `tag` (str) - e.g. 'walker'. * Return: bool\n * Parameters:\n * match_tags(self, wildcard_pattern)\nReturns True if any of the tags listed for this blueprint matches `wildcard_pattern` . Matching follows fnmatch standard. \n\n* \n `wildcard_pattern` (str) * Return: bool\n * Parameters:\n\n* get_attribute(self, id)\nReturns the actor's attribute with `id` as identifier if existing. \n\n* \n `id` (str) * Return: carla.ActorAttribute\n * Setter: carla.ActorBlueprint.set_attribute\n * Parameters:\n\n* set_attribute(self, id, value)\nIf the `id` attribute is modifiable, changes its value to `value` . \n\n* \n `id` (str) - The identifier for the attribute that is intended to be changed. * \n `value` (str) - The new value for said attribute. * Getter: carla.ActorBlueprint.get_attribute\n * Parameters:\n\n* __iter__(self)\nIterate over the carla.ActorAttribute that this blueprint has. * __len__(self)\nReturns the amount of attributes for this blueprint. * __str__(self)\n\n## carla.ActorList\n\nA class that contains every actor present on the scene and provides access to them. The list is automatically created and updated by the server and it can be returned using carla.World.\n\n* filter(self, wildcard_pattern)\nFilters a list of Actors matching `wildcard_pattern` against their variable type_id (which identifies the blueprint used to spawn them). Matching follows fnmatch standard. \n\n* \n `wildcard_pattern` (str) * Return: list\n * Parameters:\n * find(self, actor_id)\nFinds an actor using its identifier and returns it or None if it is not present. \n\n* \n `actor_id` (int) * Return: carla.Actor\n * Parameters:\n\n* __getitem__(self, pos=int)\nReturns the actor corresponding to `pos` position in the list. \n\n* Return: carla.Actor\n * __iter__(self)\nIterate over the carla.Actor contained in the list. * __len__(self)\nReturns the amount of actors listed. \n\n* Return: int\n * __str__(self)\nParses to the ID for every actor listed. \n\n## carla.ActorSnapshot\n\nA class that comprises all the information for an actor at a certain moment in time. These objects are contained in a carla.WorldSnapshot and sent to the client once every tick.\n\n* get_acceleration(self)\nReturns the acceleration vector registered for an actor in that tick. \n\n* Return: carla.Vector3D - rad/s\n * get_transform(self)\nReturns the actor's transform (location and rotation) for an actor in that tick. \n\n* Return: carla.Vector3D - m/s\n\n## carla.ActorState\n\nClass that defines the state of an actor.\n\n* Invalid\nAn actor is Invalid if a problem has occurred. * Active\nAn actor is Active when it visualized and can affect other actors. * Dormant\nAn actor is Dormant when it is not visualized and will not affect other actors through physics. For example, actors are dormant if they are on an unloaded tile in a large map. \n\n## carla.AttachmentType\n\nClass that defines attachment options between an actor and its parent. When spawning actors, these can be attached to another actor so their position changes accordingly. This is specially useful for sensors. The snipet in carla.World.spawn_actor shows some sensors being attached to a car when spawned. Note that the attachment type is declared as an enum within the class.\n\n* Rigid\nWith this fixed attachment the object follow its parent position strictly. This is the recommended attachment to retrieve precise data from the simulation. * SpringArm\nAn attachment that expands or retracts the position of the actor, depending on its parent. This attachment is only recommended to record videos from the simulation where a smooth movement is needed. SpringArms are an Unreal Engine component so check the UE docs to learn more about them. Warning: The SpringArm attachment presents weird behaviors when an actor is spawned with a relative translation in the Z-axis (e.g. \n\n). * SpringArmGhost\nAn attachment like the previous one but that does not make the collision test, and that means that it does not expands or retracts the position of the actor. The term ghost is because then the camera can cross walls and other geometries. This attachment is only recommended to record videos from the simulation where a smooth movement is needed. SpringArms are an Unreal Engine component so check the UE docs to learn more about them. Warning: The SpringArm attachment presents weird behaviors when an actor is spawned with a relative translation in the Z-axis (e.g. \n\n). \n\n## carla.BlueprintLibrary\n\nA class that contains the blueprints provided for actor spawning. Its main application is to return carla.ActorBlueprint objects needed to spawn actors. Each blueprint has an identifier and attributes that may or may not be modifiable. The library is automatically created by the server and can be accessed through carla.World.\n\nHere is a reference containing every available blueprint and its specifics.\n\n* filter(self, wildcard_pattern)\nFilters a list of blueprints matching the `wildcard_pattern` against the id and tags of every blueprint contained in this library and returns the result as a new one. Matching follows fnmatch standard. \n\n* \n `wildcard_pattern` (str) * Return: carla.BlueprintLibrary\n * Parameters:\n * filter_by_attribute(self, name, value)\nFilters a list of blueprints with a given attribute matching the `value` against every blueprint contained in this library and returns the result as a new one. Matching follows fnmatch standard. \n\n* \n `name` (str) * \n `value` (str) * Return: carla.BlueprintLibrary\n * Parameters:\n * find(self, id)\nReturns the blueprint corresponding to that identifier. \n\n* \n `id` (str) * Return: carla.ActorBlueprint\n * Parameters:\n\n* __getitem__(self, pos=int)\nReturns the blueprint stored in `pos` position inside the data structure containing them. \n\n* Return: carla.ActorBlueprint\n * __iter__(self)\nIterate over the carla.ActorBlueprint stored in the library. * __len__(self)\nReturns the amount of blueprints comprising the library. \n\n* Return: int\n * __str__(self)\nParses the identifiers for every blueprint to string. \n\n* Return: string\n\n## carla.BoundingBox\n\nBounding boxes contain the geometry of an actor or an element in the scene. They can be used by carla.DebugHelper or a carla.Client to draw their shapes for debugging. Check out the snipet in carla.DebugHelper.draw_box where a snapshot of the world is used to draw bounding boxes for traffic lights.\n\n* extent (carla.Vector3D - meters)\nVector from the center of the box to one vertex. The value in each axis equals half the size of the box for that axis. `extent.x * 2` would return the size of the box in the X-axis. * location (carla.Location - meters)\nThe center of the bounding box. * rotation (carla.Rotation)\nThe orientation of the bounding box. \n\n* __init__(self, location, extent)\n\n* \n `location` (carla.Location) - Center of the box, relative to its parent. * \n `extent` (carla.Vector3D - meters) - Vector containing half the size of the box for every axis. * Parameters:\n * contains(self, world_point, transform)\nReturns True if a point passed in world space is inside this bounding box. \n\n* \n `world_point` (carla.Location - meters) - The point in world space to be checked. * \n `transform` (carla.Transform) - Contains location and rotation needed to convert this object's local space to world space. * Return: bool\n * Parameters:\n\n* get_local_vertices(self)\nReturns a list containing the locations of this object's vertices in local space. \n\n* Return: list(carla.Location)\n * get_world_vertices(self, transform)\nReturns a list containing the locations of this object's vertices in world space. \n\n* \n `transform` (carla.Transform) - Contains location and rotation needed to convert this object's local space to world space. * Return: list(carla.Location)\n * Parameters:\n\n* __eq__(self, other=carla.BoundingBox)\nReturns true if both location and extent are equal for this and `other` . \n\n* Return: bool\n * __ne__(self, other=carla.BoundingBox)\nReturns true if either location or extent are different for this and `other` . \n\n* Return: bool\n * __str__(self)\nParses the location and extent of the bounding box to string. \n\n## carla.CityObjectLabel\n\nEnum declaration that contains the different tags available to filter the bounding boxes returned by carla.World.get_level_bbs(). These values correspond to the semantic tag that the elements in the scene have.\n\n* None\n * Buildings\n * Fences\n * Other\n * Pedestrians\n * Poles\n * RoadLines\n * Roads\n * Sidewalks\n * TrafficSigns\n * Vegetation\n * Vehicles\n * Walls\n * Sky\n * Ground\n * Bridge\n * RailTrack\n * GuardRail\n * TrafficLight\n * Static\n * Dynamic\n * Water\n * Terrain\n * Any\n\n## carla.Client\n\nThe Client connects CARLA to the server which runs the simulation. Both server and client contain a CARLA library (libcarla) with some differences that allow communication between them. Many clients can be created and each of these will connect to the RPC server inside the simulation to send commands. The simulation runs server-side. Once the connection is established, the client will only receive data retrieved from the simulation. Walkers are the exception. The client is in charge of managing pedestrians so, if you are running a simulation with multiple clients, some issues may arise. For example, if you spawn walkers through different clients, collisions may happen, as each client is only aware of the ones it is in charge of.\n\nThe client also has a recording feature that saves all the information of a simulation while running it. This allows the server to replay it at will to obtain information and experiment with it. Here is some information about how to use this recorder.\n\n* __init__(self, host=127.0.0.1, port=2000, worker_threads=0)\nClient constructor. \n\n* \n `host` (str) - IP address where a CARLA Simulator instance is running. Default is localhost (127.0.0.1). * \n `port` (int) - TCP port where the CARLA Simulator instance is running. Default are 2000 and the subsequent 2001. * \n `worker_threads` (int) - Number of working threads used for background updates. If 0, use all available concurrency. * Parameters:\n * apply_batch(self, commands)\nExecutes a list of commands on a single simulation step and retrieves no information. If you need information about the response of each command, use the apply_batch_sync() method. Here is an example on how to delete the actors that appear in carla.ActorList all at once. \n\n* \n `commands` (list) - A list of commands to execute in batch. Each command is different and has its own parameters. They appear listed at the bottom of this page. * Parameters:\n * apply_batch_sync(self, commands, due_tick_cue=False)\nExecutes a list of commands on a single simulation step, blocks until the commands are linked, and returns a list of command.Response that can be used to determine whether a single command succeeded or not. Here is an example of it being used to spawn actors. \n\n* \n `commands` (list) - A list of commands to execute in batch. The commands available are listed right above, in the method apply_batch(). * \n `due_tick_cue` (bool) - A boolean parameter to specify whether or not to perform a carla.World.tick after applying the batch in synchronous mode. It is False by default. * Return: list(command.Response)\n * Parameters:\n * generate_opendrive_world(self, opendrive, parameters=(2.0, 50.0, 1.0, 0.6, true, true), reset_settings=True)\nLoads a new world with a basic 3D topology generated from the content of an OpenDRIVE file. This content is passed as a `string` parameter. It is similar to \n\n```\nclient.load_world(map_name)\n```\n\nbut allows for custom OpenDRIVE maps in server side. Cars can drive around the map, but there are no graphics besides the road and sidewalks. \n\n* \n `opendrive` (str) - Content of an OpenDRIVE file as `string` , not the path to the `.xodr` . * \n `parameters` (carla.OpendriveGenerationParameters) - Additional settings for the mesh generation. If none are provided, default values will be used. * \n `reset_settings` (bool) - Option to reset the episode setting to default values, set to false to keep the current settings. This is useful to keep sync mode when changing map and to keep deterministic scenarios. * Parameters:\n * load_world(self, map_name, reset_settings=True, map_layers=carla.MapLayer.All)\nCreates a new world with default settings using `map_name` map. All actors in the current world will be destroyed. \n\n* \n `map_name` (str) - Name of the map to be used in this world. Accepts both full paths and map names, e.g. '/Game/Carla/Maps/Town01' or 'Town01'. Remember that these paths are dynamic. * \n `reset_settings` (bool) - Option to reset the episode setting to default values, set to false to keep the current settings. This is useful to keep sync mode when changing map and to keep deterministic scenarios. * \n `map_layers` (carla.MapLayer) - Layers of the map that will be loaded. By default all layers are loaded. This parameter works like a flag mask. * Warning:\n `map_layers` are only available for \"Opt\" maps * Parameters:\n * reload_world(self, reset_settings=True)\nReload the current world, note that a new world is created with default settings using the same map. All actors present in the world will be destroyed, but traffic manager instances will stay alive. \n\n* \n `reset_settings` (bool) - Option to reset the episode setting to default values, set to false to keep the current settings. This is useful to keep sync mode when changing map and to keep deterministic scenarios. * Raises: RuntimeError when corresponding.\n * Parameters:\n * replay_file(self, name, start, duration, follow_id, replay_sensors)\nLoad a new world with default settings using `map_name` map. All actors present in the current world will be destroyed, but traffic manager instances will stay alive. \n\n* \n `name` (str) - Name of the file containing the information of the simulation. * \n `start` (float - seconds) - Time where to start playing the simulation. Negative is read as beginning from the end, being -10 just 10 seconds before the recording finished. * \n `duration` (float - seconds) - Time that will be reenacted using the information `name` file. If the end is reached, the simulation will continue. * \n `follow_id` (int) - ID of the actor to follow. If this is 0 then camera is disabled. * \n `replay_sensors` (bool) - Flag to enable or disable the spawn of sensors during playback. * Parameters:\n * request_file(self, name)\nRequests one of the required files returned by carla.Client.get_required_files. \n\n* \n `name` (str) - Name of the file you are requesting. * Parameters:\n * show_recorder_actors_blocked(self, filename, min_time, min_distance)\nThe terminal will show the information registered for actors considered blocked. An actor is considered blocked when it does not move a minimum distance in a period of time, being these `min_distance` and `min_time` . \n\n* \n `filename` (str) - Name of the recorded file to load. * \n `min_time` (float - seconds) - Minimum time the actor has to move a minimum distance before being considered blocked. Default is 60 seconds. * \n `min_distance` (float - centimeters) - Minimum distance the actor has to move to not be considered blocked. Default is 100 centimeters. * Return: string\n * Parameters:\n * show_recorder_collisions(self, filename, category1, category2)\nThe terminal will show the collisions registered by the recorder. These can be filtered by specifying the type of actor involved. The categories will be specified in `category1` and `category2` as follows: 'h' = Hero, the one vehicle that can be controlled manually or managed by the user. 'v' = Vehicle 'w' = Walker 't' = Traffic light 'o' = Other 'a' = Any If you want to see only collisions between a vehicles and a walkers, use for `category1` as 'v' and `category2` as 'w' or vice versa. If you want to see all the collisions (filter off) you can use 'a' for both parameters. \n\n* \n `filename` (str) - Name or absolute path of the file recorded, depending on your previous choice. * \n `category1` (single char) - Character variable specifying a first type of actor involved in the collision. * \n `category2` (single char) - Character variable specifying the second type of actor involved in the collision. * Return: string\n * Parameters:\n * show_recorder_file_info(self, filename, show_all)\nThe information saved by the recorder will be parsed and shown in your terminal as text (frames, times, events, state, positions...). The information shown can be specified by using the `show_all` parameter. Here is some more information about how to read the recorder file. \n\n* \n `filename` (str) - Name or absolute path of the file recorded, depending on your previous choice. * \n `show_all` (bool) - If True, returns all the information stored for every frame (traffic light states, positions of all actors, orientation and animation data...). If False, returns a summary of key events and frames. * Return: string\n * Parameters:\n * start_recorder(self, filename, additional_data=False)\nEnables the recording feature, which will start saving every information possible needed by the server to replay the simulation. \n\n* \n `filename` (str) - Name of the file to write the recorded data. A simple name will save the recording in 'CarlaUE4/Saved/recording.log'. Otherwise, if some folder appears in the name, it will be considered an absolute path. * \n `additional_data` (bool) - Enables or disable recording non-essential data for reproducing the simulation (bounding box location, physics control parameters, etc). * Parameters:\n * stop_recorder(self)\nStops the recording in progress. If you specified a path in `filename` , the recording will be there. If not, look inside `CarlaUE4/Saved/` . * stop_replayer(self, keep_actors)\nStop current replayer. \n\n* \n `keep_actors` (bool) - True if you want autoremove all actors from the replayer, or False to keep them. * Parameters:\n\n* get_available_maps(self)\nReturns a list of strings containing the paths of the maps available on server. These paths are dynamic, they will be created during the simulation and so you will not find them when looking up in your files. One of the possible returns for this method would be: ['/Game/Carla/Maps/Town01', '/Game/Carla/Maps/Town02', '/Game/Carla/Maps/Town03', '/Game/Carla/Maps/Town04', '/Game/Carla/Maps/Town05', '/Game/Carla/Maps/Town06', '/Game/Carla/Maps/Town07']. \n\n* Return: list(str)\n * get_client_version(self)\nReturns the client libcarla version by consulting it in the \"Version.h\" file. Both client and server can use different libcarla versions but some issues may arise regarding unexpected incompatibilities. \n\n* Return: str\n * get_required_files(self, folder, download=True)\nAsks the server which files are required by the client to use the current map. Option to download files automatically if they are not already in the cache. \n\n* \n `folder` (str) - Folder where files required by the client will be downloaded to. * \n `download` (bool) - If True, downloads files that are not already in cache. * Parameters:\n * get_server_version(self)\nReturns the server libcarla version by consulting it in the \"Version.h\" file. Both client and server should use the same libcarla version. \n\n* Return: str\n * get_trafficmanager(self, client_connection=8000)\nReturns an instance of the traffic manager related to the specified port. If it does not exist, this will be created. \n\n* \n `client_connection` (int) - Port that will be used by the traffic manager. Default is `8000` . * Return: carla.TrafficManager\n * Parameters:\n * get_world(self)\nReturns the world object currently active in the simulation. This world will be later used for example to load maps. \n\n* set_files_base_folder(self, path)\n\n* \n `path` (str) - Specifies the base folder where the local cache for required files will be placed. * Parameters:\n * set_replayer_ignore_hero(self, ignore_hero)\n\n* \n `ignore_hero` (bool) - Enables or disables playback of the hero vehicle during a playback of a recorded simulation. * Parameters:\n * set_replayer_ignore_spectator(self, ignore_spectator)\n\n* \n `ignore_spectator` (bool) - Determines whether the recorded spectator movements will be replicated by the replayer. * Parameters:\n * set_replayer_time_factor(self, time_factor=1.0)\nWhen used, the time speed of the reenacted simulation is modified at will. It can be used several times while a playback is in curse. \n\n* \n `time_factor` (float) - 1.0 means normal time speed. Greater than 1.0 means fast motion (2.0 would be double speed) and lesser means slow motion (0.5 would be half speed). * Parameters:\n * set_timeout(self, seconds)\nSets the maximum time a network call is allowed before blocking it and raising a timeout exceeded error. \n\n* \n `seconds` (float - seconds) - New timeout value. Default is 5 seconds. * Parameters:\n\n## carla.CollisionEvent\n\nInherited from carla.SensorData\n\nThe CARLA simulator provides a vast library of 3D assets to populate your autonomous agent's virtual environment. The 3D asset library provides numerous pre-built maps to choose from, a diverse array of vehicle models for traffic simulation along with models of pedestrians and other structures or obstacles that can be dynamically added to your simulation during runtime. This catalogue documents all of the 3D assets available to use in your simulations.\n\nThe CARLA simulator provides 10 pre-built maps to choose from, providing a diverse array of environments for training and testing your autonomous agents.\n\n## Vehicles\n\nCARLA provides a diverse array of vehicles, with high fidelity models of real world cars, trucks and bikes, for replicating traffic in your simulations. Browse and choose the vehicles you like in the vehicle catalogue.\n\n## Pedestrians\n\nCARLA's asset library includes a variety of pedestrians to simulate foot traffic in the 3D environments surrounding your agent. Browse and choose the pedestrians you want in the pedestrian catalogue.\n\n## Props\n\nCARLA's props model the various structures and items you might find on or near roads, such as kiosks, statues, benches, boxes, bins, debris or trash. The props can be placed anywhere in your simulation dynamically during runtime. Browse and choose your props in the props catalogue.\n\nWe use Doxygen to generate the documentation of our C++ code:\n Libcarla/SourceUnreal/CarlaUE4/Source Unreal/CarlaUE4/Carla/Plugins \nThe generated documentation is available at this link http://carla.org/Doxygen/html/index.html\n\nDocument updates are done automatically by GitHub.\n\n### Create doxygen documentation\n\nDoxygen is required to generate the documentation and Graphviz for the graph drawing toolkit.\n\n1- Install doxygen and graphviz with the following command:\n\n```\n# linux\n> sudo apt-get install doxygen graphviz\n```\n\n2- Once installed, go to the project root folder where the Doxyfile file is situated and run the following command:\n `> doxygen` It will start to build the documentation webpage.The resulting webpage can be found at Doxygen/html/ \n3- Open index.html in a browser. Now you have your local cpp documentation!\n\n The Blueprint Library (\n\n```\ncarla.BlueprintLibrary\n```\n\n) is a summary of all `carla.ActorBlueprint` and its attributes ( `carla.ActorAttribute` ) available to the user in CARLA. \nHere is an example code for printing all actor blueprints and their attributes:\n\n```\nblueprints = [bp for bp in world.get_blueprint_library().filter('*')]\nfor blueprint in blueprints:\n print(blueprint.id)\n for attr in blueprint:\n print(' - {}'.format(attr))\n```\n\nCheck out the introduction to blueprints.\n\n### controller\n\n* controller.ai.walker\n\n### sensor\n\n* sensor.camera.depth\n\n(Float) - Modifiable * \n `lens_k` (Float) - Modifiable * \n `lens_kcube` (Float) - Modifiable * \n `lens_x_size` (Float) - Modifiable * \n `lens_y_size` (Float) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * Attributes:\n * sensor.camera.dvs\n\n(Float) - Modifiable * \n `negative_threshold` (Float) - Modifiable * \n `positive_threshold` (Float) - Modifiable * \n `refractory_period_ns` (Int) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * \n `shoulder` (Float) - Modifiable * \n `shutter_speed` (Float) - Modifiable * \n\n```\nsigma_negative_threshold\n```\n\n```\nsigma_positive_threshold\n```\n\n(Float) - Modifiable * \n `slope` (Float) - Modifiable * \n `temp` (Float) - Modifiable * \n `tint` (Float) - Modifiable * \n `toe` (Float) - Modifiable * \n `use_log` (Bool) - Modifiable * \n `white_clip` (Float) - Modifiable * Attributes:\n * sensor.camera.instance_segmentation\n\n(Float) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * \n `shoulder` (Float) - Modifiable * \n `shutter_speed` (Float) - Modifiable * \n `slope` (Float) - Modifiable * \n `temp` (Float) - Modifiable * \n `tint` (Float) - Modifiable * \n `toe` (Float) - Modifiable * \n `white_clip` (Float) - Modifiable * Attributes:\n * sensor.camera.semantic_segmentation\n\n```\natmosphere_attenuation_rate\n```\n\n(Float) - Modifiable * \n `channels` (Int) - Modifiable * \n `dropoff_general_rate` (Float) - Modifiable * \n\n```\ndropoff_intensity_limit\n```\n\n```\ndropoff_zero_intensity\n```\n\n* \n `role_name` (String) - Modifiable * Attributes:\n * sensor.other.gnss\n\n* \n `noise_alt_bias` (Float) - Modifiable * \n `noise_alt_stddev` (Float) - Modifiable * \n `noise_lat_bias` (Float) - Modifiable * \n `noise_lat_stddev` (Float) - Modifiable * \n `noise_lon_bias` (Float) - Modifiable * \n `noise_lon_stddev` (Float) - Modifiable * \n `noise_seed` (Int) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * Attributes:\n * sensor.other.imu\n\n* \n `noise_accel_stddev_x` (Float) - Modifiable * \n `noise_accel_stddev_y` (Float) - Modifiable * \n `noise_accel_stddev_z` (Float) - Modifiable * \n `noise_gyro_bias_x` (Float) - Modifiable * \n `noise_gyro_bias_y` (Float) - Modifiable * \n `noise_gyro_bias_z` (Float) - Modifiable * \n `noise_gyro_stddev_x` (Float) - Modifiable * \n `noise_gyro_stddev_y` (Float) - Modifiable * \n `noise_gyro_stddev_z` (Float) - Modifiable * \n `noise_seed` (Int) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * Attributes:\n * sensor.other.lane_invasion\n\n* \n `role_name` (String) - Modifiable * Attributes:\n * sensor.other.obstacle\n\n* \n `debug_linetrace` (Bool) - Modifiable * \n `distance` (Float) - Modifiable * \n `hit_radius` (Float) - Modifiable * \n `only_dynamics` (Bool) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * Attributes:\n * sensor.other.radar\n\n* \n `horizontal_fov` (Float) - Modifiable * \n `noise_seed` (Int) - Modifiable * \n `points_per_second` (Int) - Modifiable * \n `range` (Float) - Modifiable * \n `role_name` (String) - Modifiable * \n `sensor_tick` (Float) - Modifiable * \n `vertical_fov` (Float) - Modifiable * Attributes:\n * sensor.other.rss\n\n### static\n\n* static.prop.advertisement\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.barrel\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.box02\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.brokentile04\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.calibrator\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.chainbarrier\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.constructioncone\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.creasedbox01\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.dirtdebris01\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.dirtdebris02\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.doghouse\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.garbage04\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.gnome\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.haybale\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.maptable\n\n* \n `mass` (Float) - Modifiable * \n `mesh_path` (String) - Modifiable * \n `role_name` (String) - Modifiable * \n `scale` (Float) - Modifiable * Attributes:\n * static.prop.mobile\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.pergola\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.plantpot01\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.plasticchair\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.platformgarbage01\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.shoppingbag\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.shoppingcart\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.streetfountain\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.streetsign\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.trafficcone01\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.trashcan02\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.trashcan04\n\n* \n `role_name` (String) - Modifiable * \n `size` (String) * Attributes:\n * static.prop.wateringcan\n\n* \n `extent_x` (Float) - Modifiable * \n `extent_y` (Float) - Modifiable * \n `extent_z` (Float) - Modifiable * \n `friction` (Float) - Modifiable * \n `role_name` (String) - Modifiable * Attributes:\n\n### vehicle\n\n* vehicle.audi.a2\n\n* \n `base_type` (String) * \n `generation` (Int) * \n `has_dynamic_doors` (Bool) * \n `has_lights` (Bool) * \n `number_of_wheels` (Int) * \n `object_type` (String) * \n `role_name` (String) - Modifiable * \n `special_type` (String) * \n `sticky_control` (Bool) - Modifiable * \n `terramechanics` (Bool) - Modifiable * Attributes:\n * vehicle.tesla.model3\n\n### walker\n\n* walker.pedestrian.0001\n\nHere you will find the multitude of tutorials available to help you understand how to use CARLA's many features.\n\n### CARLA features\n\n Retrieve simulation data — A step by step guide to properly gather data using the recorder.Traffic manager — How to use traffic manager to guide traffic around your town. Texture streaming — Modify textures of map objects in real time to add variation. Instance segmentation camera — Use an instance segmentation camera to distinguish objects of the same class. Bounding boxes — Project bounding boxes from CARLA objects into the camera. Pedestrian bones — Project pedestrian skeleton into camera plane. Control walker skeletons — Animate walkers using skeletons. \n\n### Building and integration\n\n Build Unreal Engine and CARLA in Docker — Build Unreal Engine and CARLA in Docker.CarSim Integration — Tutorial on how to run a simulation using the CarSim vehicle dynamics engine. RLlib Integration — Find out how to run your own experiment using the RLlib library. Chrono Integration — Use the Chrono integration to simulation physics. PyGame control — Use PyGame to display the output of camera sensors. \n\n## Assets and maps\n\n Generate maps with OpenStreetMap — Use OpenStreetMap to generate maps for use in simulations.Add a new vehicle — Prepare a vehicle to be used in CARLA. Add new props — Import additional props into CARLA. Create standalone packages — Generate and handle standalone packages for assets. Material customization — Edit vehicle and building materials. \n\n## Developers\n\n How to upgrade content — Add new content to CARLA.Create a sensor — Develop a new sensor to be used in CARLA. Create semantic tags — Define customized tags for semantic segmentation. Customize vehicle suspension — Modify the suspension system of a vehicle. Generate detailed colliders — Create detailed colliders for vehicles. Make a release — How to make a release of CARLA \n\n## Video tutorials\n\n Fundamentals — Learn the fundamental concepts of CARLA and start your first script. CODEAn in depth look at CARLA's sensors — An in depth look at CARLA's sensors and how to use them. CODE\n\nBelow, you will find in depth documentation on the many extensive features of CARLA.\n\n## Advanced concepts\n\n Recorder — Register the events in a simulation and play it again.Rendering options — From quality settings to no-render or off-screen modes. Synchrony and time-step — Client-server communication and simulation time. Benchmarking Performance — Perform benchmarking using our prepared script. CARLA Agents — Agents scripts allow single vehicles to roam the map or drive to a set destination. Multi GPU — Set up the CARLA simulator to use multiple GPUs for processing. \n\n## Traffic Simulation\n\n __ Traffic Simulation Overview__ — An overview of the different options available to populate your scenes with traffic.Traffic Manager — Simulate urban traffic by setting vehicles to autopilot mode. \n\n## References\n\n Recorder binary file format — Detailed explanation of the recorder file format.Sensors reference — Everything about sensors and the data they retrieve. \n\n Overview of custom maps in CARLA — An overview of the process and options involved in adding a custom, standard sized map.Create a map in RoadRunner — How to generate a customs, standard sized map in RoadRunner. __ Import map in CARLA package__ How to import a map in a CARLA package. Import map in CARLA source build — How to import a map in CARLA built from source. Alternative ways to import maps — Alternative methods to import maps. __ Manually prepare map package__ — How to prepare a map for manual import. Customizing maps: Layered maps — How to create sub-layers in your custom map. __ Customizing maps: Traffic lights and signs__ — How to add traffic lights and signs to your custom map. __ Customizing maps: Road painter__ — How to use the road painter tool to change the appearance of the road. Customizing Maps: Procedural Buildings — Populate your custom map with buildings. __ Customizing maps: Weather and landscape__ — Create the weather profile for your custom map and populate the landscape. Generate pedestrian navigation — Obtain the information needed for walkers to move around. \n\n Large maps overview — An explanation of how large maps work in CARLA.Create a Large Map in RoadRunner — How to create a large map in RoadRunner. Import/Package a Large Map — How to import a large map.\n\nDate: 2021-01-01\nCategories: \nTags: \n\nIn a webinair series in April 2021, Ansys presented the details of their integration of the Ansys Real Time Radar (RTR) with the CARLA simulator. Here you can download and view the presentation slides and videos that accompanied the webinair.\n\nThe presentation details how the RTR was integrated with CARLA to train a vehicle longitudinal controller using reinforcement learning and includes the model, action space and reward policy used. The videos show the results of the training in the CARLA simulator.\n\nThe RLlib integration brings support between the Ray/RLlib library and CARLA, allowing the easy use of the CARLA environment for training and inference purposes. Ray is an open source framework that provides a simple, universal API for building distributed applications. Ray is packaged with RLlib, a scalable reinforcement learning library, and Tune, a scalable hyperparameter tuning library.\n\nThe RLlib integration allows users to create and use CARLA as an environment of Ray and use that environment for training and inference purposes. The integration is ready to use both locally and in the cloud using AWS.\n\nIn this guide we will outline the requirements needed for running the RLlib integration both locally and on AWS, the structure of the integration repository, an overview of how to use the library and then an example of how to set up a Ray experiment using CARLA as an environment.\n\n* Before you begin\n * RLlib repository structure\n * Creating your own experiment\n * DQN example\n * Running on AWS\n\n* Download the RLlib integration from GitHub or clone the repository directly:\n\n```\ngit clone https://github.com/carla-simulator/rllib-integration.git\n```\n\n* Requirements vary depending on if you are running locally or on AWS:\n # Requirements for running locally\n\n * Install a package version of CARLA and import the additional assets. The recommended version is CARLA 0.9.11 as the integration was designed and tested with this version. Other versions may be compatible but have not been fully tested, so use these at your own discretion.\n * Navigate into the root folder of the RLlib integration repository and install the Python requirements:\n\n```\npip3 install -r requirements.txt\n```\n\n * Set an environment variable to locate the CARLA package by running the command below or add\n\n```\nCARLA_ROOT=path/to/carla\n```\n\nto your `.bashrc` file: \n\n```\nexport CARLA_ROOT=path/to/carla\n```\n\n # Requirements for running on AWS Cloud\n\n * The requirements for running on AWS are taken care of automatically in an install script found in the RLlib integration repository. Find more details in the section \"Running on AWS\".\n\n## RLlib repository structure\n\nThe repository is divided into three directories:\n\n* \n `rllib_integration` contains all the infrastructure related to CARLA and how to set up the CARLA server, clients and actors. This provides the basic structure that all training and testing experiments must follow. * \n `aws` has the files needed to run in an AWS instance. `aws_helper.py` provides several functionalities that ease the management of EC2 instances, including instance creation and sending and receiving data. * \n `dqn_example` and the `dqn_*` files in the root directory provide an easy-to-understand example on how to set up a Ray experiment using CARLA as its environment. \n\n## Creating your own experiment\n\nThis section provides a general overview on how to create your own experiment. For a more specific example, see the next section \"DQN example\".\n\nYou will need to create at least four files:\n\n* The experiment class\n * The environment configuration\n * The training and inference scripts\n\n# 1. The experiment class\n\n To use the CARLA environment you need to define a training experiment. Ray requires environments to return a series of specific information. You can see details on the CARLA environment in\n\n```\nrllib-integration/rllib_integration/carla_env.py\n```\n\n. The information required by Ray is dependent on your specific experiment so all experiments should inherit from `BaseExperiment` . This class contains all the functions that need to be overwritten for your own experiment. These are all functions related to the actions, observations and rewards of the training. \n\n# 2. The environment configuration\n\n The experiment should be configured through a `.yaml` file. Any settings passed through the configuration file will override the default settings. The locations of the different default settings are explained below. \nThe configuration file has three main uses:\n\n* Sets up most of the CARLA server and client settings, such as timeout or map quality. See the default values here.\n * Sets up variables specific to your experiment as well as specifying town conditions and the spawning of the ego vehicle and its sensors. The default settings are found here and provide an example of how to set up sensors.\n * Configures settings specific to Ray's training. These settings are related to the specific trainer used. If you are using a built-in model, you can apply settings for it here.\n\n# 3. The training and inference scripts\n\nThe last step is to create your own training and inference scripts. This part is completely up to you and is dependent on the Ray API. If you want to create your own specific model, check out Ray's custom model documentation.\n\n## DQN example\n\nThis section builds upon the previous section to show a specific example on how to work with the RLlib integration using the BirdView pseudosensor and Ray's DQNTrainer.\n\nThe structure of the DQN example is as follows:\n\n* The experiment class:\n `DQNExperiment` , which overwrites the methods of the `BaseExperiment` class. * The configuration file:\n\n```\ndqn_example/dqn_config.yaml\n```\n\n * The training file:\n `dqn_train.py` * The inference file:\n\n* With Ray:\n `dqn_inference_ray.py` * Without Ray:\n `dqn_inference.py` * With Ray:\n\nTo run the example locally:\n\nInstall pytorch:\n\n```\npip3 install -r dqn_example/dqn_requirements.txt\n```\n\nRun the training file:\n\n```\npython3 dqn_train.py dqn_example/dqn_config.yaml --name dqn\n```\n\nThe default configuration uses 1 GPU and 12 CPUs, so if your local machine doesn't have that capacity, lower the numbers in the configuration file.\n If you experience out of memory problems, consider reducing the `buffer_size` parameter. \n\n## Running on AWS\n\nThis section explains how to use the RLlib integration to automatically run training and inference on AWS EC2 instances. To handle the scaling of instances we use the Ray autoscaler API.\n\n# Configure AWS\n\nYou will need to configure your boto3 environment correctly. Check here for more information.\n\n# Create the training AMI\n\n Use the provided `aws_helper.py` script to automatically create the image needed for training by running the command below, passing in the name of the base image and the installation script `install.sh` found in \n\n```\nrllib-integration/aws/install\n```\n\n: \n\n```\npython3 aws_helper.py create-image --name <AMI-name> --installation-scripts <installation-scripts> --instance-type <instance-type> --volume-size <volume-size>\n```\n\n# Configure the cluster\n\n Once the image is created, there will be an output with image information. To use the Ray autoscaler, update the `<ImageId>` and `<SecurityGroupIds>` settings in your autoscaler configuration file with the information from the output. \n\n# Run the training\n\nWith the image created, you can use Ray's API to run the training on the cluster:\n\n```\nray up <autoscaler_configuration_file>\n```\n\n(Optional) If the local code has been modified after the cluster initialization, run this command to update it:\n\n```\nray rsync-up <autoscaler_configuration_file> <path_to_local_folder> <path_to_remote_folder>\n```\n\n```\nray submit <autoscaler_configuration_file> <training_file>\n```\n\n```\nray down <autoscaler_configuration_file>\n```\n\n# Running the DQN example on AWS\n\nTo run the DQN example on AWS:\n\nCreate the image by passing the\n\n```\ndqn_example/dqn_autoscaler.yaml\n```\n\nconfiguration to the following command: \n\n```\npython3 aws_helper.py create-image --name <AMI-name> --installation-scripts install/install.sh --instance-type <instance-type> --volume-size <volume-size>\n```\n\nUpdate the\n `<ImageId>` and `<SecurityGroupIds>` settings in `dqn_autoscaler.yaml` with the information provided by the previous command. * \n\n```\nray up dqn_example/dqn_autoscaler.yaml\n```\n\n(Optional) Update remote files with local changes:\n\n```\nray rsync-up dqn_example/dqn_autoscaler.yaml dqn_example . ray rsync-up dqn_example/dqn_autoscaler.yaml rllib_integration .\n```\n\n```\nray submit dqn_example/dqn_autoscaler.yaml dqn_train.py -- dqn_example/dqn_config.yaml --auto\n```\n\n```\nray down dqn_example/dqn_autoscaler.yaml\n```\n\nThis guide has outlined how to install and run the RLlib integration on AWS and on a local machine. If you have any questions or ran into any issues working through the guide, feel free to post in the forum or raise an issue on GitHub.\n\nCARLA's integration with CarSim allows vehicle controls in CARLA to be forwarded to CarSim. CarSim will do all required physics calculations of the vehicle and return the new state to CARLA.\n This page shows you how to generate a `.sim` file, explains how vehicle dimensions relate between CARLA and CarSim and how to run a simulation on CARLA using the CarSim integration. \n\n* Before you begin\n * Set up CarSim\n * Run the simulation\n\n* You will need a license for CarSim and to have the software up and running. If you don't currently have a license for CarSim, you can contact the team here for information.\n * \n\nTo allow communication with Unreal Engine you will need to install the VehicleSim Dynamics plugin (version 2020.0) for Unreal Engine 4.24. For information on finding specific versions of the plugin, check this link. Installation of the plugin will depend on your operating system:\n\nFor Windows:\n\nGet the plugin here.\n\nFor Ubuntu:\n * \n\nThis step can be skipped if you are using the packaged version of CARLA. The packaged version has already been compiled using this flag but if you are building CARLA from source then you will need to compile the server with the\n `--carsim` flag. \nIf you are building CARLA from source, run the following command in the root folder to compile the server with the\n `--carsim` flag: \n\n```\nmake launch ARGS=\"--carsim\"\n```\n\n## Set up CarSim\n\n The following section details how to generate the `.sim` file which is required to run the simulation. There is also important information detailed regarding the relationship of vehicle sizes between CARLA and CarSim. \n\n# Generate the .sim file\n\n The `.sim` file describes the simulation to be run in both CARLA and CarSim. This file is required by the plugin to run the simulation. There is currently no way to generate this file on Ubuntu, however we will describe below how to use a previously generated file to run the simulation on Ubuntu. \n\n# On Windows\n\n After you have configured all the parameters on CarSim, use the GUI to generate the `.sim` file as highlighted below: The resulting `.sim` file should look something like this: \n\nSET_MACRO $(ROOT_FILE_NAME)$ Run_dd7a828d-4b14-4c77-9d09-1974401d6b25\nSET_MACRO $(OUTPUT_PATH)$ D:\\carsim\\Data\\Results\nSET_MACRO $(WORK_DIR)$ D:\\carsim\\Data\\\nSET_MACRO $(OUTPUT_FILE_PREFIX)$ $(WORK_DIR)$Results\\Run_dd7a828d-4b14-4c77-9d09-1974401d6b25\\LastRun\n\nFILEBASE $(OUTPUT_FILE_PREFIX)$\nINPUT $(WORK_DIR)$Results\\$(ROOT_FILE_NAME)$\\Run_all.par\nINPUTARCHIVE $(OUTPUT_FILE_PREFIX)$_all.par\nECHO $(OUTPUT_FILE_PREFIX)$_echo.par\nFINAL $(OUTPUT_FILE_PREFIX)$_end.par\nLOGFILE $(OUTPUT_FILE_PREFIX)$_log.txt\nERDFILE $(OUTPUT_FILE_PREFIX)$.vs\nPROGDIR D:\\carsim\\\nDATADIR D:\\carsim\\Data\\\nGUI_REFRESH_V CarSim_RefreshEvent_7760\nRESOURCEDIR D:\\carsim\\\\Resources\\\nPRODUCT_ID CarSim\nPRODUCT_VER 2020.0\nANIFILE D:\\carsim\\Data\\runs\\animator.par\nVEHICLE_CODE i_i\nEXT_MODEL_STEP 0.00050000\nPORTS_IMP 0\nPORTS_EXP 0\n\nDLLFILE D:\\carsim\\Programs\\solvers\\carsim_64.dll\nEND\n```\n\n# On Ubuntu\n\n There is no way to create the `.sim` file via GUI on Ubuntu. In order to proceed you will need to follow these steps: \n\n* Generate the\n `.sim` file in Windows or use the file template below. * Modify the\n `.sim` file so the variables `INPUT` , `INPUTARCHIVE` , `LOGFILE` and so on point towards the corresponding files in your Ubuntu system. * Replace the\n `DLLFILE` line to point towards the CarSim solver which, in the default installation, will be \n\n```\nSOFILE /opt/carsim_2020.0/lib64/libcarsim.so.2020.0\n```\n\n. \nThe resulting file should be similar to this:\n\nFILEBASE /path/to/LastRun\nINPUT /path/to/Run_all.par\nINPUTARCHIVE /path/to/LastRun_all.par\nECHO /path/to/LastRun_echo.par\nFINAL /path/to/LastRun_end.par\nLOGFILE /path/to/LastRun_log.txt\nERDFILE /path/to/LastRun.vs\nPROGDIR /opt/carsim_2020.0/lib64/\nDATADIR .\nPRODUCT_ID CarSim\nPRODUCT_VER 2020.0\nVEHICLE_CODE i_i\n\nSOFILE /opt/carsim_2020.0/lib64/libcarsim.so.2020.0\nEND\n```\n\n# Vehicle sizes\n\nAlthough CarSim lets you specify the dimensions of the vehicle to use in the simulation, there is currently no correlation between a CarSim vehicle and a CARLA vehicle. This means that the vehicles in both programmes will have different dimensions. The role of the CARLA vehicle is only to act as a placeholder during the simulation.\n\nThere is no correlation between vehicle size in CARLA and CarSim. The CARLA vehicle is only a simulation placeholder.\n\n## Run the simulation\n\n All that is needed when running the simulation is to enable CarSim when you spawn a vehicle. This can be done by passing the path to the `.sim` file to the following method of the Python API: \n\n```\nvehicle.enable_carsim(<path_to_ue4simfile.sim>)\n```\n\nAll input controls sent to the vehicle will be forwarded to CarSim. CarSim will update the physics and send back the status of the vehicle (the transform) to the CARLA vehicle.\n\nOnce the simulation has finished you can analyze all the data in CarSim as usual.\n\nThis guide outlines what Chrono is, how to use it in CARLA, and the limitations involved in the integration.\n\n## Project Chrono\n\nProject Chrono is an open-source, multi-physics simulation engine that provides highly realistic vehicle dynamics using a template-based approach. The integration in CARLA allows users to utilize Chrono templates to simulate vehicle dynamics while navigating a map.\n\n## Using Chrono on CARLA\n\nTo use the Chrono integration, you must first configure the server with a tag on startup and then use the PythonAPI to enable it on a spawned vehicle. Read on for more details.\n\n### Configuring the server\n\nChrono will only work if the CARLA server is compiled with the Chrono tag.\n\nIn the build from source version of CARLA, run the following command to start the server:\n\n```\nmake launch ARGS=\"--chrono\"\n```\n\n### Enabling Chrono physics\n\n Chrono physics is enabled using the\n\n```\nenable_chrono_physics\n```\n\nmethod available through the Actor class. As well as values for substeps and substep delta time, it requires three template files and a base path to locate those files: \n\n* \n `base_path` : Path of the directory which contains the template files. This is necessary to ensure that auxiliary files referenced from the template files have a common base path from which to search. * \n `vehicle_json` : Path of the vehicle template file relative to the `base_path` . * \n `tire_json` : Path of the tire template file relative to the `base_path` . * \n `powertrain_json` : Path of the powertrain template file relative to the `base_path` . \nImportant\n\nDouble-check your paths. Incorrect or missing paths can cause Unreal Engine to crash.\n There are a variety of example template files for different vehicles available in\n\n```\nBuild/chrono-install/share/chrono/data/vehicle\n```\n\n. Read the Project Chrono documentation to find out more about their vehicle examples and how to create templates. \nSee below for an example of how to enable Chrono physics:\n\n```\n# Spawn your vehicle\n vehicle = world.spawn_actor(bp, spawn_point)\n\n # Set the base path\n base_path = \"/path/to/carla/Build/chrono-install/share/chrono/data/vehicle/\"\n\n # Set the template files\n\n vehicle_json = \"sedan/vehicle/Sedan_Vehicle.json\"\n powertrain_json = \"sedan/powertrain/Sedan_SimpleMapPowertrain.json\"\n tire_json = \"sedan/tire/Sedan_TMeasyTire.json\"\n\n # Enable Chrono physics\n\n vehicle.enable_chrono_physics(5000, 0.002, vehicle_json, powertrain_json, tire_json, base_path)\n```\n\n You can try the Chrono physics integration using the example script\n\n```\nmanual_control_chrono.py\n```\n\nfound in `PythonAPI/examples` . After running the script, press `Ctrl + o` to enable Chrono. \n\n### Limitations\n\nThis integration does not support collisions. When a collision occurs, the vehicle will revert to CARLA default physics.\n\nRoadRunner is the recommended software to create large maps to be imported into CARLA. This guide outlines what RoadRunner is, things to consider when building the large map and how to export custom large maps ready for importing into CARLA.\n\n* Introduction to RoadRunner\n * Before you start\n * Build a large map in RoadRunner\n * Export a large map in RoadRunner\n * Next steps\n\n## Introduction to RoadRunner\n\nRoadRunner is an interactive editor that lets you design 3D scenes for simulating and testing automated driving systems. It can be used to create road layouts and accompanying OpenDRIVE and geometry information. Find out more about RoadRunner here.\n\nRoadRunner is part of the MATLAB Campus-Wide Licenses, so many universities can provide unlimited academic access. Check if your university has access. Reach out to <EMAIL> for any questions or troubles regarding accessibility. There is also a trial version available.\n\nA license for RoadRunner is also available to everyone participating in the CARLA Leaderboard. Click here for more information.\n\n## Before you start\n\nYou will need to install RoadRunner. You can follow the installation guide at the Mathworks website.\n\n## Build a large map in RoadRunner\n\nThe specifics of how to build a large map in RoadRunner go beyond the scope of this guide, however, there are video tutorials available in the RoadRunner documentation.\n\nIf you are building a large map with elevation, the recommended largest size of the map is 20km by 20km. Maps larger than this may cause RoadRunner to crash on export.\n\n## Export a large map in RoadRunner\n\nBelow is a basic guideline to export your custom large map from RoadRunner.\n\n. \nMake sure the full map is selected for export by clicking on the World settings tool and dragging the edges of the blue boundary box to encompass the full area you would like to export. when it's ready, click on Apply World Changes.\n\nWhen you are ready to export:\n 1. Export the `.fbx` : \n\n* In the main toolbar, select\n `File` -> `Export` -> `Firebox (.fbx)` \n2. In the window that pops up:\n * Check the following options:\n * Split by Segmentation: Divides the mesh by semantic segmentation and imroves pedestrian navigation.\n * Power of Two Texture Dimensions: Improves performance.\n * Embed Textures: Ensures textures are embedded in the mesh.\n * Export to Tiles: Choose the size of the tiles. The maximum size that can be used by CARLA is 2000 x 2000.\n * Export Individual Tiles: Generates the individual tiles needed for streaming large maps in CARLA.\n 3. Export the `.xodr` : \n\n* In the main toolbar, select\n `File` -> `Export` -> `OpendDRIVE (.xodr)` \nWarning\n Make sure that the `.xodr` and the `.fbx` files have the same name. \n\nYou are now ready to import your map into CARLA. See the Import a Large Map guide for more details.\n\nThis feature allows users to ingest any OpenDRIVE file as a CARLA map out-of-the-box. In order to do so, the simulator will automatically generate a road mesh for actors to navigate through.\n\nThis mode runs a full simulation using only an OpenDRIVE file, without the need of any additional geometries or assets. To this end, the simulator takes an OpenDRIVE file and procedurally creates a temporal 3D mesh to run the simulation with.\n\nThe resulting mesh describes the road definition in a minimalistic manner. All the elements will correspond with the OpenDRIVE file, but besides that, there will be only void. In order to prevent vehicles from falling off the road, two measures have been taken.\n\n* Lanes are a bit wider at junctions, where the flow of vehicles is most complex.\n * Visible walls are created at the boundaries of the road, to act as a last safety measure.\n Traffic lights, stops and yields will be generated on the fly. Pedestrians will navigate over the sidewalks and crosswalks that appear in the map. All of these elements, and every detail on the road, are based on the OpenDRIVE file. As the standalone mode uses the `.xodr` directly, any issues in it will propagate to the simulation. This could be an issue especially at junctions, where many lanes are mixed. \nImportant\n\nIt is especially important to double check the OpenDRIVE file. Any issues in it will propagate when running the simulation.\n\n## Run a standalone map\n\n Open an OpenDRIVE file is just a matter of calling\n\n```\nclient.generate_opendrive_world()\n```\n\nthrough the API. This will generate the new map, and block the simulation until it is ready. The method needs for two parameters. \n\n* \n `opendrive` is the content of the OpenDRIVE file parsed as a string. * \n `parameters` is a carla.OpendriveGenerationParameters containing settings for the generation of the mesh. This argument is optional. \n\n* \n `vertex_distance` (default 2.0 meters) — Distance between the vertices of the mesh. The bigger, the distance, the more inaccurate the mesh will be. However, if the distance is too small, the resulting mesh will be too heavy to work with. * \n `max_road_length` (default 50.0 meters) — Maximum length of a portion of the mesh. The mesh is divide in portions to reduce rendering overhead. If a portion is not visible, UE will not render it. The smaller the portions, the more probably they are discarded. However, if the portions are too small, UE will have too many objects to manage, and performance will be affected too. * \n `wall_height` (default 1.0 meters) — Height of the additional walls created on the boundaries of the road. These prevent vehicles from falling to the void. * \n `additional_width` (default 0.6 meters, 0.3 on each side) — Small width increment applied to the junction lanes. This is a safety measure to prevent vehicles from falling. * \n `smooth_junctions` (default True) — If True, some information of the OpenDRIVE will be reinterpreted to smooth the final mesh at junctions. This is done to prevent some inaccuracies that may occur when various lanes meet. If set to False, the mesh will be generated exactly as described in the OpenDRIVE. * \n\n```\nenable_mesh_visibility\n```\n\n(default True) — If False, the mesh will not be rendered, which could save a lot of rendering work to the simulator. In order to easily test this feature, the `config.py` script in `PythonAPI/util/` has a new argument, `-x` or `--xodr-path` . This argument expects a string with the path to the `.xodr` file, such as `path/example.xodr` . If the mesh is generated with this script, the parameters used will always be the default ones. \nThis feature can be tested with the new TownBig provided by CARLA.\n\n```\npython3 config.py -x opendrive/TownBig.xodr\n```\n\nImportant\n client.generate_opendrive_world() uses content of the OpenDRIVE file parsed as string. On the contrary, `config.py` script needs the path to the `.xodr` file. \nNote\n If you experience the error\n\n```\nopendrive could not be correctly parsed\n```\n\n, ensure that there are write permissions on the \n\n```\nCarlaUE4/Content/Carla/Maps/OpenDrive/\n```\n\ndirectory. This is required by the server to parse the `xodr` file correctly. \n\n## Mesh generation\n\nThe generation of the mesh is the key element of this mode. The feature can only be successful if the resulting mesh is smooth and fits its definition perfectly. For that reason, this step is constantly being improved. In the last iterations, junctions have been polished to avoid inaccuracies that occur, especially where uneven lanes joined.\n\nThe parameter\n `smooth_junctions` prevents this kind of issue. \nBesides that, instead of creating the whole map as a unique mesh, different portions are created. By dividing the mesh, the simulator can avoid rendering portions that are not visible, and save up costs. Working smaller also allows to generate huge maps and contain issues that may occur on a small portion of the mesh.\n\nRegarding the current state of the mesh generation, some considerations should be taken into account.\n\n* Junction smoothing. The default smoothing prevents the issues at tilted junctions described above. However, it will modify the original mesh in the process. Set\n `smooth_junctions` to False to disable the smoothing if preferred. * Lateral slope. This feature is currently not integrated in CARLA.\n * Sidewalk height. This is currently hard-coded for all the sidewalks the same. Sidewalks must be higher than the road level for collisions to be detected, but RoadRunner does not export this value to the OpenDRIVE file. The height is hard-coded to guarantee collisions.\n\nThat covers all there is to know so far, regarding the OpenDRIVE standalone mode. Take the chance and use any OpenDRIVE map to test it in CARLA.\n\nDoubts and suggestions in the forum.\n\nIn order to run the co-simulation, two things are necessary.\n\n* Buy a license for PTV-Vissim simulator. It is necessary to acquire the Driving Simulator Interface add-on.\n * In the PTV-Vissim installation folder, look for a\n\n```\nDrivingSimulatorProxy.dll\n```\n\n. Move it to `C:\\Windows\\System32` . \n\n Everything related with this feature can be found in\n\n```\nCo-Simulation/PTV-Vissim\n```\n\n. CARLA provides some examples that contain networks for Town01, and Town03. To run a co-simulation, use the script\n\n```\nPTV-Vissim/run_synchronization.py\n```\n\n. This has one mandatory argument containing the PTV-Vissim network, and some other optional arguments. \n\n* \n `vissim_network` — The vissim network file. This can be an example or a self-created PTV-Vissim network. * \n `--carla-host` (default: 127.0.0.1) — IP of the carla host server. * \n `--carla-port` (default: 2000) TCP port to listen to. * \n `--vissim-version` (default: 2020) — PTV-Vissim version. * \n `--step-length` (default: 0.05s) — set fixed delta seconds for the simulation time-step. * \n `--simulator-vehicles` (default: 1) — number of vehicles that will be spawned in CARLA and passed to PTV-Vissim. \n\n```\npython3 run_synchronization.py examples/Town03/Town03.inpx\n```\n\nWarning\n To stop the co-simulation, press `Ctrl+C` in the terminal that run the script. Both simulations will run in synchrony. The actions or events happening in one simulator will propagate to the other. So far, the feature only includes vehicle movement, and spawning. The spawning is limited due to PTV-Vissim types.If a vehicle is spawned in CARLA, and the Vehicle Type in PTV-Vissim is set to `car` , it will spawn a car. No matter if it as a motorbike in CARLA. In the examples provided, the vehicle type is set to `car` . If a vehicle is spawned in PTV-Vissim, CARLA will use a vehicle of the same type. The dimensions and characteristics will be similar, but not exactly the same. \n\n### Create a new network\n\nIn order for a new PTV-Vissim network to run with CARLA, there are a few settings to be done.\n\n* Activate the driving simulator. Go to\n\n```\nBase Data/Network settings/Driving simulator\n```\n\nand enable the option. * Specify the vehicle and pedestrian types. These are the types that will be used in PTV-Vissim to sync with the spawnings done in CARLA. By default are empty.\n * Export the network as\n `.inpx` . Create the network, export it, and run the co-simulation with \n\n. \nWarning\n\nPTV-Vissim will crash if the pedestrian and vehicle types are left empty.\n\nThat is all there is so far, regarding for the PTV-Vissim co-simulation with CARLA.\n\nCARLA integrates the C++ Library for Responsibility Sensitive Safety in the client library. This feature allows users to investigate behaviours of RSS without having to implement anything. CARLA will take care of providing the input, and applying the output to the AD systems on the fly.\n\nThis feature is a work in progress. Right now, it is only available for the Linux build.\n\nThe RSS library implements a mathematical model for safety assurance. It receives sensor information, and provides restrictions to the controllers of a vehicle. To sum up, the RSS module uses the sensor data to define situations. A situation describes the state of the ego vehicle with an element of the environment. For each situation, safety checks are made, and a proper response is calculated. The overall response is the result of all of the combined. For specific information on the library, read the documentation, especially the Background section.\n\nThis is implemented in CARLA using two elements.\n\n* RssSensor is in charge of the situation analysis, and response generation using the ad-rss-lib.\n * RssRestrictor applies the response by restricting the commands of the vehicle.\n\nThe following image sketches the integration of RSS into the CARLA architecture.\n\n1. The server.\n\n* Sends a camera image to the client. (Only if the client needs visualization).\n * Provides the RssSensor with world data.\n * Sends a physics model of the vehicle to the RssRestrictor. (Only if the default values are overwritten).\n\n2. The client.\n\n* Provides the RssSensor with some parameters to be considered. -Sends to the RssResrictor an initial carla.VehicleControl.\n\n3. The RssSensor.\n\n* Uses the ad-rss-lib to extract situations, do safety checks, and generate a response.\n * Sends the RssRestrictor a response containing the proper response and aceleration restrictions to be applied.\n\n4. The RssRestrictor\n\n* If the client asks for it, applies the response to the carla.VehicleControl, and returns the resulting one.\n\n## Compilation\n\nThe RSS integration has to be built aside from the rest of CARLA. The ad-rss-lib comes with an LGPL-2.1 open-source license that creates conflict. It has to be linked statically into libCarla.\n\nAs a reminder, the feature is only available for the Linux build so far.\n\n### Dependencies\n\nThere are additional prerequisites required for building RSS and its dependencies. Take a look at the official documentation) to know more about this.\n\nDependencies provided by Ubunutu (>= 16.04).\n\n```\nsudo apt-get install libgtest-dev libpython-dev libpugixml-dev libtbb-dev\n```\n\nThe dependencies are built using colcon, so it has to be installed.\n\n```\npip3 install --user -U colcon-common-extensions\n```\n\nThere are some additional dependencies for the Python bindings.\n\n```\nsudo apt-get install castxml\npip3 install --user pygccxml pyplusplus\n```\n\n### Build\n\nOnce this is done, the full set of dependencies and RSS components can be built.\n\n* Compile LibCarla to work with RSS.\n\n```\nmake LibCarla.client.rss\n```\n\n* Compile the PythonAPI to include the RSS feature.\n `make PythonAPI.rss` \n\n* As an alternative, a package can be built directly.\n `make package.rss` \n\n## Current state\n\n### RssSensor\n\ncarla.RssSensor supports ad-rss-lib v4.2.0 feature set completely, including intersections, stay on road support and unstructured constellations (e.g. with pedestrians).\n\nSo far, the server provides the sensor with ground truth data of the surroundings that includes the state of other traffic participants and traffic lights.\n\n### RssRestrictor\n\nWhen the client calls for it, the carla.RssRestrictor will modify the vehicle controller to best reach the desired accelerations or decelerations by a given response.\n Due to the stucture of carla.VehicleControl objects, the restrictions applied have certain limitations. These controllers include `throttle` , `brake` and `streering` values. However, due to car physics and the simple control options these might not be met. The restriction intervenes in lateral direction simply by counter steering towards the parallel lane direction. The brake will be activated if deceleration requested by RSS. This depends on vehicle mass and brake torques provided by the carla.Vehicle. \nNote\n\nIn an automated vehicle controller it might be possible to adapt the planned trajectory to the restrictions. A fast control loop (>1KHz) can be used to ensure these are followed.\n\nThat sets the basics regarding the RSS sensor in CARLA. Find out more about the specific attributes and parameters in the sensor reference.\n\nThis is the documentation for the ROS bridge which enables two-way communication between ROS and CARLA. The information from the CARLA server is translated to ROS topics. In the same way, the messages sent between nodes in ROS get translated to commands to be applied in CARLA.\n\nThe ROS bridge is compatible with both ROS 1 and ROS 2.\n\nThe ROS bridge boasts the following features:\n\n* Provides sensor data for LIDAR, Semantic LIDAR, Cameras (depth, segmentation, rgb, dvs), GNSS, Radar and IMU.\n * Provides object data such as transforms, traffic light status, visualisation markers, collision and lane invasion.\n * Control of AD agents through steering, throttle and brake.\n * Control of aspects of the CARLA simulation like synchronous mode, playing and pausing the simulation and setting simulation parameters.\n\n## Get started\n\n## Learn about the main ROS bridge package\n\n* CARLA ROS bridge - The main package required to run the ROS bridge\n * ROS Compatiblity Node - The interface that allows the same API to call either ROS 1 or ROS 2 functions\n\n## Learn about the additional ROS bridge packages\n\n* CARLA Spawn Objects - Provides a generic way to spawn actors\n * CARLA Manual Control- A ROS-based visualization and control tool for an ego vehicle (similar to\n\n```\ncarla_manual_control.py\n```\n\nprovided by CARLA) * CARLA Ackerman Control - A controller to convert ackermann commands to steer/throttle/brake\n * CARLA Waypoint Publisher - Publish and query CARLA waypoints\n * CARLA AD Agent - An example agent that follows a route, avoids collisions and respects traffic lights\n * CARLA AD Demo - An example package that provides everything needed to launch a CARLA ROS environment with an AD vehicle\n * CARLA ROS Scenario Runner - A wrapper to execute OpenScenarios with the CARLA Scenario Runner via ROS\n * CARLA Twist to Control - Convert twist controls to CARLA vehicle controls\n * RVIZ plugin - An RVIZ plugin to visualize/control CARLA\n * RQT Plugin - A RQT plugin to control CARLA\n * PCL Recorder - Create point cloud maps from data captured from simulations\n\n## Explore the reference material\n\n* ROS Sensors - Reference topics available in the different sensors\n * ROS messages - Reference parameters available in CARLA ROS messages\n\nThis guide provides an overview of how to use Scenic with CARLA to generate multiple, diverse scenarios with a single scenario definition. It assumes that users have prior knowledge of the Scenic syntax. If you need to learn more about Scenic, then read their \"Getting Started with Scenic\" guide and have a look at their tutorials for creating static and dynamic scenarios.\n\nBy the end of the guide you will know:\n\n* The minimum requirements needed to run a Scenic script on CARLA.\n * How to write a simple scenario definition to generate a multitude of scenario simulations.\n * How to run a Scenic script on CARLA.\n * Parameters used to configure Scenic simulations on CARLA.\n\n* Before you begin\n * Scenic domains\n * Creating a Scenic scenario to use with CARLA\n * Run the scenario\n * Additional parameters\n\nBefore using Scenic with CARLA, you will need to fulfill the following requirements:\n\n* Install Python 3.8 or higher.\n * Install Scenic.\n\n## Scenic Domains\n\nScenic has a general driving domain which allows users to define scenarios that can be run on any driving simulator. In addition, it has other domains that are specific to each simulator. Check here for more information on Scenic domains.\n\nOf particular importance within each domain are the behaviour and actions definitions. Check the links below for reference material to behaviours and actions from the Scenic driving domain and the CARLA domain:\n\n* Behaviours in the Scenic driving domain\n * Behaviours in the CARLA domain\n * Actions in the Scenic driving domain\n * Actions in the CARLA domain\n\n## Creating a Scenic scenario to use with CARLA\n\nThis section walks through how to write a basic Scenic script in which a leading vehicle decelerates suddenly due to an obstacle in the road. An ego vehicle then needs to brake suddenly to avoid a collison with the leading vehicle. The full script is found in the Scenic repository along with other examples involving more complex road networks.\n\n1. Set the map parameters and declare the model to be used in the scenario:\n\n* An\n `.xodr` file should be set as the value for the `map` parameter, this will be used later to generate road network information. * The parameter\n `carla_map` refers to the name of the CARLA map you would like to use in the simulation. If this is defined then Scenic will load all the assets of the map (buildings, trees, etc.), and if not, then the OpenDRIVE standalone mode will be used. * The model includes all the utilities specific to running scenarios on CARLA. This should be defined in all the scripts you want to run on CARLA.\n\n```\n## SET MAP AND MODEL\nparam map = localPath('../../../tests/formats/opendrive/maps/CARLA/Town01.xodr')\nparam carla_map = 'Town01'\nmodel scenic.simulators.carla.model\n```\n\n2. Define the constants to be used in the scenario:\n\nThe scenario involves two vehicles, the leading vehicle and the ego vehicle. We will define the ego vehicle model, the speeds of both cars, the distance threshold for braking and the amount of brake to apply.\n\n```\n## CONSTANTS\nEGO_MODEL = \"vehicle.lincoln.mkz_2017\"\nEGO_SPEED = 10\nEGO_BRAKING_THRESHOLD = 12\n\nLEAD_CAR_SPEED = 10\nLEADCAR_BRAKING_THRESHOLD = 10\n\nBRAKE_ACTION = 1.0\n```\n\n3. Define the scenario behaviours:\n\nIn this scenario we will use the Scenic behaviour library to instruct the ego vehicle to follow the lane at the predefined speed and then brake hard when it gets within a certain distance of another vehicle. The leading vehicle will also follow the lane at the predefined speed and brake hard within a certain distance of any objects:\n\n```\n## DEFINING BEHAVIORS\n# EGO BEHAVIOR: Follow lane, and brake after passing a threshold distance to the leading car\nbehavior EgoBehavior(speed=10):\n try:\n do FollowLaneBehavior(speed)\n\n interrupt when withinDistanceToAnyCars(self, EGO_BRAKING_THRESHOLD):\n take SetBrakeAction(BRAKE_ACTION)\n\n# LEAD CAR BEHAVIOR: Follow lane, and brake after passing a threshold distance to obstacle\nbehavior LeadingCarBehavior(speed=10):\n try: \n do FollowLaneBehavior(speed)\n\n interrupt when withinDistanceToAnyObjs(self, LEADCAR_BRAKING_THRESHOLD):\n take SetBrakeAction(BRAKE_ACTION)\n```\n\n4. Generate the road network:\n The Scenic roads library is used to generate the road network geometry and traffic information. The road network is represented by an instance of the `Network` class and is generated from the `.xodr` file defined at the beginning of the script. \n\n```\n## DEFINING SPATIAL RELATIONS\n# make sure to put '*' to uniformly randomly select from all elements of the list, 'lanes'\nlane = Uniform(*network.lanes)\n```\n\n5. Set the scene:\n\nWe will now define the starting positions for the vehicles and placement of objects.\n\n* Place a trash can in the middle of the lane:\n\n```\nobstacle = Trash on lane.centerline\n```\n\n* Place the leading car driving at the predefined speed along the road at a distance of between 50 and 30 meters behind the obstacle:\n\n```\nleadCar = Car following roadDirection from obstacle for Range(-50, -30),\n with behavior LeadingCarBehavior(LEAD_CAR_SPEED)\n```\n\n* Place the ego vehicle driving at the predefined speed along the road at a distance of between 15 to 10 meters behind the leading vehicle:\n\n```\nego = Car following roadDirection from leadCar for Range(-15, -10),\n with blueprint EGO_MODEL,\n with behavior EgoBehavior(EGO_SPEED)\n```\n\n* Make it a requirement that the scene takes place more than 80 meters from an intersection:\n\n```\nrequire (distance to intersection) > 80\n```\n\n6. Set an end point so the script knows when the scene is finished:\n\nThe scenario will end when the speed of the ego vehicle goes below 0.1 meters per second and is situated less than 30 meters from the obstacle.\n\n```\nterminate when ego.speed < 0.1 and (distance to obstacle) < 30\n```\n\n### Run the scenario\n\nTo run the Scenic scenario:\n\n1. Start the CARLA server.\n\n2. Run the following command:\n\n```\nscenic path/to/scenic/script.scenic --simulate\n```\n\n A pygame window will appear and the scenario will play out repeatedly, each time generating a unique scenario within the bounds of the restrictions set in the script. To stop the scenario generation, press `ctrl + C` in the terminal. \n\n### Additional parameters\n\n The CARLA model provides several global parameters than can be overridden in scenarios using the `param` statement or via the command line using the `--param` option. \nBelow is a table of configurable parameters in the CARLA model:\n\nName | Value | Description |\n | --- | --- | --- |\n | | Name of the CARLA map to use (e.g. 'Town01'). If set to |\n | | Timestep to use for simulations (how frequently Scenic interrupts CARLA to run behaviors, check requirements, etc.) in seconds. Default is 0.1 seconds. |\n\nb\"Name\\n Value\\n Description\\n \\n \\n \\n carla_map\\n \\n \\n str\\n \\n Name of the CARLA map to use (e.g. 'Town01'). If set to None, CARLA will attempt to create a world in the OpenDRIVE standalone mode using the .xodr file defined in the map parameter.\\n \\n \\n \\n timestep\\n \\n \\n float\\n \\n Timestep to use for simulations (how frequently Scenic interrupts CARLA to run behaviors, check requirements, etc.) in seconds. Default is 0.1 seconds.\\n \\n \\n \\n weather\\n \\n str or dict\\n Weather to use for the simulation. Can be either a string identifying one of the CARLA weather presets (e.g. 'ClearSunset') or a dictionary specifying all the weather parameters). Default is a uniform distribution over all the weather presets.\\n \\n \\n \\n address\\n \\n \\n str\\n \\n IP address to connect to CARLA. Default is localhost (127.0.0.1).\\n \\n \\n \\n port\\n \\n \\n int\\n \\n Port to connect to CARLA. Default is 2000.\\n \\n \\n \\n timeout\\n \\n \\n float\\n \\n Maximum time in seconds to wait when attempting to connect to CARLA. Default is 10.\\n \\n \\n \\n render\\n \\n \\n int\\n \\n Whether or not to have CARLA create a window showing the simulations from the point of view of the ego object: 1 for yes, 0 for no. Default 1.\\n \\n \\n \\n record\\n \\n \\n str\\n \\n If nonempty, folder in which to save CARLA record files for replaying simulations.\"\n\n* Requisites\n * Run a custom co-simulation\n * Spawn NPCs controlled by SUMO\n\nFirst and foremost, it is necessary to install SUMO to run the co-simulation. Building from source is recommended over a simple installation, as there are new features and fixes that will improve the co-simulation.\n\nOnce that is done, set the SUMO environment variable.\n\n```\necho \"export SUMO_HOME=/usr/share/sumo\" >> ~/.bashrc && source ~/.bashrc\n```\n\n SUMO is ready to run the co-simulations. There are some examples in\n\nfor Town01, Town04, and Town05. These `.sumocfg` files describe the configuration of the simulation (e.g., net, routes, vehicle types...). Use one of these to test the co-simulation. The script has different options that are detailed below. For the time being, let's run a simple example for Town04. \nRun a CARLA simulation with Town04.\n\n```\ncd ~/carla\n./CarlaUE4.sh\ncd PythonAPI/util\npython3 config.py --map Town04\n```\n\nThen, run the SUMO co-simulation example.\n\n```\ncd ~/carla/Co-Simulation/Sumo\npython3 run_synchronization.py examples/Town04.sumocfg --sumo-gui\n```\n\n### Create carla vtypes\n\n With the script\n\n```\nCo-Simulation/Sumo/util/create_sumo_vtypes.py\n```\n\nthe user can create sumo vtypes, the equivalent to CARLA blueprints, based on the CARLA blueprint library. \n\n* \n `--carla-host` (default: 127.0.0.1) — IP of the carla host server. * \n `--carla-port` (default: 2000) — TCP port to listen to. * \n `--output-file` (default: carlavtypes.rou.xml) — The generated file containing the vtypes. This script uses the information stored in `data/vtypes.json` to create the SUMO vtypes. These can be modified by editing said file. \nWarning\n\nA CARLA simulation must be running to execute the script.\n\n### Create the SUMO net\n\n The recommended way to create a SUMO net that synchronizes with CARLA is using the script\n\n```\nCo-Simulation/Sumo/util/netconvert_carla.py\n```\n\n. This will draw on the netconvert tool provided by SUMO. In order to run the script, some arguments are needed. \n\n* \n `xodr_file` — OpenDRIVE file `.xodr` . * \n `--output'` (default: `net.net.xml` ) — output file `.net.xml` . * \n `--guess-tls` (default:false) — SUMO can set traffic lights only for specific lanes in a road, but CARLA can't. If set to True, SUMO will not differenciate traffic lights for specific lanes, and these will be in sync with CARLA. The output of the script will be a `.net.xml` that can be edited using NETEDIT. Use it to edit the routes, add demand, and eventually, prepare a simulation that can be saved as `.sumocfg` . The examples provided may be helpful during this process. Take a look at\n\n. For every `example.sumocfg` there are several related files under the same name. All of them comprise a co-simulation example. \n\n### Run the synchronization\n\n Once a simulation is ready and saved as a `.sumocfg` , it is ready to run. There are some optional parameters to change the settings of the co-simulation. \n\n* \n `sumo_cfg_file` — The SUMO configuration file. * \n `--carla-host` (default: 127.0.0.1) — IP of the carla host server * \n `--carla-port` (default: 2000) — TCP port to listen to * \n `--sumo-host` (default: 127.0.0.1) — IP of the SUMO host server. * \n `--sumo-port` (default: 8813) — TCP port to listen to. * \n `--sumo-gui` — Open a window to visualize the gui version of SUMO. * \n `--step-length` (default: 0.05s) — Set fixed delta seconds for the simulation time-step. * \n\n(default: False) — Synchronize vehicle lights. * \n `--sync-vehicle-color` (default: False) — Synchronize vehicle color. * \n `--sync-vehicle-all` (default: False) — Synchronize all vehicle properties. * \n `--tls-manager` (default: none) — Choose which simulator should manage the traffic lights. The other will update those accordingly. The options are `carla` , `sumo` , and `none` . If `none` is chosen, traffic lights will not be synchronized. Each vehicle would only obey the traffic lights in the simulator that spawn it. \n\n```\npython3 run_synchronization.py <SUMOCFG FILE> --tls-manager carla --sumo-gui\n```\n\nWarning\n To stop the co-simulation, press `Ctrl+C` in the terminal that run the script. \n\n## Spawn NPCs controlled by SUMO\n\nThe co-simulation with SUMO makes for an additional feature. Vehicles can be spawned in CARLA through SUMO, and managed by the later as the Traffi Manager would do.\n The script `spawn_npc_sumo.py` is almost equivalent to the already-known `generate_traffic.py` . This script automatically generates a SUMO network in a temporal folder, based on the active town in CARLA. The script will create random routes and let the vehicles roam around. As the script runs a synchronous simulation, and spawns vehicles in it, the arguments are the same that appear in\n\nand `generate_traffic.py` . \n\n* \n `--host` (default: 127.0.0.1) — IP of the host server. * \n `--port` (default: 2000) — TCP port to listen to. * \n\n```\n-n,--number-of-vehicles\n```\n\n(default: 10) — Number of vehicles spawned. * \n `--safe` — Avoid spawning vehicles prone to accidents. * \n `--filterv` (default: \"vehicle.\")* — Filter the blueprint of the vehicles spawned. * \n `--sumo-gui` — Open a window to visualize SUMO. * \n `--step-length` (default: 0.05s) — Set fixed delta seconds for the simulation time-step. * \n\n(default: False) — Synchronize vehicle lights state. * \n `--sync-vehicle-color` (default: False) — Synchronize vehicle color. * \n `--sync-vehicle-all` (default: False) — Synchronize all vehicle properties. * \n `--tls-manager` (default: none) — Choose which simulator will change the traffic lights' state. The other will update them accordingly. If `none` , traffic lights will not be synchronized. \n\n```\n# Spawn 10 vehicles, that will be managed by SUMO instead of Traffic Manager.\n# CARLA in charge of traffic lights.\n# Open a window for SUMO visualization.\npython3 spawn_sumo_npc.py -n 10 --tls-manager carla --sumo-gui\n```\n\nThat is all there is so far, regarding for the SUMO co-simulation with CARLA.\n\nThe CARLA team is glad to accept contributions from anybody willing to collaborate. There are different ways to contribute to the project, depending on the capabilities of the contributor. The team will work as much as possible so that contributions are successfully integrated in CARLA.\n\nTake a look and don't hesitate!\n\n* Report bugs\n * Request features\n * Code contributions\n * Art contributions\n * Docs contributions\n\n## Report bugs\n\nIssues can be reported in the issue section on GitHub. Before reporting a new bug, make sure to do some checkups.\n\n1. Check if the bug has been reported. Look it up in that same issue section on GitHub.\n\n2. Read the docs. Make sure that the issue is a bug, not a misunderstanding on how is CARLA supposed to work. Read the pages related to the issue in the Documentation and take a look at the FAQ page.\n\n## Request features\n\nIdeas for new features are also a great way to contribute. Any suggestion that could improve the users' experience can be submitted in the corresponding GitHub section here.\n\n## Code contributions\n\nBefore starting hands-on on coding, please check out the issue board to check what is the team already working on, to avoid overlapping. In case of doubt or to discuss how to proceed, please contact one of us (or send an email to <EMAIL>).\n\nIn order to start working, fork the CARLA repository, and clone said fork in your computer. Remember to keep your fork in sync with the original repository.\n\n### Learn about Unreal Engine\n\nA basic introduction to C++ programming with UE4 can be found at Unreal's C++ Programming Tutorials. There are other options online, some of them not free of charge. The Unreal C++ Course at Udemy it's pretty complete and there are usually offers that make it very affordable.\n\n### Before getting started\n\nCheck out the CARLA Design document to get an idea on the different modules that compose CARLA. Choose the most appropriate one to hold the new feature. Feel free to contact the team in the Discord server in case any doubt arises during the process.\n\n### Coding standard\n\nFollow the current coding standard when submitting new code.\n\n### Submission\n\n Contributions and new features are not merged directly to the `master` branch, but to an intermediate branch named `dev` . This Gitflow branching model makes it easier to maintain a stable master branch. This model requires a specific workflow for contributions. \n\n* Always keep your\n `dev` branch updated with the lastest changes. * Develop the contribution in child branch from\n `dev` named as \n\n```\nusername/name_of_the_contribution\n```\n\n. * Once the contribution is ready, submit a pull-request from your branch to\n `dev` . Try to be as descriptive as possible when filling the description. Note that there are some checks that the new code is required to pass before merging. The checks are automatically run by the continuous integration system. A green tick mark will appear if the checks are successful. If a red mark, please correct the code accordingly. Once the contribution is merged in `dev` , it can be tested with the rest of new features. By the time of the next release, the `dev` branch will be merged to `master` , and the contribution will be available and announced. \n\n### Checklist\n\n* [ ] Your branch is up-to-date with the\n `dev` branch and tested with latest changes. * [ ] Extended the README/documentation, if necessary.\n * [ ] Code compiles correctly.\n * [ ] All tests passing with\n `make check` . \n\n## Art contributions\n\nArt contributions include vehicles, walkers, maps or any other type of assets to be used in CARLA. These are stored in a BitBucket repository, which has some account space limitations. For said reason, the contributor will have to get in touch with the CARLA team, and ask them to create a branch on the content repository for the contributions.\n\n1. Create a BitBucket account. Visit the Bitbucket page.\n\n2. Contact the art team to get access to the content repository. Join the Discord server. Go to the Contributors channel and request for access to the content repostory.\n 3. A branch will be created for each contributor. The branch will be named as\n\n```\ncontributors/contributor_name\n```\n\n. All the contributions made by said user should be made in that corresponding branch. \n4. Build CARLA. In order to contribute, a CARLA build is necessary. Follow the instructions to build either in Linux or Windows.\n\n5. Download the content repository. Follow the instructions to update the content in here.\n\n6. Update the branch to be in sync with master. The branch should always be updated with the latest changes in master.\n\n7. Upload the contribution. Do the corresponding changes and push the branch to origin.\n\n8. Wait for the art team to check it up. Once the contribution is uploaded, the team will check that everything is prepared to be merged with master.\n\n## Docs contributions\n\nIf some documentation is missing, vague or imprecise, it can be reported as with any other bug (read the previous section on how to report bugs). However, users can contribute by writing documentation.\n\nThe documentation is written with a mix of Markdown and HTML tags, with a some extra CSS code for features such as tables or the town slider. Follow the steps below to start writing documentation.\n\nImportant\n To submit docs contributions, follow the same workflow explained right above in code contributions. To sum up, contributions are made in a child branch from `dev` and merged to said branch. \n1. Build CARLA from source. Follow the steps in the docs to build on Linux or Windows.\n\n2. Install MkDocs. MkDocs is a static site generator used to build documentation.\n\n```\nsudo pip install mkdocs\n```\n\n3. Visualize the docs. In the main CARLA folder, run the following command and click the link that appears in the terminal (http://127.0.0.1:8000) to open a local visualization of the documentation.\n `mkdocs serve` 4. Create a git branch. Make sure to be in the `dev` branch (updated to latest changes) when creating a new one. \n\n```\ngit checkout -b <contributor_name>/<branch_name>\n```\n\n5. Write the docs. Edit the files following the guidelines in the documentation standard page.\n\n6. Submit the changes. Create a pull request in the GitHub repository, and add one of the suggested reviewers. Try to be as descriptive as possible when filling the pull-request description.\n\n7. Wait for review. The team will check if everything is ready to be merged or any changes are needed.\n\nWarning\n The local repository must be updated with the latest updates in the `dev` branch.\n\nb\"Coding standard\\n General\\n \\n Use spaces, not tabs.\\n Avoid adding trailing whitespace as it creates noise in the diffs.\\n \\n Python\\n \\n Comments should not exceed 80 columns, code should not exceed 120 columns.\\n All code must be compatible with Python 2.7 and 3.7.\\n Pylint should not give any error or warning (few exceptions apply with external classes like numpy and pygame, see our .pylintrc).\\n Python code follows PEP8 style guide (use autopep8 whenever\\n possible).\\n \\n C++\\n \\n Comments should not exceed 80 columns, code may exceed this limit a bit in rare occasions if it results in clearer code.\\n Compilation should not give any error or warning (clang++-8 -Wall -Wextra -std=C++14 -Wno-missing-braces).\\n The use of throw is forbidden, use carla::throw_exception instead.\\n Unreal C++ code (CarlaUE4 and Carla plugin) follow the Unreal Engine's Coding Standard with the exception of using spaces instead of tabs.\\n LibCarla uses a variation of Google's style guide.\\n Uses of try-catch blocks should be surrounded by\\n #ifndef LIBCARLA_NO_EXCEPTIONS if the code is used in the server-side.\"\nb\"Coding standard\\n General\\n \\n Use spaces, not tabs.\\n Avoid adding trailing whitespace as it creates noise in the diffs.\\n \\n Python\\n \\n Comments should not exceed 80 columns, code should not exceed 120 columns.\\n All code must be compatible with Python 2.7 and 3.7.\\n Pylint should not give any error or warning (few exceptions apply with external classes like numpy and pygame, see our .pylintrc).\\n Python code follows PEP8 style guide (use autopep8 whenever\\n possible).\\n \\n C++\\n \\n Comments should not exceed 80 columns, code may exceed this limit a bit in rare occasions if it results in clearer code.\\n Compilation should not give any error or warning (clang++-8 -Wall -Wextra -std=C++14 -Wno-missing-braces).\\n The use of throw is forbidden, use carla::throw_exception instead.\\n Unreal C++ code (CarlaUE4 and Carla plugin) follow the Unreal Engine's Coding Standard with the exception of using spaces instead of tabs.\\n LibCarla uses a variation of Google's style guide.\\n Uses of try-catch blocks should be surrounded by\\n #ifndef LIBCARLA_NO_EXCEPTIONS if the code is used in the server-side.\"\nb\"Coding standard\\n General\\n \\n Use spaces, not tabs.\\n Avoid adding trailing whitespace as it creates noise in the diffs.\\n \\n Python\\n \\n Comments should not exceed 80 columns, code should not exceed 120 columns.\\n All code must be compatible with Python 2.7 and 3.7.\\n Pylint should not give any error or warning (few exceptions apply with external classes like numpy and pygame, see our .pylintrc).\\n Python code follows PEP8 style guide (use autopep8 whenever\\n possible).\\n \\n C++\\n \\n Comments should not exceed 80 columns, code may exceed this limit a bit in rare occasions if it results in clearer code.\\n Compilation should not give any error or warning (clang++-8 -Wall -Wextra -std=C++14 -Wno-missing-braces).\\n The use of throw is forbidden, use carla::throw_exception instead.\\n Unreal C++ code (CarlaUE4 and Carla plugin) follow the Unreal Engine's Coding Standard with the exception of using spaces instead of tabs.\\n LibCarla uses a variation of Google's style guide.\\n Uses of try-catch blocks should be surrounded by\\n #ifndef LIBCARLA_NO_EXCEPTIONS if the code is used in the server-side.\"\nb\"Coding standard\\n General\\n \\n Use spaces, not tabs.\\n Avoid adding trailing whitespace as it creates noise in the diffs.\\n \\n Python\\n \\n Comments should not exceed 80 columns, code should not exceed 120 columns.\\n All code must be compatible with Python 2.7 and 3.7.\\n Pylint should not give any error or warning (few exceptions apply with external classes like numpy and pygame, see our .pylintrc).\\n Python code follows PEP8 style guide (use autopep8 whenever\\n possible).\\n \\n C++\\n \\n Comments should not exceed 80 columns, code may exceed this limit a bit in rare occasions if it results in clearer code.\\n Compilation should not give any error or warning (clang++-8 -Wall -Wextra -std=C++14 -Wno-missing-braces).\\n The use of throw is forbidden, use carla::throw_exception instead.\\n Unreal C++ code (CarlaUE4 and Carla plugin) follow the Unreal Engine's Coding Standard with the exception of using spaces instead of tabs.\\n LibCarla uses a variation of Google's style guide.\\n Uses of try-catch blocks should be surrounded by\\n #ifndef LIBCARLA_NO_EXCEPTIONS if the code is used in the server-side.\"\n\n* Use spaces, not tabs.\n * Avoid adding trailing whitespace as it creates noise in the diffs.\n\n## Python\n\n* Comments should not exceed 80 columns, code should not exceed 120 columns.\n * All code must be compatible with Python 2.7 and 3.7.\n * Pylint should not give any error or warning (few exceptions apply with external classes like\n `numpy` and `pygame` , see our `.pylintrc` ). * Python code follows PEP8 style guide (use\n `autopep8` whenever\n possible). \n\n## C++\n\n* Comments should not exceed 80 columns, code may exceed this limit a bit in rare occasions if it results in clearer code.\n * Compilation should not give any error or warning (\n\n```\nclang++-8 -Wall -Wextra -std=C++14 -Wno-missing-braces\n```\n\n). * The use of\n `throw` is forbidden, use \n\n```\ncarla::throw_exception\n```\n\ninstead. * Unreal C++ code (CarlaUE4 and Carla plugin) follow the Unreal Engine's Coding Standard with the exception of using spaces instead of tabs.\n * LibCarla uses a variation of Google's style guide.\n * Uses of\n `try-catch` blocks should be surrounded by \n\n```\n#ifndef LIBCARLA_NO_EXCEPTIONS\n```\n\nif the code is used in the server-side.\n\nThis document will serve as a guide and example of some rules that need to be followed in order to contribute to the documentation.\n\n## Docs structure\n\n We use a mix of markdown and HTML tags to customize the documentation along with an `extra.css` file.\nTo update Python API docs, instead of directly modifying the Markdown you need to edit the corresponding YAML files inside \n\n```\ncarla/PythonAPI/docs/\n```\n\nand run `doc_gen.py` or `make PythonAPI.docs` . This will re-generate the respective Markdown files inside `carla/Docs/` , which can then be fed into `mkdocs` . \n\n## Rules\n\n* Leave always an empty line between sections and at the end of the document.\n * Writting should not exceed\n `100` columns, except for HTML related content, markdown tables, code snipets and referenced links. * If an inline link exceeds the limit, use referenced\n\n```\n[name][reference_link]\n```\n\nmarkdown notation \n\n```\n[reference_link]: https://\n```\n\nrather than `[name](https://)` . * Use\n `<br>` to make inline jumps rather than leaving two spaces at the end of a line. * Use\n `<h1>Title</h1>` at the beggining of a new page in order to make a Title or `<hx>Heading<hx>` to make a heading that won't show on the navigation bar. * Use\n `------` underlining a Heading or `#` hierarchy to make headings and show them in the navigation bar. \n\n## Exceptions\n\n* Documentation generated via Python scripts like PythonAPI reference\n\nHandy markdown cheatsheet.\n"}}},{"rowIdx":592,"cells":{"project":{"kind":"string","value":"classmap"},"source":{"kind":"string","value":"cran"},"language":{"kind":"string","value":"R"},"content":{"kind":"string","value":"Package ‘classmap’\n April 23, 2023\nType Package\nTitle Visualizing Classification Results\nDate 2023-04-23\nVersion 1.2.3\nAuthor <NAME> [aut, cre],\n <NAME> [aut]\nDepends R (>= 4.1.0)\nSuggests knitr, reshape2, svd, rpart.plot, nnet, robCompositions\nImports stats, graphics, ggplot2, robustbase, e1071, cellWise,\n cluster, kernlab, gridExtra, rpart, randomForest\nMaintainer <NAME> <<EMAIL>>\nDescription Tools to visualize the results of a classification of cases.\n The graphical displays include stacked plots, silhouette plots, quasi residual plots, and class maps.\n Implements the techniques described and illustrated in Raymaekers, Rousseeuw and Hu-\n bert (2021), Class maps for visualizing classification results, Technometrics, appeared online.\n <doi:10.1080/00401706.2021.1927849> (open access) and Raymaekers and Rousseeuw (2021),\n Silhouettes and quasi residual plots for neural nets and tree-based classifiers,\n <arXiv:2106.08814>. Examples can be found in the vignettes:\n ``Discriminant_analysis_examples'',``K_nearest_neighbors_examples'',\n ``Support_vector_machine_examples'', ``Rpart_examples'', ``Random_forest_examples'',\n and ``Neural_net_examples''.\nURL https://doi.org/10.1080/00401706.2021.1927849,\n https://arxiv.org/abs/2106.08814\nLicense GPL (>= 2)\nEncoding UTF-8\nLazyData true\nVignetteBuilder knitr\nRoxygenNote 7.1.2\nNeedsCompilation no\nRepository CRAN\nDate/Publication 2023-04-23 15:30:02 UTC\nR topics documented:\nclassma... 2\nconfmat.vc... 4\ndata_bookReview... 6\ndata_floralbud... 7\ndata_instagra... 8\ndata_titani... 9\nmakeF... 10\nmakeKerne... 12\nqresplo... 13\nsilplo... 15\nstackedplo... 17\nvcr.da.newdat... 18\nvcr.da.trai... 20\nvcr.forest.newdat... 22\nvcr.forest.trai... 24\nvcr.knn.newdat... 26\nvcr.knn.trai... 28\nvcr.neural.newdat... 30\nvcr.neural.trai... 31\nvcr.rpart.newdat... 33\nvcr.rpart.trai... 34\nvcr.svm.newdat... 37\nvcr.svm.trai... 38\n classmap Draw the class map to visualize classification results.\nDescription\n Draw the class map to visualize classification results, based on the output of one of the vcr.*.*\n functions in this package. The vertical axis of the class map shows each case’s PAC, the condi-\n tional probability that it belongs to an alternative class. The farness on the horizontal axis is the\n probability of a member of the given class being at most as far from the class as the case itself.\nUsage\n classmap(vcrout, whichclass, classLabels = NULL, classCols = NULL,\n main = NULL, cutoff = 0.99, plotcutoff = TRUE,\n identify = FALSE, cex = 1, cex.main = 1.2, cex.lab = NULL,\n cex.axis = NULL, opacity = 1,\n squareplot = TRUE, maxprob = NULL, maxfactor = NULL)\nArguments\n vcrout output of vcr.*.train or vcr.*.newdata. Required.\n whichclass the number or level of the class to be displayed. Required.\n classLabels the labels (levels) of the classes. If NULL, they are taken from vcrout.\n classCols a list of colors for the class labels. There should be at least as many as there are\n levels. If NULL the classCols are taken as 2, 3, 4, ...\n main title for the plot.\n cutoff cases with overall farness vcrout$ofarness > cutoff are flagged as outliers.\n plotcutoff If true, plots the cutoff on the farness values as a vertical line.\n identify if TRUE, left-click on a point to get its number, then ESC to exit.\n cex passed on to graphics::plot.\n cex.main same, for title.\n cex.lab same, for labels on horizontal and vertical axes.\n cex.axis same, for axes.\n opacity determines opacity of plotted dots. Value between 0 and 1, where 0 is transpar-\n ent and 1 is opaque.\n squareplot If TRUE, makes the axes of the plot equally long.\n maxprob draws the farness axis at least upto probability maxprob. If NULL, the limits are\n obtained automatically.\n maxfactor if not NULL, a number slightly higher than 1 to increase the space at the right\n hand side of the plot, to make room for marking points.\nValue\n Executing the function plots the class map and returns\n coordinates a matrix with 2 columns containing the coordinates of the plotted points. The\n first coordinate is the quantile of the farness probability. This makes it eas-\n ier to add text next to interesting points. If identify = T, the attribute ids of\n coordinates contains the row numbers of the identified points in the matrix\n coordinates.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.da.train, vcr.da.newdata,\n vcr.knn.train, vcr.knn.newdata,\n vcr.svm.train, vcr.svm.newdata,\n vcr.rpart.train, vcr.rpart.newdata,\n vcr.forest.train, vcr.forest.newdata,\n vcr.neural.train, vcr.neural.newdata\nExamples\n vcrout <- vcr.da.train(iris[, 1:4], iris[, 5])\n classmap(vcrout, \"setosa\", classCols = 2:4) # tight class\n classmap(vcrout, \"versicolor\", classCols = 2:4) # less tight\n # The cases misclassified as virginica are shown in blue.\n classmap(vcrout, \"virginica\", classCols = 2:4)\n # The case misclassified as versicolor is shown in green.\n # For more examples, we refer to the vignettes:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n vignette(\"K_nearest_neighbors_examples\")\n vignette(\"Support_vector_machine_examples\")\n vignette(\"Rpart_examples\")\n vignette(\"Random_forest_examples\")\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n confmat.vcr Build a confusion matrix from the output of a function vcr.*.*.\nDescription\n Build a confusion matrix from the output of a function vcr.*.*. Optionally, a separate column for\n outliers can be added to the confusion matrix.\nUsage\n confmat.vcr(vcrout, cutoff = 0.99, showClassNumbers = FALSE,\n showOutliers = TRUE, silent = FALSE)\nArguments\n vcrout output of vcr.*.train or vcr.*.newdata.\n cutoff cases with overall farness vcrout$ofarness > cutoff are flagged as outliers.\n showClassNumbers\n if TRUE, the row and column names are the number of each level instead of the\n level itself. Useful for long level names.\n showOutliers if TRUE and some points were flagged as outliers, it adds an extra column on the\n right of the confusion matrix for these outliers, with label \"outl\".\n silent if FALSE, the confusion matrix and accuracy are shown on the screen.\nValue\n A confusion matrix\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.da.train, vcr.da.newdata,\n vcr.knn.train, vcr.knn.newdata,\n vcr.svm.train, vcr.svm.newdata,\n vcr.rpart.train, vcr.rpart.newdata,\n vcr.forest.train, vcr.forest.newdata,\n vcr.neural.train, vcr.neural.newdata\nExamples\n vcrout <- vcr.knn.train(scale(iris[, 1:4]), iris[, 5], k = 5)\n # The usual confusion matrix:\n confmat.vcr(vcrout, showOutliers = FALSE)\n # Cases with ofarness > cutoff are flagged as outliers:\n confmat.vcr(vcrout, cutoff = 0.98)\n # With the default cutoff = 0.99 only one case is flagged here:\n confmat.vcr(vcrout)\n # Note that the accuracy is computed before any cases\n # are flagged, so it does not depend on the cutoff.\n confmat.vcr(vcrout, showClassNumbers = TRUE)\n # Shows class numbers instead of labels. This option can\n # be useful for long level names.\n # For more examples, we refer to the vignettes:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n vignette(\"K_nearest_neighbors_examples\")\n vignette(\"Support_vector_machine_examples\")\n vignette(\"Rpart_examples\")\n vignette(\"Random_forest_examples\")\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n data_bookReviews Amazon book reviews data\nDescription\n This is a subset of the data used in the paper, which was assembled by Prettenhofer and Stein (2010).\n It contains 1000 reviews of books on Amazon, of which 500 were selected from the original training\n data and 500 from the test data.\n The full dataset has been used for a variety of things, including classification using svm. The subset\n was chosen small enough to keep the computation time low, while still containing the examples in\n the paper.\nUsage\n data(\"data_bookReviews\")\nFormat\n A data frame with 1000 observations on the following 2 variables.\n review the review in text format (character)\n sentiment factor indicating the sentiment of the review: negative (1) or positive (2)\nSource\n <NAME>., <NAME>. (2010). Cross-language text classification using structural correspondence\n learning. Proceedings of the 48th annual meeting of the association for computational linguistics,\n 1118-1127.\nExamples\n data(data_bookReviews)\n # Example review:\n data_bookReviews[5, 1]\n # The data are used in:\n ## Not run:\n vignette(\"Support_vector_machine_examples\")\n ## End(Not run)\n data_floralbuds Floral buds data\nDescription\n This data on floral pear bud detection was first described by Wouters et al. The goal is to classify the\n instances into buds, branches, scales and support. The numeric vectors resulted from a multispectral\n vision sensor and describe the scanned images.\nUsage\n data(\"data_floralbuds\")\nFormat\n A data frame with 550 observations on the following 7 variables.\n X1 numeric vector\n X2 numeric vector\n X3 numeric vector\n X4 numeric vector\n X5 numeric vector\n X6 numeric vector\n y a factor with levels branch bud scales support\nSource\n <NAME>., <NAME>., <NAME>. <NAME>., <NAME>. (2015). Multispectral\n detection of floral buds for automated thinning of pear. Comput. Electron. Agric. 113, C, 93–103.\n <doi:10.1016/j.compag.2015.01.015>\nExamples\n data(\"data_floralbuds\")\n str(data_floralbuds)\n summary(data_floralbuds)\n # The data are used in:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n data_instagram Instagram data\nDescription\n This dataset contains information on fake (spam) accounts on Instagram. The original source is\n https://www.kaggle.com/free4ever1/instagram-fake-spammer-genuine-accounts by <NAME>-\n deh.\n The data contains information on 696 Instagram accounts. For each account, 11 variables were\n recorded describing its characteristics. The goal is to detect fake instagram accounts, which are\n used for spamming.\nUsage\n data(\"data_instagram\")\nFormat\n A data frame with 696 observations on the following variables.\n profile.pic binary, indicates whether profile has picture.\n nums.length.username ratio of number of numerical chars in username to its length.\n fullname.words number of words in full name.\n nums.length.fullname ratio of number of numerical characters in full name to its length.\n name..username binary, indicates whether the name and username of the profile are the same.\n description.length length of the description/biography of the profile (in number of characters).\n external.URL binary, indicates whether profile has external url.\n private binary, indicates whether profile is private or not.\n X.posts number of posts made by profile.\n X.followers number of followers.\n X.follows numbers of follows.\n y whether profile is fake or not.\n dataType vector taking the values “train” or “test” indicating whether the observation belongs to\n the training or the test data.\nSource\n https://www.kaggle.com/free4ever1/instagram-fake-spammer-genuine-accounts\nExamples\n data(data_instagram)\n str(data_instagram)\n # The data are used in:\n ## Not run:\n vignette(\"Random_forest_examples\")\n ## End(Not run)\n data_titanic Titanic data\nDescription\n This dataset contains information on 1309 passengers of the RMS Titanic. The goal is to predict\n survival based on 11 characteristics such as the travel class, age and sex of the passengers.\n The original data source is https://www.kaggle.com/c/titanic/data\n The data is split up in a training data consisting of 891 observations and a test data of 418 observa-\n tions. The response in the test set was obtained by combining information from other data files, and\n has been verified by submitting it as a ‘prediction’ to kaggle and getting perfect marks.\nUsage\n data(\"data_titanic\")\nFormat\n A data frame with 1309 observations on the following variables.\n PassengerId a unique identified for each passenger.\n Pclass travel class of the passenger.\n Name name of the passenger.\n Sex sex of the passenger.\n Age age of the passenger.\n SibSp number of siblings and spouses traveling with the passenger.\n Parch number of parents and children traveling with the passenger.\n Ticket Ticket number of the passenger.\n Fare fare paid for the ticket.\n Cabin cabin number of the passenger.\n Embarked Port of embarkation. Takes the values C (Cherbourg), Q (Queenstown) and S (Southamp-\n ton).\n y factor indicating casualty or survivor.\n dataType vector taking the values “train” or “test” indicating whether the observation belongs to\n the training or the test data.\nSource\n https://www.kaggle.com/c/titanic/data\nExamples\n data(\"data_titanic\")\n traindata <- data_titanic[which(data_titanic$dataType == \"train\"), -13]\n testdata <- data_titanic[which(data_titanic$dataType == \"test\"), -13]\n str(traindata)\n table(traindata$y)\n # The data are used in:\n ## Not run:\n vignette(\"Rpart_examples\")\n ## End(Not run)\n makeFV Constructs feature vectors from a kernel matrix.\nDescription\n Constructs feature vectors from a kernel matrix.\nUsage\n makeFV(kmat, transfmat = NULL, precS = 1e-12)\nArguments\n kmat a kernel matrix. If transfmat is NULL, we are dealing with training data and\n then kmat must be a square kernel matrix (of size n by n when there are n\n cases). Such a PSD matrix kmat can e.g. be produced by makeKernel or by\n kernlab::kernelMatrix. If on the other hand transfmat is not NULL, we are\n dealing with a test set. See details for the precise working.\n transfmat transformation matrix. If not NULL, it is the value transfmat of makeFV on\n training data. It has to be a square matrix, with as many rows as there were\n training data.\n precS if not NULL, eigenvalues of kmat below precS will be set equal to precS.\nDetails\n If transfmat is non-NULL, we are dealing with a test set. Denote the number of cases in the test\n set by m ≥ 1. Each row of kmat of the test set then must contain the kernel values of a new case\n with all cases in the training set. Therefore the kernel matrix kmat must have dimensions m by\n n. The matrix kmat can e.g. be produced by makeKernel. It can also be obtained by running\n kernlab::kernelMatrix on the union of the training set and the test set, yielding an (n + m) by\n (n + m) matrix, from which one then takes the [(n + 1) : m, 1 : n] submatrix.\nValue\n A list with components:\n Xf When makeKV is applied to the training set, Xf has coordinates of n points (vec-\n tors), the plain inner products of which equal the kernel matrix of the training\n set. That is, kmat = Xf Xf’. The Xf are expressed in an orthogonal basis in which\n the variance of the coordinates is decreasing, which is useful when plotting the\n first few coordinates. When makeFV is applied to a test set, Xf are coordinates of\n the feature vectors of the test set in the same space as those of the training set,\n and then kmat = Xf %*% Xf of training data.\n transfmat square matrix for transforming kmat to Xf.\nAuthor(s)\n <NAME>., <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n makeKernel\nExamples\n library(e1071)\n set.seed(1); X <- matrix(rnorm(200 * 2), ncol = 2)\n X[1:100, ] <- X[1:100, ] + 2\n X[101:150, ] <- X[101:150, ] - 2\n y <- as.factor(c(rep(\"blue\", 150), rep(\"red\", 50)))\n cols <- c(\"deepskyblue3\", \"red\")\n plot(X, col = cols[as.numeric(y)], pch = 19)\n # We now fit an SVM with radial basis kernel to the data:\n svmfit <- svm(y~., data = data.frame(X = X, y = y), scale = FALSE,\n kernel = \"radial\", cost = 10, gamma = 1, probability = TRUE)\n Kxx <- makeKernel(X, svfit = svmfit)\n outFV <- makeFV(Kxx)\n Xf <- outFV$Xf # The data matrix in this feature space.\n dim(Xf) # The feature vectors are high dimensional.\n # The inner products of Xf match the kernel matrix:\n max(abs(as.vector(Kxx - crossprod(t(Xf), t(Xf))))) # 3.005374e-13 # tiny, OK\n range(rowSums(Xf^2)) # all points in Xf lie on the unit sphere.\n pairs(Xf[, 1:5], col = cols[as.numeric(y)])\n # In some of these we see spherical effects, e.g.\n plot(Xf[, 1], Xf[, 5], col = cols[as.numeric(y)], pch = 19)\n # The data look more separable here than in the original\n # two-dimensional space.\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Support_vector_machine_examples\")\n ## End(Not run)\n makeKernel Compute kernel matrix\nDescription\n Computes kernel value or kernel matrix, where the kernel type is extracted from an svm trained by\n e1071::svm.\nUsage\n makeKernel(X1, X2 = NULL, svfit)\nArguments\n X1 first matrix (or vector) of coordinates.\n X2 if not NULL, second data matrix or vector. If NULL, X2 is assumed equal to X1.\n svfit output from e1071::svm.\nValue\n the kernel matrix, of dimensions nrow(X1) by nrow(X2). When both X1 and X2 are vectors, the\n result is a single number.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n makeFV\nExamples\n library(e1071)\n set.seed(1); X <- matrix(rnorm(200 * 2), ncol = 2)\n X[1:100, ] <- X[1:100, ] + 2\n X[101:150, ] <- X[101:150, ] - 2\n y <- as.factor(c(rep(\"blue\", 150), rep(\"red\", 50))) # two classes\n # We now fit an SVM with radial basis kernel to the data:\n set.seed(1) # to make the result of svm() reproducible.\n svmfit <- svm(y~., data = data.frame(X = X, y = y), scale = FALSE,\n kernel = \"radial\", cost = 10, gamma = 1, probability = TRUE)\n Kxx <- makeKernel(X, svfit = svmfit)\n # The result is a square kernel matrix:\n dim(Kxx) # 200 200\n Kxx[1:5, 1:5]\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Support_vector_machine_examples\")\n ## End(Not run)\n qresplot Draw a quasi residual plot of PAC versus a data feature\nDescription\n Draw a quasi residual plot to visualize classification results. The vertical axis of the quasi residual\n plot shows each case’s probability of alternative class (PAC). The horizontal axis shows the feature\n given as the second argument in the function call.\nUsage\n qresplot(PAC, feat, xlab = NULL, xlim = NULL,\n main = NULL, identify = FALSE, gray = TRUE,\n opacity = 1, squareplot = FALSE, plotLoess = FALSE,\n plotErrorBars = FALSE, plotQuantiles = FALSE,\n grid = NULL, probs = c(0.5, 0.75),\n cols = NULL, fac = 1, cex = 1,\n cex.main = 1.2, cex.lab = 1,\n cex.axis = 1, pch = 19)\nArguments\n PAC vector with the PAC values of a classification, typically the $PAC in the return of\n a call to a function vcr.*.*\n feat the PAC will be plotted versus this data feature. Note that feat does not have to\n be one of the explanatory variables of the model. It can be another variable, a\n combination of variables (like a sum or a principal component score), the row\n number of the cases if they were recorded succesively, etc.\n xlab label for the horizontal axis, i.e. the name of variable feat.\n xlim limits for the horizontal axis. If NULL, the range of feat is used.\n main title for the plot.\n identify if TRUE, left-click on a point to get its number, then ESC to exit.\n gray logical, if TRUE (the default) the plot region where P AC < 0.5 gets a light gray\n background. Points in this region were classified into their given class, and the\n points above this region were misclassified.\n opacity determines opacity of plotted dots. Value between 0 and 1, where 0 is transpar-\n ent and 1 is opaque.\n squareplot if TRUE, the horizontal and vertical axis will get the same length.\n plotLoess if TRUE, a standard loess curve is fitted and superimposed on the plot. May\n not work well if feat is discrete with few values. At most one of the options\n plotLoess, plotErrorbars, or plotQuantiles can be selected.\n plotErrorBars if TRUE, the average PAC and its standard error are computed on the intervals\n of a grid (see option grid). Then a red curve connecting the averages is plot-\n ted, as well as two blue curves corresponding to the average plus or minus\n one standard error. At most one of the options plotLoess, plotErrorbars,\n or plotQuantiles can be selected.\n plotQuantiles if TRUE, one or more quantiles of the PAC are computed on the intervals of\n a grid (see option grid). The quantiles correspond the probabilities in option\n probs. Then the curves connecting the quantiles are plotted. At most one of the\n options plotLoess, plotErrorbars, or plotQuantiles can be selected.\n grid only used when plotErrorBars or plotQuantiles are selected. This is a vec-\n tor with increasing feat values, forming the grid. If NULL, the grid consists of the\n minimum and the maximum of feat, with 9 equispaced points between them.\n probs only used when plotQuantiles is selected. This is a vector with probabilities\n determining the quantiles. If NULL, defaults to c(0.5, 0.75).\n cols only used when plotquantiles is selected. A vector with the colors of the quantile\n curves. If NULL the cols are taken as 2, 3, ...\n fac only used when plotLoess, plotErrorBars or plotQuantiles are selected.\n A real number to multiply the resulting curves. A value fac > 1 can be useful\n to better visualize the curves when they would be too close to zero. By default\n (fac = 1) this is not done.\n cex passed on to plot.\n cex.main same, for title.\n cex.lab same, for labels on horizontal and vertical axes.\n cex.axis same, for axes.\n pch plot character for the points, defaults to 19.\nValue\n coordinates a matrix with 2 columns containing the coordinates of the plotted points. This\n makes it easier to add text next to interesting points. If identify = TRUE, the\n attribute ids of coordinates contains the row numbers of the identified points in\n the matrix coordinates.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nExamples\n library(rpart)\n data(\"data_titanic\")\n traindata <- data_titanic[which(data_titanic$dataType == \"train\"), -13]\n set.seed(123) # rpart is not deterministic\n rpart.out <- rpart(y ~ Pclass + Sex + SibSp +\n Parch + Fare + Embarked,\n data = traindata, method = 'class', model = TRUE)\n mytype <- list(nominal = c(\"Name\", \"Sex\", \"Ticket\", \"Cabin\", \"Embarked\"), ordratio = c(\"Pclass\"))\n x_train <- traindata[, -12]\n y_train <- traindata[, 12]\n vcrtrain <- vcr.rpart.train(x_train, y_train, rpart.out, mytype)\n # Quasi residual plot versus age, for males only:\n PAC <- vcrtrain$PAC[which(x_train$Sex == \"male\")]\n feat <- x_train$Age[which(x_train$Sex == \"male\")]\n qresplot(PAC, feat, xlab = \"Age (years)\", opacity = 0.5,\n main = \"quasi residual plot for male passengers\",\n plotLoess = TRUE)\n text(x = 14, y = 0.60, \"loess curve\", col = \"red\", cex = 1)\n silplot Draw the silhouette plot of a classification\nDescription\n Draw the silhouette plot to visualize classification results, based on the output of one of the vcr.*.*\n functions in this package. The horizontal axis of the silhouette plot shows each case’s s(i).\nUsage\n silplot(vcrout, classLabels = NULL, classCols = NULL,\n showLegend = TRUE, showClassNumbers = FALSE,\n showCases = FALSE, drawLineAtAverage = FALSE,\n topdown = TRUE, main = NULL, summary = TRUE)\nArguments\n vcrout output of vcr.*.train or vcr.*.newdata. Required.\n classLabels the labels (levels) of the classes. If NULL, they are taken from vcrout.\n classCols a list of colors for the classes. There should be at least as many as there are\n levels. If NULL a default palette is used.\n showLegend if TRUE, a legend is shown to the right of the plot.\n showClassNumbers\n if TRUE, the legend will show the class numbers instead of the class labels.\n showCases if TRUE, the plot shows the numbers of the cases. They are only readable when\n the number of cases is relatively small.\n topdown if TRUE (the default), the silhouettes are plotted from top to bottom. Otherwise\n they are plotted from left to right.\n drawLineAtAverage\n if TRUE, drwas a line at the average value of the s(i).\n main title for the plot. If NULL, a default title is used.\n summary if TRUE, puts a summary table on the screen with for each class its number, label,\n number of class members, and the average of its s(i).\nValue\n A ggplot object containing the silhouette plot.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.da.train, vcr.da.newdata,\n vcr.knn.train, vcr.knn.newdata,\n vcr.svm.train, vcr.svm.newdata,\n vcr.rpart.train, vcr.rpart.newdata,\n vcr.forest.train, vcr.forest.newdata,\n vcr.neural.train, vcr.neural.newdata\nExamples\n vcrout <- vcr.da.train(iris[, 1:4], iris[, 5])\n silplot(vcrout)\n # For more examples, we refer to the vignettes:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n vignette(\"K_nearest_neighbors_examples\")\n vignette(\"Support_vector_machine_examples\")\n vignette(\"Rpart_examples\")\n vignette(\"Forest_examples\")\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n stackedplot Make a vertically stacked mosaic plot of class predictions.\nDescription\n Make a vertically stacked mosaic plot of class predictions from the output of vcr.*.train or\n vcr.*.newdata. Optionally, the outliers for each class can be shown as a gray rectangle at the top.\nUsage\n stackedplot(vcrout, cutoff = 0.99, classCols = NULL,\n classLabels = NULL, separSize=1, minSize=1.5,\n showOutliers = TRUE, showLegend = FALSE, main = NULL,\n htitle = NULL, vtitle = NULL)\nArguments\n vcrout output of vcr.*.train or vcr.*.newdata.\n cutoff cases with overall farness vcrout$ofarness > cutoff are flagged as outliers.\n classCols user-specified colors for the classes. If NULL a default palette is used.\n classLabels names of given labels. If NULL they are taken from vcrout.\n separSize how much white between rectangles.\n minSize rectangles describing less than minSize percent of the data, are shown as minSize\n percent.\n showOutliers if TRUE, shows a separate class in gray with the outliers, always at the top.\n showLegend if TRUE, a legend is shown to the right of the plot. Default FALSE, since the\n legend is not necessary as the colors are already visible in the bottom part of\n each stack.\n main title for the plot.\n htitle title for horizontal axis (given labels). If NULL, a default title is shown.\n vtitle title for vertical axis (predicted labels). If NULL, a default title is shown.\nValue\n A ggplot object.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.da.train, vcr.da.newdata,\n vcr.knn.train, vcr.knn.newdata,\n vcr.svm.train, vcr.svm.newdata,\n vcr.rpart.train, vcr.rpart.newdata,\n vcr.forest.train, vcr.forest.newdata,\n vcr.neural.train, vcr.neural.newdata\nExamples\n data(\"data_floralbuds\")\n X <- data_floralbuds[, 1:6]; y <- data_floralbuds[, 7]\n vcrout <- vcr.da.train(X, y)\n cols <- c(\"saddlebrown\", \"orange\", \"olivedrab4\", \"royalblue3\")\n stackedplot(vcrout, classCols = cols, showLegend = TRUE)\n # The legend is not really needed, since we can read the\n # color of a class from the bottom of its vertical bar:\n stackedplot(vcrout, classCols = cols, main = \"Stacked plot of QDA on foral buds data\")\n # If we do not wish to show outliers:\n stackedplot(vcrout, classCols = cols, showOutliers = FALSE)\n # For more examples, we refer to the vignettes:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n vignette(\"K_nearest_neighbors_examples\")\n vignette(\"Support_vector_machine_examples\")\n vignette(\"Rpart_examples\")\n vignette(\"Random_forest_examples\")\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n vcr.da.newdata Carry out discriminant analysis on new data, and prepare to visualize\n its results.\nDescription\n Predicts class labels for new data by discriminant analysis, using the output of vcr.da.train on\n the training data. For new data cases whose label in yintnew is non-missing, additional output is\n produced for constructing graphical displays such as the classmap.\nUsage\n vcr.da.newdata(Xnew, ynew=NULL, vcr.da.train.out)\nArguments\n Xnew data matrix of the new data, with the same number of columns as in the training\n data. Missing values are not allowed.\n ynew factor with class membership of each new case. Can be NA for some or all cases.\n If NULL, is assumed to be NA everywhere.\n vcr.da.train.out\n output of vcr.da.train on the training data.\nValue\n A list with components:\n yintnew number of the given class of each case. Can contain NA’s.\n ynew given class label of each case. Can contain NA’s.\n levels levels of the response, from vcr.da.train.out.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose\n ynew is missing.\n altlab label of the alternative class. Is NA for cases whose ynew is missing.\n PAC probability of the alternative class. Is NA for cases whose ynew is missing.\n fig distance of each case i to each class g. Always exists.\n farness farness of each case i from its given class. Is NA for cases whose ynew is missing.\n ofarness For each case i, its lowest fig[i,g] to any class g. Always exists.\n classMS list with center and covariance matrix of each class, from vcr.da.train.out.\n lCurrent log of mixture density of each case in its given class. Is NA for cases with missing\n ynew.\n lPred log of mixture density of each case in its predicted class. Always exists.\n lAlt log of mixture density of each case in its alternative class. Is NA for cases with\n missing ynew.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.da.train, classmap, silplot, stackedplot\nExamples\n vcr.train <- vcr.da.train(iris[, 1:4], iris[, 5])\n inds <- c(51:150) # a subset, containing only 2 classes\n iris2 <- iris[inds, ] # fake \"new\" data\n iris2[c(1:10, 51:60), 5] <- NA\n vcr.test <- vcr.da.newdata(iris2[, 1:4], iris2[, 5], vcr.train)\n vcr.test$PAC[1:25] # between 0 and 1. Is NA where the response is.\n plot(vcr.test$PAC, vcr.train$PAC[inds]); abline(0, 1) # match\n plot(vcr.test$farness, vcr.train$farness[inds]); abline(0, 1) # match\n confmat.vcr(vcr.train) # for comparison\n confmat.vcr(vcr.test)\n stackedplot(vcr.train) # for comparison\n stackedplot(vcr.test)\n classmap(vcr.train, \"versicolor\", classCols = 2:4) # for comparison\n classmap(vcr.test, \"versicolor\", classCols = 2:4) # has fewer points\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n ## End(Not run)\n vcr.da.train Carry out discriminant analysis on training data, and prepare to visu-\n alize its results.\nDescription\n Custom DA function which prepares for graphical displays such as the classmap. The disciminant\n analysis itself is carried out by the maximum a posteriori rule, which maximizes the density of the\n mixture.\nUsage\n vcr.da.train(X, y, rule = \"QDA\", estmethod = \"meancov\")\nArguments\n X a numerical matrix containing the predictors in its columns. Missing values are\n not allowed.\n y a factor with the given class labels.\n rule either \"QDA\" for quadratic discriminant analysis or \"LDA\" for linear discriminant\n analysis.\n estmethod function for location and covariance estimation. Should return a list with the\n center $m and the covariance matrix $S. The default is \"meancov\" (classical\n mean and covariance matrix), and the option \"DetMCD\" (based on robustbase::covMcd)\n is also provided.\nValue\n A list with components:\n yint number of the given class of each case. Can contain NA’s.\n y given class label of each case. Can contain NA’s.\n levels levels of y\n predint predicted class number of each case. For each case this is the class with the\n highest posterior probability. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose y\n is missing.\n altlab label of the alternative class. Is NA for cases whose y is missing.\n PAC probability of the alternative class. Is NA for cases whose y is missing.\n figparams parameters for computing fig, can be used for new data.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose y is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\n classMS list with center and covariance matrix of each class\n lCurrent log of mixture density of each case in its given class. Is NA for cases with missing\n y.\n lPred log of mixture density of each case in its predicted class. Always exists.\n lAlt log of mixture density of each case in its alternative class. Is NA for cases with\n missing y.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.da.newdata, classmap, silplot, stackedplot\nExamples\n data(\"data_floralbuds\")\n X <- data_floralbuds[, 1:6]; y <- data_floralbuds[, 7]\n vcrout <- vcr.da.train(X, y, rule = \"QDA\")\n # For linear discriminant analysis, put rule = \"LDA\".\n confmat.vcr(vcrout) # There are a few outliers\n cols <- c(\"saddlebrown\", \"orange\", \"olivedrab4\", \"royalblue3\")\n stackedplot(vcrout, classCols = cols)\n classmap(vcrout, \"bud\", classCols = cols)\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Discriminant_analysis_examples\")\n ## End(Not run)\n vcr.forest.newdata Prepare for visualization of a random forest classification on new data.\nDescription\n Produces output for the purpose of constructing graphical displays such as the classmap on new\n data. Requires the output of vcr.forest.train as an argument.\nUsage\n vcr.forest.newdata(Xnew, ynew = NULL, vcr.forest.train.out,\n LOO = FALSE)\nArguments\n Xnew data matrix of the new data, with the same number of columns d as in the training\n data. Missing values are not allowed.\n ynew factor with class membership of each new case. Can be NA for some or all cases.\n If NULL, is assumed to be NA everywhere.\n vcr.forest.train.out\n output of vcr.forest.train on the training data.\n LOO leave one out. Only used when testing this function on a subset of the training\n data. Default is LOO=FALSE.\nValue\n A list with components:\n yintnew number of the given class of each case. Can contain NA’s.\n ynew given class label of each case. Can contain NA’s.\n levels levels of the response, from vcr.forest.train.out.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose\n ynew is missing.\n altlab alternative label if yintnew was given, else NA.\n PAC probability of the alternative class. Is NA for cases whose ynew is missing.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose ynew is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.forest.train, classmap, silplot, stackedplot\nExamples\n library(randomForest)\n data(\"data_instagram\")\n traindata <- data_instagram[which(data_instagram$dataType == \"train\"), -13]\n set.seed(71) # randomForest is not deterministic\n rfout <- randomForest(y ~ ., data = traindata, keep.forest = TRUE)\n mytype <- list(symm = c(1, 5, 7, 8)) # These 4 columns are\n # (symmetric) binary variables. The variables that are not\n # listed are interval-scaled by default.\n x_train <- traindata[, -12]\n y_train <- traindata[, 12]\n vcrtrain <- vcr.forest.train(X = x_train, y = y_train,\n trainfit = rfout, type = mytype)\n testdata <- data_instagram[which(data_instagram$dataType == \"test\"), -13]\n Xnew <- testdata[, -12]\n ynew <- testdata[, 12]\n vcrtest <- vcr.forest.newdata(Xnew, ynew, vcrtrain)\n confmat.vcr(vcrtest)\n stackedplot(vcrtest, classCol = c(4, 2))\n silplot(vcrtest, classCols = c(4, 2))\n classmap(vcrtest, \"genuine\", classCols = c(4, 2))\n classmap(vcrtest, \"fake\", classCols = c(4, 2))\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Random_forest_examples\")\n ## End(Not run)\n vcr.forest.train Prepare for visualization of a random forest classification on training\n data\nDescription\n Produces output for the purpose of constructing graphical displays such as the classmap and\n silplot. The user first needs to train a random forest on the data by randomForest::randomForest.\n This then serves as an argument to vcr.forest.train.\nUsage\n vcr.forest.train(X, y, trainfit, type = list(),\n k = 5, stand = TRUE)\nArguments\n X A rectangular matrix or data frame, where the columns (variables) may be of\n mixed type.\n y factor with the given class labels. It is crucial that X and y are exactly the same\n as in the call to randomForest::randomForest. y is allowed to contain NA’s.\n trainfit the output of a randomForest::randomForest training run.\n k the number of nearest neighbors used in the farness computation.\n type list for specifying some (or all) of the types of the variables (columns) in X,\n used for computing the dissimilarity matrix, as in cluster::daisy. The list\n may contain the following components: \"ordratio\" (ratio scaled variables to\n be treated as ordinal variables), \"logratio\" (ratio scaled variables that must be\n logarithmically transformed), \"asymm\" (asymmetric binary) and \"symm\" (sym-\n metric binary variables). Each component’s value is a vector, containing the\n names or the numbers of the corresponding columns of X. Variables not men-\n tioned in the type list are interpreted as usual (see argument X).\n stand whether or not to standardize numerical (interval scaled) variables by their range\n as in the original cluster::daisy code for the farness computation. Defaults\n to TRUE.\nValue\n A list with components:\n X The data used to train the forest.\n yint number of the given class of each case. Can contain NA’s.\n y given class label of each case. Can contain NA’s.\n levels levels of y\n predint predicted class number of each case. For each case this is the class with the\n highest posterior probability. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose y\n is missing.\n altlab label of the alternative class. Is NA for cases whose y is missing.\n PAC probability of the alternative class. Is NA for cases whose y is missing.\n figparams parameters for computing fig, can be used for new data.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose y is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\n trainfit The trained random forest which was given as an input to this function.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.forest.newdata, classmap, silplot, stackedplot\nExamples\n library(randomForest)\n data(\"data_instagram\")\n traindata <- data_instagram[which(data_instagram$dataType == \"train\"), -13]\n set.seed(71) # randomForest is not deterministic\n rfout <- randomForest(y~., data = traindata, keep.forest = TRUE)\n mytype <- list(symm = c(1, 5, 7, 8)) # These 4 columns are\n # (symmetric) binary variables. The variables that are not\n # listed are interval-scaled by default.\n x_train <- traindata[, -12]\n y_train <- traindata[, 12]\n # Prepare for visualization:\n vcrtrain <- vcr.forest.train(X = x_train, y = y_train,\n trainfit = rfout, type = mytype)\n confmat.vcr(vcrtrain)\n stackedplot(vcrtrain, classCols = c(4, 2))\n silplot(vcrtrain, classCols = c(4, 2))\n classmap(vcrtrain, \"genuine\", classCols = c(4, 2))\n classmap(vcrtrain, \"fake\", classCols = c(4, 2))\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Random_forest_examples\")\n ## End(Not run)\n vcr.knn.newdata Carry out a k-nearest neighbor classification on new data, and prepare\n to visualize its results.\nDescription\n Predicts class labels for new data by k nearest neighbors, using the output of vcr.knn.train on\n the training data. For cases in the new data whose given label ynew is not NA, additional output is\n produced for constructing graphical displays such as the classmap.\nUsage\n vcr.knn.newdata(Xnew, ynew = NULL, vcr.knn.train.out, LOO = FALSE)\nArguments\n Xnew If the training data was a matrix of coordinates, Xnew must be such a matrix with\n the same number of columns. If the training data was a set of dissimilarities,\n Xnew must be a rectangular matrix of dissimilarities, with each row containing\n the dissmilarities of a new case to all training cases. Missing values are not\n allowed.\n ynew factor with class membership of each new case. Can be NA for some or all cases.\n If NULL, is assumed to be NA everywhere.\n vcr.knn.train.out\n output of vcr.knn.train on the training data.\n LOO leave one out. Only used when testing this function on a subset of the training\n data. Default is LOO=FALSE.\nValue\n A list with components:\n yintnew number of the given class of each case. Can contain NA’s.\n ynew given class label of each case. Can contain NA’s.\n levels levels of the response, from vcr.knn.train.out.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose\n ynew is missing.\n altlab label of the alternative class. Is NA for cases whose ynew is missing.\n PAC probability of the alternative class. Is NA for cases whose ynew is missing.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose ynew is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\n k the requested number of nearest neighbors, from vcr.knn.train.out.\n ktrues for each case this contains the actual number of elements in its neighborhood.\n This can be higher than k due to ties.\n counts a matrix with 3 columns, each row representing a case. For the neighborhood of\n each case it says how many members it has from the given class, the predicted\n class, and the alternative class. The first and third entry is NA for cases whose\n ynew is missing.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.knn.train, classmap, silplot, stackedplot\nExamples\n data(\"data_floralbuds\")\n X <- data_floralbuds[, 1:6]; y <- data_floralbuds[, 7]\n set.seed(12345); trainset <- sample(1:550, 275)\n vcr.train <- vcr.knn.train(X[trainset, ], y[trainset], k = 5)\n vcr.test <- vcr.knn.newdata(X[-trainset, ], y[-trainset], vcr.train)\n confmat.vcr(vcr.train) # for comparison\n confmat.vcr(vcr.test)\n cols <- c(\"saddlebrown\", \"orange\", \"olivedrab4\", \"royalblue3\")\n stackedplot(vcr.train, classCols = cols) # for comparison\n stackedplot(vcr.test, classCols = cols)\n classmap(vcr.train, \"bud\", classCols = cols) # for comparison\n classmap(vcr.test, \"bud\", classCols = cols)\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"K_nearest_neighbors_examples\")\n ## End(Not run)\n vcr.knn.train Carry out a k-nearest neighbor classification on training data, and\n prepare to visualize its results.\nDescription\n Carries out a k-nearest neighbor classification on the training data. Various additional output is\n produced for the purpose of constructing graphical displays such as the classmap.\nUsage\n vcr.knn.train(X, y, k)\nArguments\n X This can be a rectangular matrix or data frame of (already standardized) mea-\n surements, or a dist object obtained from stats::dist or cluster::daisy.\n Missing values are not allowed.\n y factor with the given (observed) class labels. There need to be non-missing y in\n order to be able to train the classifier.\n k the number of nearest neighbors used. It can be selected by running cross-\n validation using a different package.\nValue\n A list with components:\n yint number of the given class of each case. Can contain NA’s.\n y given class label of each case. Can contain NA’s.\n levels levels of y\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose y\n is missing.\n altlab label of the alternative class. Is NA for cases whose y is missing.\n PAC probability of the alternative class. Is NA for cases whose y is missing.\n figparams parameters used to compute fig.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose y is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\n k the requested number of nearest neighbors, from the arguments. Will also be\n used for classifying new data.\n ktrues for each case this contains the actual number of elements in its neighborhood.\n This can be higher than k due to ties.\n counts a matrix with 3 columns, each row representing a case. For the neighborhood of\n each case it says how many members it has from the given class, the predicted\n class, and the alternative class. The first and third entry is NA for cases whose y\n is missing.\n X If the argument X was a data frame or matrix of coordinates, as.matrix(X) is\n returned here. This is useful for classifying new data.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.knn.newdata, classmap, silplot, stackedplot\nExamples\n vcrout <- vcr.knn.train(iris[, 1:4], iris[, 5], k = 5)\n confmat.vcr(vcrout)\n stackedplot(vcrout)\n classmap(vcrout, \"versicolor\", classCols = 2:4)\n # The cases misclassified as virginica are shown in blue.\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"K_nearest_neighbors_examples\")\n ## End(Not run)\n vcr.neural.newdata Prepare for visualization of a neural network classification on new\n data.\nDescription\n Prepares graphical display of new data fitted by a neural net that was modeled on the training data,\n using the output of vcr.neural.train on the training data.\nUsage\n vcr.neural.newdata(Xnew, ynew = NULL, probs,\n vcr.neural.train.out)\nArguments\n Xnew data matrix of the new data, with the same number of columns as in the training\n data. Missing values in Xnew are not allowed.\n ynew factor with class membership of each new case. Can be NA for some or all cases.\n If NULL, is assumed to be NA everywhere.\n probs posterior probabilities obtained by running the neural net on the new data.\n vcr.neural.train.out\n output of vcr.neural.train on the training data.\nValue\n A list with components:\n yintnew number of the given class of each case. Can contain NA’s.\n ynew given class label of each case. Can contain NA’s.\n levels levels of the response, from vcr.svm.train.out.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose\n ynew is missing.\n altlab alternative label if yintnew was given, else NA.\n PAC probability of the alternative class. Is NA for cases whose ynew is missing.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose ynew is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.neural.train, classmap, silplot, stackedplot\nExamples\n # For examples, we refer to the vignette:\n ## Not run:\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n vcr.neural.train Prepare for visualization of a neural network classification on training\n data.\nDescription\n Produces output for the purpose of constructing graphical displays such as the classmap. The user\n first needs train a neural network. The representation of the data in a given layer (e.g. the final layer\n before applying the softmax function) then serves as the argument X to vcr.neural.train.\nUsage\n vcr.neural.train(X, y, probs, estmethod = meancov)\nArguments\n X the coordinates of the n objects of the training data, in the layer chosen by the\n user. Missing values are not allowed.\n y factor with the given class labels of the objects. Make sure that the levels are in\n the same order as used in the neural net, i.e. the columns of its binary \"once-\n hot-encoded\" response vectors.\n probs posterior probabilities obtained by the neural net, e.g. in keras. For each case\n (row of X), the classes have probabilities that add up to 1. Each row of the matrix\n probs contains these probabilities. The columns of probs must be in the same\n order as the levels of y.\n estmethod function for location and covariance estimation. Should return a list with $m and\n $S. Can be meancov (classical mean and covariance matrix) or DetMCD. If one\n or more classes have a singular covariance matrix, the function automatically\n switches to the PCA-based farness used in vcr.svm.train.\nValue\n A list with components:\n X the coordinates of the n objects of the training data, in the layer chosen by the\n user.\n yint number of the given class of each case. Can contain NA’s.\n y given class label of each case. Can contain NA’s.\n levels levels of y\n predint predicted class number of each case. For each case this is the class with the\n highest posterior probability. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose y\n is missing.\n altlab label of the alternative class. Is NA for cases whose y is missing.\n ncolX number of columns in X. Keep??\n PAC probability of the alternative class. Is NA for cases whose y is missing.\n computeMD Whether or not the farness is computed using the Mahalanobis distance.\n classMS list with center and covariance matrix of each class\n PCAfits if not NULL, PCA fits to each class, estimated from the training data but also\n useful for new data.\n figparams parameters for computing fig, can be used for new data.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose y is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.neural.newdata, classmap, silplot, stackedplot\nExamples\n # For examples, we refer to the vignette:\n ## Not run:\n vignette(\"Neural_net_examples\")\n ## End(Not run)\n vcr.rpart.newdata Prepare for visualization of an rpart classification on new data.\nDescription\n Produces output for the purpose of constructing graphical displays such as the classmap on new\n data. Requires the output of vcr.rpart.train as an argument.\nUsage\n vcr.rpart.newdata(Xnew, ynew = NULL, vcr.rpart.train.out,\n LOO = FALSE)\nArguments\n Xnew data matrix of the new data, with the same number of columns d as in the training\n data. Missing values are not allowed.\n ynew factor with class membership of each new case. Can be NA for some or all cases.\n If NULL, is assumed to be NA everywhere.\n vcr.rpart.train.out\n output of vcr.rpart.train on the training data.\n LOO leave one out. Only used when testing this function on a subset of the training\n data. Default is LOO=FALSE.\nValue\n A list with components:\n yintnew number of the given class of each case. Can contain NA’s.\n ynew given class label of each case. Can contain NA’s.\n levels levels of the response, from vcr.rpart.train.out.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose\n ynew is missing.\n altlab alternative label if yintnew was given, else NA.\n PAC probability of the alternative class. Is NA for cases whose ynew is missing.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose ynew is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.rpart.train, classmap, silplot, stackedplot\nExamples\n library(rpart)\n data(\"data_titanic\")\n traindata <- data_titanic[which(data_titanic$dataType == \"train\"), -13]\n str(traindata); table(traindata$y)\n set.seed(123) # rpart is not deterministic\n rpart.out <- rpart(y ~ Pclass + Sex + SibSp +\n Parch + Fare + Embarked,\n data = traindata, method = 'class', model = TRUE)\n y_train <- traindata[, 12]\n x_train <- traindata[, -12]\n mytype <- list(nominal = c(\"Name\", \"Sex\", \"Ticket\", \"Cabin\", \"Embarked\"), ordratio = c(\"Pclass\"))\n # These are 5 nominal columns, and one ordinal.\n # The variables not listed are by default interval-scaled.\n vcrtrain <- vcr.rpart.train(x_train, y_train, rpart.out, mytype)\n testdata <- data_titanic[which(data_titanic$dataType == \"test\"), -13]\n dim(testdata)\n x_test <- testdata[, -12]\n y_test <- testdata[, 12]\n vcrtest <- vcr.rpart.newdata(x_test, y_test, vcrtrain)\n confmat.vcr(vcrtest)\n silplot(vcrtest, classCols = c(2, 4))\n classmap(vcrtest, \"casualty\", classCols = c(2, 4))\n classmap(vcrtest, \"survived\", classCols = c(2, 4))\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Rpart_examples\")\n ## End(Not run)\n vcr.rpart.train Prepare for visualization of an rpart classification on training data.\nDescription\n Produces output for the purpose of constructing graphical displays such as the classmap. The\n user first needs to train a classification tree on the data by rpart::rpart. This then serves as an\n argument to vcr.rpart.train.\nUsage\n vcr.rpart.train(X, y, trainfit, type = list(),\n k = 5, stand = TRUE)\nArguments\n X A rectangular matrix or data frame, where the columns (variables) may be of\n mixed type and may contain NA’s.\n y factor with the given class labels. It is crucial that X and y are exactly the same\n as in the call to rpart::rpart. y is allowed to contain NA’s.\n k the number of nearest neighbors used in the farness computation.\n trainfit the output of an rpart::rpart training cycle.\n type list for specifying some (or all) of the types of the variables (columns) in X,\n used for computing the dissimilarity matrix, as in cluster::daisy. The list\n may contain the following components: \"ordratio\" (ratio scaled variables to\n be treated as ordinal variables), \"logratio\" (ratio scaled variables that must be\n logarithmically transformed), \"asymm\" (asymmetric binary) and \"symm\" (sym-\n metric binary variables). Each component’s value is a vector, containing the\n names or the numbers of the corresponding columns of X. Variables not men-\n tioned in the type list are interpreted as usual (see argument X).\n stand whether or not to standardize numerical (interval scaled) variables by their range\n as in the original cluster::daisy code for the farness computation. Defaults\n to TRUE.\nValue\n A list with components:\n X The input data X. Keep??\n yint number of the given class of each case. Can contain NA’s.\n y given class label of each case. Can contain NA’s.\n levels levels of y\n predint predicted class number of each case. For each case this is the class with the\n highest posterior probability. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose y\n is missing.\n altlab label of the alternative class. Is NA for cases whose y is missing.\n PAC probability of the alternative class. Is NA for cases whose y is missing.\n figparams parameters for computing fig, can be used for new data.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose y is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\n trainfit the trainfit used to build the VCR object.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>.(2021). Silhouettes and quasi residual plots for neural nets and tree-\n based classifiers. (link to open access pdf)\nSee Also\n vcr.rpart.newdata, classmap, silplot, stackedplot\nExamples\n library(rpart)\n data(\"data_titanic\")\n traindata <- data_titanic[which(data_titanic$dataType == \"train\"), -13]\n str(traindata); table(traindata$y)\n set.seed(123) # rpart is not deterministic\n rpart.out <- rpart(y ~ Pclass + Sex + SibSp +\n Parch + Fare + Embarked,\n data = traindata, method = 'class', model = TRUE)\n y_train <- traindata[, 12]\n x_train <- traindata[, -12]\n mytype <- list(nominal = c(\"Name\", \"Sex\", \"Ticket\", \"Cabin\", \"Embarked\"), ordratio = c(\"Pclass\"))\n # These are 5 nominal columns, and one ordinal.\n # The variables not listed are by default interval-scaled.\n vcrtrain <- vcr.rpart.train(x_train, y_train, rpart.out, mytype)\n confmat.vcr(vcrtrain)\n silplot(vcrtrain, classCols = c(2, 4))\n classmap(vcrtrain, \"casualty\", classCols = c(2, 4))\n classmap(vcrtrain, \"survived\", classCols = c(2, 4))\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Rpart_examples\")\n ## End(Not run)\n vcr.svm.newdata Prepare for visualization of a support vector machine classification on\n new data.\nDescription\n Carries out a support vector machine classification of new data using the output of vcr.svm.train\n on the training data, and computes the quantities needed for its visualization.\nUsage\n vcr.svm.newdata(Xnew, ynew = NULL, vcr.svm.train.out)\nArguments\n Xnew data matrix of the new data, with the same number of columns as in the training\n data. Missing values in Xnew are not allowed.\n ynew factor with class membership of each new case. Can be NA for some or all cases.\n If NULL, is assumed to be NA everywhere.\n vcr.svm.train.out\n output of vcr.svm.train on the training data.\nValue\n A list with components:\n yintnew number of the given class of each case. Can contain NA’s.\n ynew given class label of each case. Can contain NA’s.\n levels levels of the response, from vcr.svm.train.out.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose\n ynew is missing.\n altlab alternative label if yintnew was given, else NA.\n PAC probability of the alternative class. Is NA for cases whose ynew is missing.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose ynew is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.svm.train, classmap, silplot, stackedplot, e1071::svm\nExamples\n library(e1071)\n set.seed(1); X <- matrix(rnorm(200 * 2), ncol = 2)\n X[1:100, ] <- X[1:100, ] + 2\n X[101:150, ] <- X[101:150, ] - 2\n y <- as.factor(c(rep(\"blue\", 150), rep(\"red\", 50)))\n # We now fit an SVM with radial basis kernel to the data:\n set.seed(1) # to make the result of svm() reproducible.\n svmfit <- svm(y~., data = data.frame(X = X, y = y),\n scale = FALSE, kernel = \"radial\", cost = 10,\n gamma = 1, probability = TRUE)\n vcr.train <- vcr.svm.train(X, y, svfit = svmfit)\n # As \"new\" data we take a subset of the training data:\n inds <- c(1:25, 101:125, 151:175)\n vcr.test <- vcr.svm.newdata(X[inds, ], y[inds], vcr.train)\n plot(vcr.test$PAC, vcr.train$PAC[inds]); abline(0, 1) # match\n plot(vcr.test$farness, vcr.train$farness[inds]); abline(0, 1)\n confmat.vcr(vcr.test)\n cols <- c(\"deepskyblue3\", \"red\")\n stackedplot(vcr.test, classCols = cols)\n classmap(vcr.train, \"blue\", classCols = cols) # for comparison\n classmap(vcr.test, \"blue\", classCols = cols)\n classmap(vcr.train, \"red\", classCols = cols) # for comparison\n classmap(vcr.test, \"red\", classCols = cols)\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Support_vector_machine_examples\")\n ## End(Not run)\n vcr.svm.train Prepare for visualization of a support vector machine classification on\n training data.\nDescription\n Produces output for the purpose of constructing graphical displays such as the classmap. The\n user first needs to run a support vector machine classification on the data by e1071::svm, with\n the option probability = TRUE. This classification can be with two or more classes. The output\n of e1071::svm is then an argument to vcr.svm.train. As e1071::svm does not output the data\n itself, it needs to be given as well, in the arguments X and y.\nUsage\n vcr.svm.train(X, y, svfit, ortho = FALSE)\nArguments\n X matrix of data coordinates, as used in e1071::svm. Missing values are not al-\n lowed.\n y factor with the given (observed) class labels. It is crucial that X and y are exactly\n the same as in the call to e1071::svm.\n svfit an object returned by e1071::svm, called with exactly the same X and y as\n above.\n ortho If TRUE, will compute farness in the orthogonal complement of the vector beta\n given by e1071::svm. Is only possible for 2 classes, else there would be several\n beta vectors.\nValue\n A list with components:\n yint number of the given class of each case. Can contain NA’s.\n y given class label of each case. Can contain NA’s.\n levels levels of the response y.\n predint predicted class number of each case. Always exists.\n pred predicted label of each case.\n altint number of the alternative class. Among the classes different from the given\n class, it is the one with the highest posterior probability. Is NA for cases whose y\n is missing.\n altlab label of the alternative class. Is NA for cases whose y is missing.\n PAC probability of the alternative class. Is NA for cases whose y is missing.\n figparams parameters used in fig, can be used for new data.\n fig distance of each case i from each class g. Always exists.\n farness farness of each case from its given class. Is NA for cases whose y is missing.\n ofarness for each case i, its lowest fig[i,g] to any class g. Always exists.\n svfit as it was input, will be useful for new data.\n X the matrix of data coordinates from the arguments. This is useful for classifying\n new data.\nAuthor(s)\n <NAME>., <NAME>.\nReferences\n <NAME>., <NAME>., <NAME>. (2021). Class maps for visualizing classification results.\n Technometrics, appeared online. doi: 10.1080/00401706.2021.1927849(link to open access pdf)\nSee Also\n vcr.knn.newdata, classmap, silplot, stackedplot, e1071::svm\nExamples\n library(e1071)\n set.seed(1); X <- matrix(rnorm(200 * 2), ncol = 2)\n X[1:100, ] <- X[1:100, ] + 2\n X[101:150, ] <- X[101:150, ] - 2\n y <- as.factor(c(rep(\"blue\", 150), rep(\"red\", 50)))\n cols <- c(\"deepskyblue3\", \"red\")\n plot(X, col = cols[as.numeric(y)], pch = 19)\n # We now fit an SVM with radial basis kernel to the data:\n set.seed(1) # to make the result of svm() reproducible.\n svmfit <- svm(y~., data = data.frame(X = X, y = y),\n scale = FALSE, kernel = \"radial\", cost = 10,\n gamma = 1, probability = TRUE)\n plot(svmfit$decision.values, col = cols[as.numeric(y)]); abline(h = 0)\n # so the decision values separate the classes reasonably well.\n plot(svmfit, data = data.frame(X = X, y = y), X.2~X.1, col = cols)\n # The boundary is far from linear (but in feature space it is).\n vcr.train <- vcr.svm.train(X, y, svfit = svmfit)\n confmat.vcr(vcr.train)\n stackedplot(vcr.train, classCols = cols)\n classmap(vcr.train, \"blue\", classCols = cols)\n classmap(vcr.train, \"red\", classCols = cols)\n # For more examples, we refer to the vignette:\n ## Not run:\n vignette(\"Support_vector_machine_examples\")\n ## End(Not run)"}}},{"rowIdx":593,"cells":{"project":{"kind":"string","value":"timely"},"source":{"kind":"string","value":"hex"},"language":{"kind":"string","value":"Erlang"},"content":{"kind":"string","value":"API Reference\n===\n\n Modules\n---\n\n[Timely](Timely.html)\n\nProvides functions for converting, comparing and shifting Elixir date & times.\n\n[Timely.TimeZone](Timely.TimeZone.html)\n\nProvides time zone convenience functions.\n\n[Timely.Year](Timely.Year.html)\n\nProvides functions for manipulating year numbers.\n\nTimely\n===\n\nProvides functions for converting, comparing and shifting Elixir date & times.\n\n Summary\n===\n\n[Types](#types)\n---\n\n[date_or_time_like()](#t:date_or_time_like/0)\n\n[date_tuple()](#t:date_tuple/0)\n\n[datetime_tuple()](#t:datetime_tuple/0)\n\n[microseconds()](#t:microseconds/0)\n\n[spec_or_format()](#t:spec_or_format/0)\n\nA known spec or a format string.\n\n[time_zone()](#t:time_zone/0)\n\nA valid time zone.\n\n[Functions](#functions)\n---\n\n[after?(dt1, dt2)](#after?/2)\n\n[ago(dt \\\\ utc(), units, scale)](#ago/3)\n\n[as(error, format_or_spec)](#as/2)\n\nConverts common date time like date structures to other common date time like data structures.\n\n[before?(dt1, dt2)](#before?/2)\n\n[before_or_on?(dt1, dt2)](#before_or_on?/2)\n\n[equal?(dt1, dt2)](#equal?/2)\n\n[from_now(dt \\\\ utc(), units, scale)](#from_now/3)\n\n[in_timezone(datetime, timezone)](#in_timezone/2)\n\n[new_datetime(arg, microseconds \\\\ {0, 6}, time_zone \\\\ \"Etc/UTC\")](#new_datetime/3)\n\nInitializes a DateTime.\n\n[now_in_timezone()](#now_in_timezone/0)\n\n[now_in_timezone(timezone)](#now_in_timezone/1)\n\n[on_or_after?(dt1, dt2)](#on_or_after?/2)\n\n[utc()](#utc/0)\n\n[utc_today()](#utc_today/0)\n\n[Link to this section](#types)\nTypes\n===\n```\ndate_or_time_like() :: [Date.t](https://hexdocs.pm/elixir/Date.html#t:t/0)() | [DateTime.t](https://hexdocs.pm/elixir/DateTime.html#t:t/0)() | [NaiveDateTime.t](https://hexdocs.pm/elixir/NaiveDateTime.html#t:t/0)() | [String.t](https://hexdocs.pm/elixir/String.html#t:t/0)()\n```\n```\ndate_tuple() :: {[integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()}\n```\n```\ndatetime_tuple() ::\n {{[integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()}, {[integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()}}\n```\n```\nmicroseconds() :: {[integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()}\n```\n```\nspec_or_format() :: [Atom.t](https://hexdocs.pm/elixir/Atom.html#t:t/0)() | [String.t](https://hexdocs.pm/elixir/String.html#t:t/0)()\n```\nA known spec or a format string.\n```\ntime_zone() :: [binary](https://hexdocs.pm/elixir/typespecs.html#built-in-types)()\n```\nA valid time zone.\n\n[Link to this section](#functions)\nFunctions\n===\n```\nas([date_or_time_like](#t:date_or_time_like/0)() | nil, [spec_or_format](#t:spec_or_format/0)()) :: [date_or_time_like](#t:date_or_time_like/0)() | nil\n```\nConverts common date time like date structures to other common date time like data structures.\n```\nnew_datetime([datetime_tuple](#t:datetime_tuple/0)(), [microseconds](#t:microseconds/0)(), [time_zone](#t:time_zone/0)()) :: [DateTime.t](https://hexdocs.pm/elixir/DateTime.html#t:t/0)()\n```\nInitializes a DateTime.\n\nTimely.TimeZone\n===\n\nProvides time zone convenience functions.\n\n Summary\n===\n\n[Functions](#functions)\n---\n\n[cst()](#cst/0)\n\n[est()](#est/0)\n\n[gmt()](#gmt/0)\n\n[list()](#list/0)\n\n[list(atom, opts \\\\ [])](#list/2)\n\n[mst()](#mst/0)\n\n[pst()](#pst/0)\n\n[utc()](#utc/0)\n\n[Link to this section](#functions)\nFunctions\n===\n\nTimely.Year\n===\n\nProvides functions for manipulating year numbers.\n\n Summary\n===\n\n[Functions](#functions)\n---\n\n[century(year)](#century/1)\n\nComputes the century of the specified `year`.\n\n[guess(number, list)](#guess/2)\n\nInterprets the specified `number` as a year. If necessary, it guesses the century nearest the specified `:near` option.\n\n[Link to this section](#functions)\nFunctions\n===\n```\ncentury([integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()) :: [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()\n```\nComputes the century of the specified `year`.\n\n Examples\n---\n```\niex> Timely.Year.century 1900 19\n\niex> Timely.Year.century 34 0\n```\n```\nguess([integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)(), [{:near, [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()}]) :: {:ok, [integer](https://hexdocs.pm/elixir/typespecs.html#basic-types)()} | {:error, [binary](https://hexdocs.pm/elixir/typespecs.html#built-in-types)()}\n```\nInterprets the specified `number` as a year. If necessary, it guesses the century nearest the specified `:near` option.\n\n Examples\n---\n```\niex> Timely.Year.guess 17, near: 2017\n{:ok, 2017}\n\niex> Timely.Year.guess 67, near: 2017\n{:ok, 1967}\n\niex> Timely.Year.guess 66, near: 2017\n{:ok, 2066}\n\niex> Timely.Year.guess 2017, near: 2017\n{:ok, 2017}\n\niex> Timely.Year.guess 2017, near: 17\n{:error, \":near value 17 has no century\"}\n```"}}},{"rowIdx":594,"cells":{"project":{"kind":"string","value":"flow"},"source":{"kind":"string","value":"hex"},"language":{"kind":"string","value":"Erlang"},"content":{"kind":"string","value":"\nFlow\n===\n\nComputational flows with stages.\n\n[`Flow`](Flow.html#content) allows developers to express computations on collections, similar to the [`Enum`](https://hexdocs.pm/elixir/Enum.html) and [`Stream`](https://hexdocs.pm/elixir/Stream.html) modules,\nalthough computations will be executed in parallel using multiple [`GenStage`](https://hexdocs.pm/gen_stage/1.2.1/GenStage.html)s.\n\nFlow is designed to work with both bounded (finite) and unbounded (infinite) data. By default, Flow will work with batches of 500 items. This means Flow will only show improvements when working with larger collections. However,\nfor certain cases, such as IO-bound flows, a smaller batch size can be configured through the `:min_demand` and `:max_demand`\noptions supported by [`from_enumerable/2`](#from_enumerable/2), [`from_stages/2`](#from_stages/2),\n[`from_specs/2`](#from_specs/2), [`partition/2`](#partition/2), [`departition/5`](#departition/5), etc.\n\nFlow also provides the concepts of \"windows\" and \"triggers\",\nwhich allow developers to split the data into arbitrary windows according to event time. Triggers allow computations to be materialized at different intervals, allowing developers to peek at results as they are computed.\n\nThis module doc will cover the main constructs and concepts behind Flow, with examples. There is also a presentation about GenStage and Flow from <NAME> at ElixirConf 2016, which covers data processing concepts for those unfamiliar with the domain:\n<https://youtu.be/srtMWzyqdp8?t=244[example](#module-example)\n Example\n---\n\nAs an example, let's implement the classic word counting algorithm using Flow. The word counting program will receive one file and count how many times each word appears in the document. Using the [`Enum`](https://hexdocs.pm/elixir/Enum.html) module it could be implemented as follows:\n```\nFile.stream!(\"path/to/some/file\")\n|> Enum.flat_map(&String.split(&1, \" \"))\n|> Enum.reduce(%{}, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nUnfortunately, the implementation above is not very efficient,\nas [`Enum.flat_map/2`](https://hexdocs.pm/elixir/Enum.html#flat_map/2) will build a list with all the words in the document before reducing it. If the document is, for example,\n2GB, we will load 2GB of data into memory.\n\nWe can improve the solution above by using the [`Stream`](https://hexdocs.pm/elixir/Stream.html) module:\n```\nFile.stream!(\"path/to/some/file\")\n|> Stream.flat_map(&String.split(&1, \" \"))\n|> Enum.reduce(%{}, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nNow instead of loading the whole set into memory, we will only keep the current line in memory while we process it. While this allows us to process the whole data set efficiently, it does not leverage concurrency. Flow solves that:\n```\nFile.stream!(\"path/to/some/file\")\n|> Flow.from_enumerable()\n|> Flow.flat_map(&String.split(&1, \" \"))\n|> Flow.partition()\n|> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nTo convert from Stream to Flow, we have made two changes:\n\n1. We have replaced the calls to [`Stream`](https://hexdocs.pm/elixir/Stream.html) with [`Flow`](Flow.html#content)\n2. We call [`partition/2`](#partition/2) so words are properly partitioned between stages\n\nThe example above will use all available cores and will keep an ongoing flow of data instead of traversing them line by line. Once all data is computed, it is sent to the process which invoked [`Enum.to_list/1`](https://hexdocs.pm/elixir/Enum.html#to_list/1).\n\nWhile we gain concurrency by using Flow, many of the benefits of Flow are in partitioning the data. We will discuss the need for data partitioning next.\n\n[partitioning](#module-partitioning)\n Partitioning\n---\n\nTo understand the need to partition the data, let's change the example above and remove the partition call:\n```\nFile.stream!(\"path/to/some/file\")\n|> Flow.from_enumerable()\n|> Flow.flat_map(&String.split(&1, \" \"))\n|> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nThis will execute the `flat_map` and `reduce` operations in parallel inside multiple stages. When running on a machine with two cores:\n```\n [file stream] # Flow.from_enumerable/1 (producer)\n | |\n [M1] [M2] # Flow.flat_map/2 + Flow.reduce/3 (consumer)\n```\nNow imagine that the `M1` and `M2` stages above receive the following lines:\n```\nM1 - \"roses are red\"\nM2 - \"violets are blue\"\n```\n[`flat_map/2`](#flat_map/2) will break them into:\n```\nM1 - [\"roses\", \"are\", \"red\"]\nM2 - [\"violets\", \"are\", \"blue\"]\n```\nThen [`reduce/3`](#reduce/3) will result in each stage having the following state:\n```\nM1 - %{\"roses\" => 1, \"are\" => 1, \"red\" => 1}\nM2 - %{\"violets\" => 1, \"are\" => 1, \"blue\" => 1}\n```\nWhich is converted to the list (in no particular order):\n```\n[{\"roses\", 1},\n {\"are\", 1},\n {\"red\", 1},\n {\"violets\", 1},\n {\"are\", 1},\n {\"blue\", 1}]\n```\nAlthough both stages have performed word counting, we have words like \"are\" that appear on both stages. This means we would need to perform yet another pass on the data merging the duplicated words across stages. This step would have to run on a single process,\nwhich would limit our ability to run concurrently.\n\nRemember that events are batched, so for small files, there is a chance all lines will be set to the same stage (M1 or M2) and you won't be able to replicate the issue. If you want to emulate this, either to follow along or in your test suites, you may set `:max_demand` to 1 when reading from the stream, so that the code looks like this:\n```\nFile.stream!(\"path/to/some/file\")\n|> Flow.from_enumerable(max_demand: 1)\n|> Flow.flat_map(&String.split(&1, \" \"))\n|> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nPartitioning solves this by introducing a new set of stages and making sure the same word is always mapped to the same stage with the help of a hash function. Let's introduce the call to\n[`partition/2`](#partition/2) back:\n```\nFile.stream!(\"path/to/some/file\")\n|> Flow.from_enumerable()\n|> Flow.flat_map(&String.split(&1, \" \"))\n|> Flow.partition()\n|> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nNow we will have the following topology:\n```\n [file stream] # Flow.from_enumerable/1 (producer)\n | |\n [M1] [M2] # Flow.flat_map/2 (producer-consumer)\n |\\ /|\n | \\/ |\n |/ \\ |\n [R1] [R2] # Flow.reduce/3 (consumer)\n```\nIf the `M1` and `M2` stages receive the same lines and break them into words as before:\n```\nM1 - [\"roses\", \"are\", \"red\"]\nM2 - [\"violets\", \"are\", \"blue\"]\n```\nNow, any given word will be consistently routed to `R1` or `R2`\nregardless of its origin. The default hashing function will route them like this:\n```\nR1 - [\"roses\", \"are\", \"red\", \"are\"]\nR2 - [\"violets\", \"blue\"]\n```\nResulting in the reduced state of:\n```\nR1 - %{\"roses\" => 1, \"are\" => 2, \"red\" => 1}\nR2 - %{\"violets\" => 1, \"blue\" => 1}\n```\nWhich is converted to the list (in no particular order):\n```\n[{\"roses\", 1},\n {\"are\", 2},\n {\"red\", 1},\n {\"violets\", 1},\n {\"blue\", 1}]\n```\nEach stage has a distinct subset of the data so we know that we don't need to merge the data later on, because a given word is guaranteed to have only been routed to one stage.\n\nPartitioning the data is a very useful technique. For example,\nif we wanted to count the number of unique elements in a dataset,\nwe could perform such a count in each partition and then sum their results, as the partitioning guarantees the data in each partition won't overlap. A unique element would never be counted twice.\n\nThe topology above alongside partitioning is very common in the MapReduce programming model which we will briefly discuss next.\n\n### \n[mapreduce](#module-mapreduce)\n MapReduce\n\nThe MapReduce programming model forces us to break our computations in two stages: map and reduce. The map stage is often quite easy to parallelize because events are processed individually and in isolation.\nThe reduce stages need to group the data either partially or completely.\n\nIn the example above, the stages executing [`flat_map/2`](#flat_map/2) are the mapper stages. Because the [`flat_map/2`](#flat_map/2) function works line by line,\nwe can have two, four, eight or more mapper processes that will break line by line into words without any need for coordination.\n\nHowever, the reducing stage is a bit more complicated. Reducer stages typically aggregate some result based on their inputs, such as how many times a word has appeared. This implies reducer computations need to traverse the whole data set and, in order to do so in parallel, we partition the data into distinct datasets.\n\nThe goal of the [`reduce/3`](#reduce/3) operation is to accumulate a value which then becomes the partition state. Any operation that happens after [`reduce/3`](#reduce/3) works on the whole state and is only executed after all the data for a partition is collected.\n\nWhile this approach works well for bounded (finite) data, it is quite limited for unbounded (infinite) data. After all, if the reduce operation needs to traverse the whole partition to complete, how can we do so if the data never finishes?\n\nThe answer here lies in triggers. Every partition may have a\n[`on_trigger/2`](#on_trigger/2) callback which receives the partition accumulator and returns the events to be emitted and the accumulator to be used after the trigger. All flows have at least one trigger:\nthe `:done` trigger which is executed when all the data has been processed. In this case, the accumulator returned by\n[`on_trigger/2`](#on_trigger/2) won't be used, only the events it emits.\n\nHowever, Flow provides many conveniences for working with unbound data, allowing us to set windows, time-based triggers,\nelement counters and more.\n\n[data-completion-windows-and-triggers](#module-data-completion-windows-and-triggers)\n Data completion, windows and triggers\n---\n\nBy default, Flow shuts down its processes when all data has been processed. However, when working with an unbounded stream of data,\nthere is no such thing as data completion. So when can we consider a reduce function to be \"completed\"?\n\nTo handle such cases, Flow provides windows and triggers. Windows allow us to split the data based on the event time while triggers tells us when to write the results we have computed so far. By introducing windows, we no longer think about events being partitioned across stages. Instead each event belongs to a window and the window is partitioned across the stages.\n\nBy default, all events belong to the same window (called the global window), which is partitioned across stages. However, different windowing strategies can be used by building a [`Flow.Window`](Flow.Window.html)\nand passing it to the [`Flow.partition/2`](#partition/2) function.\n\nOnce a window is specified, we can create triggers that tell us when to checkpoint the data, allowing us to report our progress while the data streams through the system, regardless of whether the data is bounded or unbounded. Every time a trigger is invoked,\nthe [`on_trigger/2`](#on_trigger/2) callback of that partition is invoked, allowing us to control which events to emit and what accumulator to use for the next time the partition starts reducing data.\n\nWindows and triggers effectively control how the [`reduce/3`](#reduce/3) function works. While windows and triggers allow us to control when data is emitted, note that data can be emitted at any time during the reducing step by using [`emit_and_reduce/3`](#emit_and_reduce/3). In truth, all window and trigger functionality provided by Flow can also be built by hand using the\n[`emit_and_reduce/3`](#emit_and_reduce/3) and [`on_trigger/2`](#on_trigger/2) functions.\n\nIn a nutshell, each stage in Flow goes through those steps:\n\n* mapping and filtering ([`map/2`](#map/2), [`filter/2`](#filter/2), [`flat_map/2`](#flat_map/2))\n* reducing ([`reduce/3`](#reduce/3), [`group_by/3`](#group_by/3), [`emit_and_reduce/3`](#emit_and_reduce/3))\n* emitting events ([`emit_and_reduce/3`](#emit_and_reduce/3), [`emit/2`](#emit/2), [`on_trigger/2`](#on_trigger/2))\n\nThe accumulator from reducing operations is shared with the one from emitting events. [`emit_and_reduce/3`](#emit_and_reduce/3) is special operation that allows both emitting and reducing events in one step.\n\nSee [`Flow.Window`](Flow.Window.html) for a complete introduction to windows and triggers.\n\n[supervisable-flows](#module-supervisable-flows)\n Supervisable flows\n---\n\nIn the examples so far we have started a flow dynamically and consumed it using [`Enum.to_list/1`](https://hexdocs.pm/elixir/Enum.html#to_list/1). Unfortunately calling a function from [`Enum`](https://hexdocs.pm/elixir/Enum.html) will cause the whole computed dataset to be sent to a single process.\n\nIn many situations, this is either too expensive or completely undesirable. For example, in data-processing pipelines, it is common to receive data continuously from external sources. At the end, this data is written to disk or another storage mechanism after being processed, rather than being sent to a single process.\n\nFlow allows computations to be started as a group of processes which may run indefinitely. This can be done by starting the flow as part of a supervision tree using `{Flow, your_flow}`\nas your child specification:\n```\nchildren = [\n {Flow,\n Flow.from_stages(...)\n |> Flow.flat_map(&String.split(&1, \" \"))\n |> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\n end)}\n]\n```\nIt is also possible to move a Flow to its own module. This is done by calling `use Flow` and then defining a [`start_link/1`](#start_link/1) function that calls [`Flow.start_link/1`](#start_link/1) at the end:\n```\ndefmodule MyFlow do\n use Flow\n\n def start_link(_) do\n Flow.from_stages(...)\n |> Flow.flat_map(&String.split(&1, \" \"))\n |> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\n end)\n |> Flow.start_link()\n end end\n```\nBy the default the [`Flow`](Flow.html#content) is permanent, which means it is always restarted. The `:shutdown` and `:restart` child spec configurations can be given to `use Flow`.\n\nFlow also provides integration with [`GenStage`](https://hexdocs.pm/gen_stage/1.2.1/GenStage.html), allowing you to specify child specifications of producers, producer consumers, and consumers that are started alongside the flow and under the same supervision tree. This is achieved with the [`from_specs/2`](#from_specs/2) (producers),\n[`through_specs/2`](#through_specs/2) (producer consumers) and [`into_specs/2`](#into_specs/2) (consumers)\nfunctions.\n\nIt is also possible to connect a flow to already running stages,\nvia the [`from_stages/2`](#from_stages/2) (producers), [`through_stages/2`](#through_stages/2) (producer consumers) and [`into_stages/2`](#into_stages/2) (consumers) functions.\n\n[`into_stages/3`](#into_stages/3) and [`into_specs/3`](#into_specs/3) are alternatives to [`start_link/1`](#start_link/1)\nthat start the flow with the given consumers stages or the given consumers child specification. Similar to [`start_link/1`](#start_link/1), they return either `{:ok, pid}` or `{:error, reason}`.\n\n[performance-discussions](#module-performance-discussions)\n Performance discussions\n---\n\nIn this section we will discuss points related to performance with flows.\n\n### \n[know-your-code](#module-know-your-code)\n Know your code\n\nThere are many optimizations we could perform in the flow above that are not necessarily related to flows themselves. Let's rewrite the flow using some of them:\n```\n# The parent process which will own the table parent = self()\n\n# Let's compile common patterns for performance empty_space = :binary.compile_pattern(\" \") # BINARY\n\nFile.stream!(\"path/to/some/file\", read_ahead: 100_000) # READ_AHEAD\n|> Flow.from_enumerable()\n|> Flow.flat_map(&String.split(&1, empty_space)) # BINARY\n|> Flow.partition()\n|> Flow.reduce(fn -> :ets.new(:words, []) end, fn word, ets -> # ETS\n :ets.update_counter(ets, word, {2, 1}, {word, 0})\n ets end)\n|> Flow.on_trigger(fn ets ->\n :ets.give_away(ets, parent, [])\n {[ets], :new_reduce_state_which_wont_be_used} # Emit the ETS end)\n|> Enum.to_list()\n```\nWe have performed three optimizations:\n\n* BINARY - the first optimization is to compile the pattern we use to split the string on\n* READ_AHEAD - the second optimization is to use the `:read_ahead`\noption for file streams allowing us to do fewer IO operations by reading large chunks of data at once\n* ETS - the third stores the data in a ETS table and uses its counter operations. For counters and a large dataset this provides a great performance benefit as it generates less garbage. At the end, we call [`on_trigger/2`](#on_trigger/2) to transfer the ETS table to the parent process and wrap the table in a list so we can access it on [`Enum.to_list/1`](https://hexdocs.pm/elixir/Enum.html#to_list/1).\nThis step is not strictly required. For example, one could write the table to disk with [`:ets.tab2file/2`](https://www.erlang.org/doc/man/ets.html#tab2file-2) at the end of the computation\n\n### \n[configuration-demand-and-the-number-of-stages](#module-configuration-demand-and-the-number-of-stages)\n Configuration (demand and the number of stages)\n\n[`from_enumerable/2`](#from_enumerable/2), [`from_stages/2`](#from_stages/2) and `partition/3` allow a set of options to configure how flows work. In particular, we recommend that developers play with the `:min_demand` and `:max_demand` options, which control the amount of data sent between stages. The difference between\n`max_demand` and `min_demand` works as the batch size when the producer is full. If the producer has fewer events than requested by consumers,\nit usually sends the remaining events available.\n\nIf stages perform IO, it may also be worth increasing the number of stages. The default value is [`System.schedulers_online/0`](https://hexdocs.pm/elixir/System.html#schedulers_online/0),\nwhich is a good default if the stages are CPU bound, but if stages are waiting on external resources or other processes, increasing the number of stages may be helpful.\n\n### \n[avoid-single-sources](#module-avoid-single-sources)\n Avoid single sources\n\nIn the examples so far we have used a single file as our data source. In practice such single sources should be avoided as they could end up being the bottleneck of our whole computation.\n\nIn the file stream case above, instead of having one single large file, it is preferable to break the file into smaller ones:\n```\nstreams = for file <- File.ls!(\"dir/with/files\") do\n File.stream!(\"dir/with/files/#{file}\", read_ahead: 100_000)\nend\n\nstreams\n|> Flow.from_enumerables()\n|> Flow.flat_map(&String.split(&1, \" \"))\n|> Flow.partition()\n|> Flow.reduce(fn -> %{} end, fn word, acc ->\n Map.update(acc, word, 1, & &1 + 1)\nend)\n|> Enum.to_list()\n```\nInstead of calling [`from_enumerable/1`](#from_enumerable/1), we now called\n[`from_enumerables/1`](#from_enumerables/1) which expects a list of enumerables to be used as source. Notice every stream also uses the `:read_ahead`\noption which tells Elixir to buffer file data in memory to avoid multiple IO lookups.\n\nIf the number of enumerables is equal to or greater than the number of cores, Flow will automatically fuse the enumerables with the mapper logic. For example, if three file streams are given as enumerables to a machine with two cores, we will have the following topology:\n```\n[F1][F2][F3] # file stream\n[M1][M2][M3] # Flow.flat_map/2 (producer)\n |\\ /\\ /|\n | /\\/\\ |\n |// \\\\|\n [R1][R2] # Flow.reduce/3 (consumer)\n```\n[Link to this section](#summary)\n Summary\n===\n\n[Types](#types)\n---\n\n[join()](#t:join/0)\n\n[t()](#t:t/0)\n\n[Functions](#functions)\n---\n\n[bounded_join(mode, left, right, left_key, right_key, join, options \\\\ [])](#bounded_join/7)\n\nJoins two bounded (finite) flows.\n\n[departition(flow, acc_fun, merge_fun, done_fun, options \\\\ [])](#departition/5)\n\nReduces windows over multiple partitions into a single stage.\n\n[each(flow, each)](#each/2)\ndeprecated\n\n[emit(flow, type)](#emit/2)\n\nControls which values should be emitted.\n\n[emit_and_reduce(flow, acc_fun, reducer_fun)](#emit_and_reduce/3)\n\nReduces values with the given accumulator and controls which values should be emitted.\n\n[filter(flow, filter)](#filter/2)\n\nApplies the given function filtering each input in parallel.\n\n[flat_map(flow, flat_mapper)](#flat_map/2)\n\nApplies the given function mapping each input in parallel and flattening the result, but only one level deep.\n\n[from_enumerable(enumerable, options \\\\ [])](#from_enumerable/2)\n\nCreates a flow with the given enumerable as the producer.\n\n[from_enumerables(enumerables, options \\\\ [])](#from_enumerables/2)\n\nCreates a flow with the given enumerable as producer.\n\n[from_specs(producers, options \\\\ [])](#from_specs/2)\n\nCreates a flow with a list of `producers` child specifications.\n\n[from_stages(producers, options \\\\ [])](#from_stages/2)\n\nCreates a flow with a list of already running stages as `producers`.\n\n[group_by(flow, key_fun, value_fun \\\\ fn x -> x end)](#group_by/3)\n\nGroups events with the given `key_fun`.\n\n[group_by_key(flow)](#group_by_key/1)\n\nGroups a series of `{key, value}` tuples by keys.\n\n[into_specs(flow, consumers, options \\\\ [])](#into_specs/3)\n\nStarts a flow and the `consumers` child specifications.\n\n[into_stages(flow, consumers, options \\\\ [])](#into_stages/3)\n\nStarts a flow with a list of already running stages as `consumers`.\n\n[map(flow, mapper)](#map/2)\n\nApplies the given function mapping each input in parallel.\n\n[map_batch(flow, function)](#map_batch/2)\n\nApplies the given function to each \"batch\" of GenStage events.\n\n[map_values(flow, value_fun)](#map_values/2)\n\nMaps over the given values in the stage state.\n\n[merge(flow_or_flows, dispatcher, options \\\\ [])](#merge/3)\n\nMerges the given flow or flows into a series of new stages with the given dispatcher and options.\n\n[on_trigger(flow, on_trigger)](#on_trigger/2)\n\nApplies the given function over the window state.\n\n[partition(flow_or_flows, options \\\\ [])](#partition/2)\n\nCreates a new partition for the given flow (or flows) with the given options.\n\n[reduce(flow, acc_fun, reducer_fun)](#reduce/3)\n\nReduces the given values with the given accumulator.\n\n[reject(flow, filter)](#reject/2)\n\nApplies the given function rejecting each input in parallel.\n\n[run(flow, opts \\\\ [])](#run/2)\n\nRuns a given flow.\n\n[shuffle(flow_or_flows, options \\\\ [])](#shuffle/2)\n\nShuffles the given flow (or flows) into a new series of stages.\n\n[start_link(flow, options \\\\ [])](#start_link/2)\n\nStarts and runs the flow as a separate process.\n\n[stream(flow, opts \\\\ [])](#stream/2)\n\nExplicitly converts the Flow into a Stream.\n\n[take_sort(flow, n, sort_fun \\\\ &<=/2, options \\\\ [])](#take_sort/4)\n\nTakes `n` events according to the sort function.\n\n[through_specs(flow, producer_consumers, options \\\\ [])](#through_specs/3)\n\nPasses a `flow` through a list of `producer_consumers` child specifications and subscriptions that will be started alongside the flow.\n\n[through_stages(flow, producer_consumers, options \\\\ [])](#through_stages/3)\n\nPasses a `flow` through a list of already running stages as `producer_consumers`.\n\n[uniq(flow)](#uniq/1)\n\nOnly emit unique events.\n\n[uniq_by(flow, by)](#uniq_by/2)\n\nOnly emit events that are unique according to the `by` function.\n\n[window_join(mode, left, right, window, left_key, right_key, join, options \\\\ [])](#window_join/8)\n\nJoins two flows with the given window.\n\n[Link to this section](#types)\nTypes\n===\n\n[Link to this section](#functions)\nFunctions\n===\n\nFlow.Window\n===\n\nSplits a flow into windows that are materialized at certain triggers.\n\nWindows allow developers to split data so we can understand incoming data as time progresses. Once a window is created, we can specify triggers that allow us to customize when the data accumulated on every window is materialized.\n\nWindows must be created by calling one of the window type functions.\nThe supported window types are as follows:\n\n* Global windows - that's the default window which means all data belongs to one single window. In other words, the data is not split in any way. The window finishes when all producers notify there is no more data\n* Fixed windows - splits incoming events into periodic, non-\noverlapping windows based on event times. In other words, a given event belongs to a single window. If data arrives late, a configured lateness can be specified.\n* Periodic windows - splits incoming events into periodic, non-\noverlapping windows based on processing times. Similar to fixed windows, a given event belongs to a single window.\n* Count windows - splits incoming events based on a count.\nSimilar to fixed windows, a given event belongs to a single window.\n\nOther common window types can be expressed with Flow functions:\n\n* Session windows - splits incoming events into unique windows which is grouped until there is a configured gap between event times. Sessions are useful for data that is irregularly distributed with respect to time.\n\nWe discuss all types and include examples below. In the first section,\n\"Global windows\", we build the basic intuition about windows and triggers as well as discuss the distinction between \"Event time and processing time\".\nThen we explore \"Fixed windows\" and the concept of lateness before moving on to other window types.\n\n[global-windows](#module-global-windows)\n Global windows\n---\n\nBy default, all events belong to the global window. The global window is automatically attached to a partition if no window is specified.\nThe flow below:\n```\nFlow.from_stages([some_producer])\n|> Flow.partition()\n|> Flow.reduce(fn -> 0 end, & &1 + 2)\n```\nis equivalent to:\n```\nFlow.from_stages([some_producer])\n|> Flow.partition(window: Flow.Window.global())\n|> Flow.reduce(fn -> 0 end, & &1 + 2)\n```\nEven though the global window does not split the data in any way, it already provides conveniences for working with both bounded (finite)\nand unbounded (infinite) via triggers.\n\nFor example, the flow below uses a global window with a count-based trigger to emit the values being summed as we sum them:\n```\niex> window = Flow.Window.global() |> Flow.Window.trigger_every(10)\niex> flow = Flow.from_enumerable(1..100) |> Flow.partition(window: window, stages: 1)\niex> flow |> Flow.reduce(fn -> 0 end, &(&1 + &2)) |> Flow.emit(:state) |> Enum.to_list()\n[55, 210, 465, 820, 1275, 1830, 2485, 3240, 4095, 5050, 5050]\n```\nLet's explore the types of triggers available next.\n\n### \n[triggers](#module-triggers)\n Triggers\n\nTriggers allow us to check point the data processed so far. There are different triggers we can use:\n\n* Event count triggers - compute state operations every X events\n* Processing time triggers - compute state operations every X time units for every stage\n* Punctuation - hand-written triggers based on the data\n\nFlow supports the triggers above via the [`trigger_every/2`](#trigger_every/2),\n[`trigger_periodically/3`](#trigger_periodically/3) and [`trigger/3`](#trigger/3) respectively.\n\nOnce a trigger is emitted, the [`Flow.reduce/3`](Flow.html#reduce/3) step halts and invokes the [`Flow.on_trigger/2`](Flow.html#on_trigger/2) callback, allowing you to emit events and change the reducer accumulator.\n\n### \n[event-time-and-processing-time](#module-event-time-and-processing-time)\n Event time and processing time\n\nBefore we move to other window types, it is important to discuss the distinction between event time and processing time. In particular,\ntriggers created with the [`trigger_periodically/3`](#trigger_periodically/3) function are intrinsically inaccurate and therefore should not be used to split the data. For example, if you are measuring the frequency that events arrive,\nusing the event time will always yield the same result, while processing time will be vulnerable to fluctuations if, for instance, an external factor causes events to processed slower or faster than usual.\n\nFurthermore, periodic triggers are established per partition and are message-based, which means partitions will emit the triggers at different times and possibly with delays based on the partition message queue size.\nHowever, it is exactly this lack of precision which makes them efficient for checkpointing data.\n\nFlow provides other window types, such as fixed windows, exactly to address the issues with processing time. Such windows use the event time which is based on the data itself. When working with event time, we can assign the data into proper windows even when late or out of order. Such windows can be used to gather time-based insight from the data (for example, the most popular hashtags in the last 10 minutes) as well as for checkpointing data.\n\n[fixed-windows-event-time](#module-fixed-windows-event-time)\n Fixed windows (event time)\n---\n\nFixed windows group the data based on the event times. Regardless if the data is bounded or not, fixed windows give us time-based insight about the data.\n\nFixed windows are created via the [`fixed/3`](#fixed/3) function which specified the duration of the window and a function that retrieves the event time from each event:\n```\nFlow.Window.fixed(1, :hour, fn {word, timestamp} -> timestamp end)\n```\nLet's see an example that will use the window above to count the frequency of words based on windows that are 1 hour long. The timestamps used by Flow are integers in milliseconds. For now, we will also set the concurrency down 1 and max demand down to 5 as it is simpler to reason about the results:\n```\niex> data = [{\"elixir\", 0}, {\"elixir\", 1_000}, {\"erlang\", 60_000},\n...> {\"concurrency\", 3_200_000}, {\"elixir\", 4_000_000},\n...> {\"erlang\", 5_000_000}, {\"erlang\", 6_000_000}]\niex> window = Flow.Window.fixed(1, :hour, fn {_word, timestamp} -> timestamp end)\niex> flow = Flow.from_enumerable(data, max_demand: 5, stages: 1)\niex> flow = Flow.partition(flow, window: window, stages: 1)\niex> flow = Flow.reduce(flow, fn -> %{} end, fn {word, _}, acc ->\n...> Map.update(acc, word, 1, & &1 + 1)\n...> end)\niex> flow |> Flow.emit(:state) |> Enum.to_list\n[%{\"elixir\" => 2, \"erlang\" => 1, \"concurrency\" => 1},\n %{\"elixir\" => 1, \"erlang\" => 2}]\n```\nSince the data has been broken in two windows, the first four events belong to the same window while the last 3 belongs to the second one. Notice that\n[`Flow.reduce/3`](Flow.html#reduce/3) is executed per window and that each event belongs to a single window exclusively.\n\nSimilar to global windows, fixed windows can also have triggers, allowing us to checkpoint the data as the computation happens.\n\n### \n[data-ordering-watermarks-and-lateness](#module-data-ordering-watermarks-and-lateness)\n Data ordering, watermarks and lateness\n\nWhen working with event time, Flow assumes by default that events are time ordered. This means that, when we move from one window to another, like when we received the entry `{\"elixir\", 4_000_000}` in the example above,\nwe assume the previous window has been completed.\n\nLet's change the events above to be out of order and move the first event to the end of the dataset and see what happens:\n```\niex> data = [{\"elixir\", 1_000}, {\"erlang\", 60_000},\n...> {\"concurrency\", 3_200_000}, {\"elixir\", 4_000_000},\n...> {\"erlang\", 5_000_000}, {\"erlang\", 6_000_000}, {\"elixir\", 0}]\niex> window = Flow.Window.fixed(1, :hour, fn {_word, timestamp} -> timestamp end)\niex> flow = Flow.from_enumerable(data) |> Flow.partition(window: window, stages: 1, max_demand: 5)\niex> flow = Flow.reduce(flow, fn -> %{} end, fn {word, _}, acc ->\n...> Map.update(acc, word, 1, & &1 + 1)\n...> end)\niex> flow |> Flow.emit(:state) |> Enum.to_list\n[%{\"elixir\" => 1, \"erlang\" => 1, \"concurrency\" => 1},\n %{\"elixir\" => 1, \"erlang\" => 2}]\n```\nNotice that now the first map did not count the \"elixir\" word twice.\nSince the event arrived late, it was marked as lost. However, in many flows we actually expect data to arrive late or out of order, especially when talking about concurrent data processing.\n\nLuckily, event time windows include the concept of lateness, which is a processing time base period we would wait to receive late events.\nLet's change the example above once more but now change the window to also call [`allowed_lateness/3`](#allowed_lateness/3):\n```\niex> data = [{\"elixir\", 1_000}, {\"erlang\", 60_000},\n...> {\"concurrency\", 3_200_000}, {\"elixir\", 4_000_000},\n...> {\"erlang\", 5_000_000}, {\"erlang\", 6_000_000}, {\"elixir\", 0}]\niex> window = Flow.Window.fixed(1, :hour, fn {_word, timestamp} -> timestamp end)\niex> window = Flow.Window.allowed_lateness(window, 5, :minute)\niex> flow = Flow.from_enumerable(data) |> Flow.partition(window: window, stages: 1, max_demand: 5)\niex> flow = Flow.reduce(flow, fn -> %{} end, fn {word, _}, acc ->\n...> Map.update(acc, word, 1, & &1 + 1)\n...> end)\niex> flow |> Flow.emit(:state) |> Enum.to_list\n[%{\"concurrency\" => 1, \"elixir\" => 1, \"erlang\" => 1},\n %{\"concurrency\" => 1, \"elixir\" => 2, \"erlang\" => 1},\n %{\"elixir\" => 1, \"erlang\" => 2}]\n```\nNow that we allow late events, we can see the first window emitted twice. Instead of the window being marked as done when 1 hour passes,\nwe say it emits a **watermark trigger**. The window will be effectively done only after the allowed lateness period. If desired, we can use\n[`Flow.on_trigger/2`](Flow.html#on_trigger/2) to get more information about each particular window and its trigger. Replace the last line above by the following:\n```\nflow\n|> Flow.on_trigger(fn state, _index, trigger -> {[{state, trigger}], state} end)\n|> Enum.to_list()\n```\nThe trigger parameter will include the type of window, the current window and what caused the window to be emitted (`:watermark` or\n`:done`).\n\nNote that all stages must receive an event that is outside of a specific window before that window is considered complete. In other words if there are multiple stages in the partition preceding a reduce operation that has a window, the reduce step won't release a window until it has seen an event that is outside of that window from all processes that it receives data from.\nThis could have an effect on how long events are delayed in the reduce step.\n\n[periodic-windows-processing-time](#module-periodic-windows-processing-time)\n Periodic windows (processing time)\n---\n\nPeriodic windows are similar to fixed windows except triggers are emitted based on processing time instead of event time. Remember that relying on periodic windows or triggers is intrinsically inaccurate and should not be used to split the data, only as a checkpointing device.\n\nPeriodic windows are also similar to global windows that use\n`trigger_periodically/2` to emit events periodically. The difference is that periodic windows emit a window in a given interval while a trigger emits a trigger. This behaviour may affect functions such as [`Flow.departition/4`](Flow.html#departition/4),\nwhich calls the `merge` callback per trigger but the `done` callback per window. Unless you are relying on functions such as [`Flow.departition/4`](Flow.html#departition/4),\nthere is no distinction between periodic windows and global windows with periodic triggers.\n\n[count-windows-event-count](#module-count-windows-event-count)\n Count windows (event count)\n---\n\nCount windows are simpler versions of fixed windows where windows are split apart by event count. Since it is not timed-based, it does not provide the concept of lateness.\n```\niex> window = Flow.Window.count(10)\niex> flow = Flow.from_enumerable(1..100) |> Flow.partition(window: window, stages: 1)\niex> flow |> Flow.reduce(fn -> 0 end, &(&1 + &2)) |> Flow.emit(:state) |> Enum.to_list()\n[55, 155, 255, 355, 455, 555, 655, 755, 855, 955, 0]\n```\nCount windows are also similar to global windows that use [`trigger_every/2`](#trigger_every/2)\nto emit events per count. The difference is that count windows emit a window per event count while a trigger belongs to a window. This behaviour may affect functions such as [`Flow.departition/4`](Flow.html#departition/4), which calls the `merge`\ncallback per trigger but the `done` callback per window. Unless you are relying on functions such as [`Flow.departition/4`](Flow.html#departition/4), there is no distinction between count windows and global windows with count triggers.\n\n[session-windows-gap-between-events](#module-session-windows-gap-between-events)\n Session windows (gap between events)\n---\n\nSession windows allow events to accumulate until a configured time gap between events occurs. This allows for grouping events that occurred close to each other, while allowing the length of the window to vary. Flow does not provide a dedicated Session window type, but it can be constructed using\n`emit_and_reduce/3` and `on_trigger/2`.\n```\niex> data = [\n...> {\"elixir\", 2_000_000},\n...> {\"erlang\", 3_100_000},\n...> {\"elixir\", 3_200_000},\n...> {\"erlang\", 4_000_000},\n...> {\"elixir\", 4_100_000},\n...> {\"erlang\", 4_150_000}\n...> ]\niex> max_gap_between_events = 1_000_000 iex> flow = Flow.from_enumerable(data) |> Flow.partition(key: fn {k, _} -> k end, stages: 1)\niex> flow =\n...> Flow.emit_and_reduce(flow, fn -> %{} end, fn {word, time}, acc ->\n...> {count, previous_time} = Map.get(acc, word, {1, time})\n...>\n...> if time - previous_time > max_gap_between_events do\n...> {[{word, {count, previous_time}}], Map.put(acc, word, {1, time})}\n...> else\n...> {[], Map.update(acc, word, {1, time}, fn {count, _} -> {count + 1, time} end)}\n...> end\n...> end)\niex> flow = Flow.on_trigger(flow, fn acc -> {Enum.to_list(acc), :unused} end)\niex> Enum.to_list(flow)\n[{\"elixir\", {1, 2000000}}, {\"elixir\", {2, 4100000}}, {\"erlang\", {3, 4150000}}]\n```\n[Link to this section](#summary)\n Summary\n===\n\n[Types](#types)\n---\n\n[by()](#t:by/0)\n\nA function that returns the event time to window by.\n\n[id()](#t:id/0)\n\nThe window identifier.\n\n[t()](#t:t/0)\n\n[time_unit()](#t:time_unit/0)\n\nThe supported time units for fixed and periodic windows.\n\n[trigger()](#t:trigger/0)\n\nThe name of the trigger.\n\n[type()](#t:type/0)\n\nThe supported window types.\n\n[Functions](#functions)\n---\n\n[allowed_lateness(window, count, unit)](#allowed_lateness/3)\n\nSets a duration, in processing time, of how long we will wait for late events for a given window.\n\n[count(count)](#count/1)\n\nReturns a count-based window of every `count` elements.\n\n[fixed(count, unit, by)](#fixed/3)\n\nReturns a fixed window of duration `count` `unit` where the event time is calculated by the given function `by`.\n\n[global()](#global/0)\n\nReturns a global window.\n\n[periodic(count, unit)](#periodic/2)\n\nReturns a period-based window of every `count` `unit`.\n\n[trigger(window, acc_fun, trigger_fun)](#trigger/3)\n\nCalculates when to emit a trigger.\n\n[trigger_every(window, count)](#trigger_every/2)\n\nA trigger emitted every `count` elements in a window.\n\n[trigger_periodically(window, count, unit)](#trigger_periodically/3)\n\nEmits a trigger periodically every `count` `unit`.\n\n[Link to this section](#types)\nTypes\n===\n\n[Link to this section](#functions)\nFunctions\n==="}}},{"rowIdx":595,"cells":{"project":{"kind":"string","value":"sarsop"},"source":{"kind":"string","value":"cran"},"language":{"kind":"string","value":"R"},"content":{"kind":"string","value":"Package ‘sarsop’\n January 10, 2023\nType Package\nTitle Approximate POMDP Planning Software\nVersion 0.6.14\nDescription A toolkit for Partially Observed Markov Decision Processes (POMDP). Provides\n bindings to C++ libraries implementing the algorithm SARSOP (Successive Approximations\n of the Reachable Space under Optimal Policies) and described in Kurniawati et al (2008),\n <doi:10.15607/RSS.2008.IV.009>. This package also provides a high-level interface\n for generating, solving and simulating POMDP problems and their solutions.\nLicense GPL-2\nURL https://github.com/boettiger-lab/sarsop\nBugReports https://github.com/boettiger-lab/sarsop/issues\nRoxygenNote 7.1.1\nImports xml2, parallel, processx, digest, Matrix\nSuggests testthat, roxygen2, knitr, covr, spelling\nLinkingTo BH\nEncoding UTF-8\nLanguage en-US\nSystemRequirements mallinfo, hence Linux, MacOS or Windows\nNeedsCompilation yes\nAuthor <NAME> [cre, aut, cph]\n (<https://orcid.org/0000-0002-1642-628X>),\n <NAME> [aut],\n <NAME> [aut],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb],\n <NAME> [ctb],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb],\n Free Software Foundation [cph],\n <NAME> [ctb, cph],\n <NAME> [ctb, cph],\n <NAME> [ctb],\n RSA Data Security, Inc. [cph]\nMaintainer <NAME> <<EMAIL>>\nRepository CRAN\nDate/Publication 2023-01-10 09:10:06 UTC\nR topics documented:\nalphas_from_lo... 2\nassert_has_app... 3\ncompute_polic... 4\nfisheries_matrice... 5\nf_from_lo... 6\nhindcast_pomd... 6\nmeta_from_lo... 8\nmodels_from_lo... 8\npomdpso... 9\nread_policy... 11\nsarso... 12\nsim_pomd... 13\nwrite_pomdp... 15\n alphas_from_log alphas_from_log\nDescription\n Read alpha vectors from a log file.\nUsage\n alphas_from_log(meta, log_dir = \".\")\nArguments\n meta a data frame containing the log metadata for each set of alpha vectors desired,\n see meta_from_log\n log_dir path to log directory\nValue\n a list with a matrix of alpha vectors for each entry in the provided metadata (as returned by sarsop).\nExamples\n # takes > 5s\n source(system.file(\"examples/fisheries-ex.R\", package = \"sarsop\"))\n log = tempfile()\n alpha <- sarsop(transition, observation, reward, discount, precision = 10,\n log_dir = log)\n assert_has_appl test the APPL binaries\nDescription\n Asserts that the C++ binaries for appl have been compiled successfully\nUsage\n assert_has_appl()\nValue\n Will return TRUE if binaries are installed and can be located and executed, and FALSE otherwise.\nExamples\n assert_has_appl()\n compute_policy compute_policy\nDescription\n Derive the corresponding policy function from the alpha vectors\nUsage\n compute_policy(\n alpha,\n transition,\n observation,\n reward,\n state_prior = rep(1, dim(observation)[[1]])/dim(observation)[[1]],\n a_0 = 1\n )\nArguments\n alpha the matrix of alpha vectors returned by sarsop\n transition Transition matrix, dimension n_s x n_s x n_a\n observation Observation matrix, dimension n_s x n_z x n_a\n reward reward matrix, dimension n_s x n_a\n state_prior initial belief state, optional, defaults to uniform over states\n a_0 previous action. Belief in state depends not only on observation, but on prior\n belief of the state and subsequent action that had been taken.\nValue\n a data frame providing the optimal policy (choice of action) and corresponding value of the action\n for each possible belief state\nExamples\n m <- fisheries_matrices()\n ## Takes > 5s\n if(assert_has_appl()){\n alpha <- sarsop(m$transition, m$observation, m$reward, 0.95, precision = 10)\n compute_policy(alpha, m$transition, m$observation, m$reward)\n }\n fisheries_matrices fisheries_matrices\nDescription\n Initialize the transition, observation, and reward matrices given a transition function, reward func-\n tion, and state space\nUsage\n fisheries_matrices(\n states = 0:20,\n actions = states,\n observed_states = states,\n reward_fn = function(x, a) pmin(x, a),\n f = ricker(1, 15),\n sigma_g = 0.1,\n sigma_m = 0.1,\n noise = c(\"rescaled-lognormal\", \"lognormal\", \"uniform\", \"normal\")\n )\nArguments\n states sequence of possible states\n actions sequence of possible actions\n observed_states\n sequence of possible observations\n reward_fn function of x and a that gives reward for tacking action a when state is x\n f transition function of state x and action a.\n sigma_g half-width of uniform shock or equivalent variance for log-normal\n sigma_m half-width of uniform shock or equivalent variance for log-normal\n noise distribution for noise, \"lognormal\" or \"uniform\"\nDetails\n assumes log-normally distributed observation errors and process errors\nValue\n list of transition matrix, observation matrix, and reward matrix\nExamples\n m <- fisheries_matrices()\n f_from_log f from log\nDescription\n Read transition function from log\nUsage\n f_from_log(meta)\nArguments\n meta a data frame containing the log metadata for each set of alpha vectors desired,\n see meta_from_log\nDetails\n note this function is unique to the fisheries example problem and assumes that sarsop call is run\n with logging specifying a column \"model\" that contains either the string \"ricker\" (corresponding to\n a Ricker-type growth function) or \"allen\" (corresponding to an Allen-type.)\nValue\n the growth function associated with the model indicated.\nExamples\n # takes > 5s\n source(system.file(\"examples/fisheries-ex.R\", package = \"sarsop\"))\n log = tempfile()\n alpha <- sarsop(transition, observation, reward, discount, precision = 10,\n log_dir = log)\n hindcast_pomdp hindcast_pomdp\nDescription\n Compare historical actions to what pomdp recommendation would have been.\nUsage\n hindcast_pomdp(\n transition,\n observation,\n reward,\n discount,\n obs,\n action,\n state_prior = rep(1, dim(observation)[[1]])/dim(observation)[[1]],\n alpha = NULL,\n ...\n )\nArguments\n transition Transition matrix, dimension n_s x n_s x n_a\n observation Observation matrix, dimension n_s x n_z x n_a\n reward reward matrix, dimension n_s x n_a\n discount the discount factor\n obs a given sequence of observations\n action the corresponding sequence of actions\n state_prior initial belief state, optional, defaults to uniform over states\n alpha the matrix of alpha vectors returned by sarsop\n ... additional arguments to appl.\nValue\n a list, containing: a data frame with columns for time, obs, action, and optimal action, and an array\n containing the posterior belief distribution at each time t\nExamples\n m <- fisheries_matrices()\n ## Takes > 5s\n if(assert_has_appl()){\n alpha <- sarsop(m$transition, m$observation, m$reward, 0.95, precision = 10)\n sim <- hindcast_pomdp(m$transition, m$observation, m$reward, 0.95,\n obs = rnorm(21, 15, .1), action = rep(1, 21),\n alpha = alpha)\n }\n meta_from_log meta from log\nDescription\n load metadata from a log file\nUsage\n meta_from_log(\n parameters,\n log_dir = \".\",\n metafile = paste0(log_dir, \"/meta.csv\")\n )\nArguments\n parameters a data.frame with the desired parameter values as given in metafile\n log_dir path to log directory\n metafile path to metafile index, assumed to be meta.csv in log_dir\nValue\n a data.frame with the rows of the matching metadata.\nExamples\n # takes > 5s\n source(system.file(\"examples/fisheries-ex.R\", package = \"sarsop\"))\n log = tempfile()\n alpha <- sarsop(transition, observation, reward, discount, precision = 10,\n log_dir = log)\n models_from_log model from log\nDescription\n Read model details from log file\nUsage\n models_from_log(meta, reward_fn = function(x, h) pmin(x, h))\nArguments\n meta a data frame containing the log metadata for each set of alpha vectors desired,\n see meta_from_log\n reward_fn a function f(x,a) giving the reward for taking action a given a system in state x.\nDetails\n assumes transition can be determined by the f_from_log function, which is specific to the fisheries\n example\nValue\n a list with an element for each row in the requested meta data frame, which itself is a list of the\n three matrices: transition, observation, and reward, defining the pomdp problem.\nExamples\n # takes > 5s\n source(system.file(\"examples/fisheries-ex.R\", package = \"sarsop\"))\n log = tempfile()\n alpha <- sarsop(transition, observation, reward, discount, precision = 10,\n log_dir = log)\n pomdpsol APPL wrappers\nDescription\n Wrappers for the APPL executables. The pomdpsol function solves a model file and returns the\n path to the output policy file.\nUsage\n pomdpsol(\n model,\n output = tempfile(),\n precision = 0.001,\n timeout = NULL,\n fast = FALSE,\n randomization = FALSE,\n memory = NULL,\n improvementConstant = NULL,\n timeInterval = NULL,\n stdout = tempfile(),\n stderr = tempfile(),\n spinner = TRUE\n )\n polgraph(\n model,\n policy,\n output = tempfile(),\n max_depth = 3,\n max_branches = 10,\n min_prob = 0.001,\n stdout = \"\",\n spinner = TRUE\n )\n pomdpsim(\n model,\n policy,\n output = tempfile(),\n steps = 100,\n simulations = 3,\n stdout = \"\",\n spinner = TRUE\n )\n pomdpeval(\n model,\n policy,\n output = tempfile(),\n steps = 100,\n simulations = 3,\n stdout = \"\",\n spinner = TRUE\n )\n pomdpconvert(model, stdout = \"\", spinner = TRUE)\nArguments\n model file/path to the pomdp model file\n output file/path of the output policy file. This is also returned by the function.\n precision targetPrecision. Set targetPrecision as the target precision in solution quality;\n run ends when target precision is reached. The target precision is 1e-3 by default.\n timeout Use timeLimit as the timeout in seconds. If running time exceeds the specified\n value, pomdpsol writes out a policy and terminates. There is no time limit by\n default.\n fast logical, default FALSE. use fast (but very picky) alternate parser for .pomdp\n files.\n randomization logical, default FALSE. Turn on randomization for the sampling algorithm.\n memory Use memoryLimit as the memory limit in MB. No memory limit by default. If\n memory usage exceeds the specified value, pomdpsol writes out a policy and\n terminates. Set the value to be less than physical memory to avoid swapping.\n improvementConstant\n Use improvementConstant as the trial improvement factor in the sampling algo-\n rithm. At the default of 0.5, a trial terminates at a belief when the gap between\n its upper and lower bound is 0.5 of the current precision at the initial belief.\n timeInterval Use timeInterval as the time interval between two consecutive write-out of pol-\n icy files. If this is not specified, pomdpsol only writes out a policy file upon\n termination.\n stdout a filename where pomdp run statistics will be stored\n stderr currently ignored.\n spinner should we show a spinner while sarsop is running?\n policy file/path to the policy file\n max_depth the maximum horizon of the generated policy graph\n max_branches maximum number of branches to show in the policy graph\n min_prob the minimum probability threshold for a branch to be shown in the policy graph\n steps number of steps for each simulation run\n simulations as the number of simulation runs\nExamples\n if(assert_has_appl()){\n model <- system.file(\"models\", \"example.pomdp\", package = \"sarsop\")\n policy <- tempfile(fileext = \".policyx\")\n pomdpsol(model, output = policy, timeout = 1)\n # Other tools\n evaluation <- pomdpeval(model, policy, stdout = FALSE)\n graph <- polgraph(model, policy, stdout = FALSE)\n simulations <- pomdpsim(model, policy, stdout = FALSE)\n }\n read_policyx read_policyx\nDescription\n read a .policyx file created by SARSOP and return alpha vectors and associated actions.\nUsage\n read_policyx(file = \"output.policyx\")\nArguments\n file name of the policyx file to be read.\nValue\n a list, first element \"vectors\" is an n_states x n_vectors array of alpha vectors, second element is a\n numeric vector \"action\" of length n_vectors whose i’th element indicates the action corresponding\n to the i’th alpha vector (column) in the vectors array.\nExamples\n f <- system.file(\"extdata\", \"out.policy\", package=\"sarsop\", mustWork = TRUE)\n policy <- read_policyx(f)\n sarsop sarsop\nDescription\n sarsop wraps the tasks of writing the pomdpx file defining the problem, running the pomdsol (SAR-\n SOP) algorithm in C++, and then reading the resulting policy file back into R. The returned alpha\n vectors and alpha_action information is then transformed into a more generic, user-friendly repre-\n sentation as a matrix whose columns correspond to actions and rows to states. This function can\n thus be used at the heart of most pomdp applications.\nUsage\n sarsop(\n transition,\n observation,\n reward,\n discount,\n state_prior = rep(1, dim(observation)[[1]])/dim(observation)[[1]],\n verbose = TRUE,\n log_dir = tempdir(),\n log_data = NULL,\n cache = TRUE,\n ...\n )\nArguments\n transition Transition matrix, dimension n_s x n_s x n_a\n observation Observation matrix, dimension n_s x n_z x n_a\n reward reward matrix, dimension n_s x n_a\n discount the discount factor\n state_prior initial belief state, optional, defaults to uniform over states\n verbose logical, should the function include a message with pomdp diagnostics (timings,\n final precision, end condition)\n log_dir pomdpx and policyx files will be saved here, along with a metadata file\n log_data a data.frame of additional columns to include in the log, such as model param-\n eters. A unique id value for each run can be provided as one of the columns,\n otherwise, a globally unique id will be generated.\n cache should results from the log directory be cached? Default TRUE. Identical func-\n tional calls will quickly return previously cached alpha vectors from file rather\n than re-running.\n ... additional arguments to appl.\nValue\n a matrix of alpha vectors. Column index indicates action associated with the alpha vector, (1:n_actions),\n rows indicate system state, x. Actions for which no alpha vector was found are included as all -Inf,\n since such actions are not optimal regardless of belief, and thus have no corresponding alpha vectors\n in alpha_action list.\nExamples\n ## Takes > 5s\n ## Use example code to generate matrices for pomdp problem:\n source(system.file(\"examples/fisheries-ex.R\", package = \"sarsop\"))\n alpha <- sarsop(transition, observation, reward, discount, precision = 10)\n compute_policy(alpha, transition, observation, reward)\n sim_pomdp simulate a POMDP\nDescription\n Simulate a POMDP given the appropriate matrices.\nUsage\n sim_pomdp(\n transition,\n observation,\n reward,\n discount,\n state_prior = rep(1, dim(observation)[[1]])/dim(observation)[[1]],\n x0,\n a0 = 1,\n Tmax = 20,\n policy = NULL,\n alpha = NULL,\n reps = 1,\n ...\n )\nArguments\n transition Transition matrix, dimension n_s x n_s x n_a\n observation Observation matrix, dimension n_s x n_z x n_a\n reward reward matrix, dimension n_s x n_a\n discount the discount factor\n state_prior initial belief state, optional, defaults to uniform over states\n x0 initial state\n a0 initial action (default is action 1, e.g. can be arbitrary if the observation process\n is independent of the action taken)\n Tmax duration of simulation\n policy Simulate using a pre-computed policy (e.g. MDP policy) instead of POMDP\n alpha the matrix of alpha vectors returned by sarsop\n reps number of replicate simulations to compute\n ... additional arguments to mclapply\nDetails\n simulation assumes the following order of updating: For system in state[t] at time t, an observation\n of the system obs[t] is made, and then action[t] is based on that observation and the given policy,\n returning (discounted) reward[t].\nValue\n a data frame with columns for time, state, obs, action, and (discounted) value.\nExamples\n m <- fisheries_matrices()\n discount <- 0.95\n ## Takes > 5s\n if(assert_has_appl()){\n alpha <- sarsop(m$transition, m$observation, m$reward, discount, precision = 10)\n sim <- sim_pomdp(m$transition, m$observation, m$reward, discount,\n x0 = 5, Tmax = 20, alpha = alpha)\n }\n write_pomdpx write pomdpx files\nDescription\n A POMDPX file specifies a POMDP problem in terms of the transition, observation, and reward\n matrices, the discount factor, and the initial belief.\nUsage\n write_pomdpx(\n P,\n O,\n R,\n gamma,\n b = rep(1/dim(O)[1], dim(O)[1]),\n file = \"input.pomdpx\",\n digits = 12,\n digits2 = 12,\n format = \"f\"\n )\nArguments\n P transition matrix\n O observation matrix\n R reward\n gamma discount factor\n b initial belief\n file pomdpx file to create\n digits precision to round to before normalizing. Leave at 4 since sarsop seems unable\n to do more?\n digits2 precision to write solution to. Leave at 10, since normalizing requires additional\n precision\n format floating point format, because sarsop parser doesn’t seem to know scientific\n notation\nExamples\n m <- fisheries_matrices()\n f <- tempfile()\n write_pomdpx(m$transition, m$observation, m$reward, 0.95,\n file = f)"}}},{"rowIdx":596,"cells":{"project":{"kind":"string","value":"www_nic_funet_fi_c++opas"},"source":{"kind":"string","value":"free_programming_book"},"language":{"kind":"string","value":"Unknown"},"content":{"kind":"string","value":"# :n hämmästyttävä maailma\n\n## :n hämmästyttävä maailma\n\n### - hassun hauska C++-opas -\n\ncopyright (c) 1997-2002 <NAME>\n\nTervetuloa vaatimattoman C++-oppaani pariin. Ihan näin aluksi varottaisin, että tämä sepustus ei ole eikä haluakaan olla perinteinen ohjelmointiopas. Siis jos etsit kompaktia ja koherenttia opasta C++-ohjelmoinnin oleellisten pääkohtien opiskeluun, niin en lupaa paljoa. Hieman kärjistäen voisi sanoa, että minä en yritäkään kertoa mikä C++-kieli on - vaan kuinka sinä voit sitä oppia. C++-kieli on niin mammuttimainen kokonaisuus, että harva sitä ihan kokonaan hallitsee.\n\nMutta vaikka tyylini onkin melko vapaamuotoinen, niin silti olen pyrkinyt kertoman vain totuuden ja koko totuuden. Erityinen tavoite oppaassani on ollut se, että en pelkästään kerro miten joku toimii, vaan mihin ja miten sitä kannattaa käyttää - esimerkkien ja käytännön kokemusten terästämänä. Tieteellinen kieli tarjoaa valtavan sanaston asioiden ylimalkaiseen käsittelyyn, joten arkikielen ei tarvitse olla ainakaan este ytimekkäälle jutustelulle.\n\nSisällysluettelossa tähdellä merkityt kappaleet ovat hieman haastavampia. Aluksi suosittelen lukemaan Yleistä-osion.\n\nHUOM! Lue ainakin Yleistä-osion ensimmäinen kappale, se sisältää tärkeää \"päivitystietoa\"!\n\n* Yleistä\n * Perusteet\n\n* Asiaan\n * Syöttö ja tulostus\n * Muuttujat\n * Liukuluvut ja lukujen merkitseminen\n * Tyyppimuunnos\n * Taulukot\n * Kuinka mokata taulukoiden kanssa\n * sizeof ja muuttujat\n * Kommentoiminen\n * Matemaattiset operaattorit\n\n* Laskutoimitukset\n * Etuliiteoperaattorit\n * Aivojumppaa: uhmaako a = a + 1; todellisuuden luonnetta?\n * Rakenteet\n\n* Ehtolauseet\n * Jos ei niin sitten..\n * Toistorakenteet: while ja for\n * Rakenteiden yhdistely ja do..while\n * break ja continue\n * switch..case -rakenne\n * Nimiavaruudet *\n * Funktiot\n\n* Funktiot\n * Funktion oletusparametrit\n * Funktioiden uudelleenmäärittely\n * main()-funktio\n * Lohkot, lauseet ja lausekkeet\n * Muuttujien näkyvyys\n * Esikääntäjä\n\n* Esikääntäjän perustemput\n * Vakiot oikeaoppisesti\n * typedef\n * Lueteltu tyyppi: enum\n * Esikääntäjä tappaa talossa ja puutarhassa\n * Makrot\n * Elegantti vaihtoehto makroille\n * Ei vara venettä kaada - eikä assert() toimivaa ohjelmaa\n * Osoittimet\n\n* Viittaukset\n * Osoittimet\n * Salattu totuus taulukoista ja moninkertaisista osoittimista\n * Kun viittaillaan, osoitellaan ja tökitään miten sattuu\n * Osoittimet funktioihin\n * Funktio-osoitintaulukot ja funktio-osoittimet parametreina\n * Oliot ja luokat\n\n* Oliot ja luokat\n * Olio on tiedot ja toiminnallisuus\n * Tiedon kapselointi\n * Muodostin- ja tuhoajafunktiot\n * Operaattoreiden ylikuormittaminen\n * coutin todellinen luonne\n * Osoitin jäsenfunktioon\n * Muistinhallinta\n\n* Muistin varaaminen ja vapauttaminen\n * Taulukot ja oliot muistia varaamalla\n * Varo vaanivaa vaaraa\n * Periytyminen\n\n* Luokkahierarkiat\n * Muodostinfunktiot\n * Moniperintä\n * Virtuaaliset funktiot\n * Polymorfismi isolla P:llä\n * Perinteinen standardikirjasto\n\n* Merkkijonot\n * atoi ja itoa\n * Sattumia soppaan\n * qsort\n * Trigonometria\n * Mallit ja geneerinen ohjelmointi\n\n* Tee-se-itse: linkitetty lista\n * Mitä mallit oikeasti ovat?\n * Mallien spesialisointi\n * Mallit käytäntöjen parametrisoijana\n * Mallien monimutkainen käyttö\n * Mitä mallit abstraktisti ovat? *\n * Geneerinen ohjelmointi *\n * STL: Lyhyenläntä oppimäärä\n\n* Standard Template Libraryn idea\n * Tietorakenteet ja lähes tietorakenteet\n * Iteraattorit\n * Algoritmit\n * Virrat\n * Numerot ja matematiikka\n * Oliosuunnittelu\n\n* Luokan kaksi liittymää\n * Ohjelmoinnin ihmissuhdeteoria\n * Oliosuunnittelun pyhä kolminaisuus\n * Oliomallinnuksen heikkoudet\n * Numeerinen matematiikka\n\n* Sattuu ja tapahtuu - satunnaislukugeneraattorit\n * Sekalaista\n\n* Hyvän koodin kirjoitus\n * Muistialueet\n * C++:n varatut sanat\n * volatile ja register\n * Komentoriviparametrit\n * Sanasto\n * Kysymykset ja vastaukset\n * Mistä löydän lisätietoa?\n\nKaikki tämä materiaali löytyy myös paketista cppopas.zip (lähes vastaava kuin online-versio). Oppaan tekijää voi lähestyä sähköpostittamalla osoitteeseen aleksi.kallio (at) iki.fi.\n\nViimeisin päivitys tehty 23.11.2004. Koko sisältöä ei ole käyty läpi huolella pitkiin aikoihin...\n\n# Tärkeä huomautus\n\nAika kuluu ja kellot paukkaa. Opas on kirjoitettu omana aikanaan ja C++ on elänyt omaa elämäänsä. Perusasiat ovat pysyneet melkolailla ennallaan, mutta oppaassa esitetään asioita, jotka eivät ole väärin, mutta eivät enää se oikea ja hyvä tapa kirjoittaa C++-ohjelmia. Nämä asiat ovat nimiavaruudet ja main-funktion paluuarvo. Molemmista kyllä kerrotaan vallitseva totuus, mutta sitä ei noudateta kaikissa esimerkkiohjelmissa. Esimerkkien päivittäminen on niin iso urakka, että minulla ei siihen ole aikaa - mutta vapaaehtoisia otetaan vastaan. Nykymaailmassa oikea tapa tehdä Hello World -ohjelma on:\n > #include <iostream> int main() { std::cout << \"Hello world!\" << std::endl; return EXIT_SUCCESS; // tämä rivi ei ole välttämätön }\n\nLisäksi tässä oppaassa oleva sisältö keskittyy enemmän C++:n C-henkiseen osuuteen. Nykyaikainen C++-ohjelmointi painottuu enemmän olioihin ja luokkiin, joita ei tässä oppaassa käsitellä riittävän kattavasti.\n # Mitä tarvitaan, että voi aloittaa C++-ohjelmoinnin?\n\nLyhyt vastaus\n Tee kuten täällä sanotaan:http://csjava.occ.cccd.edu/~gilberts/devcpp5/ \nPidempi vastaus:\n\nNäiden esimerkkien ajamiseen tarvitaan asennettu ja toimiva C++- kääntäjä. Mutta näiden esimerkkien ja oppien pitäisi toimia kaikilla ANSI-standardin mukaisilla C++- kääntäjillä (huomaa kuitenkin edellisen kappaleen lisäys).\n\nLista ilmaisista kääntäjistä löytyy osoitteesta http://www.thefreecountry.com/compilers/cpp.shtml. Windows-maailmaan voisi suositella helppokäyttöiseksi vaihtoehdoksi Dev-C++-kääntäjää. Linuxissa luonnollinen valinta on GCC, joka tulee myös käyttöjärjestelmän mukana. Windowsissa GCC:ta voi ajaa myös Cygwin UNIX-emulaattorin avulla. Ohjeet asennukseen löytyvät osoitteesta http://www.cygwin.com/cygwin-ug-net/setup-net.html.\n # Mikäs juttu tämä on?\n\nTämän tuhkimotarinan juuria kaivellessa pitää porautua hyvin syvälle historian pölyyn ja nöyhtään. Joskus aikojen alussa, kun miehet vielä olivat rautaa ja laivoilla ei saanut verovapaata viinaa, pyysi <NAME> minua kirjoittamaan ohjelmointisivuillensa oppaan C++-ohjelmoinnin alkeisiin. No, minä tein työtä käskettyä. Opas oli melko vajaavainen, mutta jaksamista ei riittänyt sen täydentämiseen. En myöskään osannut kunnolla C++-kieltä, mikä vaikuttaa toisena hyvin raskaana seikkana laiskuuden lisäksi. Myöhemmin, kun jopa kaksi ihmistä olivat ottaneet minuun yhteyttä oppaan puitteissa, jatkui oppaan kirjoittaminen valtavan menestyksen hurmioittamana.\n\nNykyään pidän opasta näillä www-sivuilla, joten se voi nuorekkaan dynaamisesti kehittyä päivittäin, tai kerran kahdessa vuodessa - riippuen joutoaikani määrästä. Lukijoitakin nykyään on kertynyt jopa niin monta, että niitä ei yhden käden sormilla lasketakaan. Palautettakin on tullut ja mikäs siinä, kun tiimi toimii ja palautetta tulee. Oma aikani on vaan sen verran rajallinen, että yritän aina poimia vain pahimmat virheet ja puutteet ja korjata ne. Mutta silti palautetta otetaan kyllä mielellään vastaan.\n # Voinko minä nyt lukea tätä?\n\nNo mikä ettei. Opastus on suunnattu pääasiassa nuorille aloittelijoille, mutta todistettavasti myös eräät jo kunnioitettavan iän saavuttaneet ovat tykänneet lähestymistyylistäni. Siitä olenkin hyvin ylpeä - onhan se sukupolvi jo useaan otteeseen tuomittu täysin kyvyttömäksi oppimaan mitään tekstinkäsittelyn alkeita vaativampaa tietokoneenkäyttöä.\n\nAsiat ovat likipitäen etenemisjärjestyksessä, aloittelijan kannattaa lukea kappaleita järjestyksessä. Tähdellä merkityt kappaleet ovat hieman haastavampia, joten jos siltä tuntuu voi niiden yli hypätä ja palata tutkiskelemaan niitä sitten myöhemmin. Tarpeen mukaan tekstiin on ripoteltu kehotuksia lukea pätkiä muista aihealueista, lähinnä Sekalaiset-kohdasta. Loppupuolella ei enää johdattalua ole niin paljon - kai jo kaiken kokenut C++-ohjelmoija osaa itsekin ajatella.\n\nHarva asia on yhtä huvittavaa kuin \"Opi C++-ohjelmointi 21 päivässä\" -tyylinen pelleily. Mikäli ostaa sellaisen kirjan ja lukee yhden kappaleen päivässä, niin 21 päivän päästä ei kyllä voi sanoa osaavansa C++-kieltä. Käytäntö on hyvä opettaja, varsinkin kun pitää oppia jotain teoreettista, kuten C++. Tämän oppaan nimi voisikin olla \"Opi C++-ohjelmointi hyvin pitkän ajanjakson kuluessa\" tai paremminkin \"Opiskele C++:aa, vaikka et sitä ikinä täysin opikaan\". Välillä kannattaa jättää koko opas ja tehdä jotain oikeasti. Sitten voi taas palata katsomaan, mitä kaikkea virheitä tulikaan tehdyksi. C++ on todennäköisesti maailman mammuttimaisin ohjelmointikieli, joten sen opiskelu kattavasti ottaa aikansa.\n # Lainopillinen osio\n\nKuten normaaliin käytäntöön kuuluu, en ota sivuista rahaa sen enemmän kuin vastuutakaan. Kaikki sivuilla oleva materiaali on ilmaiseksi käytössäsi. Tekstiin minulla on tietenkin normaalit tekijänoikeudet, joten sitä lainattaessa pitää minut aina mainita tekstin kirjoittajaksi. Täältä löytyvien ohjelmien ja ohjelmanosasten suhteen luovun täysin tekijänoikeuksistani, joten niitä saa venyttää ja paukuttaa ihan miten haluaa. En ota mitään vastuuta tekstistä tai ohjelmista koituvasta harmista. Vaikea kyllä on kuvitella mitä harmia niistä voisi koitua - seonnutta vuorokausirytmiä lukuunottamatta.\n # Ohjelmoinnista\n\nOhjelmointi on kehittävä harrastus ja ihan hauskaa myös yleensä. Mutta aika vaikeaa se on, joten ei kannata odottaa oppivansa guruksi parissa viikossa - tai edes vuodessa. Mutta kun sitä tarpeeksi osaa, alkaa näpyttely tuntua aina vaan mukavammalta, joten pitää jaksaa yrittää. Ennen pitkää huomaa, että vain mielikuvitus on rajana - ja sen takia ohjelmoijat yleensä hommasta pitävätkin, omien mielikuvitusmaailmojen suunnittelu ja toteuttaminen käytönnössä on mukavaa puuhaa. Ja sen myös sanon, että nykyään ohjelmointibisnes on melko hurja ala - oli lama tai ei. Töitä saa helposti vaikka asuu kaukana korvessa ja on alan koulutusta vailla oleva pojankloppi tai tytönhuitake.\n # Kääntäminen\n\nC++ on hieman ihmiskieltä muistuttava kieli, joka tahtoo sanoa sitä, että tietokone ei sitä semmoisenaan ymmärrä. Joten silloin tarvitaan kääntäjää. Se tulkitsee C++-lähdekoodin ja muuntaa sen konekieleksi (.exe tms..), jotta konekin sen ymmärtää. Idea siis on: meillä on tekstimuotoinen C++-koodi, kääntäjä lukee sen ja korvaa kaikki ilmaukset kirjastoistaan löytyvillä binäärikoodeilla, joita sitten prosessori osaa suorittaa. Binäärikoodit tietenkin riippuvat ihan siitä, missä ympäristössä ja prosessorissa ohjelma toimii. C++-ohjelma on kuitenkin aina sama.\n\nTässä oppaassa opetetaan käyttämään C++:n standardiominaisuuksia. On kuitenkin olemassa ympäristöjä, joissa niiden käyttäminen ei ole samalla tavalla mahdollista - siis vaikka oppaassa esitetään vain standardin mukaista C++-koodia, niin aivan jokaisesta C++-kääntäjästä se ei mene läpi. Esimerkkinä mainittakoon Windows-ohjelmointi - ikkunapohjaisessa maailmassa ei ole vastineita kaikille C++:n konsolipohjaisille ominaisuuksille. Vaadittavat muutokset ovat kuitenkin pieniä ja kielihän on aivan sama - ainoastaan esitettävä asia hieman erilainen. Windows-kääntäjästäkin saa oppaan esimerkkiohjelmat menemään sellaisenaan läpi, kun asettaa sen kääntämään konsolitilaan (console mode application).\n # C++:n historia\n\nAivan ensimmäisiä tietokoneita ohjattiin kääntelemällä vipuja, joista bitit ovat tavallaan periytyneet. Sitten tulivat transistorit ja mikropiirit, jotka mahdollistivat nykyisen kokoiset tietokoneet. Ennen ne olivat olleet huoneen kokoisia. Aluksi koneita ohjattiin niiden omalla konekielellä, kirjoittamalla suoraan niiden ymmärtämää kieltä. Se oli kuitenkin vaikeaa ja virheiden etsiminen oli todella työlästä.\n\nNiinpä keksittiin Assembly-kieli (Kyllä, se on Assembly. Assembler tarkoittaa Assembly-kääntäjää.). Assemblyssa, tutuille Assyssa, käytettiin yhä konekieltä, mutta muistipaikoille voitiin antaa nimiä eli käyttää muuttujia ja myös käskyt olivat inhimillisempiä. Silloin tarvittiin kuitenkin kääntäjä, joka kääntää Assembly-koodin puhtaaksi konekieleksi. Sitten tuli korkeamman tason kieliä, kuten legendaarinen Basic, Pascal, C, Cobol, Fortran - ja vihdoin C++. Kielet erkanevat koko ajan koneesta ja konekielestä, mikä teki niistä helpommin käytettäviä (ja hitaampia).\n # C++-kieli\n\nC++-kieli on uudistettu versio C-kielestä (nii-in, C+ kieltä ei ole olemassa!). Perusasiat on hoidettu samalla mallilla kuin C-kielessä, mutta voisi sanoa että C++ menee \"pidemmälle\". C++ kieli nimittäin tarjoaa paljon uutta mitä C-kielessä ei ole. C kieltä voi sotkea C++-ohjelmien sekaan, ne toimivat kyllä yhteen, mutta erityisen suositeltavaa se ei ole. Eikä sille kyllä ole tarvettakaan.\n\nC++ on yleiskäyttöinen ohjelmointikieli, joka sopii melkein kaikkeen mitä tietokone voidaan ohjelmoida tekemään. C++ on korkean tason kieli, tarkoittaen että sillä ei ole hirveästi yhteistä itse tietokoneen konekielen kanssa. Se tekee siitä melko mukavan käyttää, mutta toisaalta tietenkin hitaamman kuin puhdas konekieli. Nykyajan hyvin optimoivilla kääntäjillä ei ero kuitenkaan ole kovin dramaattinen. Uudempiin kieliin, kuten Java ja C#, verrattuna C++ on laiteläheinen ja nopea. Nopeutta vaativissa C++-ohjelmissa voidaan kriittiset kohdat, siis ne kohdat joita rullataan suurimman osan ajasta, kirjoittaa puhtaalla konekielellä, mutta yleensä ottaen konekielen käyttö C++:n seassa lähinnä sotkee muuten niin siistiä ohjelmaa.\n\nC++ on oliopohjainen kieli. Ennen muinoin kielet olivat proseduraalisia, siis pääosaa esittivät toiminnot. Ohjelma rakennettiin funktioista, toiminnoista. Yksi toiminto luki näppäimen painalluksen, toinen siirsi tietoa paikasta toiseen. Sitten huomattiin, että isoissa ohjelmissa homma ei enää pelaa. Niinpä keksittiin oliopohjaisuus. Oliopohjaiset ohjelmat koostuvat olioista, kuinkas ollakaan. Olio esittää jotain ohjelmaan liittyvää kokonaisuutta; räiskintäpelissä vaikka yksi hirviö voisi olla olio. Oikeaoppiset C++-ohjelmat perustuvat olioiden vuorovaikutukseen. Toiminnot ja tieto on yhdistetty niihin olioihin joihin se liittyy.\n\nTietotyypeillä on myös tärkeä rooli C++-kielessä. C++ on hyvin tarkka tietotyyppien suhteen. Aluksi se tuntuu vähän hankalalta, mutta suuremmissa ohjelmissa hyöty on melkoinen. Kun C++-kääntäjä valvoo tietotyyppien oikeaa käyttöä, on se melkoinen työmäärä pois ohjelmoijalta.\n\nOhjelmointikielien kehitys ja laitteistosta erkaneminen on jatkunut C++:n jälkeen. Merkittävin askel on ollut virtuaalikoneen päällä toimivat kielet, ensin Java ja sitten Microsoftin .Net-alusta ja C#-kieli. Virtuaalikoneeseen perustuvat kielet eivät toimi suoraan tietokoneen prosessorissa, vaan virtuaalikoneessa, joka toimii natiivina eli on suoraan yhteydessä prosessoriin. Koska laitteen ja ohjelman välissä on virtuaalikone, voidaan ohjelmaa hallita paljon paremmin. Ja koska virtuaalikoneen voi toteuttaa lukemattomille eri tietokoneympäristöille, toimivat myös ohjelmat suoraan eri ympäristöissä. Javan ja C#:n opiskelu C++:aa osaaville on melko vaivatonta, koska näiden kielten kieliopit ovat hyvin samankaltaisia.\n # Merkinnöistä\n\nOlen kirjoittanut tämän oppaan tietokonefriikkinä, en kielifriikkinä (joka tietyssä määrin olen myös). Joten esimerkiksi olioiden ja funktioiden nimet on kirjoitettu pienellä, myös lauseen alussa. Asia on katsos niin, että esimerkiksi syötettä lukeva olio cin kirjoitetaan aina ohjelmoidessa pienellä. Cin:n voi tietenkin kirjoittaa lauseen alussa isolla, mutta isolla kirjoitettu Cin ei toimi ohjelmissa, koska C++ erottelee isot ja pienet kirjaimet; MeidanTalo, Meidantalo ja meidantalo ovat C++-kääntäjän silmissä eri asioita.\n\nKoska englanti on ohjelmoinnin kieli ja koska C++ on suunniteltu englannin pohjalta ja koska lähes kaikki oheiskirjastot mitä maailmasta löytyy ovat englanniksi, ovat myös tämän oppaan laajemmat esimerkkiohjelmat englanniksi. Aluksi ajattelin laittaa kaiken C++-kielisen osuuden englanniksi, mutta lopulta päätinkin jättää lyhyemmät esimerkit suomeksi. Isommat esimerkkiohjelmat ja yleensäkin loppupuolella olevat kehittyneemmät ohjelmaesimerkit voivat olla englanniksi. Olen myös lisännyt uusien termien perään mitä ne ovat englanniksi (in english), jotta opit tärkeimmät termit sillä tärkeimmällä kielellä heti aluksi. Sanastosta löytyvät myös englanninkieliset termit. Jos aikoo oppia ohjelmoimaan ilman säädyllistä englanninkielen taitoa, on tilanne sama kun opettelisi uimaan ilman käsiä.\n\nVaratut sanat, siis C++:n \"käskyt\", olen kirjoittanut paksunnettuna. Paitsi silloin jos niitä toistetaan niin usein, että niiden paksuntaminen aiheuttaisi jo boldofobiaa.\n # Mainosmaakarin toivomus\n\nKun yön yksinäisinä tunteinä näpyttelen opasta, juolahtaa joskus, tosin melko harvoin, mieleeni se seikka, että lukeekohan kukaan tätä tekstiä ikinä. No, sen varjolla voin sitten keksiä mitä tahansa mauttomia vitsejä, kun kukaan ei niitä kuitenkaan lue. Kuitenniin, kun olen nähnyt ainakin jonkun verran vaivaa tämän oppaan eteen, niin olisi kiva että joku sitä lukisikin. Tai ainakin kokeilisi, kun eihän tämä lysti teille maksa yhtään mitään. Siksi siis nyt tämä mainoshumpuuki.\n\n[makea ääni päälle] Oletko ohjelmointihenkinen nuori? Tai ehkä jo varttuneempi teknonörtti? Mikä olisikaan siistimpää kun julistaa C++-vakaumuksestasi omilla kotisivuillasi? Nyt nimittäen me tarjoamme kahta supermageeta C++-banneria aivan vapaasti käyttöösi. Näin voit tukea monia uljaita aatteita, kuten ilmaisuuden vakaa periaate, ohjelmoinnin komea doktriini ja C++:n jalo aate. Erotu massasta - ja pian massat seuraavat sinua.\n\nVaikka tämmöisellä HTML-koodin jämällä saat bannerin kivasti paikalleen:\n > <p align=\"center\"><a href=\"http://www.funet.fi/c++opas\"> <img src=\"http://www.funet.fi/c++opas/banneri.gif\" border=\"0\" width=\"400\" height=\"40\" alt=\"C++-oppaan banneri\"></a></pKun haluat alemman bannerin, laita \"banneri.gif\" tilalle \"banneri2.gif\". Kuva ladataan oppaan www-levytilasta, siis sinun ei tarvitse sitä imuroida. Kuvat eivät ole mitään isoja, molemmat alle 10 kt. Osoite on siis http://www.funet.fi/c++opas. Osoitteen pitäisi pysyä muuttumattomana. Tietenkin on täysin sallittua imuroida banneri ja sijoittaa se oman palvelimen levytilaan.\n # Kiitokset\n\nMinä olen niitä MBnet-sukupolven ihmisiä, jotka ovat kasvaneet MBnetin viestialueiden parissa. Tosin en MBnetiä ole käyttänyt enää moneen vuoteen. Kuitenkin, paljon kiitoksia tulisi kai lähettää MBnetin ylläpidolle ja eritoten alueen 8 - PC-Ohjelmointi kaikille guruille ja muille avustajille. Tärkeä tekijä on ollut myös Jesse Libertyn kohtalaisen kattava (tosin tylsä) Opeta Itsellesi C++-ohjelmointi -kirja, joka toimi aloittelevan matkamiehen oppaana samotessani C++-kielen autiomaita. Nykyään en kyllä edes muista missä tuo kirja on, ei ainakaan kirjahyllyssäni. <NAME>in järkelemäinen The C++ Programming Language on nykyään tärkein tietolähteeni, parin WWW-sivun lisäksi.\n # Palautetta\n\nAsiaa oppaassa on jo ihan kohtalaisesti, vaikka paljon vielä puuttuukin. Kokonaisuus on ehkä vieläkin vähän epätasainen ja joitakin oleellisia asioita on \"unohtunut\" välistä pois. Niinpä toivoisinkin jonkun aloittelijan antavan palautetta siitä, mitä pitäisi selittää paremmin ja mikä asia on unohtunut melkein kokonaan. Mukana tulee jonkun verran ohjelmakoodia, joka on testattu joko Watcom C++- tai GCC-kääntäjällä. Ei ole kuitenkaan mikään ihme, vaikka mukana tulevien ohjelmien seassa olisikin virheitä. Jos siis et saa niitä toimimaan, älä syytä itseäsi, vaan lähetä minulle sähköpostia (jos lähetät lähdekoodia, niin pistä se viestin rungossa eikä liitteenä, koska niin se on helpompi lukea). Yleensäkin kaikki asiavirheet, puutteet, epäselvyydet ja muut kammottavuudet kannattaa ilmoittaa minulle, niin ne tulevat sitten \"pian\" (pian on tässä tapauksessa hyvin liukuva käsite) korjatuksi. Onhan se jo ihan tarpeeksi, että jaksan kirjoittaa tätä tekstiä, en kai minä sitä sentään enää jaksa uudestaan läpi lukea!\n\nOtan myös mielellään vastaan asiavirheitä koskevaa palautetta kokeneemmilta ohjelmoijilta. Opas on ollut melko ankarassa syynissä Usenetin sfnet.atk.ohjelmointi uutisryhmässä, joten mitään oikeita asiavirheitä ei pitäisi olla. Mutta eihän mikään ole mahdotonta. Myös mielipideasioista saa ruveta väittelemään, jos siltä tuntuu. On tosin hyvin epätodennäköistä että muuttaisin sen seurauksena opasta, mutta maininnan tästä toisesta ajattelutavasta kyllä voin lisätä aloittelijoiden iloksi. Joten: kyselyjä, kehuja, haukkuja, ehdotuksia, kommentteja ja ylistysvirsiä - siis ihan mitä vaan - otetaan vastaan sähköpostitse :\n\n(katso alkusivua, en laita sähköpostiosoitetta tähän kun se kuitenkin muuttuu ja jää päivittämättä)\n\n# Asiaan\n\nSitten suoraan asiaan ja ensimmäiseen C++-ohjelman esimerkkiin:\n > #include <iostream.h> void main() { cout << \"Hello world!\"; }\n\nKyseessä on äärettömän klassinen ohjelma. Se tulostaa ruudulle \"Hello world!\" Ruvetaanpa tutkimaan ohjelmaa hieman syvällisemmin.\n\nEnsimmäisella rivillä käytetään esikääntäjän (preprocessor) käskyä. Sen erottaa #-merkistä alussa. Esikääntäjä on ohjelma, joka käsittelee lähdekoodin #-alkuiset kohdat ennen kuin oikea kääntäjä pääsee siihen käsiksi. Kääntäjistä ja kääntämisestä kerroin Yleistä-osiossa.\n\nInclude on englantia ja tarkoittaa sisällytä. Ja nerokkaasti C++:ssa sillä on sama tarkoitus. #include <iostream.h> nimittäin sisällyttää iostream.h nimisen tiedoston tuolla kohdalle. Eli aito kääntäjä (compiler) saa tiedoston sellaisena, että #include <iostream.h> tilalla on tiedoston iostream.h sisältö.\n\niostream.h sisältää tulostukseen ja syöttöön liittyviä toimintoja, kuten cout. C++:ssä on vain parikymmentä käskyä, koska lähes kaikki tapahtuu näiden otsikkotiedostojen (.h) sisältämien toimintojen avulla. Sisällyttämällä poimitaan ne toiminnot, mitä kussakin ohjelmassa tarvitaan.\n\nSitten seuraavalle riville. Siellä lukee:\n > void main()\n\nTässä määritellään pääfunktio. Jokaisessa C++-ohjelmassa pitää olla main()-osio. void tarkoittaa että main() osa ei palauta arvoa, mistä meidän ei vielä tarvitse välittää sen enemmän kuin suluistakaan. (Olen saanut melko paljon kritiikkiä tässä esitellystä tavasta määritellä main(). Tässä esitetty tapa on kuitenkin aivan oikea, tosin \"oikeissa\" ohjelmissa olisi kiltti tapa palauttaa paluuarvo. Tätä kysymystä käsittelenkin myöhemmin Funktio-osiossa.)\n\nSitten eteenpäin. {-merkki aloittaa main()-osion, josta löytyykin vanha tuttu, cout. cout on olio (object), josta sinun ei tarvitse myöskään välittää vähään aikaan. Sinun tarvitsee tietää vain, että coutia käytetään tekstin tulostamiseen. coutin jälkeen tulevat <<- ohjausmerkit ja haluttu teksti lainausmerkeissä.\n\nJokaisen ohjelmarivin C++:ssa päättää ;-merkki, jonka unohtaminen voi aiheuttaa todella kummallisia virheitä. Kannattaa siis olla tarkkana: jos kääntäjä valittaa jostain rivistä, josta et löydä mitään virhettä, kannattaa tarkistaa onko edellisiltä riveiltä jäänyt uupumaan ;-merkki.\n\nLopuksi vielä päätetään main()-osio toisin päin olevalla aaltosululla, eli }-merkillä. Sitäkään ei tule unohtaa.\n\nSiinäpä se.\n # Syöttö ja tulostus\n\nOhjelma, joka pelkästään tulostaa kaikenlaisia rivouksia ruutuun käy pitemmän päälle hieman köyhäksi, joten otetaanpa sitten jotain muuta mukavaa mukaan. Eli esimerkin voimin taas:\n > #include <iostream.h> void main() { int luku; cout << \"Anna luku\" << endl; cin >> luku; cout << \"Pöh, ei \" << luku << \" nyt mitenkään kummoinen ole.\"; }\n\nint luku; asti kaiken pitäisi olla pässinlihaa. Mutta sitten alkaa tapahtua, pidä laidoista kiinni!\n\nEnsin luodaan int-tyyppinen muuttuja (variable). Tyypeistä sitten myöhemmin. (äsh, tälle pitää kehittä joku lyhenne. Vaikka TSM, Tästä Sitten Myöhemmin. OK?) int-tyyppinen muuttuja pystyy tallentamaan yhden kokonaisluvun. Muuttujia käytetään jonkin tiedon säilömiseen. Käytännössä ne ovat vain kohtia muistista, joille on annettu inhimillisempi nimi.\n\nSeuraavana tuleva cout on olio - hetkonen, mikä himputti on olio? No, se selviää kun on sen aika. cout on siis.. härveli, jolla tulostetaan tavaraa ruudulle. Sitten mukaan tulee coutin kaveri, cin. Se toimii coutin vastaparina: kun cout tulostaa, cin lukee. Tässä tapauksessa luetaan luku-muuttujaan. Sitten vielä sen arvo tulostetaan. Muuttujat pitää erottaa tekstistä <<-merkein ja teksti pitää ympäröidä lainausmerkein. Lopussa on endl, joka tarkoittaa end line. Eli siinä tulee rivinvaihto. Tekstit, muuttujat ja endl:n tyyliset ohjauskäskyt pitää erottaa toisistaan <<-merkein.\n\nJos olet ollut tarkkana, olet ehkä huomannut että cinin nuolet osoittavatkin toiseen suuntaan. Nuolien suunta on helppo muistaa siitä, että ne osoittavat aina siihen suuntaan mihin tieto kulkee. Eli coutissa tieto kulkee näyttöön, jota tässä edustaa cout, ja tällöin nuolet ovat coutin suuntaan. cinissa taas tieto kulkee muuttujaan, jolloin nuolet osoittavat muuttujaan päin.\n # Muuttujat\n\nNyt sitten niistä kauan kaivatuista muuttujista ja tyypeistä. Jotta muuttujaa voidaan käyttää, pitää se määritellä. Jotain alkeellista Basicin versiota aiemmin käyttäneestä se voi tuntua vähän hankalalta, mutta on itseasiassa todella hyvä asia, koska näin ei pääse vahingossa käyttämään olematonta muuttujaa. Muuttuja määritellään näin:\n\ntyyppi nimi;\n\nEli tyyppi kertoo minkä tyyppistä tietoa muuttuja sisältää (TSM, Tästä Sitten Myöhemmin) ja nimi minkä niminen muuttuja on. Yleensä muuttuja kannattaa alustaa (initialise) jollakin arvolla luonnin yhteydessä. Niinpä luomme tässä ika-nimisen kokonaisluvun sisältävän muuttujan ja laitamme siihen arvon 0.\n > int ika = 0;\n\nAlustaminen on todella tärkeää: jos muuttujaa ei alusteta, siinä voi olla mitä tahansa roskaa. Nimeksi kelpaa mikä tahansa yhteen kirjoitettu tekstipötkö, kunhan se ei sisällä ääkkösiä, ei ala numerolla ja ei ole varattu sana. Varattu sana tarkoittaa C++-kielessä sanaa, jolla on jo jokin erityinen merkitys ohjelmointikielessä. Eli varattu sana on \"komento\". Lista varatuista sanoista löytyy Sekalaista-kohdasta. Nimi saa sisältää numeroita, mutta ei saa alkaa numerolla. Myös alaviivaa (_) saa käyttää vaikka nimen alussa. Tosin ihan nimen alkuun en laittaisi alaviivaa, koska muuttuja helposti sekottuisi joihinkin kääntäjän muuttujiin, jotka alkavat myös alaviivalla. Ja vielä yritän syövyttää tätä aivokudoksiisi: pieni ja iso kirjain ovat eri asia - muuttujat painekattila, paineKattila, PaineKattila ja PAINEKATTILA ovat kaikki eri muuttujia.\n\nSitten ne tyypit:\n > int kokonaisluku char merkki(kirjain) float desimaaliluku double pidempi desimaaliluku\n\nSitten osaa näistä tyypeistä voi vielä ryydittää etuliitteillä:\n > long suurempi luku short pienempi luku unsigned etumerkitön(voi siis olla vain positiivinen)\n\n..ja vielä pari muuta joista sinun ei tarvitse välittää.\n\nEli lopulta saamme tämmöisen listan:\n\nTyyppi | Koko(tavuina) | Arvoalue |\n | --- | --- | --- |\nint | 2 | -32768..32767 |\nunsigned int | 2 | 0..65535 |\nshort int | 2 | -32768..32767 |\nunsigned short int | 2 | 0..65535 |\nlong int | 4 | -2147483648..2147483647 |\nunsigned long int | 4 | 0..4294967295 |\nchar | 1 | -128..128 (ASCII-merkit) |\nunsigned char | 1 | 0..255 (ASCII-merkit) |\nfloat | 4 | 1.2e-38..3.4e38 |\ndouble | 8 | 2.2e-308..1.8e308 |\nbool | tosi tai epätosi |\n\nMuuttujien arvoalueet vaihtelevat kääntäjittäin. Tai oikeastaan lähinnä int-tyypin arvot vaihtelevat. Vanhemmissa PC:n real mode -kääntäjissä int on 2 tavua, mutta uudemmissa protected mode -kääntäjissä 4 tavua. Tällöin long int ja int ovat saman kokoisia. short int on kuitenkin kaksi tavua. Ainakin DJGPP:ssä on myös erikoisempi tyyppi long long int, joka on 128-bittiä eli 16 tavua.\n\nKun ajatellaan näitä tietotekniikan peruskäsitteitä, eli bittejä (bit), tavuja (byte) ja sanoja (word) (jälkimmäinen ei kyllä ole ihan peruskäsite, mutta olet ehkä kuullut sen), niin unsigned char vastaisi tavua, joka koostuu 8 bitistä. 2-tavuinen int olisi sana ja long int kaksoissana (double word).\n\nYksittäistä bittiä lähimpänä on bool-tyyppi (Boolen totuusarvo). Sitä ei alunperin C++-kielessä ollut ja niinpä kaikki kääntäjät eivät sitä välttämättä tue. bool-muuttujan arvo voi olla tosi tai epätosi, siis sillä voi esimerkiksi kertoa onko hiiren nappi pohjassa. bool-tyypin esittämiseen käytetään yleensä enemmän kuin yksi bitti tilaa, koska kokonaisten tavujen käsittely on nopeampaa - tämä on kääntäjäkohtaista. Tietokoneen bitteihin pääsee konkreettisestikin käsiksi käyttämällä binäärioperaattoreita, jotka esitellään myöhemmin.\n\nOtetaanpa nämä muuttujat nyt käyttöön:\n > #include <iostream.h> void main() { int luku1, luku2, tulos; luku1 = luku2 = tulos = 0; cout << endl << \"Anna ensimmäinen luku:\"; cin >> luku1; cout << endl << \"Anna toinen luku:\"; cin >> luku2; tulos = luku1 + luku2; cout << \"Tulos on \" << tulos; }\n\nNoin. Kuten huomaat, voidaan saman tyyppiset muuttujat määritellä pötkössä pilkulla erottaen. Seuraavalla rivillä on kätevä tapa alustaa monta muuttujaa yhdellä kertaa. Sitten kysytään kaksi lukua, jotka tallennetaan luku1- ja luku2-muuttujiin, lasketaan ne yhteen (TSM) ja sijoitetaan tulos tulos-muuttujaan. Lopuksi vielä tulos-muuttujan arvo tulostetaan.\n # Liukuluvut ja lukujen merkitseminen\n\nLukuja merkitessä voi käyttää tällaisia kirjainlyhenteitä (ekassa sarakkeessa olevat symbolit ovat vaihtoehtoisia, siis vain yhtä niistä käytetään):\n\nl L | loppuliite | Kokonaisluku (long) |\n | --- | --- | --- |\nu U | loppuliite | Etumerkitön kokonaisluku (unsigned) |\nf F | loppuliite | Reaaliluku (float) |\nl L | loppuliite | Reaaliluku (long double) |\nO | etuliite | Oktaaliluku |\n0x 0X | etuliite | Heksaluku |\ne E | välissä | Reaaliluvun kymmenpotenssimuoto |\n\nKaikkea tuosta ei tarvitse ymmärtää. Selittelen kuitenkin jotakin. Ensinnäkin liukuluvut (floating point number). Mitä ne ovat? Hirveän syvällisesti emme voi ruotia liukulukuja, siis muuttujatyyppejä float, double ja long double, tässä yhteydessä. Mikäli olet opiskellut jonkin verran fysiikkaa tai vastaavaa luonnontiedettä, niin varmaan tämän tyylinen merkintä on tullut sinulle tutuksi: 1.245 * 10³, siis 1.245 kertaa kymmenen potenssiin kolme. Idea on, että alkuosa ilmoittaa itse arvon ja loppuosa suuruusluokan. Esimerkkinä kilometri: kilo tarkoittaa tuhatta, siis tuhat metriä. Kolme kilometriä olisi: 3 * 10³ m=3 * 1000 m=3000m. Kymmenen potenssi voi olla myös negatiivinen; milli on tuhannesosa ja kolme millimetriä on 3 * 10^-3. Merkintä \"^-3\" tarkoittaa potenssiin miinus kolme, tuota potenssia kun ei ole valmiina symbolina. Liukuluvuissa on ihan sama idea, mutta nyt kun kyseessä ovat bitit, niin pelaamme kahden potensseilla. Eli liukuluvut voivat esittää hyvinkin suuria summia, mutta tarkkuus kärsii.\n\nJos haluat ohjelmoidessa käyttää kymmenpotensseihin perustuvaa merkintätapaa, niin se käy näin: 1e1, siis kymmenen potenssi tulee e:n (eksponentti) perään. Esimerkiksi luku miljardi on järkevämpi kirjoittaa 1e9 kuin 1000000000. Elektronin paino levossa on noin 9.11e-31 kg, siis 0.000000000000000000000000000000911 kg. Kumpi tapa on kätevämpi?\n\nMonesti rautatasolla kikkailtaessa (eli ohjelmoidessa koodia, joka käsittelee tietokoneen laitteistoa) heksalukujen käyttäminen on paljon kätevämpää. Jos et tiedä mitä heksaluvut ovat, niin hyppää tämä yli (idea heksaluvuissa on kuusitoistakantaisuus; kun normaalit luvut perustuvat kymmenen potensseihin, ovat siis muotoa a * 10^0 + b * 10^1 + c * 10^2 jne.. niin heksaluvuilla kymmenen paikalla on kuusitoista) Nolla-äks alussa merkitsee heksaluku, siis vaikka 0x22 tulkitaan 2*16 + 2=34. Oktaaliluvut ovat samaa sarjaa, kantaluku on vaan kahdeksan.\n\nYllä olevan taulukon muut lukuliitteet (neljä ensimmäistä) kertovat kääntäjälle, minkä tyyppinen joku kirjoitettu luku on. Harvoin niitä kyllä oikeasti tarvitsee. Kääntäjä olettaa kaikki luvut int-tyyppisiksi tai jos niissä on desimaalipiste (tai ovat eksponenttimuotoisia, esim 1e1) niin tyypiksi räimäistään double. Ja sillä pärjää jo hyvin pitkälle.\n\nVielä käännä silmiäsi vähän takapakkia edelliseen kappaleeseen. Mitäs siellä roilotellaan: desimaalipiste? Siis mikä piste, pilkullahan desimaalit erotellaan... Mutta niin ei ole Ameriikoissa ja muissa hienoissa paikoissa, joissa C-kielen syntysanat on loitsittu. Niinpä erotin on yhä piste ja sillä selvä. Vastaan ei auta vängätä. Piste.\n # Tyyppimuunnos\n\nJoskus sitä tulee tarvetta muuntaa muuttujaa tai tietoa tyypistä toiseen. No, sehän sopii. Tyyppimuunnosta (typecasting) käytetään laittamalla haluttu tyyppi sulkuihin. Jos siis haluat vaikka sijoittaa double-arvon int-muuttujaan, käy se näin: int i=(int)doubleMuuttuja;\n\nKun desimaaliosan sisältävä muuttuja muutetaan kokonaislukumuuttujaksi, tehdään se katkaisemalla (truncate). Siis desimaalipilkun jälkeiset numerot heitetään mäkeen. Jos arvo halutaan kuitenkin oikeaoppisesti, pitää se pyöristää. Kätevästi se onnistuu lisäämällä muuttujaan 0.5 ennen muunnosta. Jos muuttuja on negatiivinen, pitää silloin vähentää. Esim. 3.2 + 0.5=3.7 -> 3 tai 3.6 + 0.5=4.1 -> 4 tai -2.6 - 0.5=-3.1 -> -3.\n\nJos muuttuja on liian suuri haluttuun arvoon, se pyörähtää ympäri. Esimerkiksi unsigned char muuttujan arvoalue on 0..255. Jos siihen sijoitetaan luku 260, pyörähtää muuttuja ympäri ja saa arvon 260 - 256 = 4.\n > double d = 3.487: int i; if (d > 0) i = (int)(d + 0.5); // \"pyöristys\" else i = (int)(d - 0.5);\n\nAsetuksista ja kääntäjästä riippuen onnistuvat jotkut tyyppimuunnokset myös ilman suluilla ilmoitettua muunnosoperaatiota. Hyvään ohjelmointitapaan kuuluu kuitenkin aina erikseen kertoa että nyt muunnetaan tietoa tyypistä toiseen. Näin ohjelmista tulee helppolukuisempia ja virheiden tekeminen ei ole ihan niin helppoa.\n\nTuon esimerkin ymmärtäminen voi aiheuttaa vähän ongelmia, mutta ei hätää. Lue lisää niin opit. En vaan osaa keksiä mihin minä tämän tyyppimuunnosjutun muuallekaan lykkäisin, joten laitoin sen tähän. Pari kappaletta vielä ja kaikki selkenee.\n # Taulukot\n\nSitten siirrymmekin vähän järeämpiin muuttujiin eli taulukoihin (array). Kuvitellaan että haluat luoda muuttujan, joka kuvaa jätkänshakin pelialuetta. Tietenkin voisi luoda 9 erillistä muuttujaan, mutta on kätevämpää käyttää taulukoita. Taulukko luodaan näin:\n > alkioiden_tyyppi taulukonNimi[eka_ulottovuus][toka ulottuvuus jne..];\n\nEli jotta saisimme jätkänshakkialuetta (3x3) vastaavan int taulukon, teemme näin:\n > int peliAlue[3][3];\n\nTaulukko koostuu alkioista (3x3 taulukossa niitä on 9) ja taulukon nimen edessä oleva tyyppi määrää minkä tyyppisiä alkiot ovat.\n\nTaulukko voidaan alustaa luonnin yhteydessä - siis siihen voidaan tunkea matskua kun se määritellään. Se tehdään yhtäsuuruusoperaattorilla, kirjoittamalla arvot kaarisulkeiden sisään:\n\nint taulukko[5]={0, 1, 2, 3, 4};\n\nJos taulukko alustetaan näin, sen kokoa ei tarvitse antaa - osaahan kääntäjäkin laskea. Myös moniulotteinen taulukko voidaan alustaa tähän tyyliin, tosin silloin koko tulee antaa, koska kääntäjä ei voi päätellä sitä itse. Arvot pitää luetella niin, että ensin käydään viimeisen (oikeanpuoleisen) ulottuvuuden arvot läpi. Siis jos ajatellaan, että ensimmäinen ulottuvuus on rivit ja toinen sarakkeet, niin ensin laitetaan ensimmäisen rivin kaikki arvot, sitten toisen jne.. Jospa alla oleva esimerkki olisi havainnollisempi. Arvoja voidaan ryhmitellä hakasulkein esityksen selventämiseksi.\n > #include <iostream.h> void main() { //int taulukko[2][3] = {1, 2, 3, 4, 5, 6}; int taulukko[2][3] = { {1, 2, 3}, {4, 5, 6} }; cout << taulukko[0][0] << \" \" << taulukko[0][1] << \" \" << taulukko[0][2] << endl; cout << taulukko[1][0] << \" \" << taulukko[1][1] << \" \" << taulukko[1][2] << endl; }\n\nOhjelmaa tulostaa:\n > 1 2 3 4 5 6\n\nAlustuksesta on esitetty kaksi täysin saman asian tekevää versiota. Toinen on tietenkin kommentoitu pois, ettei kääntäjä murahtelisi. Kuten siis huomaat, ensin tulevat ensimmäisen rivin arvot [0][0], [0][1] ja [0][2], sitten toisen rivin arvot.\n\nOletkin jo ehkä odottanut ohjelmaa, joka kysyy nimen ja sanoo \"Terve, <nimi>\". Nyt sellainen tulee, ja koska C++:ssä ei ole omaa tyyppiään merkkijonoille, käytämme merkkitaulukkoa.\n > #include <iostream.h> void main() { cout << \"Mikä on nimesi? \"; char nimi[20]; cin >> nimi; cout << endl <<\"Jaa, että \" << nimi << \". Vihje vanhemmilta, vai?\"; }\n\nNimi-merkkitaulukko määritellään ja sille annetaan kokoa 20-alkiota, eli siihen mahtuu enintään 20-merkkiä (joten <NAME> <NAME> ei mahdu). Kun on painettu enteriä, cin lopettaa lukemisen ja laittaa annetun nimen taulukkoon. Myös merkkijonotaulukko voidaan alustaa suoraan. Silloin käytetään lainausmerkkejä. Kokoa ei tarvitse antaa, kääntäjä määrittää sen ja lisää myös nollatavun (nollatavun? lue eteenpäin...), sekä ottaa sen huomioon kokoa laskiessa. On se luksusta...\n > #include <iostream.h> void main() { char* nimi = \"Oiva Apu\"; cout << nimi << endl; if (nimi[8] == '\\0') cout << \"Nollatavu se on, peeveli vieköön!\"; }\n\nMerkkitaulukot eli merkkijonot (string) ovat jäänne C:stä, C++:ssa yleensä käytetäänkin merkkijonoluokkia. Mutta se ei toki ole mikään tekosyy sille, etteikö merkkijonoja pitäisi osata. Merkkitaulukko toimii itseasiassa näin: kun määrittelemme taulukko[20], kääntäjä varaa 20 merkin verran muistia (muistin varaaminen tarkoittaa sitä, että alue merkitään käytetyksi eikä mikään muu muuttuja voi käyttää sitä) ja laittaa taulukon osoittaamaan jonon ekaan alkioon. Osoittaminen ja osoitinmuuttujat kuuluvat taas kategoriaan TSM. Kun haluamme merkin taulukko[5], ohjelman menee taulukon osoittamaan kohtaan muistia ja siirtyy siitä viiden merkin viemän tilan verran eteenpäin, ja sitten lukee merkin siltä kohden. Kun käsittelemme koko jonoa, meidän pitää tietenkin tietää missä se päättyy. Niinpä merkkijonot ovat nollatavuun päättyviä (NULL terminated), eli niiden viimeisenä merkkinä on '\\n' eli '\\0' eli NULL (nolla). Koska nollatavu vie yhden merkin verran tilaa, pitää merkkitaulukko aina tehdä yhtä isommaksi kuin todellista tarvetta on.\n\nAlla olevassa kuvassa on esitetty, mitä muistissa tapahtuu kun taulukkoon char merkkijono[5] sijoitetaan sanat LEGO ja PALIKKA. PALIKKA\\n on kolme merkkiä liian pitkä varattuun tilaan, joten se sotkee kolme tavua muistia. Seuraus voi olla melkein mitä vaan, mutta ei kuitenkaan mitään kovin positiivista.\n # Kuinka mokata taulukoiden kanssa\n\nLyön munuaiseni vetoa, että teet ainakin kerran elämässäsi tämän virheen: viittaat taulukko[1] luullen, että tuo osoittaa taulukon ekaan alkioon. Mutta niinpäs ei olekaan. Nimittäin C++ aloittaa taulukon alkiot jo nollasta. Eli taulukossa jono[3] on alkiot 0, 1 ja 2. Se tuntuu aluksi pöljältä, mutta kyllä siihen tottuu. Tilanne on sama kuin englantilaisten kerrostalojen kanssa: siellä saarivaltiossahan ja monissa muissa Euroopan maissa kerros yksi ei suinkaan ole maanpinnalla, vaan se kerros minkä me miellämme toiseksi kerrokseksi. Ohjelmoinnin harrastajalle tuo tuntuu kyllä hyvin fiksulta ratkaisulta. Myöhemmin tälle ratkaisulle esitetään myös hieman teknisempi selitys.\n # sizeof ja muuttujat\n\nMuuttujien arvoalueet vaihtelevat, koska niiden koko muistissa on erilainen. Muuttujien todellinen muistinkulutus vaihtelee hieman ympäristöstä toiseen, joten ei kannata olettaa mitään muuttujien kokoon liittyvää. Esimerkiksi jos käytät nopeaa memcpy(..) -funktiota (TSM) muistialueiden kopiointiin, tulee muuttujien viemän tilan laskeminen eteen. memcpy(..) ottaa parametreikseen kohteen, lähteen ja kopioitavien tavujen määrän. Jos haluat kopioida 200 int-lukua taulukosta 1 taulukkoon 2, tapahtuu se näin:\n > memcpy( taulukko2, taulukko1, 200 * sizeof(int) );\n\nEnsin on kohde (!), sitten lähde. Sitten tulee kopioitava määrä tavuina. Mikäli olisimme katsoneet tässä kappaleesta olevasta taulukosta, että: \"Jaahas. int näyttäis olevan 2 tavua, joten lykätään siihen sitten 200*2..\" niin ohjelma olisi toiminut noin 20%:ssa ympäristöistä. int voi olla, ja yleensä onkin, 4 tavua, jolloin 2 tavuisen intin olettaminen veisi ojasta allikkoon tai johonkin vielä kauheampaan paikkaan. Tämä sääntö syövytä neitseellisiin aivokudoksiisi, joita eivät vielä maallisen huolimattoman ohjelmoinnin siveettömyydet ole tahranneet: oleta niin vähän kuin mahdollista. C++:ssa on operaattori, jolla saadaan selville jonkun tietotyypin koko: sizeof. sizeof(int) tai sizeof int kertoo muuttujan koon. Alla olevassa ohjelmassa selvitellään eri muuttajatyyppien kokoja. long double -tyyppi ei ole aivan standardi ja monissa ympäristöissä se onkin samankokoinen kuin pelkkä double. Jotkin kääntäjät voivat yskiä bool-tyypistä, joten sen rivin voi joutua ottamaan pois.\n > #include <iostream.h> void main() { cout << \"sizeof(short int) \" << sizeof(short int) << endl; cout << \"sizeof(int) \" << sizeof(int) << endl; cout << \"sizeof(long int) \" << sizeof(long int) << endl; cout << endl; cout << \"sizeof(char) \" << sizeof(char) << endl; cout << endl; cout << \"sizeof(float) \" << sizeof(float) << endl; cout << \"sizeof(double) \" << sizeof(double) << endl; cout << \"sizeof(long double) \" << sizeof(long double) << endl; cout << \"sizeof(bool)\" << sizeof(bool) << endl; }\n # Kommentoiminen\n\nC++:aa on haukuttu maailman ainoaksi write-only (vain kirjoitettava) kieleksi. Sitä se helposti onkin ellei pidä mielessä muutamia juttuja. Kerron nyt aluksi kommentoinnista ja muita kikkoja sitten vähän myöhemmin.\n\nVaikka C++ onkin ohjelmointikieli, se on silti aika kaukana ihmiskielestä. Monesti onkin hyvä sotkea mukaan suomeksi tai savoksi kirjoitettuja kommentteja koodin toiminnasta kyseisessä kohdassa. C++:ssa on siihen kaksi tapaa:\n > // Kätevä yhden rivin kommentti. (C++-tyyliä)\n > /* tällainen C-tyylinen kommentti voi olla monta riviä pitkä */\n\nEli // aloittaa kommenttirivin ja /*..*/ merkein voi rajata kommenttialueen (voi käyttää myös koodin kommentoimiseen väliaikaisesti pois - tosin ei hirveän hyvin sovi siihen, koska koodin seassa olevat muut kommentoinnit ja merkit voivat sotkea).\n\nKommentointi on hyvä tapa, mutta rajansa kaikella. Einstein on sanonut, että hyvä teoria on vain niin monimutkainen kuin on välttämätöntä. Sama pätee kommentointiin: hyvä ohjelmoija kommentoi vain juuri sen verran kuin on välttämätöntä. Kommentointi on tärkeää, mutta löysäleukainen lavertelu ja itsestäänselvyyksien raapustelu vain hankaloittaa ohjelman lukemista ja syö arvoa seassa olevilta hyödyllisiltä kommenteilta.\n\nHuono ohjelma ei muutu hyväksi kommentoimalla. Mikäli haluat viestiä jotakin ohjelman toiminnasta, pyri tekemään se ohjelman rakenteella ja muuttujien järkevällä nimeämisellä. Vain sellainen jota ei voi sanoa C++:n avulla kannattaa kirjoittaa kommenteiksi.\n\n# Laskutoimitukset\n\nLaskutoimitusten suorittaminen C++:lla on helppoa kuin heinänteko. Pyydän anteeksi teiltä kaikilta maa- ja metsätalousihmisiltä, jotka ihan oikeasti olette joskus tehneet heinätöitä ja tiedätte, ettei se heinänteko oikeasti mitenkään hirveän helppoa ole. Me massat asumme kaupungissa.\n\nKun halutaan laskea jotakin yhteen, kirjoitetaan yksinkertaisesti muuttuja1 + muuttuja2. Voidaan sanoa, että tämä laskutoimitus palauttaa arvon. Arvo on muuttujien summa. Meidän tulee enää lopuksi sijoittaa tuo arvo jonnekin, eli saamme hahmoteltua tällaisen ohjelmanpätkän:\n > tulos = muuttuja1 + muuttuja2;\n\nVäliin voi sujauttaa plussan tilalle minkä tahansa muunkin matemaattisen operaattorin. Operaattorien suoritusjärjestys on sama kuin matematiikassakin, ensin kerto- ja jakolaskut sekä jakojäännökset järjestyksessä vasemmalta oikealle, sitten plus- ja miinuslaskut vasemmalta oikealle. Sulkeilla voidaan järjestystä muuttaa - sulkeet käsitellään ennen muita laskuoperaatioita.\n\nOperaattori | Merkitys |\n | --- | --- |\n+ | yhteenlasku |\n- | vähennyslasku |\n* | kertolasku |\n/ | jakolasku |\n% | jakojäännös |\n\nJoitakin esimerkkejä vielä selventämään muutenkin niin selvää asiaa.\n > keskiNopeus = matka / aika; keskiArvo = (arvo1 + arvo2) / 2; koulunKoko = luokkienLkm * oppilaidenLkm + luokkienLkm * opettajiaPerLuokka + muuHenkilokunta; koulunKoko = luokkienLkm * (oppilaidenLkm + opettajiaPerLuokka) + muuHenkilokunta; // sama kuin edellinen, kätevämmin esitettynä\n # Etuliiteoperaattorit\n\n > muuttuja = muuttuja + 1;\n\nKasvatamme taas luonnettasi perinteisin armeijan keinoin. Kirjoitapa tuo sata kertaa. Hyvä, nyt kerron kuinka olisit voinut tehdä sen paljon helpommin. <virnistys>\n > muuttuja++;\n\nMuuttujan perään kirjoitettu ++ -operaattori kasvattaa muuttujan arvoa yhdellä. Vastaavasti löytyy myös -- -operaattori, joka pienentää muuttujaa yhdellä. Kätevyyden lisäksi nämä operaattorit voivat olla myös nopeampia, kääntäjästä ja ympäristöstä riippuen.\n\nVoidaan kirjoittaa myös --a tai ++a. Näillä on kuitenkin yksi tärkeä ero: ++a käsitellään niin, että ensin a-muuttujaan lisätään yksi ja sitten sitä käytetään muussa lauseessa. a++ taas käsitellään toisin päin: ensin käytetään a:ta ja sitten kasvatetaan sitä. Jos halutaan vain muuttaa muuttujan arvoa, ei merkintätavoilla ole eroa, mutta jos käytetään muuttujaa samassa yhteydessä muuhunkin, kuten vaikka taulukon indeksinä, ero tulee näkyviin.\n\nb=taulukko[++a] kasvattaa a:ta yhdellä ja sitten ottaa arvon taulukosta a:n kasvatetulla arvolla ja sijoittaa sen b:hen. b=taulukko[a++] taas ottaa taulukon alkion a:n alkuperäisen arvon kohdalta, sijoittaa sen b:hen ja lopuksi vasta kasvattaa a:ta.\n\nJos haluammekin kasvattaa muuttujaa kahdella, mutta emme jaksa kirjoittaa a=a+2, niin voimme käyttää kätevää +=operaattoria. a +=2. Ei liene enää yllätys, että -=vastaavasti vähentää. Näistä operaattoreista löytyy myös kerto- ja jakolaskut sekä jakojäännös.\n\nOperaattori | Merkitys |\n | --- | --- |\n+= | lisää muuttujan arvoa |\n-= | vähentää muuttujan arvoa |\n*= | kertoo muuttujan luvulla |\n/= | jakaa muuttujan luvulla |\n%= | sijoittaa muuttujaan jakojäännöksen |\n\nEsimerkiksi:\n > muuttuja += 2; // kasvattaa muuttujaa kahdella muuttuja *= 2; // muuttuja kaksinkertaistetaan muuttuja %= 3; // sijoittaa jakolaskun (muuttuja / 3) jakojäännöksen muuttujaan muuttuja %= 2; // muuttuja on 0 jos parillinen, 1 jos pariton\n # Aivojumppaa: uhmaako a=a + 1; todellisuuden luonnetta?\n\nMuuttujan a kasvattaminen lauseella a = a + 1; voi vaikuttaa järjettömältä. Kuinka a voi olla yhtäsuuri kuin a plus yksi? Ja kuinka a:han voidaan sijoittaa sitä yhtä suurempi arvo? Eikö siitä synny ikuinen silmukka, kun a:n pitää olla itseään suurempi?\n\nTäyttä typerehtimistä tuollaiset pohdinnot eivät todellakaan ole. Pulma ratkeaa, kun muistaa, että a:n ei todeta olevan itseään suurempi, vaan esitetään toivomus että a olisi yhtä suurempi. Vertailuoperaattori == on erikseen: lauseke a == a + 1 on myös mahdollinen ja se palauttaa aina epätoden arvon - koska muuttujan a:n arvo ei tietenkään voi olla yhtä suurempi itseään. Tämä juttu siis vaikuttaa aika selvältä. Mutta kuinka a:n arvo voi olla itseään suurempi, siinäpä sitä onkin metafyysistä mussutettavaa kokonaiselle filosofien yhdyskunnalle.\n\na:n ongelmaa pitää lähestyä tietokoneiden ja C++-kielen sarjamuotoisen toiminnan kautta. Mitkään asiat eivät tapahdu yhtä aikaa. Kääntäjä käsittelee lauseen näin; ensin luetaan muuttujan a arvo muistista, lisätään siihen yksi ja sitten sijoitetaan se muistiin muuttujan a kohdalle. Ensin haetaan ja sijoitetaan, siis oikea puoli suoritetaan ensin. Käytännössä kääntäjä tekee näin:\n > int b = a + 1; a = b;\n\nKääntäjä sijoittaa ensin oikean puolen arvon väliaikaiseen muuttujaan (jonka C++-kääntäjä sijoittaa prosessorin nopeisiin rekistereihin) ja vasta sen jälkeen sijoittaa sen muuttujaan a. C++-kielisesti siis a = a + 1 ei ole yksi lauseke, vaan kaksi lauseketta: (a = (a + 1)), joista sisimmäinen suoritetaan ensin.\n\nTästä seuraa myös, että kun käsketään näin:\n > a = 5; b = a + 1; a = 6;\n\n..niin lopuksi muuttujan b arvo ei ole seitsemän, vaan kuusi. Ilmaus b = a + 1 ei ole mikään sääntö, joka sen esittämisen jälkeen pätee aina. Se on vain sijoitus käskyjen perättäisessä virrassa, eikä sijoituksen pohjalta voida b:n arvosta olla varmoja kuin seuraavassa lauseessa.\n\nC++-kielinen ohjelma siis toimii askel kerrallaan, se ratkaisee tämän pulman. Käytännössä nykyaikaisilla prosessoreilla voidaan suorittaa useita käskyjä kerrallaan, mutta siinäkin tapauksessa kaikki on koodattu perättäiseksi, mutta suoritetaan enemmän tai vähemmän onnistuneesti yhtäaikaisesti. C++-ohjelma voidaan yhä ajatella sarjamuotoisena, prosessori vaan ripsauttelee rinnakkain useita käskyjä kun se ei sotke ohjelman toimintaa. Tätä teknistä hankaluttaa ei C++-ohjelmoijan tarvitse ajatella, ellei rupea kirjoittamaan konekieltä C++-ohjelmiensa sekaan. Toki C++:lla voidaan tehdä ohjelmia joita ihan oikeasti ja aidosti suoritetaan useasta kohdasta yhtä aikaa. Siihen tarvitaan ympäristö, joka tukee säikeitä (thread of execution) ja se on oikein tehtynä hyvin hankalaa. Moni ammattiohjelmoijakaan ei tarvitse säikeitä ja moniprosessointia, joten sinäkin voit sellaiset hankaluudet vielä unohtaa.\n\n# Rakenteet\n\n# Ehtolauseet\n\nTaas lisää kaikkea hämmentävää, nimittäin ehtolauseita. Yksi ohjelmien tärkeä ominaisuus on reagoida eri tilanteisiin eri tavoin ja tämä hoituu ehtolauseilla. Ehtolause rakentuu näin:\n > if (ehto) tee_jotain;\n\nEsimerkiksi näin:\n > if (ika == 5) cout << \"Voi pikkuista..\";\n\nEhdossa voidaan käyttää näitä vertailuoperaattoreita:\n\n== | yhtäsuuri kuin |\n | --- | --- |\n!= | erisuuri kuin |\n> | suurempi kuin |\n< | pienempi kuin |\n>= | suurempi tai yhtäsuuri kuin |\n<= | pienempi tai yhtäsuuri kuin |\n\nNyt viritä päänsisäiset vastaanottimesi oikealle kanavalle (onhan tv-lupa maksettu?), tulee hyvin tärkeä asia. Yhtäsuuruusoperaattorissa on kaksi yhtäsuuruusmerkkiä. Siis kaksi, yhtä monta kuin polkupyörässä on renkaita. Yksipyöräisellä kikkailevat sirkuspellet koodaakin sitten Pascalilla. C++-kääntäjä natisee melkein aina kun vastuuttomuuttasi töpelehdit ohjelmoidessa, mutta tässä tapauksessa kääntäjä on hiljaa. Yhtäsuuruuden korvaaminen sijoituksella, siis toisen = merkin unohtaminen, on C++-kieliopin mukainen temppu. Sijoituksen arvo on itse sijoitettu arvo, joten ehto on tosi aina kun sijoitetaan joku muu arvo kuin nolla, kuten tulet kohta huomaamaan. Tämä on erittäin vaikea virhe aloittelijan huomata. Opi se nyt, tai kantapään kautta - kuten Akilles teki.\n\nMuutamia esimerkkejä vertailemisesta:\n > if (aika < 10) cout << \"Aikaa ei ole paljon.\"; if (ika >= 18) cout << \"Olet kahdeksantoista tai yli.\"; if (ika > 17) cout << \"Olet siis täysi-ikäinen.\"; // sama kuin edellinen (kokonaisluvuilla) if (robottiID != 2373) cout << \"Et ole se betazoidi jota etsin.\";\n\nEntä jos halutaan etsiä semmoista parikymppistä, mutta ei kuitenkaan yli kolmekymppistä neitoa? (etsinnän tarkoituksen jätän jokaisen oman mielikuvituksen varaan)\n\nTietenkin, onhan toki mahdollista tehdä näin:\n > if (ika >= 18) if (ika < 30) cout <<\"Käytkö täällä usein?\";\n\nMutta mutta... Voihan sitä ajaa pyörälläkin ilman satulaa, mutta kovin mukavaa se ei ole. Niinpä C++ tarjoaakin meille mahdollisuuden yhdistellä vertailuja näpsäkillä loogisilla operaattoreilla, jotka ovat:\n\n&& | JA |\n | --- | --- |\n|| | TAI |\n! | EI |\n\nNyt voimme kirjoittaa edellisen lauseen muotoon:\n > if (ika >= 18 && ika < 30) cout << \"Pidän silmiesi väristä.\";\n\nLisää valaisevia esimerkkitapauksia:\n > if (a == 5 || b < 3) cout << \"Olette syyllinen, koska a on viisi tai b on pienempi kuin kolme.\"; if (x == 3 || x == 2) cout << \"Nyt selvisi. x on kolme tai kaksi, tai molemmat.(teoriassa..)\"; if (tupakointiStatus == 1 && ika > 50) cout << \"Aijai. Kuulutte keuhkosyövän riskiryhmään.\";\n\nVielä vähän tuosta viimeisestä Sosiaali- ja terveysministeriön suosittelemasta esimerkistä. tupakointiStatus kuvaa henkilön tupakoimista. Se on nolla, jos henkilö ei polta ja 1 jos hän polttaa. Miksi näin? Siksi näin, että tämä on standardi C++-kielessä. Kun lause on tosi, sen arvo on nollasta poikkeva. Kun taas epätosi, se on nolla. Lauseen 5==5 arvo on aina tosi, eli nollasta poikkeava.\n\nTätä voi kokeilla näin:\n > cout << (5 == 5); // tulos pitäisi olla 1 cout << (4 == 5); // tulos pitäisi olla 0\n\nMitäs sitten? Sitäs sitten, että ehdossa ei aina tarvitse olla operaattoreita, vaan pelkkä arvo riittää. Voidaan esim. tehdä näin:\n > int arvo = 1; if (arvo) cout << \"Arvo on nollasta poikkeava.\";\n\nTällä tavalla voimme edistää kansaterveyttä hieman yksinkertaisemmin, eli lause muuntuu muotoon:\n > if (tupakointiStatus && ika > 50) cout << \"Aijai. Kuulutte keuhkosyövän riskiryhmään.\";\n\nTäysin vastaavia lauseet eivät ole: jälkimmäisessa tupakointiStatus saa olla mikä tahansa ei-nolla, mutta edellisessä se sai olla vain yksi. Nyt voimmekin käyttää tupakointiStatusta ilmoittamaan, montako sikaaria henkilö tupruttaa päivässä. Jo yksi tupakka päivässä kuitenkin riittää viemään hänet riskiryhmään.\n\nVielä pikkuisen tuosta !-merkistä, nimittäin EI-operaattorista. Se kääntää jonkun lausekeen arvon toisin päin, tällä tavalla:\n > if (!onMuusikko) cout << \"Et ole muusikko.\"; if (!(ika < 50)) cout << \"Ikäsi ei ole pienempi kuin 50.\"; if (ika > 50) cout << \"Ikäsi on suurempi kuin 50.\"; // sama kuin edellinen, paitsi // että 50 ei lasketa mukaan if (ika >= 50) cout << \"Ikäsi on suurempi tai yhtäsuuri kuin 50.\"; // täysin sama // kuin ensimmäinen\n # Jos ei niin sitten..\n\nMonesti, jos if lause ei ole tosi, on tarve reagoida jollain muulla tavalla. Niinpä if-käskyyn voidaankin lisätä osa else, eli jos ei niin sitten..\n > if (numero == 123) cout << \"Aha, olet siis osa numero 123\"; else cout << \"Olet joku muu osa\";\n\niffin ja elsen jälkeen suoritettavaksi voidaan myös laittaa lohko eli { ja } -merkkien rajaama alue tähän tyyliin:\n > if (ika < 18) { cout << \"Ei taida ikä riittää...\"; PotkaiseUlos(); // Funktiokutsu, TSM } else { cout << \"Tervetuloa!\"; PotkaiseSisaan(); }\n\nNäitä pikku pirulaisia voi sitten yhdistellä aivan mielin määrin, kuten esimerkissä:\n > if (ika > 65) { if (onSotaveteraani) cout << \"Olet sotaveteraani.\"; else cout << \"Olet muu eläkeläinen.\"; } else { if (ika < 35) { if (osaaCpp) cout << \"Lupaava alku..\"; else cout << \"Et ole ajatellut tutustua C++-oppaaseen?\"; } else cout << \"Sitä suurta ikäluokkaa, vai?\"; }\n # Toistorakenteet: while ja for\n\n > int taulukko[2][3] = {1, 2, 3, 4, 5, 6}; cout << taulukko[0][0] << \" \" << taulukko[0][1] << \" \" << taulukko[0][2] << endl; cout << taulukko[1][0] << \" \" << taulukko[1][1] << \" \" << taulukko[1][2] << endl;\n\nAloitamme esimerkillä, jota vilkuilimme taulukkoja käsittelevässä kappaleessa. Taulukkojen käsittely käsipelillä voi olla melko raskasta. Jo kyseisen 2x3-taulukon tulostamiseen saa kirjoittaa merkin jos toisenkin. Ja entä kun kyseessä on 640x480x3-taulukko, joka voisi olla vaikka modernin grafiikkajärjestelmän näyttömuisti? Eihän siitä mitään tule, kun käsin pitää kaikki tehdä, vaikka automaattista tietokonetta rämpätään. Tuupataan toistorakentein tietokone töihin:\n > #include <iostream.h> void main() { int taulukko[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; int a = 0; while (a < 10) { cout << taulukko[a] << \" \"; a = a + 1; } }\n\nwhile-suorittaa alla olevassa lohkossa olevaa koodia, kunnes suluissa oleva lauseke on epätosi. Eli tällainen lause:\n > while(1) { cout << \"Juuhuu\"; }\n\n...tulostaa \"Juuhuu\"-tekstin MONTA kertaa.(niin kauan kuin sähköä riittää).\n\nToinen vaihtoehto toistoon on for:\n > int a; for (a = 0; a < 10; a = a + 1) { .. }\n\nEnsimmäisessä forin osassa on muuttujan alustus, toisessa ehto ja kolmannessa muuttujan päivittäminen. Muuttujan luonnin voi yhdistää foriin näin kätevästi:\n > for (int a = 0; a < 10; a++) // a++ on sama kuin a = a + 1\n # Rakenteiden yhdistely ja do..while\n\nJoskus silmukan ehto ei ole pelkkä yksinkertainen lauseke, jonka voisi mahduttaa whilen ja forin ehdoksi. Silloin yksi vaihtoehto on laittaa se whilen rungon sisälle ja käyttää jotain muuttujaa ehdossa, kuten ehtoTosi, jolla seurataan milloin silmukan voi lopettaa. ehtoTosin arvo saadaan jollain monimutkaisellakin tavalla silmukan sisällä. Ongelma on kuitenkin, että ehtoTosilla ei ole mitään järkevää arvoa kun silmukkaa ei vielä ole suoritettu - ja toisaalta ehtoTosin arvo pitäisi tietää, että ohjelma voi päättää alkaako suorittamaan silmukkaa ollenkaan. Tämän taas voi ratkaista kopioimalla ehdon silmukan sisältä myös silmukan edelle, jotta ehtoTosi saa järkevän arvon jo ennen silmukkaa. Kopiointi on kuitenkin hirveän vaarallista. Se kasvattaa ohjelmaa ihan turhaan ja tekee siitä mahdottoman kehitettävän. Kyseessähän on automaattinen tietokone, joten parempiakin vaihtoehtoja on.\n\nJos haluamme luoda silmukan, joka suoritetaan ainakin kerran, oli sitten tilanne mikä tahansa, niin avainsana on do..while. Kielioppi on:\n > do { // silmukan sisältö } while (ehto); // huomaa puolipiste lopussa\n\nSiis itse silmukka tulee don ja whilen väliin. Normaalin whilen perään ei saa laittaa puolipistettä, ellei nyt välttämättä halua tehdä tyhjää silmukkaa, mutta nyt whilen loppuun tulee puolipiste. Sisältö suoritetaan aina vähintään kerran.\n\nSilmukoita ja ehtoja voi yhdistellä mielin määrin. Jos haluaisimme pyytää käyttäjältä 20 int-lukua, jotka ovat kaikki erilaisia, voisi sen tehdä esimerkiksi niin kuin olen alas koodaillut. Idea siis on, että aina kun käyttäjä antaa uuden luvun, niin tarkistamme ettei jo annetuissa luvuissa vielä esiintynyt kyseistä lukua:\n > int luvut[20]; int lukuja = 0; while (lukuja < 20) { int uusiLuku; int onVanha; do // pitää kysyä ainakin kerran { cout << endl << \"Anna \" << lukuja << \". luku \"; cin >> uusiLuku; onVanha = 0; for (int a = 0; a < lukuja; a++) if (luvut[a] == uusiLuku) onVanha = 1; // löytyi edellisistä } while (onVanha); // tivataan kunnes saadaan ihan uusi luku luvut[lukuja] = uusiLuku; // lisätään täysin uusi luku lukuja++; }\n # break ja continue\n\nfor ja while-silmukoista pääsee pois myös break-käskyllä. Itse tapasin ajatella, että break on merkki huonosti suunnitellusta silmukasta. Ja sitten kehittelin kaikenlaisia purkkaviritelmiä millä pääsin eroon sen käytöstä. Mutta loppujen lopuksi, mitä sitä väistää väistämätöntä, break on joskus ihan helv... erinomaisen kätevä. Eli kaikessa rumuudessaan ja kätevyydessään estradille astuu: break, ja kitaralla säestää continue.\n\nPähkinänkuoreen puristettuna: break lopettaa silmukan suorituksen siihen paikkaan. Eli jos esimerkiksi jonkin erityisen tapauksen (muisti loppuu tms..) vuoksi joudutaan lopettamaan silmukka kesken tai jos silmukan toistoehto on osa itse silmukan sisältöä, kannattaa breakia käyttää. continue, kuten nimestä voi päätellä, jatkaa silmukkaa. Se siis hyppää silmukaan alkuun, jättäen silmukan lopun ohjelmakoodin suorittamatta, mutta jatkaen kuitenkin silmukan suoritusta.\n > #include<iostream.h> void main() { int luku; while (1) // päättymätön silmukka { cout << endl << \"Arvaa luku: \"; cin >> luku; if (luku == 5) { cout << endl<< \"OIKEIN!\"; break; } if (luku == 0) { cout << endl << \"Ei nolla ole mikään kunnon luku, uudelleen..\"; continue; } cout << endl<< \"Väärin, arvaa uudelleen..\"; } }\n\nTämäkö muka teennäinen esimerkki...\n # switch..case -rakenne\n\nOn muuttuja, jolla voi olla kymmenen eri arvoa. Se voisi olla vaikka muuttuja, joka kertoo mitä käyttäjä on valinnut jostain valikosta. Kun meidän pitää valinnan mukaan päättää mitä teemme, tulee jo opittuja konsteja käyttäen ongelmia. Jos käytämme normaalia if-rakennetta, saamme aikaan melkoisen if-hässäkän, josta ei sitten enää ota pirukaan selvää. Mutta hädän hetkellä apuun ryntää tiukan punaisissa trikoissaan switch..case-rakenne!\n > switch (muuttuja) { case 0: cout << \"Arvo on nolla\"; break; case 1: cout << \"Arvo on yksi\"; break; case 2: cout << \"Arvo on kaksi\"; break; default: cout << \"Arvo on joku muu\"; }\n\nIdeana on tämä: muuttuja otetaan tässä vivuksi (switch englanniksi). switchia seuraavassa lohkossa hypätään siihen kohtaan, joka vastaa muuttujan arvoa. Jos vastaava arvoa ei löydy, mutta default -kohta löytyy, hypätään siihen. Paino sanalla hypätään. Suoritus jatkuu nimittäin siitä kohdasta aivan loppuun asti. Niinpä pitääkin jokaisen vaihtoehdon käsittelyn jälkeen laittaa break-käskyt, jos halutaan käsitellä vain ja ainoastaan siihen vaihtoehtoon liittyvä ohjelmakoodi.\n\nAina ei kuitenkaan näin ole. Otetaan esimerkki käytännön maailmasta. Teollisuusvartiointipalvelu Pamppu ja sateenvarjo oy laajenee lamakauden jälkeen ja palkkaa 150 uutta ja verestä vartijaa. Palkat on ennen laskettu paristokäyttöisellä parin kympin taskulaskimella. Nyt tarvitaan kuitenkin jotain vähän järeämpää. Sinut on palkattu suunnittelemaan ohjelma, joka laskee jokaisen vartijan palkan. Peruspalkka on 7000 mk/kk, vaarallisen työn lisä on 500 mk/kk ja yötyölisä 1000 mk/kk. Koska alue on hyvin levotonta ja kaikenlaiset perverssit kukkuvat siellä yöaikaan, tulee yötyön tekijälle myös vaarallisen työn lisä automaattisesti. Vaarallisen työn tekijälle ei kuitenkaan aina tule yötyölisää; paikallisen ammustehtaan vartiointi on melko vaarallista hommaa päiväsaikaankin. Kaikille tulee tietenkin peruspalkka.\n\nOlet saanut ohjelman jo muuten kasaan, mutta juuri se kohta, joka lisää palkan, sinulta vielä puuttuu. Otat yhteyttä paikalliseen C++-guruun ja kun pari kokispulloa ja jokunen puoliksi syöty kylmä pitsa vaihtaa omistajaansa, hän antaa sinulle vinkin:\n > // tyonTyyppi: 0 = normaali, 1 = vaarallinen, 2 = yötyö switch(tyonTyyppi) { case 2: palkka += 1000; case 1: palkka += 500; case 0: // default: kävisi myös palkka += 7000; }\n\nNoin. Yötyön tekijä saa 1000+500+7000=8500 mk/kk, kun taas päivisin karkkikauppaa vahtiva vain 7000 mk/kk. Esimerkki on kieltämättä aika teennäinen ja oikeasti toteutus olisi melko erilainen: palkkamäärät olisivat vähintään vakiomuuttujia, ei suoraan koodin kirjoitettuja.\n # Nimiavaruudet *\n\nKerronpa tarinan. Kaikki tapahtui kun olin vielä nuori ja kokematon (siis ohjelmoijana). Kehitin iltojeni iloksi ja vapaapäiviäni ratoksi järjestelmää graafisten esitysten rakentamiseen. Järjestelmä toimi niin, että siihen kytkettiin komponenttejä (kolmiulotteisia efektejä, videoita, kuvia jne...) ja järjestelmä hoiti efektien ajastuksen ja lopputuloksen piirtämisen ruudulle. Järjestelmä oli yhteydessä efektikomponenttehin Interface-nimisen oman tietotyypin avulla.\n\nAluksi kehitin järjestelmää käyttäen omaa grafiikkakoodia, siis toteutin itse grafiikan piirron ruudulle. Koska oma grafiikkakoodini oli hyvin yksinkertainen, se ei riittänyt pitkälle. Minulla ei ollut aikaa eikä mahdollisuutta kehittää sitä eteenpäin, olisinhan kaikenlisäksi tarvinnut kymmeniä erilaisia näytönohjaimia jolla testata grafiikanpiirtoa. Joten päätin käyttää hyvää ja valmista grafiikkakirjastoa. Silloin törmäsin ongelmaan: kirjasto käytti myös Interface-tietotyyppiä. Kun lisäsin kirjaston mukaan ohjelmaani, ei sitä voinut kääntää koska kääntäjä havaitsi saman nimen määrittelyn kahteen kertaan eikä siten pystynyt päättämään että kumpaa aina kulloinkin käytettiin. Lopputulos oli, että projektini kuivui kasaan ja minun oli keksittävä jotain muuta tekemistä iltojeni ratoksi.\n\nKun yhdistetään kahta eri ohjelmaa, on hyvin yleistä että törmätään nimiristiriitoihin (name clash) - kuten äskeisessä tarinassa kävi. Kyseessä ei tarvitse olla edes kahden eri henkilön tekemät ohjelmat, vaan riittää että yrittää käyttää valmista ohjelmanpätkää jonka on viikko sitten ohjelmoinut - silloinkin saattaa jo törmätä tilanteeseen, jossa harmittelee että miksi sitä piti mennä antamaan noille kahdelle muuttujalle samat nimet, nyt kääntäjä on sekaisin niiden kanssa... Yksi vaihtoehto on muuttaa nimiä, mutta usean kymmenen tuhannen rivin pituisessa ohjelmassa se ei kuulostaa enää kovin herkulliselta vaihtoehdolta, ja mikä vielä epäherkullisempaa, jos unohtaa muuttaa yhdenkin nimen, niin kääntäjä luulee sitä toiseksi ja ohjelma toimii täysin järjettömästi. Silloin viimeistään menee hermot ja päätyy vaihtamaan alaa.\n\nNimiristiriitojen rauhanomaiseen ratkaisuun C++-kielessä on ominaisuus nimeltään nimiavaruudet. Niiden avulla voidaan suuremmat kokonaisuudet (ohjelmat tai ohjelman osat) sijoittaa omiin avaruuksiinsa, niin että ne voivat sisältää päällekkäisiä nimiä. Totuushan nimittäin on, että hyviä nimiä on maailmassa aika vähän. Tässäpä lyhyt ja teennäinen esimerkki (minulla oli mielessä myös paljon vähemmän teennäinen esimerkki, mutta koska ohjelmointimaailmassa suurin osa esimerkeistä on hyvin teennäisiä, niin näen velvollisuudekseni totuttaa sinut jo tässä vaiheessa):\n > namespace Piirto_ohjelma { int pallo; int nelio; int kuutio; }\n > namespace Jalkapallopeli { int pallo; int palloilija; int huligaani; }\n > Piirto_ohjelma::pallo = Jalkapallopeli::pallo;\n\nNimiavaruus määritellään namespace-käskyllä ja sen perässä olevassa lohkossa määritellyt nimet tulevat nimiavaruuden sisälle. Viimeisellä rivillä pistetään leikisti piirto-ohjelma piirtämään jalkapallopelin pelitilanne, jota voidaan sitten käyttää futispelin markkinointimateriaalissa. Nimiavaruuden sisällä olevaa muuttujaa käytetään niin, että kirjoitetaan nimiavaruuden nimi ja kaksi kaksoispistettä ja muuttujan nimi. Yleisesti ottaen sekä jalkapallopelit että piirto-ohjelmat ovat hieman monimutkaisempia kuin kolme kokonaislukumuuttujaa... Koska nimiavaruuden jatkuva toistaminen on työlästä, voidaan todeta että nyt pallo tarkoittaa jalkapallopelin nahkakuulaa ellei toisin sanota. Eli tehdä näin:\n > using Jalkapallopeli::pallo;\n > // using Jalkapallopeli;\n > pallo = Piirto_ohjelma::pallo;\n Nyt pelkkä pallo viittaa pallopeliin, koska kerroimme että käytämme jalkapallopelin palloja. Piirto-ohjelman palleroiden pyörittely vaatii tarkkaa viittausta, siis\n\n```\nPiirto_ohjelma::pallo\n```\n\n. Emme tietenkään voi tuoda molempia palloja yhtä aikaa käyttöön, koska kääntäjä ei tietäisi enää kumpi on kumpi. Mikäli using-käskylle antaa syötteeksi namespace ja nimiavaruuden (eli using namespace Piirto_ohjelma;), ottaa se kaikki nimiavaruuden nimet käyttöön. Se ei välttämättä ole hyvä idea, koska oikeiden ohjelmien nimiavaruuksissa on paljon nimiä ja Murphyn lakia noudatellen kuitenkin jotkut sitten menevät päällekkäin ohjelman nimien kanssa. \nMyös C++:n mukana tulevat tietotyypit on sijoitettu omaan nimiavaruuteensa, nimeltään std (niinkuin standard). Tästä johtuen oikeaoppinen \"Hello World\" -ohjelma tulisikin olla tämmöinen:\n > #include <iostream> void main() { std:: cout << \"Hello world!\"; }\n Siis cout tulee kaivella sieltä std-nimiavaruuden kätköistä. Tarkkasilmäisimmät saattavat havaita, että iostreamin lopusta puuttuu se piste ja hoo. Nimiavaruudet ovat uudehko ominaisuus ja olisi ollut kovin kurjaa, jos niiden käyttöönoton jälkeen olisivat vanhat C++-ohjelmat lopettaneet toimintansa. Niinpä perinteiset .h-päätteiset otsikkotiedostot määrittelevät kaiken nimettömään nimiavaruuteen, siis oletusarvoiseen nimiavaruuteen. Esimerkiksi pelkkä `cout` siis viittaa nimettömään avaruuteen. Kun taas käytetään otsikkotiedostojen hoottomia versioita, on kaikki siirretty std-avaruuteen ja ylläoleva esimerkki ei siis toimisi jos `std::` otettaisiin coutin alusta pois. Nimettömän avaruuden käyttöä tulisi välttää, joten myös .h-otsikkotiedostot eivät ole suositeltavia (tätä opasta ei ole näiltä osin ole vielä päivitetty joka paikasta, .h-tiedostojen käyttöön saattaa törmätä). \nToki toimiva vaihtoehto on myös:\n > #include <iostream> using std::cout; void main() { cout << \"Hello world!\"; }\n\nKuten huomaat, nimiavaruuksien käyttäminen tuo hieman lisää vaivaa. Siksi en turhaan monimutkaista lyhyitä esimerkkejä nimiavaruuksilla. Kokonaisissa esimerkkiohjelmissa pyrin noudattamaan oikeaoppista nimiavaruuksien käyttöä, mutta kuten totesin, päivityksen ovat vielä kesken. Esimerkit siis kyllä toimivat uusillakin kääntäjillä, mutta .h-otsikkotiedostojen käyttö ei ole kaikkien ohjelmointitaiteen sääntöjen mukaista.\n\nOletetaan että on asia, joka pitää tehdä ohjelmassa monta kertaa. Voi taas tietenkin tehdä sen joka paikassa - kasvattaa koodin kokoa turhaan. Mutta fiksumpi valjastaa funktiot käyttöönsä. Jos jatkamme filosofointia, voimme kuvitella tilanteen jossa tätä toimintoa pitäisi muuttaa. Tyhmempi joutuu muuttamaan sen joka kohdasta missä sitä käytetään, mutta fiksu muuttaa vain tekemäänsä funktiota. Kuinka näitä funktioita sitten tehdään, se selviää aivan heti:\n > funktion_paluuarvon_tyyppi funktion_nimi(parametri_yksi, parametri_kaksi);\n\nOkei, se homma on käsitelty. Sitten polymorfismiin... :) Kuulenko jotain vikinää? Okei, selitetään sitten vähän perusteellisemmin.\n\nFunktio (function) on kansantajuisesti toiminto. Se tekee jonkin tietyn toiminnon. Funktion toimintaa voidaan ohjata sille annettavilla parametreilla, ja se palauttaa tuloksena arvon. Näin teoriassa. Todellisuudessa funktiolle ei tarvitse antaa mitään parametrejä. Se voi vaikka tyhjentää ruudun, jolloin tarkempaa ohjausta ei tarvita. Funktion ei myöskään ole pakko palauttaa arvoa.\n\nKun funktio määritellään, pitää sen paluuarvon tyyppi määritellä. Jos ei haluta palauttaa yhtikäs mitään, annetaan paluuarvon tyypiksi void (\"tyhjyys\"). Sitten määrittelyssä annetaan funktion nimi. Minulla on tapana aloittaa funktion nimi isolla ja kirjoittaa jokainen nimen osa isolla. Muista! C++ tekee eron isojen ja pienten kirjainten välillä!\n\nFunktiolle annettavat käynnistysarvot, parametrit, kirjoitetaan sulkeisiin. Niitä voi olla ihan miten paljon tahansa, tietenkin noin kymmenen on käytännön maksimi. Oliopohjaisissa ohjelmissa niitä tarvitaan vain muutama, melko usein ei yhtään. Älä kuitenkaan vaivaa päätäsi tällä vielä, kyllä ne oliot jo nurkan takana odottavat.\n\nKuvitellaan, että teemme jonkun tilastotieteellisen ohjelman, jossa pitää laskea kahden luvun keskiarvo. Niinpä teemme KeskiArvo()-funktion.\n > double KeskiArvo(double luku1, double luku2);\n\nMääritellään funktio ensin. Sille voitaisiin kirjoittaa sisältö nyt heti, mutta minä ainakin pidän enemmän tavasta, jossa funktiot määritellään ohjelman alussa, sitten tulee main()-funktio ja lopussa annetaan funktioille lihaa luiden väliin. Funktion määrittely on nimeltään prototyyppi (sitä ei vielä yksinään voi käyttää mihinkään) ja itse sisällön määrittely on funktion runko.\n\nJoten ohjelman loppuun tulisi:\n > double KeskiArvo(double luku1, double luku2) // Huomaa, ei ;-merkkiä! { double tulos = 0; tulos = (luku1 + luku2) / 2; return tulos; }\n\nFunktiota käytettäisiin näin, jos haluttaisiin laskea kolmen ja viiden keskiarvo:\n > #include<iostream.h> double KeskiArvo(double luku1, double luku2); void main() { cout << KeskiArvo(3, 5); } double KeskiArvo(double luku1, double luku2) // Huomaa, ei ;-merkkiä! { double tulos = 0; tulos = (luku1 + luku2) / 2; return tulos; }\n\nTarkastellaan vielä kohtaa:\n > double KeskiArvo(double luku1, double luku2);\n\ndouble on funktion paluuarvon tyyppi. Eli kun funktio ajetaan, se palauttaa jonkun arvon, jonka pitää olla double-tyyppiä. Suluissa olevat ovat parametreja. double on parametrin tyyppi, ja luku1 on muuttuja johon se tallennetaan. luku2 on toinen double-tyyppinen parametri.\n\nFunktiossa keskiarvolaskun tulos palautetaan return-käskyllä ja se annetaan vastaus-muuttujalle aivan kuten funktiokutsun tilalla olisi muuttuja.\n\nJos haluamme funktion, jolle ei anneta parametrejä ja joka ei palauta arvoa - tällainen funktio voisi esimerkiksi soittaa äänimerkin tietokoneen kaiuttimesta - määrittelemme sen näin:\n > void Funktio();\n\ntai:\n > void Funktio(void);\n\nKummin vaan - ylempi tulkitaan automaattisesti alemmaksi. Huomaa myös se tärkeä asia, että funktiota kutsuttaessa käytetään aina sulkumerkkejä. Hyvin ilkeää on, että mikäli unohdat sulkumerkit kutsusta, ei kalikka kalahda, nalli napsahda tai kääntäjä älähdä. Funktion nimi yksinään on funktion osoite muistissa ja sen käyttö on myös sallittua. Mikäli rivillä on vain pelkkä muistiosoite, eikä mitään käskyä, niin ohjelma ei sitten tee yhtään mitään. Eli kun tosissaan haluat sitä Funktiota kutsua, niin ohjeista ohjelmaa: Funktio();.\n # Funktion oletusparametrit\n\nFunktiolle voidaan määritellä myös oletusparametrejä. Ne määritellään prototyypissä, tai jos funktiolla ei ole prototyyppiä, niin sitten rungossa. Kuitenkin vain kerran. Määrittely tehdään näin:\n > #include <iostream.h> void Funktio(int a = 5, int b = 8); void main() { Funktio(); Funktio(5); Funktio(5, 8); } void Funktio(int a, int b) { cout << \"a \" << a << \" b \" << b << endl; }\n\nOhjelma tulostaa ajettaessa:\n > a 5 b 8 a 5 b 8 a 5 b 8\n\nSiis jos parametrille ei anneta mitään arvoa, käytetään oletusarvoa.\n # Funktioiden uudelleenmäärittely\n\nC++:ssa funktiota ei valita pelkän nimen, vaan myös parametrien mukaan. Siis esimerkiksi int KeskiArvo(int eka, int toka) ja float KeskiArvo(float eka, float toka) ovat eri funktioita. Kun funktiokutsu suoritetaan, etsii kääntäjä parametrien perusteella oikean funktion ja kutsuu sitä.\n\nTätä ihmeellisyyttä kutsutaan funktioiden uudelleenmäärittelyksi, monimuotoisuudeksi, siis ulkomaankielellä polymorfismiksi. Polymorfiset funktiot ovat siitä kivoja, että niitä voi käyttää muistamatta muuttujien tyyppejä; kunhan oikea funktio on vaan tehty, hoitaa kääntäjä homman kotiin.\n\nHmm. Tulipas lyhyt selostus. Mitenkä minä vielä tätä lisäisin, eihän asia nyt niin yksinkertainen ole. No voihan vimputti, siinä se kyllä on. Ehkä minä vielä yhden esimerkin tähän kyhään, niin saatte vähän kosketusta käytännön toteutukseen. Huomaathan esimerkkiä tavatessasi, että int-lukuina annetut keskiarvot eivät tietenkään ole tarkkoja.\n > #include<iostream.h> int KeskiArvo(int luku1, int luku2) { double summa = (double)luku1 + (double)luku2; return (int)(summa / 2 + 0.5); // + 0.5 on köyhän miehen pyöristys, joka ei toimi kuin positiivisilla luvuilla } int KeskiArvo(int luku1, int luku2, int luku3) { double summa = (double)luku1 + (double)luku2 + (double)luku3; return (int)(summa / 3 + 0.5); } double KeskiArvo(double luku1, double luku2) { double summa = luku1 + luku2; return summa / 2; } void main() { int i1, i2, i3; i1 = 2; i2 = 4; i3 = 5; double d1, d2; d1 = 2.5; d2 = 6.66; cout << \"Lukujen \" << i1 << \" ja \" << i2 << \" keskiarvo on \" << KeskiArvo(i1, i2) << endl; cout << \"Lukujen \" << i1 << \", \" << i2 << \" ja \" << i3 << \" keskiarvo on \" << KeskiArvo(i1, i2, i3) << endl; cout << \"Lukujen \" << d1 << \" ja \" << d2 << \" keskiarvo on \" << KeskiArvo(d1, d2) << endl; }\n\nTämä oli vain kevyt raapaisu polymorfismiin; kuin avaisi jugurttipurkin ja nuolisi kannen, mutta jättäisi itse sisällön syömättä. Funktioiden uudelleenmäärittely on polymorfismia funktiotasolla - toisin sanoen melko vaisua polymorfismia. Yleensä olio-ohjelmoinnissa polymorfismilla tarkoitetaan periyttämisen avulla toteutettua olioiden polymorfismia, joka onkin kulmakivi monissa olio-pohjaisissa järjestelmissä.\n # main()-funktio\n\nmain() on funktio, josta ohjelman suoritus alkaa - tässä ei liene mitään uutta. Tähän mennessä main() on määritelty:\n > void main() { // ohjelma }\n\nTämä on kuitenkin hieman puutteellinen tapa, kuten kohta tulet huomaamaan. Määrittelyä on oppaan aluksi käytetty selkeyden vuoksi. Toinen yleinen, mutta hieman monimutkaisempi tapa on määritellä:\n > int main(void) { // ohjelma return 0; }\n\nKuten huomaat, tavoissa on kaksi eroa. Parametrit ovat erilaisia, mutta käytännössä määrittelyt ovat identtisiä - määrittely main() tulkitaan C++-kielessä main(void). Tämä koskee kaikkia funktioita, ei pelkästään main():ia. Molemmat tavat toimivat, kuten alla olevasta esimerkistä huomaat:\n > #include <iostream.h> int Funktio(void); // käytetään voidia void main() { cout << Funktio(); } int Funktio() // ei käytetä voidia, mutta sama on Funktio silti.. { return 5; }\n\nKysymys on siis pelkästään makuasiasta - joten tappelu alkakoon! Miksi sitten ei kirjoittaa tyhjää (void), kun parametrien lista kerta on tyhjä? No, onhan tyhjä määrittely melko kuvaava määrittely tyhjälle. Tarkkaavainen saattaisi todeta, että kun siihen jotain kirjoittaa, niin eihän se enää ole tyhjä. Minusta siis voidin poisjättäminen on havainnollisempaa. Toinen syy on siinä, että voidin voi sotkea void* -osoittimeen, kuten alla olevassa esimerkissä demonstroidaan:\n > #include <iostream.h> int Funktio(void*); void main() { int luku = 5; cout << Funktio((void*)&luku); } int Funktio(void* param) { int* p = (int*)param; return (*p) + 1; }\n\nJos olet aito aloittelija, niin saat olla melkoinen maaginen ihmemies mikäli täysin ymmärrät yllä olevan esimerkin - kun osoitinmuuttujia ei ole vielä edes vielä selitetty. Ja hyvä on jos et ymmärrä, nimittäin tuo ohjelma on hyvien sääntöjen, puhtaan järjen ja itsesuojeluvaiston vastainen. Mutta toimii silti. Ohjelmassa on kuitenkin oikeastaan vain yksi tärkeä rivi, jonka varmaan ymmärrät: Funktio():n prototyyppi.\n > int Funktio(void*);\n\nSe on yhtä tähteä vaille samanlainen kuin edellisessä esimerkissä. Funktion toiminta on kuitenkin aivan erilainen. Tyhjän parametrilistan määrittely on helpommin erotettavissa void* -osoittimesta. Valitettavasti tämä perustelu ei ole mitenkään väkevä, koska void*-osoittimien käyttö C++-ohjelmissa on merkki huonosti suunnitellusta ohjelmasta. Ainoa syy niiden käyttöön on maksimaalisen nopeuden saavuttaminen, mutta vastapainona on melkoinen riski yhdellä ohjelmointivirheellä saada aikaan kokonainen virheiden kyinen pelto kynnettäväksi.\n\nToinen ero äsken esitellyissä main()-funktioissa on paluuarvo - ja tämä onkin tärkeämpi tapaus. Mihin main():n paluuarvo palautuu? Kuka main():ia edes kutsuu? Vastaus on, että kääntäjä kutsuu. Kun käynnistät ohjelman, käyttöjärjestelmä lataa sen ja rupeaa suorittamaan sitä. Se, että miten käyttöjärjestelmä käynnistää ohjelman riippuu ihan käyttöjärjestelmästä. Yksinkertaisessa tapauksessa se vain rupeaa syöttämään prosessorille ohjelmakoodia tiedoston alusta, yleensä kuitenkin ohjelmatiedostoissa (kuten .exe-tiedostoissa) on alussa jonkinlainen tunnisteosa, jonka käyttöjärjestelmä lukee ja siirtyy sen jälkeen ennalta määrättyyn kohtaan ohjelmakooditiedostoa ja rupeaa suorittamaan ohjelmaa siitä eteenpäin. Niinpä meidän kääntäjämme ovelasti järjestää asiat niin, että juuri siinä kohden mistä ohjelman suoritus alkaa on kutsu main()-funktioon. Eli käyttöjärjestelmä antaa alkusysäyksen ohjelmalle ja käyttöjärjestelmä myöskin saa main()-funktion paluuarvon.\n\nPaluuarvo on siis on arvo, jonka ajettu ohjelma palauttaa käyttöjärjestelmään. Paluuarvo on peräisin Unixeista, joissa sitä hyödynnetäänkin melko ahkerasti. On hyvän ohjelmointitavan mukaista, että ohjelmat palauttavat arvon, jolla viestivät siitä kuinka ohjelman suoritus onnistui. Standardi on, että onnistunut ohjelma palauttaa arvon EXIT_SUCCESS (EXIT_SUCCESS on siis vakio, muuttuja joka on kääntäjän määrittelemä). Jos jokin menee pieleen, palautetaan EXIT_FAILURE. EXIT_SUCCESS on lähes poikkeuksetta 0, kun taas EXIT_FAILURE riippuu järjestelmästä riippuen - yleensä se on 1 tai 255. Yleinen tapa palauttaa nolla main():n onnistuneen suorituksen päätteeksi ei siis ole ihan kaikkien taiteen sääntöjen mukainen, vaikka käytännössä aina toimiikin.\n\nPaluuarvo on hyvin kätevä, kun rakennetaan komentojonoja, jotka kutsuvat C++-ohjelmaa ja jatkavat toimintaansa suorituksen onnistumisen, siis paluuarvon, perusteella. Esimerkiksi kun kopiointiohjelma palauttaa EXIT_FAILURE-arvon mikäli levytila loppuu kopioidessa kesken, voi varmuuskopioita tekevä komentojono lukea paluuarvon ja sen perusteella käynnistää sähköpostiohjelman, joka lähettää ylläpitäjälle \"Vaihda nauhavarmistimeen uusi nauha\"-viestin. Unixissa lapsiprosessien suorituksen onnistumista voi myös tutkia paluuarvon perusteella. Useissa Unix-shelleissä paluuarvo löytyy $?-ympäristömuuttujasta, kun taas DOSissa (ja NT4 DOS-shellissä) paluuarvo löytyy muuttujasta ERRORLEVEL. Sen voit todeta vaikka tekemällä ohjelman, jonka main() palauttaa tietyn arvon, ajamalla sen ja komentamalla komentorivillä:\n > echo %ERRORLEVEL%\n\nJa vaikka et itse käyttäisi ohjelmaa tällaiseen tarkoitukseen, saat hyvin pienellä vaivalla aikaan hyvää mieltä muille, kun teet ohjelmasi niin että se viestii toiminnastaan paluuarvolla (esimerkiksi: EXIT_SUCCESS (tai 0) = virheetön toiminta, 1 = ajonaikainen virhe, 2 = virhe tiedoston avauksessa jne.. tai yksinkertaisesti ja standardisti: EXIT_SUCCESS = virheetön suoritus, EXIT_FAILURE = virheellinen suoritus).\n\nTästä eteenpäin käytämme oppaassa oikeaoppista main()-määrittelyä. Kaikkien taiteen sääntöjen ja pölyisten oppikirjojen mukainen main()-funktio on siis tällainen:\n > int main() { // ohjelma return EXIT_SUCCESS; }\n # Lohkot, lauseet ja lausekkeet\n\nKolme L:ää, lohkot, lauseet ja lausekkeet. Mitä ne ovat? Aloitamme lauseesta, se on nimittäin helppo nakki. Lause on pätkä ohjelmaa, joka tekee jonkun tietyn asian. Lause päättyy puolipisteeseen ( ; ).\n > a = 10 * b; // lause\n\nLause voi myös olla tyhjä, silloin se siis on pelkkä puolipiste. Normaalin lauseen voi korvata monella lauseella, siis lohkolla. Lohko on {}-merkkien väliin kerätty kasa lauseita. if-käskyn jälkeen tulee lause, jonka voi tietenkin korvata lohkolla. Eli:\n > if (a == 10) doSomething(); // lause if (a == 10) // lohko { a += 150; b--; }\n\nLohkoa ei siis päätetä puolipistein, mutta lohkon sisällä olevat lauseet kylläkin. Lohkoilla on myös tärkeä merkitys muuttujien näkyvyyden kannalta. Tästä sitten seuraavassa kappaleessa.\n\nSitten viimeinen villahousu, lauseke. Lauseke on pätkä, jolla on joku arvo. Vanha kansa sanoo, että lauseke palauttaa arvon. Lauseke 10 + 15 palauttaa arvon 25. Tämä arvo voidaan sitten hyödyntää lauseessa, sijoittamalla se vaikka johonkin.\n > c = 10 + 15;\n\nMutta myös lause on lauseke. Lauseke c=10 + 15 palauttaa c:hen sijoitetun arvon, eli voidaan kirjoittaa:\n > a = c = 10 + 15;\n\nNyt kannattaisi Sekalaiset-kohdasta lukea hyvän koodin kirjoitusta käsittelevä kohta ja sitten palata Muuttujien näkyvyyteen.\n # Muuttujien näkyvyys\n\nMuuttujilla on näkyvyysalueita. Tällä tavalla ei muistia hukata, kun turhat muuttujat poistuvat käytöstä. Muuttujat voidaan jakaa raa'asti kahteen osaan, globaaleihin (global) ja paikallisiin (local). Globaaleja muuttujia käytetään hyvin harvoin, hyvin suunnitelluissa ohjelmissa ehkä ei koskaan. Itseasiassa en muista milloin viimeksi olisin globaalin muuttujan määritellyt, siitä on jo aikaa. Globaalit muuttujat näkyvät koko ohjelmassa. Ne ovat siis kaikkien käytettävissä. Paikalliset muuttujat näkyvät vain siinä lohkossa, missä ne ovat määritelty. Kun lohko loppuu, muuttujat hävitetään. Funktion parametrit ovat funktion paikallisia muuttujia.\n\nGlobaali muuttuja määritellään ohjelman alussa ennen main() -lohkoa. Paikallinen muuttuja määritellään lohkon sisällä ja se häviää lohkon lopussa. Muuttujia ei C++:ssa tarvitse määritellä lohkon alussa, kuten C:ssa, vaan ne voi määritellä missä haluaa. Eroa siis ei ole itse muuttujan määrittelyssä, vaan missä kohti muuttuja sijaitsee.\n\nEsimerkki: (kääntäjä ei suostu tätä kääntämään!)\n > void Funktio(); int olenGlobaaliMuuttuja; int main() { int olenPaikallinenMuuttuja; Funktio(); olenGlobaaliMuuttuja = 1; // onnistuu olenPaikallinenMuuttuja = 1; // onnistuu olenMyosPaikallinenMuuttuja = 1; // ei onnistu return EXIT_SUCCESS; } void Funktio() { int olenMyosPaikallinenMuuttuja; olenGlobaaliMuuttuja = 1; // onnistuu olenMyosPaikallinenMuuttuja = 1; // onnistuu olenPaikallinenMuuttuja = 1; // ei onnistu }\n\nGlobaali muuttuja määritellään ohjelman alussa. Sitä voidaan käyttää mistä vain. Ohjelmassa määritellään myös kaksi paikallista muuttuja ja niitä voidaan käyttää vain niistä lohkoista missä ne on määritelty.\n\nHyvään ohjelmointitapaan kuuluu globaalien muuttujien välttäminen. Miksi? Koska niille voidaan antaa arvo mistä vaan, niin niille voidaan antaa väärä arvo mistä vaan. Väljästi totuuspohjainen esimerkki: on kaksi funktiota. Toinen on tehty valmiiksi ja lopussa on virheentarkistukseen liittyvä rivi:\n > if (globaaliTila = 1) return 0;\n\nTämän tarkoitus olisi siis tarkistaa, että globaaliTila on 1 eli kaikki on kunnossa. Vertailuoperaattori ==:n sijaan onkin tullut vain yksi =, mikä meinaa sijoitusta. Sijoitus on aina tosi, siis funktio palauttaa arvon 0 aina. Ja sen lisäksi globaaliTila:n sijoitetaan arvo 1, joten jos vaikka todellisuudessa globaaliTila olisi 1000 (maailmanloppu kolkuttaa ovella ja Belsebuubi puhaltaa vaskiseen torveensa), kaikki nollautuisi tämän rivin jälkeen. Se on riittävän inhottavaa jo yksinään, mutta kun virhettä ei heti huomata - kaikkihan näyttää toimivan, vaikka todellisuudessa ei toimisikaan - ja rupeamme kirjoittamaan toista funktiota, huomaamme että kaikki ei ole kunnossa vaikka globaaliTila niin väittääkin. Tässä vaiheessa ohjelmoija seisoo polvia myöten juoksuhiekassa ja punapyllyiset paviaanit kutittelevat häntä nenästä strutsinsulilla - tai ainakin yhtä hermostuttava tilanne on. Vaatii paljon epätoivoa, että meidän tuskastunut ohjelmoijamme vielä kerran katsoo jo valmiiksi luultuun funktioon ja löytää virheen sieltä. Nyrkkisääntö on: mahdollisuus muuttaa muuttujan arvoa tulee olla vain niillä ohjelman kohdilla, jossa sitä oikeasti tarvitaan. Globaaleja muuttujia on mahdollista muuttaa joka ikisessä ohjelman kohdassa, mikä on noin 99% liikaa.\n\nMuuttujan näkyvyysalue ei ole aivan sama asia kuin viittausalue, siis se alue jossa muuttujan nimeä voidaan käyttää siihen viittaamiseen. Ero tulee esille silloin, kuin paikallisesti määritellään muuttuja, joka on samanniminen kuin joku globaali muuttuja. Silloin muuttujan nimi viittaa paikalliseen muuttujaan - niin kauan kuin se on olemassa. Siis vähempiarvoinen, paikallisempi muuttuja on jonossa ekana jos samannimisiä muuttujia on paljon. Jos haluamme tehdä selväksi, että tarkoitamme globaalia muuttujaa, käytämme :: (kaksi kaksoispistettä) -operaattoria. Tällä ei vielä tässä vaiheessa ole juurikaan merkitystä, mutta alla on kuitenkin demonstraatioesitys aiheesta.\n > #include <iostream.h> int muuttuja = 1; int main() { int muuttuja = 2; cout << \"Paikallinen muuttuja \" << muuttuja << endl; cout << \"Globaali muuttuja \" << ::muuttuja << endl; return EXIT_SUCCESS; }\n\n# Esikääntäjän perustemput\n\nEsikääntäjä on kuin esipesu pyykkikoneissa; se tapahtuu ennen varsinaista huljuuttelua. Haa, puhun vertauksilla ihan kuin Jeesus konsanaan. Esikääntäjä on siis ohjelma, joka käsittelee lähdekoodia ennen kuin oikea kääntäjä saa sen hyppysiinsä. Esikääntäjää ohjataan #-alkuisilla käskyillä ja niiden loppuun ei kirjoiteta puolipistettä. Hyvin yleinen esikääntäjälle annettu käsky on:\n > #include <iostream.hAlussa on #, kuten pitääkin. Sitten include, siis sisällytä. Niinpä tuohon kohtaan esikääntäjä asettelee tiedoston iostream.h ja kun tiedosto syötetään oikealle kääntäjälle, niin iostream.h:n sisältö on rivin kohdalla. #-alkuiset käskyt eivät ole enää mukana kääntäjälle menevässä versiossa. Sisällytettävän tiedoston nimi kirjoitetaan <>-merkkien väliin. Tämä tarkoittaa, että se löytyy siitä hakemistosta missä kääntäjän mukana tulevat otsikkotiedostot (.h) ovat, yleensä hakemisto on kääntäjän hakemiston alihakemisto INCLUDE tai H. Tiedoston nimi voidaan kirjoittaa myös lainausmerkkeihin, mikä tarkoittaa, että tiedosto löytyy samasta hakemistosta lähdekoodin kanssa. Tätä siis yleensä käytetään omien otsikkotiedostojen sisällyttämiseen, kun taas <>-merkkejä kääntäjän otsikkotiedostoihin.\n\nToinen usein käytetty esikääntäjän kikka on vakioiden määritteleminen. Jos ohjelma piirtää 320x200 tarkkuudella olevaa grafiikkaa, pitää resoluutiot 320 ja 200 kirjoittaa usein koodin sekaan. Kun tulee aika päivittää ohjelmaa ja laittaa se toimimaan tilassa 640x480, tulee pirunmoinen urakka vaihtaa jok'ikinen luku. Hyvin todennäköisesti joku arvo jää vaihtamatta, jolloin homma ei toimi tai pahemmassa tapauksessa ohjelma toimii mystisellä tavalla väärin ja se ei valmistu ikinä ja ohjelmistofirma menee nurin jne..\n\nKaiken tämän kurjuuden voi välttää määrittelemällä vakion X_RES, siis horisontaaliresoluutio, joka on 320. Se tehdään esikääntäjän avulla näin näppärästi:\n > #define X_RES 320 #define Y_RES 200\n\nSitten voimme käyttää sanoja X_RES ja Y_RES aivan kuin ne olisivat lukuja. Kun muutamme tarkkuutta, pitää se muuttaa vain #define-lauseista. Kätevää, eikö olekin? Kun esikääntäjä saa define-käskyn, se plaraa lähdekoodin läpi ja korvaa kaikki X_RES-sanan ilmentymät arvolla 320. Tämä koskee tietenkin vain kokonaisia sanoja, X_RESOLUTION_DETECT ei muutu 320OLUTION_DETECT:ksi. Esikääntäjä ei myöskään käsittele kommentteja tai lainausmerkkien sisällä olevia pätkiä, kuten coutin tulostuksia.\n # Vakiot oikeaoppisesti\n\nOlen varmaan jo maininnut muutaman kerran, että esikääntäjä on kääntäjä, joka käsittelee lähdekoodin ennen kääntäjää. Eli esikääntäjä käsittelee vakiot ja hävittää niiden jäljet, jolloin oikealla kääntäjällä ei ole mitään tietoa mitä tyyppiä eri vakioarvot ovat. Kääntäjä ei siis voi tarkistaa arvojen tyyppiä. Sehän ei käy päinsä C++-kielessä, jossa muuttujien tyyppitarkastus on viety hyvin pitkälle. Pieni esimerkki:\n > #define ARVO 1280 unsigned char tavu = ARVO;\n\nMikäkö tässä mättää? unsigned charin arvoalue on 0..255, joten 1280:n sijoittaminen siihen ei onnistu. Tarkoitus oli laittaa ARVOksi 128, joka olisi ollut oikein, mutta huolimaton ohjelmoija painoi vahingossa yhden nollan liikaa (kertomus perustuu täysin tositapahtumiin). Kääntäjä ei tiedä mitä tyyppiä ARVOn pitäisi olla, eikä se osaa varoittaa siitä, että sille annetaan väärän tyyppinen arvo. Niinpä onkin järkevämpää käyttää vakioiden määrittelemiseen esikääntäjän sijasta oikeaa kääntäjää, jolloin se voi valvoa myös vakioiden oikeaoppista käyttöä. Niin saamme taas yhden vastuun siirrettyä kääntäjälle, joka tekee sen meitä nopeammin, huolellisemmin eikä kyllästy hommaansa saati sitten vaadi palkkaa.\n\nKääntäjän vakiot määritellään const-määreen avulla. Sen jälkeen tulee ihan tavallinen muuttujan määrittely. Ero on kuitenkin se, ettei const-muuttujan arvoa luonnin jälkeen voi muuttaa.\n > const unsigned char ARVO = 1280; unsigned char tavu = ARVO;\n\nNyt kääntäjä osaa heti huomauttaa siitä, että unsigned char-tyyppiseen muuttujaan ei voi sijoittaa arvoa 1280 ja selviämme paljon vähemmällä virheen jahtaamisella ja itkuvirsien luikuttelulla.\n # typedef\n\nHyvin yleinen villitys on tämänlainen tapa määritellä tietotyypeille käteviä lyhenteitä:\n > #define byte unsigned char // määritellään byte vastaamaan unsigned charia\n\nTässä on vaan taas se kommervenkki, että esikääntäjä on vain typerä merkkijonojen korvaaja - eikä siis pysty millään lailla valvomaan määrittelyjen käyttöä. Parempi on taas antaa kääntäjän hoitaa tämä tyypin määrittely, siis type definition eli lyhyemmin typedef:\n > typedef unsigned char byte;\n\nHuomaa, että järjestys määrittelyssä on nyt toisinpäin ja lopussa on puolipiste, koska koodi menee kääntäjälle. Nyt voimme käyttää unsigned char -tyypin tilalla peitenimeä byte. Se nopeuttaa ohjelman kirjoittamista ja tekee siitä helpommin luettavan. Koska tietotyypit ovat ohjelmointiympäristökohtaisia, voimme myös peitenimien avulla peitellä tätä ongelmaa - käytämme vain peitetyyppiä, ja eri ympäristöissä määrittelemme sen vastaamaan eri tietotyyppejä.\n # Lueteltu tyyppi: enum\n\nenum on semmoinen kätevä (?) juttu, jota voi käyttää numeroin koodatun tiedon säilyttämiseen. \"Kätevä\"-sanan perään lykkäsin kysymysmerkin, koska en itse ole enumia juuri koskaan käyttänyt mihinkään. Mutta kun nyt tarkemmin ajattelen, niin ehkä vika sittenkin on minussa. Jospa pyrin muuttamaan tapojani, niin suhde minun ja enumin välillä voi vielä kehittyä antavaksi ja hedelmälliseksi. Mikäs paholaisen keksintö se enum sitten on? No, sehän lueteltu tyyppi, siis enumerated type, mistä nimikin on varmaan keksitty. Sillä voi kätevästi esittää jotain tietoa, joka on koodattu numeroarvoin: siis esimerkiksi viikonpäiviä esittävässä muuttujassa on maanantai koodattu viikon ensimmäiseksi päiväksi, siis C++:ssa luvuksi nolla (indeksointi alkaa nollasta C++:ssa, kuten varmasti muistatkin). Eli käytännössä:\n > enum PAIVA {MA, TI, KE, TO, PE, LA, SU };\n\nNoin se toimii. Luodaan uusi tietotyyppi PAIVA, jolla on seitsemän sallittua arvoa MA, TI, KE, TO, PE, LA ja SU. Muuttuja on itseasiassa int-luku, jolla on arvot 0 - 6. Siis vertailu TI < TO tarkoittaa samaa kuin 1 < 3, siis tosi. Tiistai on ennen torstaita. Jotkut kääntäjät antavat sijoittaa lueteltuun tyyppiin myös numeroarvon, siis viikonpaiva=2 ja viikonpaiva=KE ovat sama sijoitus. Yleensä kuitenkin kääntäjät murahtavat tällaisesta sijoituksesta - ja aiheesta. enumin idea on juuri päästä eroon paljaiden lukujen käytöstä. Huomaa myös sellainen seikka, että vakionimet (siis MA, TI... edellisessä esimerkissä) ovat vain kääntäjän ymmärtämiä peitteitä lukuarvoille - ja kun kääntäjä sylkäisee valmiin ohjelman sisuksistaan, ei merkkijonoja enää ole. Sijoitus PAIVA=\"MA\" ei onnistu, koska \"MA\" on merkkijono eikä luvun 0 peitenimi. Vakionimille voi antaa myös itse numeroarvot tyypin luonnin yhteydessä.\n > enum TURVALLISUUSLUOKITUS { VIERAS = 0, PERUSKAYTTAJA = 2, TEHOKAYTTAJA = 4, YLLAPITAJA = 10 }; int main() { TURVALLISUUSLUOKITUS jaska; jaska = PERUSKAYTTAJA; cout << \"Jaskan luokitus on \" << jaska << endl; if (jaska > VIERAS) cout << \"Jaskalle voi paljastaa vähän salaisempiakin tietoja..\" << endl; return EXIT_SUCCESS; }\n # Esikääntäjä tappaa talossa ja puutarhassa\n\nKukaan ei tee virheetöntä koodia, en edes minä (itseasiassa teen paljon virheita, koska virheistä oppii parhaiten ja olen innokas uuden oppija...). Kiireessä kirjoitettu lähdekoodi on bugien luonnollisinta esiintymisaluetta. Bugihan on siis virhe ohjelmassa, joka joko laittaa ohjelman toimimaan väärin tai kaatumaan kokonaan, yleensä molempia ja hieman satunnaisesti.\n\nBugin tappaminen voi olla joskus vaikeaa; metsästyslupia niille on hyvin helppo saada, mutta hyvän suojavärin omaavan bugin löytäminen on pirullisen vaikeaa. Joskus virheitä etsittäessä tulee mieleen, että olisipa kiva tietää millaisia arvoja tuo muuttuja saa. Senhän selvittäminen onnistuu yksinkertaisesti coutilla. Kun koodi on ripoteltu täyteen tarkistuksia ja virhe löytyy, pitää ne kaikki napsia käsin pois. Ja sitten huomataankin, että ohjelma ei ihan vielä toimikaan ja tarkistukset pitää laittaa takaisin.\n\nOn olemassa kuitenkin helpompikin keino. Valitsemme sopivan sanan, esimerkiksi DEBUG, jolla kerromme milloin käännämme ohjelmakoodia tarkistustilassa, jolloin kaikki ylimääräinen tarkistustauhka tulee mukaan. Kun ohjelma on valmis, otamme DEBUGin määrittelyn pois ja esikääntäjä karsii kaiken ylimääräisen pois meidän puolestamme.\n > #include iostream.h #define DEBUG int main() { int muuttuja = 0; cin >> muuttuja; #ifdef DEBUG cout << \"muuttuja \" << muuttuja <<endl; #endif return EXIT_SUCCESS; }\n\n#ifdef, siis if defined (jos määritelty) ottaa mukaansa jäljessä olevan koodin #endifiin asti, jos pyydetty sana on määritelty. Ja sehän on, ihan alussa. DEBUGille ei anneta mitään arvoa, se on vaan määritelty. Jos heitämme kommenttimerkit ensimmäisen lauseen eteen, ei DEBUGia ole määritelty ja esikääntäjä karsii #ifdefin ja #endifin väliset tarkistukset pois.\n\nMuuttujien arvojen seuraaminen onnistuu myös huomattavasti helpommin debuggerilla, joka yleensä tulee kääntäjän mukana. Tosin onnellinen on se, joka ei ikinä joudu ilman debuggeria ohjelmoimaan. Yleensä vähän eksoottisempi ohjelmointivälineiden yhdistely takaa sen, että debuggeri ei ole käytössä tai että se ainakaan ei toimi kunnolla. KUN debuggeri toimii, se suorittaa tekemäämme ohjelmaa askel askeleelta ja antaa seurata muuttujien arvoja. Ongelmia saattaa kuitenkin tulla esimerkiksi käytettäessä erikoisempia grafiikkatiloja, kuten PC:n SVGA-tiloja. Asian voi hoitaa kommentoimalla grafiikan käyttöön liittyvät kohdat pois, mutta toisaalta senkin työn voi antaa esikääntäjän hommaksi. Tähän käytämme käskyä #ifndef, if not defined. Se on kuin #ifdef, mutta toimii toisinpäin, siis ottaa merkityn alueen mukaan jos tiettyä sanaa ei ole määritelty.\n > // gfxlib.h on mielikuvituksellinen grafiikkajärjestelmä, tätä esimerkkiä // siis ei voi kääntää #define DEBUG #include\"gfxlib.h\" // grafiikkaan liittyviä juttuja int main() { #ifndef DEBUG AsetaKummallinenNayttotila(); #endif for (int a=0; a < 100; a++) { TeeMuutJutut(); #ifndef DEBUG PiirraKuva(); #endif } #ifndef DEBUG PalaaTekstitilaan(); #endif return EXIT_SUCCESS; }\n # Makrot\n\nKuvitellaan että ohjelmoit tarpeettoman väkivaltaista toimintapeliä, jonka huippunopeassa grafiikkaa piirtävässä silmukassa pitää laskea jonkun muuttujan toinen potenssi useassa kohdassa. Et viitsisi kirjoittaa sitä jokaiseen kohtaan, varsinkin kun kaava saattaa muuttua. Silloin se pitäisi muuttaa käsin useaan kohtaan ja tietäähän kaikki mitä siitä tulee. Toisaalta funktion kutsuminen aiheuttaisi aivan liikaa tehoa syövää lisätyötä ja tärvelisi huippunopean silmukan. Esikääntäjä se osaa.\n > #define NELIO(x) (x)*(x) // NELIO-makron määrittely int main() { cout << \"5+5 toiseen on \" << NELIO(5+5) << endl; return EXIT_SUCCESS; }\n\nOtin tässä tapauksessa NELIO-makron parametriksi lausekkeen 5+5, jotta huomaisit kuinka tärkeitä sulut ovat makromäärittelyssä. Kuvitellaan, että emme käyttäisi niitä:\n > #define NELIO(x) x*x\n\nNäin määritellessä kääntäjälle kohta NELIO(5) tarjoillaan muodossa 5+5*5+5, mistä lasketaan ensin tulo 5*5 ja lopulta päädytään vastaukseen 35. Elon laskuopin mukaan (5+5)² eli 10² on kuitenkin 100. Siis laskujärjestys työntää pitkät sormensa tähänkin asiaan. Kun määrittelemme makron sulkujen kera, tulee kääntäjälle menevä lause muotoon (5+5)*(5+5) = 10*10 = 100 eli ihan oikein. Koska esikääntäjä ei tunne puolipistettä rivin päättymisen merkkinä, se tulkitsee yhden tekstirivin yhdeksi ohjelmariviksi. Mikäli makro ei mahdu yhdelle tekstiriville, voidaan se jakaa monelle riville \\-merkin (kenoviiva) avulla, tähän tyyliin:\n > #define KOKONAISENERGIA(m) (m)*\\ ((2.998e8)*(2.998e8))\n\nLopuksi vielä hyvin vakava varoitus. Ole todella, todella varovainen tuon yllämainitun e = mc² -kaavan kanssa. Sen vastuuttomat käyttäjät ovat hävittäneet kokonaisia kaupunkeja.\n # Elegantti vaihtoehto makroille\n\nMakroihin kuitenkin liittyy pari ongelmaa. Debuggeri osaa harvemmin purkaa niitä, joten ohjelmakoodin suoritus askel askeleelta ei niissä kohdin onnistu - keskikokoinen ongelma. Esikääntäjä ei osaa tehdä tyyppitarkastusta - iso ongelma. Toisaalta funktion kutsuminen hidastaa aina ohjelmaa. Mutta ovela ohjelmoija tietää avoimet funktiot. Ne ovat kuin makroja, mutta kääntäjä käsittelee niitä. Siis tyypit tarkastetaan ja debuggaus sujuu sukkelasti. inline määrittelee funktion avoimeksi.\n > inline double KokonaisEnergia(double m) { (m)* ((2.998e8)*(2.998e8)); }\n\nMakroilla on kuitenkin se etu, että niillä voidaan käsitellä tietoa mitä kääntäjällä ei ole - kuten ohjelmatiedoston nimi ja kyseinen rivi, senhetkinen kellonaika jne.. Tätä jujua käytämme seuraavassa kappaleessa.\n # Ei vara venettä kaada - eikä assert() toimivaa ohjelmaa\n\nOhjelmoija usein olettaa aika paljon. Esimerkiksi tällaisessa silmukassa:\n > for (int a=0; a != ylaRaja; a++) x += a;\n\n..oletetaan, että ylaRaja tulee joskus vastaan. Jos ylaRaja on int-muuttuja, jolla on arvo -5, niin silmukka ei lopu vasta kun a on pyörähtänyt ympäri. Vähän huonohermoisempi käyttäjä voi jo kyllästyä odottelemaan, eikä se varmaan olekaan ollut tarkoitus. Varsinkin jos ohjelmoijia on monta, niin vain <NAME> uskaltaa olettaa tällaisia asioita - muut ohjelmoijat kun tunnetusti ovat vastuuttomia poropeukaloita. Toisaalta eihän siitä mitään tulisi, jos jokaisiin kohtaan pistettäisiin varmistuksia eri muuttujien arvoista. Ohjelmasta tulisi vain valtava kasa virheentarkistuksia. Ja mitäpä käyttäjä tekee sillä tiedolla, että muuttuja xTerminalVelocity on saanut epäkelvon arvon - avaa ohjelman binäärikoodin heksaeditoriin ja korjaa virheen, vai?\n\nOhjelmoijalle kuitenkin tämmoinen tieto voi olla melko arvokas. Hym, hym, hankala tilanne... Tällaisen ajatuskulun lopputuloksena ovat suuret mielet kehittäneet assert-makron. Se varmistaa, että sille annettu ehto on tosi - siis esimerkiksi että muuttujalla on sallittu arvo. assert tulee mukaan ohjelmaan vain jos sana DEBUG on määritelty. Siis julkaistavaan versioon assertit eivät tule eikä valmiin ohjelman koko kasva. Koska assert on esikääntäjän makro, se voi antaa melko tarkkaa tietoa virheestä, käyttäen hyväksi esikääntäjän määrittämiä vakioita (muotoa __VAKIO__). Kääntäjien mukana yleensä seuraa assert.h -tiedosto, josta makron määrittely löytyy. Jos sellaista ei ole, niin voidaan assert tehdä itse.\n\nTiedosto assert.hpp:\n > #ifndef _assert_hpp #define _assert_hpp #ifndef DEBUG #define assert(x) // jos DEBUG ei määritelty, assert on tyhjä #else #define assert(x) if (! (x)) { \\ cout << \"VIRHEELLINEN TILANNE!\" << endl; \\ cout << \"Assert epäonnistui: \" << #x << \", tiedostossa \" << __FILE__ << \" rivillä \"\\ << __LINE__ << \".\" << endl; } #endif #endif\n\nNäin sitä sitten käytettäisiin:\n > #define DEBUG #include \"assert.hpp\" int main() { int ika = -5; assert(ika >= 0); return EXIT_SUCCESS; }\n\nKannattaa muuten varoa, ettei kirjoita assertia näin:\n > assert(status = OK);\n\nSehän ei vertaile statuksen arvoa, vaan sijoittaa siihen OK:n. Siis mahdollinen virhetilanne häviää, mutta kun kun julkaisuversiossa assertit poistetaan, niin virhe tulee takaisin. O' mama, en haluaisi joutua tuollaista virhettä korjaamaan... Assertia ei pitäisi käyttää kuin ohjelmointivirheiden etsimiseen. Esimerkiksi tiedoston avaamisen onnistumista ei saa varmistaa assertilla, vaan sille pitää rakentaa järjestelmä, joka ilmoittaa käyttäjälle tilanteesta. Tiedoston puuttiminenhan ei ole virhe ohjelmassa, vaan lähinnäkin käyttäjässä. Mutta toisaalta ohjelman kehityksen alkuvaiheessa, kun virheiden käsittelyyn tarvittavia osia ei vielä ole ohjelmoitu - mutta ohjelmoija kuitenkin haluaisi varmistaa esimerkiksi tiedostojen avaamisen ja muistin varaamisen onnistumisen - voi vastaavaa makroa käyttää. Itse määrittelen makron tassert (temporary assert), jolla ohjelman alkuvaiheessa varmistan tällaiset tilanteet. Siinä vaiheessa kun tulee aika rakentaa virheidenkäsittelyn osat, on mahdolliset vaarapaikat helppo etsiä - siis kaikki tassert-makrot pitää korvata.\n\n# Viittaukset ja osoittimet\n\n# Viittaukset\n\nHaluatko tietää, mitä tapahtuu kun funktiota kutsutaan. Ai, et? No, tämä kasvattaakin luonnetta.\n\nPC-tietokoneessa on erityinen muistialue, pino (stack). Kun funktiota kutsutaan, kääntäjä heittää funktiolle välitettävät parametrit pinoon. Sitten funktiossa parametrit luetaan sieltä pinosta. Muuttujia ei kuitenkaan siirretä pinoon, vaan kopioidaan. Kun muutamme funktiosta käsin jotain arvoa, ei alkuperäinen parametriksi annettu muuttuja muutu. Kuvittele, että teet funktion joka käsittelee sadan megatavun tietokantaa. Sinulla on kaksi ongelmaa: sadan megatavun kopioiminen syö prosessoriaikaa melko roimasti ja muuttaessasi tietokantaa funktiossa ei itse oikea tietokanta muutukaan.\n\nMutta eikö olisikin kätevää, jos funktiolle kerrottaisiin missä päin muistia tietokanta majailee? Tämän osoitteen avulla se voisi muutta itse tietokantaa. Tällöin tietokantaa ei tarvitsisi siirtääkään minnekään. Mikähän se mahtaisi olla semmoinen vempele joka tämän tempun osaisi..\n\nLöpinät sikseen ja viittaukset esille! Viittaus (reference) on muuttuja, joka kertoo jonkun toisen muuttujan sijainnin muistissa. Viittaus ei siis sisällä sitä arvoa mikä muuttujalla on, vaan muuttujan muistipaikan osoitteen. Viittauksen tyyppi on sen muuttujan tyyppi, mihin viittaus viittaa. &-merkki kuitenkin tarkoittaa, että nyt olemme luomassa viittausta, emme \"oikeaa\" muuttujaa.\n > #include<iostream.h> int main() { int muuttuja = 2; // muuttuja int& rViittaus = muuttuja; // viittaus cout << \"muuttuja on \" << muuttuja << endl; cout << \"rViittaus on \" << rViittaus << endl; muuttuja = 5; cout << \"muuttuja on \" << muuttuja << endl; cout << \"rViittaus on \" << rViittaus << endl; rViittaus = 2; cout << \"muuttuja on \" << muuttuja << endl; cout << \"rViittaus on \" << rViittaus << endl; return EXIT_SUCCESS; }\n\nKuten huomaat, viittausta käytetään ihan kuin muuttujaakin. Viittauksen osoitetta ei voi käsitellä sen luonnin jälkeen. Viittaus alustetaan jonkun muuttujan osoitteella ja se säilyttää arvonsa niin kauan kun se on olemassa.\n\nKun haluamme laittaa viittauksen funktion parametriksi, merkkaamme sen viittaukseksi &-operaattorilla ja käytämme sitä muuten kuten normaalia muuttujaakin. Tällä kertaa vaan muutamme alkuperäistä muuttujaa, emme sen kopioita. Näin se käy käytännössä:\n > #include<iostream.h> void Kasvata(int& luku) { luku++; } int main() { int arvo = 5; cout << \"arvo: \" << arvo << endl; Kasvata(arvo); cout << \"arvo: \" << arvo << endl; return EXIT_SUCCESS; }\n\nViittauksilla on kuitenkin yksi huono puoli: ne viittaavat samaan muuttujaan. Monissa asioissa, kuten linkitetyissä listoissa, tarvitaan viittausta, jonka kohdetta voidaan vaihtaa. Sellainen on osoitin.\n # Osoittimet\n\nOn oikeastaan väärin sanoa, että osoitin on viittaus, joka on hieman monipuolisempi. Pikemminkin viittaus on osoitin, josta on karsittu epäturvallisia ominaisuuksia. Osoittimien etu on siinä, että niiden oikeaa arvoa, siis itse osoitetta, voi käsitellä. Toisaalta se on niiden haittakin: osoitin joka osoittaa väärään paikkaan muistia on melkoinen aikapommi. Osoittimien käyttäminen on myös paljon hankalampaa, koska niiden kielioppi on monimutkaisempi.\n\nOsoitin (pointer), kuten viittauskin, osoittaa johonkin muuttujaan. Sen tyyppi on sama kuin osoitetulla kohteella. Erona kuitenkin osoittimet merkitään *-merkillä. Se on sama kuin kertomerkki, mutta asiayhteydestä voidaan aina päätellä kumpi operaattori on kyseessä. Otetaan ja sorvataan nyt osoitin.\n > int muuttuja; // muuttuja int* pOsoitin = 0; // osoitin pOsoitin = &muuttuja // muuttujan osoite osoittimeen\n\nAluksi luodaan ihan normaali muuttuja. Sitten luodaan osoitin int-tyyppiseen tietoon, nimeltään pOsoitin ja alustetaan se nollaksi. Osoitin ei siis osoita mihinkään muistissa olevaan nollaan, vaan se osoittaa muistin kohtaan nolla. Silloin se on NULL-osoitin. Jos emme alustaisi osoitinta, se voisi osoittaa ihan mihin tahansa ja käytettäessä sitä kirjoittaisimme ihan minne tahansa ja sillä tavalla sotkisimme kaiken perinpohjaisesti. Kun alustamme osoittimen nollalla, se on vaarattomampi jos erehdymme sitä alustamattomana käyttämään.\n\nSitten marssitamme esiin uuden operaattorin. Se on osoite-operaattori, &. Sillä saadaan muuttujan osoite kaivettua esille. Tämä osoite tallennetaan sitten osoitinmuuttujaan.\n\nOsoittimien käyttö on hieman monimutkaisempaa kuin viittauksien. Itse osoitinmuuttujan arvo on muistiosoite. Kun haluamme päästä käsiksi siinä muistiosoitteessa sijaitsevaan tietoon, meidän tulee käyttää osoitus-operaattoria, *.\n > int eka, toka; // kaksi muuttujaa eka = 10; // alustetaan eka int* pOsoitin = 0; // luodaan osoitin pOsoitin = &eka; // pOsoitin osoittaa ekaan toka = *pOsoitin; // toka sisältää arvon 10 cout << toka; // varmistetaan\n\nKuten arvaat, osoitteiden ja osoitettujen tietojen kanssa menee helposti sekaisin. Niinpä kannattaakin käyttää viittauksia aina kuin mahdollista. Joskus kuitenkin pitää pystyä vaihtamaan osoituksen kohdetta, jolloin viittaukset eivät riitä.\n > int yy, kaa, koo; yy = 1; kaa = 2; koo = 3; int* pMonesko = 0; pMonesko = &yy; cout << *pMonesko; pMonesko = &kaa; cout << *pMonesko; pMonesko = &koo; cout << *pMonesko;\n # Salattu totuus taulukoista ja moninkertaisista osoittimista\n\nOppipoikani/tyttöni, olet jo edennyt pitkälle ja Voima on sinussa vahva. Ehkäpä tässä vaiheessa on oikea aika kertoa sinulle totuus - totuus taulukoista.\n\nTaulukko ei todellisuudessa ole kuin osoitin. Kyllä, ymmärrän, se voi tuntua vaikealta hyväksyä. Mutta minäpä kerron tarkemmin. Taulukon nimi itseasiassa on vain osoitin taulukon ensimmäiseen alkioon. Taulukko-operaattori [] toimii siis samoin kuin osoite-operaattori *. Merkintä taulukko[5] voidaan tulkita myös *(taulukko+5). Siis otamme taulukon osoitteen ja lisäämme siihen viisi kertaa taulukon yhden alkion koon. Ei siis viisi tavua, vaan viisi kertaa taulukon alkion koon verran - oli koko sitten mikä tahansa. Kääntäjä hoitaa tämän laskutoimituksen. Jos halutaan taulukon kymmenennen (eli indeksiss� yhdeks�n olevan) alkion osoite, voidaan se tehdä perinteisesti &taulukko[9] tai gurummin taulukko+9. Ja hoplaa, nyt ymmärrät myös miksi taulukon ensimmäinen alkio on 0, eikä yksi. Koska taulukon nimi osoittaa jo ensimmäiseen alkioon, ei siihen pidä lisätä mitään - siis pitää lisätä 0 - jotta saadaan eka alkio hyppysiimme.\n\nToki vielä pitemmälle voidaan mennä ja luoda taulukollinen osoittimia. Se tapahtuu tyyliin\n > int* taulukko[10];\n\nNyt siis jokainen taulukon alkio osoittaa johonkin int-muuttujaan. Sijoitus taulukko[2]=3; ei ole todellakaan laillinen, koska silloin taulukko[2] osoittaa muistin kohtaan kolme, jossa on mitä sattuu. Kun sitä käytetään, on kaikki totaalisen sekaisin. Nyt seuraakin pähkinä: miten saataisiin kyseisen taulukon ensimmäisen alkion osoittama tieto esille? No, tietenkin näin: *taulukko[0]. Mutta myös tämmöinen on mahdollista: **taulukko. Ja mikä hienointa, tämä esimerkki ei ole teennäinen tai hatusta vedetty. Jos haluamme luoda taulukollisen vanhanaikaisia C-tyylisiä merkkijonoja - esimerkiksi kaikkien veljien nimet - niin tarvitsemme tuota **taulukko (tai *taulukko[]) osoitinta, siis osoitinta osoittimeen (kutsutaan myös kaksoisosoittimeksi tai tuplapointteriksi). Myös kun haluamme tehdä matriisia vastaavan taulukon, tarvitsemme osoitinta osoittimeen. Matriisi on kaksiulotteinen taulukko, siis esimerkiksi kuvapisteet ruudulla muodostavat eräänlaisen matriisin. Se voitaisiin tietenkin tehdä tavallisena kaksiulotteisena taulukkona (matriisi[][]), mutta \"kaksoisosoittimen\" käytössä on etunsa - ne ovat nopeampia ja joustavampia. Eikä osoitinhommailu rajoitu kaksoisosoittimeen, vaan voidaan tehdä myös osoitin osoittimen osoittimeen jne.. Käytännössä kaksinkertainen osoitin on suurin mitä tarvitaan. Mutta pitäähän sitä elämässä olla leikkiä, kuten alla olevassa esimerkissä:\n > #include <iostream.h> int main() { int a = 5; int *p = &a; int **pp = &p; int ***ppp = &pp; int ****pppp = &ppp; int *****ppppp = &pppp; cout << \"a on \" << *****ppppp << endl; return EXIT_SUCCESS; }\n # Kun viittaillaan, osoitellaan ja tökitään miten sattuu\n\nEn päästä sinua kuitenkaan ihan näin helpolla, vaan tähän kohti lykätään vielä iso kasa hankalia viittaus- ja osoitustemppuja, jotta varmasti olet hahmottanut tilanteen.\n > #include <iostream.h> int main() { int luku = 2; int &viittaus = luku; int &toinenViittaus = viittaus; // int &toinenViittaus = luku; int *osoitin = &viittaus; // int *osoitin = &luku; cout << \"Arvo osoittimen kautta \" << *osoitin << endl; int *(&viittausOsoittimeen) = osoitin; // int *(viittausOsoittimeen) = &luku; cout << \"Viittaus osoittimeen \" << *viittausOsoittimeen << endl; int taulukko[5] = {1, 2, 3, 4, 5}; int (&viittausTaulukkoon)[] = taulukko; for (int i = 0; i < 5; i++) cout << viittausTaulukkoon[i] << \" \"; const int &vakioViittaus = 3; return EXIT_SUCCESS; }\n # Osoittimet funktioihin\n\nJoo, myös funktioihin voi osoittimilla sohia. Vaan miksi pitäisi? Eikö sitä voi aina vaikka switch..case -rakenteella päättää mitä funktiota käytetään? Voi, mutta se on epäkätevää - millä sinänsä ei ole väliä - mutta myös koodin kopioimista! Härrendüdel, se on jo jotain.\n\nKuvitellaan vaikka tällainen vanhentunut esimerkki, että joku ohjelma tukee rautatasolla satoja näytönohjaimia. Eihän näin nykyään ole, kun on standardia vaikka millaista. Nykyään voisi vaikka ajatella, että ohjelma tukee kaikkia mahdollisia standardeja: Glide, OpenGl, GDI, DirectX... Pysytään nyt kuitenkin menneisyydessä: ohjelma käyttää näytönohjainkohtaisia funktioita näytön käsittelyyn: pikselin piirtoon jne.. Funktiot on kirjoitettu kymmenien eri ihmisten toimesta - eihän kenelläkään ole kymmeniä näytönohjaimia koneessaan millä testata funktioita. Funktiot ovat kaikki samanlaisia prototyypiltään, ainoastaan sisältö on erilainen. Pikselinpiirton käytetty funktio voisi vaikka olla tällainen:\n\nint putPixel(int x, int y, char* buffer);\n\nKutsuessa funktiota pitäisi siis valita kymmenistä erilaisista putPixeleistä. Tulee melkoinen kasa switcheja ja vielä lohduttomampi viidakko caseja, kun näytönkäsittelyyn liittyviä kohtia on kuitenkin useissa kohdissa ohjelmaa. Ei, ei tuohon kelkkaan kannata kivuta. Nuoruus vaan menee pilalle kun näpyttelee kymmeniä kertoja samoja rivejä tietokoneen näyttöpäätteellä. Ja sitten jos rupeaa leikepöydän kauttaa niitä viljelemään, niin mielenterveys tärväytyy virheitä etsiessä. Kyllä se menee ihan selvästi funktiopointteriksi. Sellainen muuten määriteltäisiin edellisessä esimerkissä näin:\n > int (*pPutPixel)(int, int, char*);\n\nEli ihan kuin tavallinen funktio, * vaan nimen eteen merkkaamaan osoitinta. Eipä liene yllätys kenellekään. Sulkujen kanssa ei kuitenkaan pidä mennä hökeltämään, nimittäin tällaisessa muodossa juttu ei mene läpi:\n > int *pPutPixel(int, int, char*);\n\nJuksasin, kyllä se läpi menee. Ei vaan tosin toimi. Kun sulkeilla ei viestitä, että * liittyy funktion nimeen, se tulkitaan liittyväksi int:iin. Siis yllä oleva on funktio, joka palauttaa osoittimen int-tietoon - ei funktio-osoitin funktioon, joka palauttaa int-muuttujan.\n\nJos palaamme taas esimerkkiin. Meidän tulee vain kerran valita oikea grafiikkafunktio, kas näin:\n > int (*pPutPixel)(int, int, char*); switch (naytonOhjain) { case STANDARD_SVGA: pPutPixel = SvgaPutPixel; break; case ET4000: pPutPixel = Et4000PutPixel; break; case CIRRUS: pPutPixel = CirrusPutPixel; break; } pPutPixel(100, 100, puskuri); (*pPutPixel)(100, 100, puskuri);\n\nKuten huomaat, sijoitus funktio-osoittimeen tapahtuu käyttämällä funktion nimeä ilman sulkeita. Kaikki PutPixel-funktiot palauttavat int-muuttujan ja ottavat parametreikseen (int, int, char*). Funktio-osoittimen avulla kutsutaan funktiota kuten se olisi tavallinen funktio. Myös osoitinoperaattoria voidaan käyttää, kuten viimeisellä rivillä on tehty. Tavalla ei ole väliä; kaksi viimeistä riviä tekevät saman asian.\n\nFunktio-osoittimia voi myös kätevästi kasata taulukoksi. Jos esimerkiksi pitää ohjelmoida joku toimintosarja, jonka ohjelma suorittaa, voi funktio-osoitintaulukko olla näpsäkkä ratkaisu. Varsinkin kun kyse on nopeudesta osoittimet puolustavat kyllä paikkaansa. Monimutkaiset valintarakenteet ovat hitaita, mutta osoittimet vain aavistuksen tai ei yhtään hitaampia kuin suora käyttö.\n # Funktio-osoitintaulukot ja funktio-osoittimet parametreina\n\nFunktio-osoitintaulukon määrittelemisessä ei ole mitään erikoista. Kunhan muistaa, että osoittimen nimi on sen kaiken muun sotkun keskellä: siis taulukoinnin tapauksessa hakasulkeet tulevat nimen perään, ei koko litanian perään. Ja sulkeita ei myöskään kannata unohtaa.\n > void (*pFunktioTaulukko[5])(int, int);\n\nFunktiopointteri kulkee myös mukavasti parametrina. Funktion prototyypissä voidaan laittaa näin:\n > void Funktio(int (*) (int, int));\n\n..jos ei haluta antaa parametrille nimeä siinä vaiheessa. Myös nimi voidaan antaa, mikä on pakko tehdä viimeistään funktion runkoa määritellessä:\n > void Funktio(int (*pFunktio) (int, int)) { pFunktio(1, 2); // kutsutaan osoitettua funktiota }\n\nNäissä vähän kehittyneemmissä jutuissa funktio-osoittimeen liittyvän litanian kirjoittaminen meinaa olla harmittavan hankalaa. Niinpä kannattaakin ottaa tyypin määrittely (typedef) käyttöön:\n > typedef int (*IPF) (int, int); IPF pFunktio; void Funktio(IPF);\n\nMääritellään siis IPF (paluuarvo Int, Pointer to Function), jonka avulla tehdään yksi funktio-osoitin ja funktio, joka ottaa parametrikseen sen tyyppisen funktio-osoittimen.\n\nTervetuloa t�m�n oppaan ehdottomasti t�rkeimm�n osion pariin. Kuten ehk� oletkin jo huomannut, rakastan suuresti k�yt�nn�n tilanteiden pohtimista C++:n avulla. Ja niit� on tulossa viel� paljon lis��, joten ei auta kuin tottua. Nyt menn��n taas: Koska vartiointifirma Pamppu ja sateenvarjo oy:lle tekem�si ohjelma toimi loistavasti ja moitteettomasti, p��tt�v�t he tilata sinulta toisenkin ohjelman. Ohjelman pit�isi yll�pit�� heid�n asiakasluetteloaan. Jokaisella asiakkaalla on tietoina nimi, osoite, sovittu kuukausimaksu jne..\n\nKuinka t�llainen tietom��r� pit�isi j�rjest��? No, hommahan on helppo. Tehd��n taulukko nimi[ASIAKKAIDEN_LKM], maksu[ASIAKKAIDEN_LKM] jne.. N�in se onnistuisi ihan perusominaisuuksien avulla. Mutta mites suu pannaan, kun noin puolet asiakkaista haluaa y�vartioinnin ja toinen puoli ei? Kaiken kukkuraksi y�vartijoiden m��r� vaihtelee. Yksi ratkaisu on tehd� taulukko yovartijat[ASIAKKAIDEN_LKM] ja olla v�litt�m�tt� siit�, ett� osa alkioista on tyhji� ja turhia. Jos ei viel� hymy hyydy, lis��mme soppaan sen, ett� ohjelman pit�isi pysty� lis��m��n ja poistamaan asiakkaita lennossa. Ohjelmaa py�ritt�� vanha 386-kone, jossa on v�h�n muistia ja tehoa. Niinp� muistia tai koneen prosessoriaikaa ei saisi hukata ollenkaan.\n\nKuulen jo kuinka huudatte edellisen esimerkin ikeen alla: \"Me haluamme olioita ja luokkia! Tahtoo!\" Hyv� on, nyt niit� tulee. Pient� jaarittelua kuitenkin viel�.\n\nLapsikin huomaa, ett� edellisen esimerkkiongelman ratkaisu taulukoilla ontuu. Asiakas olisi parempi pit�� omana kokonaisuutenaan, ei vain yhten� indeksin� moniin taulukoihin. Pelkill� taulukoilla ja isolla kasalla purkkavirititelmi� edellisen tapauksen voi kyll� hoitaa muistia ja tehoa haaskaamatta, mutta tulos on sellainen ohjelmanv�nkyr�, jota kukaan ei vapaaehtoisesti kyll� ala en�� kehitt�m��n. Niinp� k�sittelemmekin nyt luokat (class) ja oliot (object). T�m� on nyt vihdoinkin sit� C++:aa itse��n. C++ on oliopohjainen kieli, joten ilman olioita ei pitk�lle p�tki. Toki C++:lla voi ohjelmoida ilmankin olioita, mutta harvemmin syyt� sellaiseen on..\n\nAjatellaan nyt n�in p�in, ett� kaikkia asiakkaan tietoja ei laiteta taulukkoon, vaan ne s�il�t��n asiakkaaseen, ja sitten tehd��n asiakkaista taulukko. Me tarvitsemme asiakasolioita. Koska kaikki asiakkaat ovat samanlaisia, sit� y�vahtijuttua lukuunottamatta, ne ovat samoja olioita. Niill� on samat ominaisuudet, mutta eri tiedot. Samanlaiset oliot kuuluvat samaan luokkaan. Nyt otamme ja m��rittelemme luokan Asiakas.\n > class Asiakas { public: char* nimi; char* osoite; int kuukausiMaksu; }; // huomaa ; -merkki lohkon lopussa!!!\n\nEnsin on varattu sanan class. Sitten seuraa luokan nimi. Sitten alkaa lohko, jossa luokka m��ritell��n. public tarkoittaa, ett� alla olevat muuttujat ovat kaikkien k�yt�ss�. TSM. Sen j�lkeen homma on tuttua, m��rittelemme vain Asiakkaaseen liittyv�t muuttujat. Lohko loppuu ja sitten tulee taas penteleen t�rke� kohta, nimitt�in puolipiste lohkon lopussa. Muista se! Lohkojen loppuun ei muuten tule C++:ssa puolipistett�, mutta luokan m��rittely on (mielest�ni typer�) poikkeus.\n\nKun haluamme luoda asiakkaan, k�y se n�in (kunhan luokka on ensin m��ritelty):\n > Asiakas erkinKumikorjaamo;\n\nLuomme olion erkinKumikorjaamo. Asiakas on itseasiassa kuin mik� tahansa muuttujatyyppi. Voi tehd� Asiakas-taulukoita ja muiden luokkien j�senen� voi olla Asiakas-olioita. Palataksemme esimerkkiin, teemme n�in:\n > Asiakas asiakkaat[ASIAKKAIDEN_LKM];\n\nLuomme siis taulukon asiakkaat, joka sis�lt�� ASIAKKAIDEN_LKM (vakio) kappaletta Asiakas-luokan olioita. Olion sis�lt�mi� muuttujia k�ytet��n piste-operaattorin avulla. Siis olionNimi.muuttuja.\n > Asiakas kalevinKukkakauppa; kalevinKukkakauppa.kuukausiMaksu = 150; // Kalevi maksaa 150 mk kuukaudessa\n\nOn t�rke�t� hahmottaa luokan ja olion ero. Luokka on kuin muotti. Se kertoo mit� ominaisuuksia olioilla on. Olio on taas yksi sill� muotilla tehty piparkakku. Sill� on luokan ominaisuudet, siis muuttujat, mutta niiss� omat arvonsa.\n\nT�m� ei kuitenkaan ratkaise esimerkkimme kahta ongelmaa, y�vahtiasian eroavaisuutta ja asiakkaiden alati muuttuvaa lukum��r��. N�ihin asioihin tarvitaan kuitenkin osoittimia, dynaamista muistinhallintaa ja perint��. Ennen niit� sinun pit�� kuitenkin oppia luokkien perusteet, joten niit� ensin.\n\nLuokka on muutakin kuin pelkk� kasa muuttujia. Luokkaan saa nimitt�in j�senfunktioita eli metodeja. Niiden kautta luokan olioita k�ytet��n. Seuraa lastenmielinen esimerkkiohjelma:\n > #include<iostream.h> class Veturi { public: int nopeus; void Puhu(); }; void Veturi::Puhu() { cout << \"Tuut! Tuut! Hurjastelen \" << nopeus << \" km/h nopeutta!\"; } int main() { Veturi villeVeturi; villeVeturi.nopeus = 50; villeVeturi.Puhu(); return EXIT_SUCCESS; }\n # Olio on tiedot ja toiminnallisuus\n\nKeksitk� mit��n muuta tapaa toteuttaa Veturia matkiva ohjelma? On nimitt�in olemassa toinenkin vaihtoehto... Etk�? Eritt�in hyv�, koska se toinen vaihtoehto on v��r� ja tuo yll� esitetty oikea. Mietip�s mill� tavalla alla oleva muunnelma Veturista on huonompi:\n > #include<iostream.h> class Veturi { public: int nopeus; }; void Puhu(Veturi veturi) { cout << \"Tuut! Tuut! Hurjastelen \" << veturi.nopeus << \" km/h nopeutta!\"; } int main() { Veturi villeVeturi; villeVeturi.nopeus = 50; Puhu(villeVeturi); return EXIT_SUCCESS; }\n\nVarmasti mieleesi tulee ainakin, ett� j�lkimm�inen vaihtoehto on ep�looginen. Kun vertaamme puhumista, on villeVeturi.Puhu() eritt�in looginen, sen voisi k��nt�� selkokieliseksi k�skyksi: \"Ville Veturi! Puhu!\". Puhu(villeVeturi) taas voisi vastata suomen kielen lausetta: \"Suorita puheoperaatio Ville Veturilla\". Kuulostaa v�h�n KELA:n lomakkeen t�ytt�ohjeilta...\n\nKuten huomaat, kun ohjelman metodit (j�senfunktiot) sijoitetaan samaan luokkaan ohjelman tietojen kanssa, saavutetaan kaksi etua: ohjelma vaikuttaa loogiselta eli on sellainen kuin terveell� maalaisj�rjell� sen kuvittelisi olevan, ja sen lis�ksi ohjelman l�hdekoodi on selke�mp��. Minusta ainakin veturin antaminen Puhu()-funktioille on hankalaa verrattuna luokan sis�ll� toteutettuun puhumiseen, jossa vastaavaa hankaluutta ei tarvitse tehd� - ollaanhan jo valmiiksi oikean olion \"sis�ll�\" (tuolle \"sis�ll� olemiselle\" on my�s teknisempi m��ritelm�, mihin palaamme my�hemmin). Ja nytp� olemmekin tunkeutuneet C++-ohjelmoinnin, ja olio-ohjelmoinnin yleens�, kaikkein pyhimp��n. Olio-ohjelmointi on sit�, ett� tiedot (muuttujat) ja toiminnallisuus (metodit) ovat yhdess�. Kaikki mit� t�m�n j�lkeen kerron ei ole l�hellek��n yht� t�rke�� kuin tuo edellinen havainto.\n\nOLIO = TIEDOT + TOIMINNALLISUUS\n\nHaluaisin viel� lis�t�, ett� tiedon ja toiminnallisuuden yhdist�minen ei ole pelk�st��n loogista, vaan johtaa parempiin ohjelmiin. Kun luokkaan on paketoitu sek� tiedot ett� toiminnot, syntyy \"musta laatikko\". Luokan k�ytt�j�n ei tarvitse v�litt�� siit� miten luokka itseasiassa toimii, kunhan se toimii oikein. Ohjelmoidessa voi hyvinkin tuntua, ett� p��n sis�ll� on menossa italialaisen talonyhti�n kokous, siis kaaos. Juuri t�t� varten olio-ohjelmoinnissa koitetaan piilottaa kaikki turha, joka muuten kuluttaisi ohjelmoijan kallista mutta v�h�ist� (?) aivokapasiteettia.\n # Tiedon kapselointi\n\nTiedon kapselointi. Armottomana ihmisen� iskin sinua suoraan p�in kasvoja yhdell� hyvin t�rke�ll� oliopohjaisen ajattelun termill�. Viel� uudestaan: tiedon kapselointi. Idea on, ett� jokaiseen k�sitteeseen liittyv�t tiedot on kapseloitu siihen k�sitteeseen (olioon), eiv�tk� muut p��se niit� sorkkimaan. Tiedon kapselointi! Edellisess� esimerkiss� tietoa ei oltu kapseloitu, vaan se roikkui villin vapaana kuin Kemppaisen kolli kes�housuissaan.\n\nJos mietit edellista esimerkki�, niin huomaat ett� kuka tahansa p��see sorkkimaan luokan muuttujia. Mit� kapselointia ja suojaamista se on muka olevinaan? Nyt konkari vet�� takataskustaan taika-avaimen, nimitt�in varatun sanan private. private on publicin kaveri. Kun public m��rittelee julkisia j�senmuuttujia ja funktioita, niin private m��rittelee yksityisi�. Julkiset muodostavat olion k�ytt�liittym�n, tavan jolla muut ohjelman osat kommunikoivat olion kanssa. Yksityiset osat muodostavat luokan sis�isen toiminnan. Ne ovat muuttujia ja funktioita, joita luokka tarvitsee omaan sis�iseen toimintaansa ja joita ulkopuoliset eiv�t p��se sotkemaan. Yksityiseksi m��ritelty� tietoa voivat k�ytt�� vain luokan omat metodit, j�senmuuttujat. Luokan j�senet ovat oletuksena yksityisi�.\n\nEsittelemme nyt lis�� h�yrykoneiden kauhuja.\n > #include<iostream.h> const int MAX_NOPEUS = 180; class Veturi { public: void AsetaNopeus(int n); void Kiihdyta(); void Jarruta(); int LueMittari(); // nk. saantifunktio private: int nopeus; }; void Veturi::AsetaNopeus(int n) { nopeus = n; } void Veturi::Kiihdyta() { nopeus += 20; if (nopeus > MAX_NOPEUS) nopeus = MAX_NOPEUS; } void Veturi::Jarruta() { nopeus -= 20; if (nopeus < 0) nopeus = 0; } int Veturi::LueMittari() { return nopeus; } int main() { Veturi villeVeturi; villeVeturi.AsetaNopeus(0); villeVeturi.Kiihdyta(); villeVeturi.Kiihdyta(); cout << \"Nopeutta \" << villeVeturi.LueMittari() << \" km/h!\" << endl; villeVeturi.Jarruta(); cout << \"Nopeutta \" << villeVeturi.LueMittari() << \" km/h!\" << endl; // villeVeturi.nopeus = 50; return EXIT_SUCCESS; }\n\nVeturi osaa muuttaa nopeuttaan ja ilmoittaa sen. Nopeus asetetaan nollaksi olion luonnin yhteydess�. Ensin veturi kiihdytet��n 40 km/h nopeuteen ja nopeus tulostetaan. Sitten jarrutetaan ja nopeus ilmoitetaan uudestaan. Huomaa viimeisell� rivill� oleva viittaus yksityiseen muuttujaan. Jos sit� ei olisi kommentoitu, se ei olisi mennyt k��nt�j�st� l�pi. Yksityinen tieto ei ole ulkopuolisten k�ytett�viss�.\n\nNopeus on varma muuttuja. Jarruta() ja Kaasuta() metodit valvovat tehokkaasti nopeuden k�ytt��. Jos pelk��t, ett� muuttujien k�ytt� erillisten funktioiden kautta hidastaa ohjelmaa, niin h�ps�n p�ps�n. Hyv� k��nt�j� optimoi saantifunktiot olemattomiin. Huomaa kohta: k��nt�j� optimoi. Samalla k��nt�j� tarkistaa tietotyypit. Eli k��nt�j� tekee enemm�n ty�t�, mutta lopputulos (konekielinen ohjelma) on sama. Metodin AsetaNopeus(int) avulla nopeuden voi kuitenkin sotkea pahanp�iv�isesti. Ihannetilanne olisi semmoinen, jossa luokan k�ytt�j� ei pystyisi sotkemaan ollenkaan luokan j�senmuuttujien arvoja. Kun kirjoittaa v�h�n pitempi� ja monimutkaisempia ohjelmia, jaksaa t�llaist� ominaisuutta kyll� arvostaa... Niinp� pit�isi olla joku kikka, jolla nopeus voitaisiin alustaa olion luonnin yhteydess� ja AsetaNopeus(int) metodi tulisi tarpeettomaksi... n�en horisontissa h��m�tt�v�n aasinsillan...\n # Muodostin- ja tuhoajafunktiot\n\nUsein oliota luodessa t�ytyy tehd� jotain toimia, kuten varata muistia luokan tiedoille. Ei kannata j�tt�� luokan k�ytt�j�n vastuulle kutsua homman hoitavaa funktiota, vaan k�ytt�� luokkaan liittyv�� muodostinfunktiota (constructor). Kun luokka luodaan, luo k��nt�j� sille automaattisesti muodostinfunktion - joka ei tee mit��n. Jos haluamme laittaa jotain toimia luokan tyyppisen olion luonnin yhteyteen, voimme korvata muodostinfuktion omallamme. Muodostinfunktion nimi on luokan nimi ja sill� ei ole paluuarvoa. Muodostinfunktio pit�� tietenkin m��ritell� julkiseksi.\n > #include<iostream.h> class Auto { public: Auto(); // muodostin }; Auto::Auto() { cout << \"Muodostinta kutsuttu\"; } int main() { Auto lada; return EXIT_SUCCESS; }\n\nMuodostinfunktiolle voi my�s v�litt�� parametrej� ja siit� voi kirjoittaa monta erilaista versiota eri parametreill� - polymorfismi siis toimii t�ss�kin suhteessa. Muodostinfunktion parina toimii tuhoajafunktio (destructor). Sit� kutsutaan kun olio tuhotaan. Sen m��rittely on muuten vastaava, mutta funktion nimi alkaa ~ (tilde, mato)-merkill�. Jos m��rittelet oman muodostinfunktion, niin k��nt�j� j�tt�� oman tyhj�n muodostimensa m��rittelem�tt�. Siis jos m��rittelet yhden int-parametrin ottavan muodostimen, ei luokkaa voida en�� luoda ilman parametrej�, koska tyhj� parametriton muodostin j�� m��rittelem�tt�.\n\nRakennamme nyt luokan, jota voidaan k�ytt�� hyvin yksinkertaiseen tiedon kryptaamiseen, siis salaamiseen. Siin� on taulukollinen unsigned char muuttujia. Taulukko varataan dynaamisesti (dynaamisesta varauksesta kerron tarkemmin sitten my�hemmin), sen koko annetaan oliota luodessa. Jos kokoa ei anneta, k�ytet��n oletuskokoa. Tietenkin varattu muisti vapautetaan kun olio lakkaa olemasta. Itse kryptausosa on mukana l�hinn� aidon tunnelman saavuttamiseksi.\n > const int OLETUS_KOKO = 256; class KryptattuTaulukko { public: KryptattuTaulukko(); KryptattuTaulukko(int koko); ~KryptattuTaulukko(); void Koodaa(); unsigned char *taulukko; int taulukonKoko; }; KryptattuTaulukko::KryptattuTaulukko() { taulukko = new unsigned char[OLETUS_KOKO]; // varataan muisti taulukonKoko = OLETUS_KOKO; } KryptattuTaulukko::KryptattuTaulukko(int koko) { taulukko = new unsigned char[koko]; // varataan muisti taulukonKoko = koko; } KryptattuTaulukko::~KryptattuTaulukko() { delete [] taulukko; // vapautetaan muisti } void KryptattuTaulukko::Koodaa() { for (int i=0; i < taulukonKoko; i++) taulukko[i] = 255 ^ taulukko[i]; // py�r�ytet��n bitit ymp�ri }\n\nPari puutetta viel� yll� olevan ohjelman rakenteessa on, mutta ne eiv�t ole niin oleellisi� - viel�.\n\nMuodostinfunktiossa muuttujien alustus voidaan hoitaa my�s itse funktion rungon ulkopuolella, t�h�n tyyliin:\n > KryptattuTaulukko::KryptattuTaulukko() : taulukonKoko(OLETUS_KOKO) { taulukko = new unsigned char[OLETUS_KOKO]; }\n\nSiis muodostinfunktion nimen j�lkeen kaksoispiste, sitten muuttujien alustus. Muuttujan arvo annetaan suluissa, muuttujan nimen per�ss�. T�m� tapa on suositeltavampi kuin muodostinfunktion rungossa muuttujien alustaminen. Yll� oleva funktio on karsea esimerkki muodostinfunktiosta. Koska muodostinfunktio ei palauta arvoa, se ei voi viesti� onnistumisesta mitenk��n. Ja koska se varaa muistia, voi ongelmiakin tulla. Muodostinfunktiossa ei saa tehd� mit��n, mik� voi ep�onnistua (muistin varaus, tiedostojen avaus jne...). Joten luokan kehittely jatkuu, kunhan vaan ved�mme operaattorit ensin k�ytt��n.\n # Operaattoreiden ylikuormittaminen\n\nMik�li et ole viel� tutustunut String-luokkaan, niin kertoilenpa siit� t�ss� aluksi. Merkkijonojen ja String-luokan k�ytt� on tarkemmin esitelty standardikirjastojen yhteydess�. String luokka on kuin yhdistetty luokka ja taulukko. Toisaalta sill� on muodostin- ja tuhoajafunktiot, mutta toisaalta sit� voi k�ytt�� indeksointioperaattorilla kuin tavallista taulukkoa. Siis String-luokan olioita voi k�ytt�� n�in: merkkijono[3]. T�m� palauttaa merkkijonon nelj�nnen merkin. Vaikka String onkin k��nt�j�n mukana tuleva, ei siihen kuitenkaan liity mit��n maagisia, kuolevaisille saavuttamattomia temppuja. Pelk�st��n operaattoreiden ylikuormittamista, mik� kyll� tavallisille kuolevaisille voi vaikuttaa mystisten voimien ty�lt� - mutta ei C++-velholle!\n\nKun k��nt�j�n pit�� k�sitell� +-operaattori kahden int-luvun yhteydess�, ei se ole mik��n ongelma. Kai nyt jokainen pari lukua osaa yhteen ynn�t�. Mutta ent� jos k��nt�j�� k�sket��n ynn��m��n kaksi itse ohjelmoidun Tyontekija-luokan oliota? K��nt�j� ei tunne luokan ominaisuuksia, joten ainoa heti mieleen tuleva ratkaisu olisi laskea olioiden muistiosoitteet yhteen. Ratkaisu onkin mahdollinen, mutta j�rjeton. Muistiosoitteella ei ole mit��n tekemist� luokan toiminnan kanssa ja tulos osoittaisi mihin sattuu. Parempi vaihtoehto olisi vaikka laskea yhteen ty�ntekij�iden palkat. N�in �lyk�st� toimintaa emme kuitenkaan C++-k��nt�j�lt� voi odottaa, vaan meid�n pit�� se itse ohjelmoida.\n\nEnsimm�inen ratkaisu olisi tehd� Tyontekija-luokkaan metodi Lisaa(Tyontekija&). Lisays tehtaisiin nain:\n > Tyontekija jamppa; Tyontekija jomppa; palkatYhteensa = jomppa.Lisaa(jamppa);\n\nTuo ei kuitenkaan ole hirve�n havainnollinen tapa. Me nimitt�in voimme ohjelmoida Tyontekija-luokkaan +-operaattorin, siis ylikuormittaa +-operaattorin. C++ antaa mahdollisuuden ylikuormittaa seuraavat operaattorit:\n > + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- ->* , -> [] () new delete\n\nYlikuormitettu operaattori on funktio, joka saa operaattorista riippuvat parametrit. Se siis toimii kuin Lisays(Tyontekija&) -funktio toimisi aikaisemmassa esimerkiss�. Operaattorifunktiota voidaan kuitenkin kutsua niin kuin operaatoreita k�ytet��n. Funktio m��ritell��n operator-sanalla. Sen per��n kirjoitetaan haluttu operaattori, siis vaikka operator+. Jotta operaattorit ++olio ja olio++ voitaisiin erottaa toisistaan, m��ritell��n j�lkimm�isempi (postfix-muoto)\n\nint operator(int) {}\n\nSiis se saa int-tyyppisen haamuparametrin, parametrin joka ei sis�ll� mit��n. T�ss�p� sit� on sitten ylikuormitusta kullekin.\n > #include <iostream.h> class Tyontekija { public: void AsetaPalkka(int p) { palkka = p; } int AnnaPalkka() { return palkka; } int operator+(Tyontekija& toinen) { return palkka + toinen.AnnaPalkka(); } private: int palkka; }; int main() { Tyontekija jamppa; jamppa.AsetaPalkka(8000); Tyontekija jomppa; jomppa.AsetaPalkka(12000); cout << \"Kaveruksille pit�� maksaa yhteens� \" << jomppa + jamppa << endl; return EXIT_SUCCESS; }\n\nNyt voimme kirjoittaa kryptatusta taulukosta hienon luokan. Sit� voi k�ytt�� kuin taulukkoa, mutta se on kuitenkin luokka - siis sijoituksien oikeellisuus voidaan tarkistaa, muutamia hienouksia mainitakseni.\n > #include\nconst int OLETUS_KOKO = 256; class KryptattuTaulukko { public: KryptattuTaulukko(int koko = OLETUS_KOKO); // oletusparametri ~KryptattuTaulukko(); int Alusta(); // todellinen muodostinfunktio void Koodaa(); int AnnaKoko() { return taulukonKoko; } int OnkoKoodattu() { return onKoodattu; } int OnkoAlustettu() { return onAlustettu; } int& operator[](unsigned kohta); // voidaan sijoittaa kuin taulukkoon int operator[](unsigned kohta) const; // voidaan lukea kuin taulukkoa void operator=(const int* arvot);// voidaan sijoittaa taulukollinen arvoja private: int onAlustettu; int onKoodattu; int *taulukko; int taulukonKoko; int virhe; // virheelliset viittaukset ohjataan t�nne }; KryptattuTaulukko::KryptattuTaulukko(int koko) : onAlustettu(0), onKoodattu(0), taulukonKoko(koko), virhe(0) { // tyhj� muodostimen runko } int KryptattuTaulukko::Alusta() { taulukko = new int[taulukonKoko]; if (taulukko == 0) return 0; onAlustettu = 1; return 1; } KryptattuTaulukko::~KryptattuTaulukko() { if (onAlustettu) delete [] taulukko; } int& KryptattuTaulukko::operator[](unsigned kohta) { if (onAlustettu) { if (kohta < taulukonKoko) return taulukko[kohta]; // laillinen sijoitus else return virhe; // ylivuoto } else return virhe; // vakion nolla palauttaminen ei olisi mahdollista, koska se ei ole olemassa kuin metodissa } int KryptattuTaulukko::operator[](unsigned kohta) const // unsigned est�� laittomat negatiiviset indeksit { if (onAlustettu) { if (kohta < taulukonKoko) return taulukko[kohta]; else return 0; } else return 0; // ei tarvita viitattavaa kohdetta, joten nolla k�y } void KryptattuTaulukko::operator=(const int* arvot) { // vaarallista, const int* arvot eiv�t v�ltt�m�tt� osoita taulukonKoko kokoiseen muistialueeseen... if (onAlustettu) for (int a = 0; a < taulukonKoko; a++) taulukko[a] = arvot[a]; } void KryptattuTaulukko::Koodaa() { for (int i=0; i < taulukonKoko; i++) taulukko[i] = 255 ^ taulukko[i]; // py�r�ytet��n bitit ymp�ri if (onKoodattu) onKoodattu = 0; // vaihdetaan koodauksen tila else onKoodattu = 1; } int main() { int alkupTaulu[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; KryptattuTaulukko taulu(10); taulu[5] = 5; // ei tee mit��n, koska ei alustettu if (!taulu.Alusta()) return EXIT_FAILURE; // taulukon luonti ep�onnistui taulu = alkupTaulu; // kopioidaan alkupTaulu taulu:n taulu[-1] = 5; // kumpikin laittomia sijoituksia, eiv�t tee mit��n taulu[100] = 5; taulu.Koodaa(); cout << \"Koodattu taulu: \"; for (int a = 0; a < 10; a++) cout << taulu[a] << \" \"; taulu.Koodaa(); cout << endl << \"Koodaamaton taulu: \"; for (int b = 0; b < 10; b++) cout << taulu[b] << \" \"; cout << endl << endl; cout << \"Ensimm�inen alkio on nyt \" << taulu[0] << endl; taulu[0] = 7; cout << \"Sijoituksen j�lkeen se on \" << taulu[0] << endl << endl; cout << \"Tilamuuttujat: koodaus:\" <\n\n# coutin todellinen luonne\n\nItse olen joskus kummastellut: \"C++:ss� on olemassa muuttujia, funktioita, luokkia ja olioita. Mik� ihmeen vetkutin se cout sitten on?\" Vaikka ihan ensimm�isest� ohjelmasta asti olet k�ytt�nyt cini� ja coutia, niin silti niiden olemus lienee hieman ep�selv�.\n\ncin ja cout ovat olioita. Ne ovat iostream.h:ssa (tai sen alaisessa otsikkotiedostossa) valmiiksi m��riteltyj� olioita. Niist� l�ytyy uudelleenm��riteltyn� << tai >> operaattori. Siksi siis kun k�skemme coutia tulostamaan - siis kutsumme sen j�senfunktiota - ei toimenpide vaikuta milt��n funktiokutsulta, vaikka se sit� onkin. Sellaisia peijooneita ne operaattorit ovat, varsinkin uudelleenm��ritellyt. << -operaattorin k�ytt�minen kutsuu todellisuudessa operator<<(...) -funktiota, jonka me alla olevassa esimerkiss� esiinmerkitsemme:\n#include <iostream.h> int main() { int luku = 5; cout << \"Ik�ni on \" << luku << endl; cout.operator<<(\"Ik�ni on \").operator<<(luku).operator<<(endl); return EXIT_SUCCESS; } \nEsimerkin kahden tulostuslauseen tulostama teksti on sama, k�yt�mme funktiokutsun mit� muotoa tahansa. Monien per�kk�isten funktiokutsujen ketjuttaminen onnistuu sen vuoksi, ett� operator<<(...) palauttaa viittauksen coutiin. Siis alku:\ncout.operator<<(\"Ik�ni on \") \n... muuttuu funktiokutsun j�lkeen lausekkeeksi...\ncout \n.. ja sen per��n voi lyk�t� uutta funktiokutsua ihan rauhassa. Kuten ehk� arvasitkin, n�m� pohdinnot ovat kuin hyv� ranskanleip�: ne toimivat my�s toisesta p��st� pureskeltuna - siis sama idea p�tee ciniin, operaattorin nuolet ovat vain toiseen suuntaan.\n\n# Osoitin j�senfunktioon\n\nPiti sitten t�llekin asialle oma kappale kyh�t�. No, nyt on komia paragraafi, niin pit�� sitten jotakin yritt�� t�h�n rustata.\n\nvoid (Luokka::*pFunktio)(int, char);\n\nVoi kehveli, tuohon se nyt lipsahti. Mahtaako sit� en�� mit��n sanoa? Siis * merkkaamaan osoitinta, luokka ja n�kyvyysoperaattori (siis :: ) alkuun. Ja asteriski eli * ennen funktion nime�, ei koko rimpsun alkuun, koska luokalla ei olla osoittelemassa mihink��n.\n\n# Muistinhallinta\n\n# Muistin varaaminen ja vapauttaminen\n\nNyt kannattaisi lukea aluksi Sekalaiset-osiosta kappale muistialueista.\n\nKuten nyt tiedät, pidetään kaikki paikalliset muuttujat pinossa (stack). Paikalliset muuttujat eivät ole kuitenkaan pysyviä, mikä on melkoinen ongelma. Globaalit muuttujat ovat kyllä pysyviä, mutta niitä sää sörkkiä kuka tahansa ja niinpä tiedon kapselointi ei toteudu ollenkaan. Ja vielä samaan hengenvetoon mainittakoon, että pino on melko pieni, joten suurien alueiden säilyttäminen siellä ei ole mahdollista. Sanonpa senkin, että muistia ei voi myöskään kätevästi vapauttaa, joten vähänkään kehittyneempi muistinhallinta ei ole mahdollista. Muistin kulutus kasvaa kuin bensan hinta konsanaan. Mutta meillähän on vapaa muistialue, jota ratkaisee kaikki nämä ongelmat! Joko olet valmis marssimaan dynaamisen muistinhallinnan liehuvan lipun alla?\n\nMuistin varaaminen tehdään new-käskyllä. Muistialuetta ei pidä tietenkään hukata, vaan joku osoitin pitää laittaa osoittamaan sen alkua. Varattu muistialue vapautetaan delete-käskyllä. Sen jälkeen osoitin kannattaa asettaa nollaksi, koska se ei enää osoita mitään aluetta. Jos nollaamaton, satunnaiseen paikkaan osoittava osoitin annetaan deletelle uudestaan, niin tapahtuu kauheita.\n > int *pOsoitin = new int; // luodaan osoitin ja varataan muisti *pOsoitin = 666; // käytetään muistia, * alkuun koska haluamme muuttaa // muistialueen sisältöä, emme osoittimen sisältöä (=osoitetta) delete pOsoitin; // vapautetaan muisti pOsoitin = 0; // varmuuden vuoksi\n # Taulukot ja oliot muistia varaamalla\n\nOmimmillaan muistin varaaminen on suuria tietomääriä - siis yleensä taulukoita - käsitellessä. Taulukon varaaminen tapahtuu antamalla taulukon koko muuttujatyypin yhteydessä. Osoitin osoittaa taulukon ensimmäiseen alkioon, joten delete vapauttaa vain taulukon ensimmäisen alkion. delete [] sen sijaan vapauttaa koko taulukon.\n > int *pTaulukko = new int[800]; pTaulukko[0] = 10; // taulukon ensimmäisen alkion arvon on 10 delete [] pTaulukko; pTaulukko = 0;\n\nNyt ei tarvitse laittaa *-merkkiä osoittimen eteen, koska taulukon kanssa käytettävä []-operaattori ajaa saman asian.\n\nMyös olioita voidaan luoda muistia varaamalla. Kun olioita käyttää, tulee muistaa että käyttää olion osoitinta. Siis olioon viitataan (*pOlio).muuttuja. Tuo on kuitenkin vähän inhottava kirjoittaa, joten on kehitelty mukavampi tapa tehdä sama asia: pOlio->muuttuja.\n > class Hirmu { public: int ika; }; Hirmu *karvainenHirvio = new Hirmu; (*karvainenHirvio).ika = 10; karvainenHirvio->ika = 20; // mukavampi tapa delete karvainenHirvio;\n # Varo vaanivaa vaaraa\n\nKun muistin hallinta ei ole enää niin paljon kääntäjän vastuulla, on paljon enemmän mahdollisuuksia mokata. Ja sinisilmäinen aloittelijahan käyttää jokaisen mahdollisuuden hyväkseen ja oppii kantapään kautta jokaisen sudenkuopan oikein isän kädestä (tässä vaiheessa kai vanha kansa napsii jo nitroja).\n\nKauhein virhe on tietenkin vahingossa muuttaa osoitinta. Kun se osoittaa väärään paikkaan muistialuetta ohjelma kaatuu kuin lonkkavikainen tuhatjalkainen rasvatuissa liukuportaissa. Jos taas muistialue vapautetaan ja sitä yhä käytetään, on tilanne suunnilleen sama. Alueella saattaa olla jo jotain muuta käyttöä ja niinpä sinne kirjoitettaessa meneekin kaikki pahemman kerran sekaisin.\n\nPienempi paha on jos muistia vain hukataan. Ohjelma ei kaadu, mutta kuluttaa muistia turhaan. Esimerkiksi jos käytät jotain osoitinta - joka yhä osoittaa varattuun muistiin - muistin varaukseen uudestaan, jää vanha alue vapauttamatta ja menee hukkaan. Myös jos vapautat taulukon deletellä ilman []-merkkejä, jää taulukko ekaa alkiota lukuunottamatta vapauttamatta ja taas menee muistia tärviölle. Eikä siinä kaikki, vaan tuloksena saattaa olla myös muistin korruptoituminen ja ohjelman kaatuminen tai muistin loppuminen kesken ja ohjelman kaatuminen tai vastaava virhetilanne. Eli iso virhe se muistin hukkaaminenkin on.\n\nSaatat ehkä ihmetellä, että kun tämä dynaamisen muistinhallinnan hienous tuo niin monia uusia vaaroja ohjelmointiin, niin miksi tätä yleensäkään on olemassa. Raaka tosiasia on, että kehittyneemmät ja ohjelmoinnin kannalta välttämättömät tietorakenteet eivät ole mahdollisia ilman dynaamista muistinhallintaa. Sellaisia rakenteita ovat esimerkiksi lennossa kokoaan muuttavat tai tehokkaat hakumahdollisuudet omaavat rakenteet. Näiden tietorakenteiden vaatima muistinkäyttö on niin monimutkaista, ettei kääntäjän ole mahdollista hoitaa niiden vaatimaa muistinkäsittelyä - yksinkertaisesti kääntämisvaiheessa ei vielä voida tietää, miten tietorakenteet tulevat tarvitsemaan muistia. Eli käyttäjän on itse ohjelmoitava niiden muistinkäyttö.\n\nToki on myös mahdollista tehdä ohjelmaan osa, joka valvoo muistinkäyttöä. Siis ohjelman suorituksen aikana seuraa mitkä muistialueet ovat käytössä ja mitkä saa jo vapauttaa. Sellaista kutsutaan roskien kerääjäksi (garbage collector). Esimerkiksi Javassa roskienkeruu on, mutta C++:ssa ei ole eikä todennäköisesti tule. C++:n on saatavana kyllä roskienkeruumekanismeja erillisinä paketteina, joten sellaisenkin voi ottaa käyttöön jos haluaa. Vaikka roskienkeruussa on joitain ongelmia, niin täytyy silti henkilökohtaisesti tunnustaa että ihan mahtava apuväline se on...\n\n# Periytyminen\n\n# Luokkahierarkiat\n\nPäivän mörkö on koodin kopioiminen. Tämä ohjelmoitsijoiden perivihollinen voi vapaaksi päästessään aiheuttaa suurta tuhoa ja mielipahaa. Ongelmahan on siis se, että joudumme monistamaan samaa ohjelmakoodia moniin ohjelman eri kohtiin. Se johtaa siihen, että meillä on tuplasti enemmän ylläpidettävää ja vaarallinen mahdollisuus unohtaa toisen kopion päivittäminen.\n\nPieni esimerkki taas kehiin, näitä klassikkoja Libertyn kirjasta. On luokat Koira ja Kissa. Ne ovat erilaisia, koska kissa haukkuu ja koira naukuu. Eikunsiis... Kuitenkin, ne liikkuvat samalla tavalla: neljällä jalalla kävellen. Joutuisimme siis kopioimaan kissan Liiku()-metodin Koira-luokkaan, mikä olisi hyvin harmillista. Toisaalta kissojen ja koirien esittäminen samalla luokalla ei ole järkevää, koska erojakin on paljon.\n\nOngelmaan on kuitenkin ratkaisu. Voimme ajatella, että kissat ja koirat ovat nisäkkäitä - ja eläimiä. Tämän pohjalta voisimme rakentaa tällaisen luokkahierarkian.\n\nTuo biologisesti hyvin korrekti hierarkia voidaan kääntää C++:ksi suoraan. Tarvitsemme vain yhtä uutta niksiä, nimittäin perintää. Idea on simppeli: Koira perii luokan Nisakas. Se siis saa kaikki Nisakas-luokan ominaisuudet, joita se sitten voi täydentää omillaan. Samankaltaisuudet täytyy koodata vain Nisakas-luokkaan, joten työmäärä vähenee. Ja mikä tärkeintä, meillä on koodista vain yksi versio ylläpidettävänä. Eiköhän tuo ala olla jo selvää, joten läimäistään nyt se periytymisen kielioppi tähän.\n > class Nisakas { public: int ika; int paino; }; class Koira : public Nisakas { public: int hannanPituus; }; int main() { Koira jesse; jesse.ika = 10; // näin ei saisi tehdä, halusin vaan pitää esimerkin lyhyenä return EXIT_SUCCESS; }\n\nKoira siis perii luokan Nisakas. Koska jesse on koira, se on perinyt Nisakas-luokalta jäsenmuuttujan ika ja niinpä sitä voidaan käyttää. Metodit periytyvät myös, mutta niitä en laiskuudessani jaksanut kirjoittaa. Koira ei pelkästään ole samankaltainen kuin Nisakas, vaan Koira on Nisakas. Nisakas-osoittimeen voi sijoittaa Koira olion - tosin ainoastaan Nisakkaassa olevia ominaisuuksia voi käyttää osoittimen kautta.\n\nKäytännössä periminen tapahtuu siis kirjoittamalla luokan määrittelyssä.\n > : public KantaLuokka\n\npublic tarkoittaa julkista periytymistä, mikä on yleisimmin käytetty periytymisen muoto. Muilla muodoilla ei kannata vielä stressata itseään.\n\nJos jäsentieto määritellään yksityiseksi, se ei näy luokan perillisille. Toisaalta sen määritteleminen julkiseksi olisi hirmuinen riski, koska jokainen huolimaton luokan käyttäjä voisi sotkea sen. Niinpä jäsentiedon voi määritellä suojatuksi, protected, jolloin vain luokan jäsenfunktiot pääsevät siihen käsiksi, mutta se on käytössä myös luokan perillisissä.\n\nKantaluokan metodeja voidaan korvata kirjoittamalla niistä uusi versio periytyvään luokkaan. Tämä kuitenkin piilottaa kaikki kantaluokasta peräisin olevat sen funktion versiot. Jos kantaluokassa on metodit Metodi(), Metodi(int) ja Metodi(int, int) ja periytyvässä luokassa uudelleenmääritellään metodi Metodi(int), ei siinä luokassa voida käyttää kantaluokan metodeja Metodi() ja Metodi(int, int).\n # Muodostinfunktiot\n\nKun luokkaa luodaan, kutsutaan ensin sen kantaluokan muodostinfunktiota ja sen jälkeen luokan omaa muodostinfunktiota. Koska luokan perillinen on myös sen kantaluokan jäsen, kuten vaikka koira on nisäkäs, pitää nisäkäsosa luoda ennen koiraosan luomista. Sama pätee myös tuhoajafunktioihin, mutta niitä tietenkin kutsutaan päinvastaisessa järjestyksessa. Ensin siis tuhotaan koira, sitten nisäkäs. Koiran tai yleensä nisäkkään tuhoaminen on kyllä tuhmaa. Sellaista ei saa tehdä kuin virtuaalimaailmassa.\n\nLuokan muodostinfunktio voi myös antaa parametreja kantaluokan muodostimelle. Se tapahtuu kirjoittamalla muodostinfunktion sisällön määrittelyn yhteyteen : kantaLuokka(parametri).\n > #include <iostream.h> class Nisakas { public: Nisakas(int p); int ika; int paino; }; class Hirvio : public Nisakas { public: Hirvio(int paino, int silmienLkm); }; Nisakas::Nisakas(int p) { cout << \"Nisäkäs luotu\" << endl; paino = p; } Hirvio::Hirvio(int paino, int silmienLkm) : Nisakas(paino) { cout << \"Hirviö luotu\" << endl; } int main() { Hirvio roellipeikko(85, 2); return EXIT_SUCCESS; }\n\nHirviota luodessa luodaan siis Nisakas, jolle annetaan parametriksi haluttu ikä. Toisin sanoen annettu paino passitetaan kantaluokan muodostinfunktiolle.\n # Moniperintä\n\nJos ryhdyt tarkemmin miettimään eläinkuntaa, voi joidenkin eläinten sijoittaminen edellä esitettyyn luokkahierarkiaan olla vaikeaa. Esimerkiksi lohikäärme: sehän on toisaalta kala, mutta toisaalta matelija. Pitäisikö se periyttää kalasta vai matelijasta? C++ tukee moniperintää, joten kysymykseen on kolmaskin vastausvaihtoehto: periytetään se molemmista!\n > class Lohikaarme : public Kala, Matelija { public: Lohikaarme(int suomujenLkm, int pituus); }; Lohikaarme::Lohikaarme(int suomujenLkm, int pituus) : Kala(suomujenLkm), Matelija(pituus) { cout << \"Lohikaarme luotu\"; }\n\nNäin ongelma ratkaistiin, Lohikaarme on sekä Kala että Matelija ja se perii molempien kantaluokkiensa ominaisuudet. Esimerkistä myös näet kuinka monen kantaluokan muodostinfunktioita voidaan kutsua - siinähän ei toki ole mitään erikoista tai yllättävää.\n # Virtuaaliset funktiot\n\nNyt jätämme eläintarhan ja palaamme puhtaasti tietokonemaailman asioihin. Todennäköisesti katsot parhaillaan ruutua, joka on täynnä painonappeja, vierityspalkkeja ja muita graafisia vipuja joiden avulla ohjelmia käytetään. Oletko tullut ajatelleeksi, kuinka noita vempeleitä käytetään?\n\nOletetaan, että jokainen vipstaaki on oma luokkansa (todellisuudessakin monet graafiset käyttöliittymät toimivat näin). Otetaan hyvin yksinkertainen ongelma: kun piirretään uusi ikkuna, pitää jokaista oliota pyytää piirtämään itsensä. Koska erityyppisiä vipstaakeja on paljon, syntyy hankala if-kasauma kun päätämme mitä luokkaa milloinkin käytämme. Luokat tarvitsisivat jotain yhteistä, koska jokaisen namiskuukkelin tulisi pystyä piirtämään itsensä. Yhteistä piirtofunktiota ei voi tehdä, koska vitkuttimet ovat erinäköisiä, joten ne piirretäänkin erilailla. Eli tarvitsisimme yhtenäisen liittymän erilaisiin toiminnallisuuksiin.\n\nAuttaisiko periyttäminen? Halleluja! Teemme yhteisen kantaluokan Vipstaakkeli, josta kaikki erilaiset nappulat ja palkit periytyvät. piirraItsesi()-metodi voi sijaita kantaluokassa. Kun haluamme piirtää namiskat ruudulle, voimme käsitellä niitä kantaluokan osoittimen kautta ja kutsua piirraItsesi()-metodia - kätevästi yhdessä silmukassa. Itse luokalla ei ole väliä, koska kaikki periytyvät Vipstaakkelista ja siten niitä voi käyttää Vipstaakkeli-osoittimen kautta.\n\nMutta voihan räkä! Kuten edellä kerrotiin, kantaluokan osoittimen kautta käytettäessä voidaan käyttää vain kantaluokan ominaisuuksia ja niinpä ollen kutsutaan vain kantaluokan piirraItsesi()-metodia, eikä sitä oikeaa lapsiluokan metodia. Voi kun ohjelmointi osaakin olla kinkkistä. Tähän asti opituilla nikseillä ongelma ei ratkea, mutta C++:ssahan niitä niksejä riittää ihan haitaksi asti.\n\nC++ antaa mahdollisuuden määritellä funktio virtuaaliseksi. Se tarkoittaa sitä, että siitä funktiosta kutsutaan aina luokkahierarkiassa alinna olevaa toteutusta. Eli jos Vipstaakkelin piirraItsesi() on virtuaalinen, niin silloin kutsutaan lapsiluokan piirraItsesi()-metodia vaikka funktiokutsu tehdäänkin Vipstaakkeli-osoittimen kautta. Eli suomeksi: kun piirraItsesi() määritellään virtuaaliseksi, ratkeaa ongelmamme siihen.\n\nTässä on pieni esimerkkitoteutus aiheesta. Määrittelin Vipstaakkeli::piirraItsesi()-metodin puhtaasti virtuaaliseksi, siis tein sijoituksen = 0, enkä kirjoittanut mitään runkoa. Se tarkoittaa sitä, että funktiota ei ole toteutettu. Luokkaan, jossa on toteuttamattomia funktioita, ei voi tietenkään luoda olioita, koska olion funktioita pitää pystyä kutsumaan ja huono sellaista on kutsua johon ei ole ohjelmoitu mitään sisältöä. Siis pelkkää Vipstaakkeli-oliota ei voi olla olemassa: ja sehän on vain hyvä, koska Vipstaakkeli on abstrakti ja hassu sana, ja käytännössä vipstaakkelit ovat aina nappeja, palkkeja tai valikoita - pelkkää \"vipstaakkelia\" ei ole konkreettisesti olemassa. Myös mikäli lapsiluokka ei määrittele runkoa piirraItsesi()-metodille, ei siitäkään voi luoda olioita - eli lapsiluokkien ohjelmoijat eivät voi unohtaa metodin ohjelmoimista.Vipstaakkeli on abstrakti luokka (abstract class).\n > #include<iostream.h> class Vipstaakkeli { public: virtual void piirraItsesi() = 0; }; class Painonappi : public Vipstaakkeli { public: void piirraItsesi(); }; class Vierityspalkki : public Vipstaakkeli { public: void piirraItsesi(); }; void Painonappi::piirraItsesi() { cout << \"Painonappi piirretty\" << endl; } void Vierityspalkki::piirraItsesi() { cout << \"Vierityspalkki piirretty\" << endl; } int main() { const int vipsLkm = 2; Vipstaakkeli* ikkunanVipstaakkelit[vipsLkm]; ikkunanVipstaakkelit[0] = new Painonappi(); ikkunanVipstaakkelit[1] = new Vierityspalkki(); for (int i = 0; i < vipsLkm; i++) ikkunanVipstaakkelit[i]->piirraItsesi(); return EXIT_SUCCESS; }\n # Polymorfismi isolla P:llä\n\nEdellisessä kappaleessa läpikäyty esimerkki on sitä Polymorfismia, siis ohjelmointitekniikka johon sanalla polymorfismi useimmiten viitataan. Funktiotason polymorfismi on vain pieni näppärä konsti verrattuna äsken esitettyyn. Luokkahierarkioiden ja virtuaalisten funktioiden avulla toteutettu polymorfismi voi toimia pohjana koko järjestelmän rakenteelle - kuten äsken käsitellyn ikkunointijärjestelmän yhteydessä olikin.\n\nPolymorfismin hienous piilee siinä, että ohjelmassa voidaan tunnetun liittymän kautta käyttää tuntematonta toteutusta. Siis kun esimerkissä tunnetaan Vipstaakkeli-luokka, voidaan sen luokan kautta käyttää Painonappi- ja Vierityspalkkiluokkien ominaisuuksia - tietämättä itse Painonappi- tai Vierityspalkkiluokista yhtään mitään. Ajattele kuinka helppoa on lisätä erilaisia vipstaakkeleja tai muuttaa vaikka Painonapin toteutusta! Se ei vaadi mitään muutoksia yhteisen Vipstaakkeli-liittymän eli kantaluokan kautta toimivaan koodiin.\n\nOlio-ohjelmissa ei pitäisikään törmätä tilanteeseen, jossa käsipelillä, eli if- tai switch..case-rakenteilla, valitaan saman toiminnon eri muoto. Siis tehdään sama asia, mutta se joudutaan tekemään erilailla erilaisten luokkien kanssa. Jos luokilla on yhteisiä ominaisuuksia, tulee niitä voida käyttää samalla tavalla, olivatpa sitten toimintojen luokkakohtaiset toteutukset millaisia tahansa.\n\nPeriytymisen avulla toteutettu polymorfismi on ajonaikaista polymorfismia, koska kutsuttava funktio päätetään vasta ohjelman suorituksen aikana. Virtuaalista funktiota kutsuttaessa lähdekoodissa ei mitenkään kerrota, mitä tiettyä funktion toteutusta kutsutaan, vaan ohjelman tulee päätellä se ajonaikana kutsun kohteena olevan olion tyypistä. Tämä operaatio vaatii jonkin verran suoritusaikaa, joten virtuaaliset funktiot ovat hitaampia kuin tavalliset. C++:lla voidaan käyttää myös käännöksenaikaista polymorfismia, joka toteutetaan mallien avulla.\n\nKääntäjän mukana seuraa aina paljon kivaa, kuten erilaisia kirjastoja kaikenlaisten tehtävien hoitamiseen. Kirjastot vaihtelevat kääntäjittäin, mutta standardinmukaiset osat löytyvät jokaisesta. Yleisesti standardikirjastoa voisi kuvailla funktioiksi ja luokiksi, joilla voi tehdä kaikki kakkahommat. Ja sehän meille sopii - emmehän halua haaskata aivokapasiteettiamme joutavanpäiväisyyksiin, kun järjenjuoksu meinaa ontua jo muutenkin.\n\nC++:n perinteinen standardikirjasto on kohtuullisen suppea. Juuri sen vuoksi se löytyy jokaisesta kääntäjästä - kirjaston toteuttaminen ei ole ollut ylivoimainen työmäärä kääntäjän tekijöille. Myöhemmin C++:n on tullut myös laaja ja kattava kirjasto, Standard Template Library (STL). Mutta sellaista ei näpyttelekään illan tai parin aikana, joten ihan jokainen kääntäjä ei STL:ää sisällä. Siksi onkin hyvä tietää myös mitä perinteinen kirjasto pitää sisällään.\n # Merkkijonot\n\nC:ssä merkkijonot ovat char-taulukoita. Ja niinhän ne pohjimmiltaan ovat C++:ssakin. Merkkijonoja käytettäessä on hyvä muistaa, että niitä ei pidä mennä käyttämään.Vältä niitä kuin ruttoa. Ehkä vähän liioittelin, mutta minä ja monet muut ohjelmoijat olemme huomanneet, että jostain maagisesta syystä merkkijonot onnistuvat houkuttelemaan virheitä kuin \"toinen linssi kaupan päälle\" -tarjous kyklooppipariskuntia. Nollatavu lopusta saattaa unohtua tai jonoa käsitellessä hukkua, jolloin merkkijonoja käsittelevät funktiot rullaavat ympäri muistia ja sotkevat sen. Ohjelma ei todennäköisesti kaadu siihen paikkaan, vaan virhe esiintyy myöhemmin täysin käsittämättömänä käytöksenä - joku ihan satunnainen muuttuja on voinut muuttaa arvoaan. Siksi kannattaakin merkkijonojen sijasta käyttää merkkijonoluokkaa.\n\nIhan perinteen vuoksi kerrataan kuitenkin merkkijonojen käsittelyn perusfunktiot: strcmp(..), strcat(..), strcpy(..) ja strlen(..). Kaikkien määrittelyt löytyvät string.h-tiedostosta. strcmp(..) (string compare) vertailee kahta merkkijonoa. Merkkijonoja ei voi vertailla ==-operaattorilla, koska se vain vertailee kahta char-osoitinta, jotka osoittavat eri kohdassa muistia oleviin merkkijonoihin: vertailu on aina epätosi (ellei vertaile merkkijonomuuttujaa itseensä). strcmp(..) palauttaa 0, jos merkkijonot ovat samat. Siis:\n > if (strcmp(mjono1, mjono2)) cout << \"Samat.\";\n\n.. on väärin, koska strcmp(..) palauttaa epätoden mikäli jonot ovat samat. Jos jälkimmäinen on aakkosissa aikaisempi, paluuarvo on suurempi kuin nolla, ja toisinpäin paluuarvo on pienempi kuin nolla. Mikäli strcmp toimisi loogisesti ja palauttaisi toden (nollasta poikkeavan) kun merkkijonot ovat samat, niin aakkosellinen vertailu ei onnistuisi. Tämmöistä ikuista itkuvirttä se on näiden C-merkkijonojen kanssa...\n\nstrcat(..) (string concanate) lisää ensimmäisenä parametrina annetun merkkijonon perään toisena annetun. strcpy(..) (string copy) kopioi taas ensimmäiseen merkkijonoon toisen. strlen(..) (string length) palauttaa merkkijonon pituuden. Nyt sitten pistetään nämä merkkihirmut tositoimiin:\n > #include <string.h> #include <iostream.h> int main() { char testi[40] = \"<NAME>\"; char oikea[20] = \"<NAME>\"; cout << testi << endl; if (!strcmp(testi, \"<NAME>ainen haisee kukkasille.\")) // eivät ole samat cout << \"Samat ovat merkkijonot.\" << endl; else cout << \"Erilaisia ovat.\" << endl; strcpy(testi, oikea); // kopioidaan oikea alku strcat(testi, \" haisee kukkasille.\"); // lisätään oikea loppu cout << testi << endl; if (!strcmp(testi, \"Herra Tossavainen haisee kukkasille.\")) // ovat samat cout << \"No nyt ovat samat.\" << endl; else cout << \"Erilaisia ovat vielä.\" << endl; return EXIT_SUCCESS; }\n\nMutta ei näitä C-kielen aikuisia merkkijonoräpsyjä kannata käyttää, jos vaan vaihtoehto löytyy. Juuri nollatavuun päättyminen tekee merkkijonoista yhden pahimmista ongelmapesäkkeistä C:ssa. Merkkijonojen kanssa taistellessa olen minäkin pahimmat kolhuni hankkinut ohjelmoijan kimmeltävään sotisopaan. Onhan siinä opittu, vaan olisi tuon voinut uskoa vähemmälläkin. Ja nyt uskon: paljon parempi vaihtoehto on tehdä luokka, joka hoitaa merkkijonojen käsittelyn. Kun kaikki merkkijonotemppuilu on yhden pirun hyvin testatun luokan sisällä, ei mahdollisuuksia merkkijonojen kanssa niin yleisiin inhimillisiin virheisiin enää ole. Luokan tekemisessä on vaan oma vaivansa. Niinpä onkin mukavaa ja mieltä ylentävää, että tuo maallinen puurtaminen on hoidettu meidän puolestamme - C++:n STL-standardikirjastosta löytyy näpsäkkä merkkijonoluokka string. Sitä käyttäen voidaan merkkijonoja, kiitos uudelleenmääriteltyjen operaattoreiden, käyttää kuin mitä tahansa muuttujia. Tällä tavalla yllä oleva tehtäisiin standardikirjaston string-luokan avulla:\n > #include <string> #include <iostream> using std::string; using std::cout; using std::endl; int main() { string testi = \"<NAME>\"; string oikea = \"<NAME>\"; cout << testi << endl; if (testi == \"H<NAME>ainen haisee kukkasille.\") cout << \"Samat ovat merkkijonot.\" << endl; else cout << \"Erilaisia ovat.\" << endl; testi = oikea; testi += \" haisee kukkasille.\"; cout << testi << endl; if (testi == \"Herra Tossavainen haisee kukkasille.\") cout << \"No nyt ovat samat.\" << endl; else cout << \"Erilaisia ovat vielä.\" << endl; return EXIT_SUCCESS; }\n\nItseasiassa standardikirjaston toteutus on hoidettu niin kätevästi, että luokan avulla ei pelkästään voi käsitellä merkkijonoja, vaan mitä tahansa merkkijonon kaltaisia tietorakenteita: vaikka numerojonoja tai Tilaus-oliojonoja. Tämän joustavuuden hyödyntäminen vaatii kuitenkin mallien hallintaa, mihin emme tässä voi pureutua. Koska merkkijonot ovat ylivoimaisesti yleisimpiä tarvittuja jonoja, on tyyppimäärittelyn (typedef) avulla määritelty tyyppi string, joka on siis ihan perinteinen merkkijono. Taustalla piilee ovela mallitoteutus, mutta se on niin hyvin piiloitettu että siitä ei käyttäjän tarvitse välittää.\n\nVanhempien kääntäjien kirjastot eivät sisällä STL:ää - eivätkä siis string-luokkaa. Kuitenkin lähes poikkeuksetta löytyy kääntäjän oma samantyyppinen merkkijonoluokka, nimeltään yleensä String. Sellaisen löytää otsikkotiedostosta string.hpp, joissain kääntäjissä (Turbo C++) strng.h. Luokkien käyttäminen on yleensä samanlaista kuin standardin string-luokan. Toki aina tulee käyttää standardia vaihtoehtoa, mikäli mahdollista.\n # atoi ja itoa\n\natoi tulee sanoista alphabet to integer, kirjaimet numeroiksi. atoi() siis heittää merkkijonon int-muotoon. Sehän onnistuu myös pelkällä tyyppimuunnoksella, mutta silloin int luku muutetaan tavuksi - siis kaikki ylimääräiset bitit heitetään mäkeen ja tulos ei ole ollenkaan sitä mitä haluttiin. Jos haluamme että merkkijono \"222\" muuttuu int-luvuksi, jonka arvo on 222, pitää se tekemän atoi():lla. Toisinpäin taas käytetään itoa():aa.\n > #include <iostream.h> int main() { char luku1[] = \"222\"; char luku2[5]; int x = atoi(luku); itoa(x, luku2, 10); // kymmenlukumuunnos cout << \"Ja muunnosten tulos on \" << luku2 << endl; return EXIT_SUCCESS; }\n\nSiis atoi():lle annetaan osoitin merkkijonoon ja saadaan muunnettu int-numero. itoa() syö vähän enemmän argumentteja, ensin annetaan muunnettava int-luku, sitten osoitin kohdemerkkijonoon ja lopuksi minkä kantainen muunnos tehdään. Matti Meikäläinen käyttää kymmenlukuja, joten viimeinen parametri on siinä tapauksessa kymmenen. C++-tyylinen tapa hoitaa muunnokset on käyttää STL:n stringstream-luokkaa.\n # Sattumia soppaan\n\nSeuraava aihe sattuu olemaan satunnaisuus. Filosofisesta näkökulmasta kurkistaen aihe on enemmänkin kuin mielenkiintoinen. Satunnaisuus on metafysiikan perustavanlaatuisia kysymyksiä, johon liittyy mm. kiistakysymys siitä, onko maailma deterministinen vai ei. Myös modernilla kvanttifysiikalla on kantansa asiassa - satunnaisuutta puolustava kanta, keskimäärin.\n\nKuitenkaan kovin syvällistä filosofista katsantoa ei tarvita noppapelin ohjelmoimiseen, joten tartumme taas käytäntöä kädestä ja talutamme sen toiselle puolelle tietä kuin Sudenpojat ikään. Koska tietokone on deterministinen vehje, siis syöte määrää aina tarkasti tulosteen, ei \"todellista satunnaisuutta\" saada aikaan. Moneen tarkoitukseen ihan riittävän lähelle päästään kuitenkin käyttämällä ns. kaaottisia kaavoja. Hauska sana kaaos tarkoittaa sitä, että kaava on puhtaan matemaattinen ja samoilla alkuarvoilla saadaan aina sama tulos, mutta riippuvuus syötteen ja tuloksen välillä on niin monimutkainen, että käytännössä mitään riippuvuutta ei ole havaittavissa. Tulokset heittelehtivät villisti kuin villiintyneet viidakkoapinat.\n\nKaikkien kääntäjien mukana toimitetaan satunnaislukujen luomiseen tarvittava ohjelmanpätkä, satunnaislukugeneraattori. Generaattori laskee uuden satunnaisluvun aina edellisen pohjalta. Ensimmäinen luku on nimeltään siemenluku, joka kannattaa ottaa kellosta, jotta syntyvä satunnaislukusarja olisi aina erilainen. Siemenluku asetetaan näin (menoon mukaan tarvitaan stdlib.h ja time.h):\n > srand(time(0)); // jossain kääntäjissä (DJGPP) srandom(time(0))\n\nSatunnaisluku väliltä 0 - max:\n > luku = rand() % max;\n\nSatunnaisluku väliltä min - max:\n > luku = min + rand() % (max - min);\n\nTämä kääntäjän standardi satunnaislukugeneraattori ei kuitenkaan ole kovin satunnainen. Jotkut algoritmit vaativat kunnollista satunnaisuutta, johon kääntäjän mukana tuleva ANSI C -standardin mukainen valitettavan köykäinen generaattori ei kelpaa. Kuten mainitsinkin, aitoa satunnaisuutta deterministisellä ja loogisella tietokoneella ei saavuteta - ilman pieniä, tai itseasiassa aivan hemmetin suureellisia, jippoja. Näitä kaikkia kiinnostavia kysymyksiä pohditaan Matematiikka-sektion kappaleessa Sattuu ja tapahtuu...\n # qsort\n\nSorttia löytyy monenlaista sorttia. Viittaamme nyt lajittelualgoritmeihin, siis \"sort algorithms\". Ne järjestävät kasan tietoa tietyn säännön mukaan, esimerkiksi numerojärjestykseen. Saatan joskus luennoida erilaisista lajittelualgoritmeistä, mutta en nyt. Lätkäisen vaan kääntäjän mukana tulevan valmiin ja hyvän qsortin käyttöohjeet. Lähes kaikissa C++-kääntäjissä on mukana yleispätevä ja hyvä quicksort-algoritmin toteutus. Se on nopea ja joustava, niinpä sitä voi käyttää melkein mihin tarkoitukseen vain.\n\nqsort(..) nielaisee neljä parametria. Ensin pistetaan lajiteltavan taulukon osoite, sitten tieto kuinka monta alkiota lajitellaan, sitten yhden alkion koko tavuina ja lopuksi annetaan osoitin vertailufunktioon. Vertailufunktio tehdään itse. Sen tulee ottaa kaksi void*-tyyppistä parametria, siis tyypittömät osoittimet vertailtaviin arvoihin. Osoittimet kannattaa aluksi muuntaa oikeaan tyyppiin. Sen jälkeen vertailtaessa pitää muistaa, että vertailee osoittimien osoittamaa dataa - ei itse osoittimia. Mikäli sen unohtaa, niin ainakin Watcom-kääntäjän qsort(..) kiemurtelee umpisolmulle ja tukehtuu lopulta. Vertailufunktion pitää palauttaa int-arvo, joka on pienempi kuin nolla jos ensimmäinen on pienempi, 0 jos vertailtavat ovat yhtäsuuret ja suurempi kuin 0 jos ensimmäinen on suurempi. Alla lepää sitten int-taulukon lajitteleva esimerkki.\n > #include <stdlib.h> #include <iostream.h> int compare(const void *op1, const void *op2) { const int *p1 = (const int *) op1; // typecast void pointers to int const int *p2 = (const int *) op2; // void pointer is type insensitive, it can point to anything if ((*p1) < (*p2)) return -1; // first is less, so return is less than 0 else if ((*p1) > (*p2)) return 1; // first is more, so return is more than 0 return 0; // equal } void main() { const int cVal = 20; int values[cVal]; for (int a=0; a < cVal; a++) values[a] = rand() % 200; cout << \"Before: \"; for (a=0; a < cVal; a++) cout << values[a] << \" \"; qsort((void*)values, cVal, sizeof(int), compare); cout << endl << \"After: \"; for (a=0; a < cVal; a++) cout << values[a] << \" \"; return EXIT_SUCCESS; }\n\nAidosti C++-tyylinen tapa hoitaa tämä juttu olisi käyttää STL:ää (Standard Template Library). Ongelmahan on siinä, että yleispätevän lajittelualgoritmin pitäisi pystyä lajittelemaan mitä vain tietoa. Alla olevassa esimerkissä se on ratkaistu käyttämällä tyypitöntä void*-osoitinta, joka kuitenkin on hyvin vaarallinen lelu. STL:ssä ongelma on elegantisti ratkaistu malleilla. Palaamme asiaan siis mallien yhteydessä.\n # Trigonometria\n\nKyllä niitä sinejä ja kosinejä voi C++:llakin laskea. Funktiot ovat sin(..), cos(..) ja tan(..), otsikkotiedosto math.h, katso kääntäjän helpeistä loput.\n\nNo, mikäli trigonometrologia ei ole niin hirveän tuttua, niin yhden kompastuskiveyksen voisin nostaa tässä esille. Tosi insinöörit eivät käytä asteita kulmien mittaamiseen, vaan tupsulakkien keskuudessa pinnalle noussut ilmiö on radiaanien käyttö perinteisten asteiden sijasta. Kun täysi kulma on 360 astetta, niin radiaaneina se on 2*PII. Siis kaksi kertaa pii. Pii on se loppumaton luku, joka alkaa 3.141... ja jonka desimaalien opettelu on tapa päästä Guinnesin kirjan sivuille - mikäli ei jaksa syödä kilokaupalla kuukiaisenmunia. Pii radiaania on 180 astetta, siis oikokulma. Mitä ideaa piillä pilailemisessa sitten on? No, se on ympyrän, tässä tapauksessa yksikköympyrän, perustavanlaatuisiin ominaisuuksiin liittyvä, eikä mitenkään vaikea juttu. En minä rupea sitä kuitenkaan nyt selostamaan tässä, ei se ole mitenkään kiinnostavaa - sen voi siis opetella vaikka koulussa. Lapset, olkaa tarkkaavaisia laskento-opin tunnilla.\n\nHarvoin kyllä tulee vajottua näin alas, kun yritän keksiä jotain sisältöä aiheesta, jossa mitään erityistä selitettävää ei juurikaan ole. Taidanpa nyt tipauttaa leikepöydältä esimerkin tähän. Vielä ennen kuin ryntäät paheellisiin harrastuksiisi, niin mainitsen että edellä esiteltyjen funktioiden käänteisfunktiot (arkusfunktiot) ovat acos(..), asin(..) ja atan(..). Niillä saa laskettua kulmia, kun tietää suorakulmaisen kolmion kahden sivun pituudet. Esimerkki on englanniksi, älä suotta peljästy.\n > #include <math.h> #include <iostream.h> const double pi = 3.141; // far from accurate value double DegToRad(double deg) { return (deg/180.0) * pi; } double RadToDeg(double rad) { return (rad/pi) * 180.0; } int main() { double n, number; cout << \"Give me an angle in degrees: \"; cin >> n; number = DegToRad(n); cout << \"Thank you.\" << endl; cout << \" Sine of \" << \" radians is \" << sin(number) << endl; return EXIT_SUCCESS; }\n\n# Tee-se-itse: linkitetty lista\n\nK�yn t�ss� l�pi k�yt�nn�nl�heisen esimerkin, jonka avulla toivottavasti ymm�rr�t mik� juju mallien takana piilee. Kuvittele, ett� sinun pit�isi ohjelmoida ammuskelupeli. Unohtaen kaiken muun mit� r�iskint�pelin ohjelmointiin voisikaan liitty�, keskitymme yhteen haasteeseen: miten hoitaa ammuttujen laukausten k�sittely (siis niiden jotka lentelev�t ymp�riins�). Selv�stikin laukausta esitt�v�t oliot pit�� ker�t� yhteen, jotta niiden sijaintia voi p�ivitt�� lentoradan mukaan ja mahdolliset osumat havaita. Yht�aikaa voidaan joutua k�sittelem��n suuriakin m��ri� ammuksia (asearsenaali on hyvin konetulipainotteinen). Joten jos ker��mme ammutut kutit taulukkoon, tulee sen olla suuri.\n\nSuurimman osan ajasta ei lent�vi� luoteja ole yht��n, koska pelaaja lymyilee vihollisten n�kym�tt�miss�. Eli suurimman osan ajasta taulukko veisi turhaan suuren m��r�n muistia ja teki siit� kuinka ison tahansa, aina voi tulla eteen tilanteita jossa se ei ole riitt�v�n iso. Tarvitsemme fiksumpaa tietorakennetta, linkitetty� listaa. Lista idea on, ett� yhdest� tietoalkiosta on aina osoitin seuraavaan - siis sen kokoa ei ole rajoitettu ja alkioiden lis��minen ja poistaminen on helppoa.\n\nLuonnostelemme Ammus-luokan:\nclass Ammus { public: // saantifunktiot private: int x; int y; int z; Ammus* seuraava; }; \nKoska Ammus-luokka mallintaa pelin todellisuuden k�sitett�, sen pit�isi olla mahdollisimman yhdenmukainen peliss� suihkivien ammusten kanssa. Ja se onkin, ammuksella on sijainti jota kolmella koordinaatilla (x, y, z) kuvataan.\n\nSopiiko Ammus*-osoitin kuvaan? Ei, koska pelin todellisuudessa ammuksia ole mitenk��n linkitetty toisiinsa. Ratkaisu ei ole siis paras mahdollinen: samaa linkitetty� listaa olisi mukava k�ytt�� muuallakin ja toisaalta mik�li ammuksien tallentamiseen p��tet��n k�ytt�� jotain viel� fiksumpaa tietorakennetta, on kurjaa menn� muuttamaan Ammus-luokkaa joka ei tietorakenneasiaan suuremmin liity. Siis linkitetyn listan toteutus pit�� repi� irti Ammus-luokasta (toki listalla olisi my�s oma luokkansa, jonka kautta sit� k�ytett�isiin; t�ss� on esitelty pelk�st��n yht� linkki� eli solmua esitt�v� luokka jotta esimerkit olisivat lyhyit� ja ytimekk�it�):\nclass ListanSolmu { public: // saantifunktiot private: Ammus* alkio; ListanSolmu* seuraava; }; \nT�m� on parempi: linkitetyn listan voi vaihtaa ilman ett� Ammus-luokkaan tarvitsee koskeakaan. Mutta listaa ei voi viel�k��n k�ytt�� muiden luokkien kanssa, koska sen osoitin tietoalkioon on Ammus*-tyyppinen. C++-k��nt�j� huolehtii tietotyyppien oikeasta k�yt�st� - mik� toki on hyvin jalo ja kunnioitettava teko - eik� anna sijoittaa Ammus*-osoittimeen mink��n muun tyyppist� tietoa.\n\nTarvitsisimme osoitinta, joka kattaa kaikki mahdolliset tietotyypit. Ja sellainen onkin, nimitt�in void*. Mutta koska void* on tyypit�n osoitin, ei sen k�ytt� anna k��nt�j�lle mink��nlaista vinkki� siit� mit� me olemme oikein tekem�ss�, joten k��nt�j� ei my�sk��n osaa varoittaa jos teemme huolimattomuuserheen. Siis void*-osoittimella toteutettuun listaan voimme ammuksien sekaan sijoitella ep�huomiossa vaikka ensiapulaukkuja tai muuta ammuskelupeleiss� yleist� tarveaineistoa - k��nt�j� ei �r�hd� ollenkaan. Toisaalta olisihan se voitto maailman rauhalle, jos konekiv��ri ampuisikin vain laastereita ja sideharsoa...\n\nvoid*-osoittimet eiv�t ole hyv� idea. Itseasiassa ajatus tyypitt�mien osoittimien k�yt�st� n�in korkean tason ohjelmoinnissa on loukkaus ket� tahansa osaavaa ohjelmoijaa kohtaan. Seuraavaksi turvaudummekin viisaisiin opetuksiin, joita t�ss� oppaassa tarjotaan. K�yt�mme abstraktiota, eli nousemme yl�s ansakuopasta siirt�m�ll� t�m�n pohdinnan korkeammalle abstraktiotasolle. Meh�n haluamme listan, joka osaa k�sitell� kaikkia pelin luokkia. Joten teemme luokan PeliObjekti, joka kuvaa mit� tahansa peliss� esiintyv�� asiaa ja josta kaikki pelin luokan on periytetty. Nyt - kiitos polymorfismin - voimme tehd� listan, joka PeliObjekti-kantaluokan avulla voi k�sitell� kaikkia pelin luokkia.\n class PeliObjekti {};class Ammus : public PeliObjekti { public: // saantifunktiot private: int x; int y; int z; };class ListanSolmu { public: // saantifunktiot private: PeliObjekti* alkio; ListanSolmu* seuraava; }; \nT�m� ei olekaan ihan huono ratkaisu, n�in nimitt�in Java-ohjelmointikieless� on toteutettu kielen standardikirjaston linkitetty lista ja muut tietorakenteet. Mutta Java on siin� mieless� erilainen tapaus, ett� Javassa kaikki luokat periytyv�t kantaluokasta Object, joten listaan voi ihan oikeasti laittaa kaikentyyppist� tietoja. Meid�n listamme toimii vain pelin sis�ll�, siihen ei voi esimerkiksi laittaa int-lukuja tai jonkun muun ohjelman olioita.\n\nHuomaat varmaan my�s, ett� t�ll� toteutuksella voidaan kyll� samaan listaan laittaa lyijy� ja laastareita, mutta Sidepakkaus-oliota ei voida vahingossa k�sitell� kuin se olisi Ammus-olio. Siis tyyppiturvallisuus s�ilyy, vaikka lista voikin sis�lt�� eri tietotyyppien olioita. Sen lis�ksi, ett� t�m� ratkaisu ei ole yleist�tt�viss� kaikelle tiedolle, se on my�skin hitaahko. Varsinkin jos rakentaisimme monimutkaisempia rakenteita, ei polymorfismia k�ytt�en saavutettaisi huippusuorituskyky�.\n\nJos ongelmaan olisi olemassa unelmaratkaisu, se olisi t�m�nlainen: voitaisiin luoda koodia, joka pystyy k�sittelem��n kaikkea mahdollista tietoa, joka olisi tyyppiturvallinen ja joka tuottaisi yht� tehokasta k��nnetty� koodia kuin saman C++-koodin kirjoittaminen k�sin jokaiselle tietotyypille erikseen. Mutta ei vaan tule sellaista ratkaisua mieleen. Tietenkin yksi mahdollisuus olisi makrojen avulla rakentaa viritelm�, joka esik��nt�j�� k�ytt�en loisi useita versioita koodinp�tkist�, mutta makromagian harjoittaminen on aina ep�suotavaa, koska lopputulos on vaikeasti ymm�rrett�v� ja huonosti hallittava kyh�elm�, joka ei ole edes kunnolla tyyppiturvallinen. K�sink��n ei viitsisi aina luoda uutta versiota koodista, kun kerta t�ysin samaa logiikka vain sovelletaan uuteen tietotyyppiin.\n\nValitettavasti ei ole varaa my�sk��n palkata toista ohjelmoijaa tekem��n rutiininomaista koodin monistamista, eik� �lykk�ist� simpansseistakaan saa mill��n koulutettua hyvi� C++-ohjelmoijia (toiseen suuntaan kouluttaminen on joskus, tosin harvoin, mahdollista). Mutta IT-maailmassa unelmat k�yv�t toteen ja ongelmiin l�ytyy t�ydellinen ratkaisu; saanen esitell� mallit:\ntemplate <class T> class ListanSolmu { public: // saantifunktiot private: T* alkio; ListanSolmu* seuraava; }; \n\n# Mit� mallit oikeasti ovat?\n\nMallit ovat tekniikka, jonka avulla k��nt�j�n saa luomaan koodia k��nn�ksen yhteydess�. Kuuluu vain ilmavaa huminaa, kun ongelmien raskas pilviverho haihtuu pois ja p�iv� paistaa taas. Mallien avulla saadaan k��nt�j� luomaan automaattisesti listasta uusi versio kaikkia tarvittavia tietotyyppej� varten. Koska k��nt�j� on asialla, se voi hoitaa tyyppien tarkistuksen t�ysin normaalisti ja havaita kurjat ohjelmointivirheet jo k��nn�svaiheessa. Ja koska ty� tapahtuu k��nn�ksen aikana, on lopputuloksena syntyv� ohjelma yht� nopea kuin k�sin r��t�l�ity.\n\nTarkastellaan esimerkki� l�hemmin:\ntemplate <class T> class ListanSolmu { public: // saantifunktiot private: T* alkio; ListanSolmu* seuraava; }; \nTemplate alussa tarkoittaa mallia. Emme siis t�ss� m��rittele luokkaa, vaan mallin jonka mukaan k��nt�j� osaa luoda uusia luokkia. Mik�li listaa ei k�ytet� ollenkaan, ei k��nt�j� luo yht��n\n `ListanSolmu<...` -luokkaa. Jos oliot ovat piparkakkuja ja luokat muotteja joilla ne tehd��n, ovat mallit valumuotteja jonka avulla piparkakkumuotit tehtaalla valmistetaan. Koodissa esiintyy eriskummallinen luokka T. Itseasiassa T ei ole luokka, vaan parametrisoitu tyyppi (T on m��ritelty class-tyyppiseksi eli tietotyypiksi, T voi siis olla luokka tai muuttujatyyppi). T on toisinsanoen tyyppi, joka voidaan sy�tt�� parametrina. Huomaa ett� T ei voi olla mik� tahansa tyyppi, vaan sen pit�� tukea kaikkia niit� operaatioita, joita malli sill� tekee. Jos T-oliosta kutsutaan metodia, jota sill� ei ole, antaa k��nt�j� luonnollisesti virheilmoituksen. \nMallin avulla voidaan kertoa, ett� mink� tyypin listoja halutaan. Solmu-malliluokan instanssi ammuksia varten luotaisiin n�in:\nListanSolmu<Ammus> ammusSolmu; \nLause itseasiassa luo kaksi asiaa: luokan ja olion.\n `ListanSolmu<Ammus>` saa k��nt�j�n luomaan `ListanSolmu<...>` -mallista instanssin `ListanSolmu<Ammus>` , siis uuden luokan. Sen j�lkeen luodaan olio `ammusSolmu` ; t�h�n luokkaan. Jos olisimme tekem�ss� piparkakkuja, niin ensin kone muotoilisi luodin muotoisen piparkakkumuotin, jolla sitten painettaisiin yksi leivonnainen. \nMit�p� tekisi seuraavanlainen koodi?\nListanSolmu<Ammus> ammusSolmu; ListanSolmu<Luotiliivi> luotiliivisolmuSolmu; ListanSolmu<Sidepakkaus> sideSolmu; ListanSolmu<Avainkortti> avainSolmu; ListanSolmu<Limsapullo> limsaSolmu; ListanSolmu<Vihollinen> vihollisSolmu; ListanSolmu<Rajahde> pommiSolmu; ListanSolmu<Tehtava> tehtavaSolmu; ListanSolmu<Pelaaja> tunariSolmu; ListanSolmu<Luodinreika> jalkiSolmu; \nNo, aika monta luokkaa, nimitt�in kymmenen. Sit� koodia n�pyttelisi k�sin jo hetken jos toisenkin. Joidenkin mielest� mallien suuri ongelma on, ett� ne aiheuttavat koodin paisumista (code bloat). Siit�h�n t�ss�kin on kyse, kymmenen kertaa iso luokka on aika paljon koodia.\n\nC++-k��nt�j� voi ja sen pit�isi osata optimoida t�m�nkaltaisia tilanteita: mik�li luokissa on identtisi� metodeja, niit� ei tarvitse monistaa vaan yhdell� p�rj��. Toki sellaiset metodit joissa k�sitell��n parametrisoitua tyyppi� tulee monistaa, koska ne k�sittelev�t erilaista tietoa eiv�tk� ole identtisi�. Mutta esimerkiksi oikeassa linkitetyn listan toteutuksessa suurin osa metodeista ei ole riippuvaisia listaan sijoitettujen alkioiden tyypist� (listan koko, onko lista lopussa? jne...) ja niinp� niit� ei tarvitse useita. Joten hyv� k��nt�j� monistaa vain ne metodit jotka on ehdottomasti pakko ja natinat koodin paisumisesta ovat kohtuullisen per�tt�mi�. Valitettavasti kaikki k��nt�j�t eiv�t ole hyvi�, joten tietty� varovaisuutta tulee noudattaa ettei k��nnetyn ohjelman koko paisu kuin pullasorsan maha.\n\nKun pohditaan millaista koodia mallit tuottavat, niin ei voi kuin todeta: s�p�kk��. Koska jokaiselle tietotyypille generoidaan oma koodinsa, voi k��nt�j� optimoida sen viimeiseen asti (toisin kuin k�ytett�ess� virtuaalifunktioilla toteutettua polymorfismia) ja syntyv� konekielinen ohjelma on nopeampi mit� keskiverto ohjelmoija saisi aikaan konekielist� koodia viilaamalla.\n\nYksi inhottava k�yt�nn�n puoli malleissa on. Koska k�ytett�ess� malleja k��nt�j� generoi C++-koodia ja yleisesti ottaen k��nt�j� ei ole kovin luova nime�m��n luokkia, voi tuloksena synty� hyvin kummallisia virheilmoituksia. T�m� on erityisen totta kun k�ytet��n C++:n mallikirjastoa, jossa malleja on k�ytetty ja paljon. Yksi virheilmoitus voi olla sivun pituinen eli toisinsanoen melko k�sitt�m�t�n. Hyv�t k��nt�j�t osaavat tuottaa fiksuja virheilmoituksia my�s malleja k�ytett�ess�, mutta varmasti pitki� itkuvirsi� luritteleviin k��nt�jiinkin t�rm��.\n\nEsittelen nyt laajemman esimerkin mallien k�yt�st�. Siin� on vanha tuttu\n `ListanSolmu<...>` , jota k�ytt�� `LinkitettyLista<...>` - eli homma on hoidettu tyylikk��sti. Listasta instantioidaan `int` - ja `Ammus` -versiot, ja niill� hieman temppuillaan jotta n�hd��n miten homma toimii. Kuten huomaat, mallien kanssa koodista tulee melko monimutkaista. Olen kommentoinut esimerkki� paljon, jotta se varmasti avautuu. Suosittelen viett�m��n hetken jos toisenkin tuon pikku p�tk�n parissa, jotta mallien k�ytt� varmasti aukenee.#include <iostream> using std::cout; using std::endl; // Ensimm�inen malli, linkitetyn listan solmu. T�m� ei n�y listan k�ytt�j�lle. template <class T> class ListanSolmu { public: ListanSolmu(); // Kuten huomaat, C++ sallii pient� lepsuilua muodostimen nime�misess� //ListanSolmu<T>(); // Tarkkaan ottaen oikean niminen muodostin (toimii my�s) void asetaAlkio(const T* alkio); const T* annaAlkio(); void asetaSeuraava(ListanSolmu<T>* seuraava); ListanSolmu<T>* annaSeuraava(); private: const T* alkio; // Alkio on const T*, koska se ei voi muuttua ListanSolmu<T>* seuraava; // Seuraava solmu linkkien ketjussa }; // Kun mallimetodi m��ritell��n, ei se kuulu luokkaan vaan malliin // (eli ListanSolmu::ListanSolmu() ei kelpaa) template <class T> ListanSolmu<T>::ListanSolmu() { alkio = 0; seuraava = 0; } template <class T> void ListanSolmu<T>::asetaAlkio(const T* alkio) { this->alkio = alkio; // this, jotta luokan alkio ja parametrialkio eiv�t sekoitu } template <class T> const T* ListanSolmu<T>::annaAlkio() { return alkio; } // Huomaa, ett� seuraava:n tyyppi ei ole ListanSolmu. K��nt�j� pystyy p��ttelem��n // tyyppej� ja t�ss� k�visi my�s pelkk� ListanSolmu, mutta ListanSolmu<T> on tarkka // ja yleens� kannattaa m��ritell� aina mahdollisimman tarkasti mit� haluaa, k��nt�j�n // j�rjenlentoon ei ole aina luottaminen... template <class T> void ListanSolmu<T>::asetaSeuraava(ListanSolmu<T>* seuraava) { this->seuraava = seuraava; } template <class T> ListanSolmu<T>* ListanSolmu<T>::annaSeuraava() { return seuraava; } template <class T> class LinkitettyLista { public: LinkitettyLista(); void LisaaListaan(const T& alkio); const T& AnnaEnsimmainen(); const T& AnnaSeuraava(); bool OnkoViimeinen(); private: ListanSolmu<T>* alku; // Ensimm�inen solmu, ei sis�ll� listan tietoa ListanSolmu<T>* nykyinen; // Listan l�pik�ynti� varten }; template <class T> LinkitettyLista<T>::LinkitettyLista() { alku = new ListanSolmu<T>; // Tyhj� \"otsikkosolmu\" nykyinen = alku; } // LisaaListaan lis�� listan loppuun template <class T> void LinkitettyLista<T>::LisaaListaan(const T& alkio) { // Luo uusi solmu tietoa varten ListanSolmu<T>* uusi = new ListanSolmu<T>(); uusi->asetaAlkio(&alkio); // L�hde liikkeelle nykyisest� ja kulje listan loppuun asti ListanSolmu<T>* solmu = nykyinen; while (solmu->annaSeuraava() != 0) solmu = solmu->annaSeuraava(); // Lis�� listan jatkoksi solmu->asetaSeuraava(uusi); // P�ivit� nykyinen nykyinen = uusi; } template <class T> const T& LinkitettyLista<T>::AnnaEnsimmainen() { nykyinen = alku; // Otsikkosolmusta ei voi viel� ottaa alkiota koska se on tyhj� return AnnaSeuraava(); } template <class T> const T& LinkitettyLista<T>::AnnaSeuraava() { // Ota askel eteenp�in linkkien ketjussa nykyinen = nykyinen->annaSeuraava(); // Jos olemme tulleet loppuun, palauta nolla (muuntuu tyypiksi T) if (nykyinen == 0) return 0; // Palauta itse alkio return *(nykyinen->annaAlkio()); } // bool on kaksiarvoinen tietotyyppi (tosi / ep�tosi) // int k�visi my�s paluuarvon tyypiksi template <class T> bool LinkitettyLista<T>::OnkoViimeinen() { // Olemmeko yli listan lopun? return nykyinen != 0; } // Listan kokeilua varten class Ammus { int x; int y; int z; }; int main() { // Luo numerolista LinkitettyLista<int> pisteet; // Lis�� sinne muutamia lukuja pisteet.LisaaListaan(1); pisteet.LisaaListaan(2); pisteet.LisaaListaan(3); pisteet.LisaaListaan(4); pisteet.LisaaListaan(5); // Katsotaan tulevatko oikeat luvut ulos... for (int i = pisteet.AnnaEnsimmainen(); pisteet.OnkoViimeinen(); i = pisteet.AnnaSeuraava()) cout << i << endl; // Instantioidaan listasta my�s Ammus-versio (eli luokka LinkitettyLista<Ammus>) LinkitettyLista<Ammus> paukut; paukut.LisaaListaan(*new Ammus()); return EXIT_SUCCESS; } \n\n# Mallien spesialisointi\n\nMalleja ei voida soveltaa pelk�st��n luokkiin ja niiden metodeihin, vaan my�s yksitt�isiin funktioihin. On siis mahdollista luoda funktio summaa, jossa summattavien tyyppi on parametrisoitu:\ntemplate <class T> summaa(T t1, T t2) { return t1 + t2; } int i = summaa<int>(1, 2); // esimerkki funktion k�yt�st� \nMiten toimisi\n `summaa<string>` ? No huonosti, koska se ei summaisi merkkijonoja vaan yhdist�isi ne. Meid�n tulisi siis pysty� ohjelmoimaan malli t�lle erikoistapaukselle. Aivan kuten luokka voidaan periytt�� ja siit� luoda erikoistunut lapsiluokka, my�s malleja voi spesialisoida. Spesialisoitu versio summaa-funktiosta voi k�ytt�� yleisemp�� versiota hyv�kseen, vain muuttaen merkkijonot luvuiksi ja tuloksen takaisin merkkijonoksi. Huomaa t�rke� ero t�ydellisen (complete spesialisation) ja osittaisen (partial spesialisation) spesialisoinnin v�lill�: t�ydellinen spesialisointi on luokka, osittainen taas malli jonka parametrisoinnit ovat vain yleist� mallia rajatumpia. Eli summaa<string> on t�ydellinen spesialisointi, koska siin� tyyppi ei ole mill��n tavalla parametrisoitu, kun taas summaa<T*> on osittainen, koska siin� tyyppi voi olla mit� vain, sill� rajoituksella ett� se on osoitin. T�ydellisess� spesialisoinnissa ei parametrilistassa saa olla tyyppej�, koska niit� ei k�ytet� mallin rungossa.#include<cstdlib> #include<iostream> #include<sstream> #include<string> // Yleinen summaa-malli template <class T> T summaa(T t1, T t2) { return t1 + t2; } // Koska teemme t�ydellisen spesialisoinnin, m��rittelemme paluuarvon // ja parametrit string-tyyppisiksi. Koska emme k�yt� parametrisoitua // tyyppi� T, se ei my�sk��n saa olla mallin parametrilistassa. // Vain osittainen spesialisointi saa k�ytt�� parametrisoitua tyyppi�, // (esim. T* olisi osittainen spesialisointi) - mutta t�ydellisess� // spesialisoinnissa parametrisointia ei tietenk��n tarvittaisikaan! template <> string summaa<string>(string t1, string t2) { // T�m� metodi itseasiassa tekee vain tyyppimuunnoksia // ja delegoi itse ty�n yleiselle mallille stringstream ss; // jotta voimme muuttaa intin stringiksi // kutsutaan yleisen version int-instanssia hoitamaan itse homma ss << summaa<int>(std::atoi(t1.c_str()), std::atoi(t2.c_str())); return ss.str(); // tyyppimuunnos takaisin } int main() { string kolme(\"3\"), nelja(\"4\"); std::cout << summaa<string>(kolme, nelja); return EXIT_SUCCESS; } \nKuten todettiin, spesialisoinnin voi tehd� esimerkiksi kaikille osoittimille. T�llainen tarve tulee esille, mik�li malli vaatii operaatioita, jotka on m��ritelty (j�rkev�sti) osoittimen osoittamassa tyypiss�. Hyv� esimerkki on summaa. summaa<int*> palauttaa kahden osoittimen yhteenlasketun osoitteen, mik� on t�ysin hy�dyt�n tulos. Parempi olisi, ett� se palauttaisi osoittimen int-lukuun, joka on annettujen osoittimien osoittamien lukujen summa. Mik�li osoittimet ovat tyyppi� void*, ei tietenk��n mit��n summaa voida laskea ja silloin palautetaan tyhj� osoitin (osoitin, jonka arvo on 0). T�m� saataisiin aikaan seuraavilla malleilla (pelk�t esittelyt):\ntemplate <class T> summaa(T t1, T t2); template <class T> summaa<T*>(T t1, T t2); template <class T> summaa<void*>(T t1, T t2); \nK��nt�j� poimisi aina kaikista spesialisoiduimman version, eli\n `void*` -osoittimille `void*` -version, muille osoittimille osoitinversion ja yleisen version lopuille. Huomaa ett� osoitinversion parametrit eiv�t ole T*-tyyppisi�, vaan T-tyyppisi�. Jos luodaan `summaa<int*>` , sopii tyyppimaski T* tyyppiin int* niin, ett� T on int. Eli silloin summaa saisi int-parametreja. \n\n# Mallit k�yt�nt�jen parametrisoijana\n\nEhdottomasti yleisin tapa k�ytt�� malleja on tietorakenneluokkien luominen. Koska rakenteiden tulee toimia kaikilla tietotyypeill� ja koska niiden tulee olla nopeita, sopivat mallit kuin nyrkki silm��n. Toinen hyv� k�ytt�kohde malleille on k�yt�nt�jen parametrisointi (policy parametrization). Siis mahdollisuus p��tt�� jonkin toiminnon toteutus tarpeen mukaan. Esimerkki voisi olla mallifunktio \"suositeltavampi\":\ntemplate <class T> suositeltavampi(T t1, T t2) { if (ti > t2) return t1; else return t2; } \nSe valitsisi kahdesta sy�tteest� aina paremmin soveltuvan. Mutta soveltuvuus ei ole pelk�st��n suureemmuutta, olisi siis hyv� jos vertailuehto olisi asetettavissa tilanteen mukaan. Eli toisinsanoen olisi hyv�, jos vertailuk�yt�nt� olisi parametrisoitavissa. Voimmekin tehd� luokan, jossa on m��ritelty staattinen vertailumetodi ja joka voidaan antaa suositeltavampi-mallille parametrina. T�t� luokkaa kutsutaan k�yt�nt�luokaksi (policy class):\n#include<iostream> #include<string> using std::string; using std::cout; using std::endl; // K�yt�nt�, joka suosii pidempi� rakenteita. // Toimii vain tyypeill� jotka sis�lt�v�t metodin \"int size()\". template <class T> class Pidempi { public: static bool ParempiKuin(T t1, T t2) { return t1.size() > t2.size(); } }; template <class T, class K> T suositeltavampi(T t1, T t2) { if (K::ParempiKuin(t1, t2)) return t1; else return t2; } int main() { string nimi1(\"Aki\"); string nimi2(\"Aki-Petteri\"); // Huomaa t�rke� v�lily�nti > > -merkkien v�liss�, ettei sit� // tulkita >>-operaattoriksi! string lapsenNimi = suositeltavampi<string, Pidempi<string> >(nimi1, nimi2); cout << \"Kastan sinut \" << lapsenNimi << \"...\" << endl; return EXIT_SUCCESS; } \nHyvi� k�ytt�kohteita parametrisoiduille k�yt�nn�ille ovat juuri vertailut (esimerkiksi tietorakenteen j�rjestely suuruusj�rjestykseen) tai pysyvien olioiden instantiointi (haetaan verkon yli, luetaan tiedostosta, luetaan tietokannasta jne...). Huomaa, ett� my�s virtuaalifunktioita k�ytt�en voidaan saavuttaa sama asia. Virtuaalifunktiolla toteutettuna my�s k�yt�nt�� voidaan vaihtaa kesken suorituksen - toisin kuin mallien avulla. Mutta toisaalta mallit ovat rutkasti nopeampia, mik� on erityisen t�rke�� jos k�sitelt�v�n tiedon m��r� on suuri, kuten tietorakenteita tai suuria pysyvien olioiden laumoja k�sitelless� asia yleens� on.\n\n# Mallien monimutkainen k�ytt�\n\nMallien erikoisemmat k�ytt�mahdollisuudet perustuvat kahteen asiaan: mallien avulla ei voi parametrisoida pelk�st��n tyyppej� (esimerkiksi\n `class T` ), vaan my�s ihan normaaleja muuttujia (kuten `int i` ). Lis�ksi muuttujan tyyppi voi olla mallissa parametrisoitu tyyppi, kunhan parametrisoidun tyypin m��rittely on ennen muuttujan m��rittely�. Pieni esimerkki selvent�nee asiaa:#include<iostream> template <class T, int koko, T oletusarvo> class Taulukko { public: Taulukko() { for (int i = 0; i < koko; i++) taulu[i] = oletusarvo; } T taulu[koko]; }; int main() { Taulukko<int, 2, 3> luvut; std::cout << luvut.taulu[1] << std::endl; // tulostaa 3... return 0; } \nN�in voi luoda taulukon, joka on sovellettavissa kaikille tyypeille ja josta voidaan luoda oikeankokoinen versio eri tarkoituksiin. Koska luominen ja koon asettaminen tapahtuu k��nn�ksen yhteydess�, voi k��nt�j� optimoida taulukon k�ytt�� paremmin kuin ajonaikaisia rakenteita. T�m� tarkoittaa my�s sit�, ett� koko- ja oletusarvo-parametrien tulee olla vakioita. Jokaiselle k�ytetylle eri tyypin, koon ja oletusarvon yhdistelm�lle luodaan oma luokkansa k��nn�ksen aikana, joten normaali muuttuja ei kelpaa: sen arvoa kun ei voi tiet�� viel� k��nn�ksen aikana. Vaikka t�llainen mallimagia onkin mahdollista, kannattaa kuitenkin usein mietti� onko se perusteltua. Mallien k�yt�ss� on yleens� paras rajoittua geneerisiin tietotyyppeihin ja tarvittaessa k�yt�nt�jen parametrisointiin.\n\n# Mit� mallit abstraktisti ovat? *\n\nPeriytt�misell� toteutetun polymorfismin avulla voidaan luoda koodia, joka pystyy k�sittelem��n useita eri tyyppej�. Siin� kaikki perustuu kantaluokkaan, eli koodin vaikutusalue voidaan ajatella puuna, jonka juurena on kantaluokka ja oksina periytyv� luokkahierarkia. Malleilla toteutetun koodin vaikutusalue on kaikkien niiden tietotyyppien lista, jotka tukevat kaikkia koodissa k�ytettyj� operaatioita - mit��n j�rke� operaatioissa ei tarvitse olla, kunhan ne on m��ritelty. Malleihin verrattuna polymorfismi on t�sm�ase, sen vaikutusalue on pienempi ja paljon rajatumpi: vaikka kantaluokkaa k�sittelev�n koodin kirjoittaja ei voikaan aina arvata, millaisia lapsiluokkia luokalla tulee olemaan, niin huomattavasti vaikeampi on mallia kirjoittavan ohjelmoijan arvata mink�laiset luokat tulevatkaan tukemaan mallin vaatimia operaatioita - ja miten j�rjett�m�sti ne sen tulevat tekem��n.\n\nItseasiassa mallien k�ytt�kin voidaan ajatella polymorfismina. Puhutaankin C++:n kahdesta erilaisesta polymorfismista, k��nn�ksenaikaisesta - tai parametrisoidusta - polymorfismista (mallit) ja ajonaikaisesta polymorfismista (periytt�minen ja virtuaalifunktiot). N�ill� kahdella on sek� k�yt�nn�llisi� ett� teoreettisia eroja. K�yt�nn�ss� mallit ovat nopeampia, mutta hieman hankalampia ja ep�intuitiivisempia.\n\nTeoreettisesti t�rkein ero on vaikutusalueella. Ajonaikaisen polymorfismin vaikutusalue on pienempi, mutta ennen kaikkea hallittavampi. Koska virtuaalifunktioiden m��rittelyt rajoittavat huomattavasti lapsiluokkien toteuttajia, on polymorfisen koodin kirjoittajalla paljon selke�mpi ja rajatumpi kuva koodin vaikutuksesta kohteena oleviin tietotyyppeihin.\n\nYleens�, kuten my�s t�ss� oppaassa, polymorfismilla viitataan juuri ajonaikaiseen polymorfismiin ja mallien avuilla luotua monimuotoisuutta kutsutaan geneeriseksi ohjelmoinniksi. Geneerinen eli yleinen kuvaa hyvin mallien k�ytt��: malli eli parametrisoitu ohjelmanp�tk� antaa yleisen valtakirjan kaikille, jotka sit� haluavat k�ytt��. Perinteinen polymorfismi vaatii hyvin rajoittavasti, ett� kohteena oleva olio on jotakin tietty�: lapsiluokan olio on kantaluokan olio, siis PaloAuto on Auto. Vaikka polymorfinen koodi voikin k�sitell� PaloAutoja, KuormaAutoja ja PakettiAutoja, ne kaikki ovat Autoja. Vastakohtana geneerinen lista voidaan instantioida Autoille tai int*-osoittimille, eik� Auto ole int* tai int* ole Auto. Niill� ei ole juuri mit��n muuta yhteist�, kuin ett� niiss� on m��ritelty sijoitusoperaattori - mik� riitt��kin linkitetyn listan toteutukselle. T�m� yleisyys voi olla vaarallistakin ja johtaa v��rin toimivaan koodin: esimerkiksi yhteenlasku on normaali toimitus numeroille, mutta kahdella osoittimella tehtyn� ynn�ys ei tuota mit��n j�rkev�� - mutta on mahdollista!\n\nToki malleja on mahdollista spesialisoida ja luoda osoittimille oma versionsa, joka tuottaa j�rkevi� tuloksia. T�ss� kuitenkin havaitaan, ett� liian pitk�lle vietyn� p��dymme kopioimaan tietotyyppien v�lisi� suhteita (esim. luokkahierarkiat) omassa spesialisaatiorakenteessamme, mik� ei ole hyv� merkki - kaksinkertainen rakenne on tuhatkertainen p��nvaiva. Voikin havaita, ett� parametrisoiduilta tyypeilt� ei saa vaatia kovin useita tai monimutkaisia operaatioita - niit� tulisi k�ytt�� hyvin rajatulla tavalla. Mik�li t�h�n ei pystyt�, on hyv� ratkaisu tehd� v�liin erillinen kerros geneerisi� tyyppej�, joiden avulla operaatiot voidaan suorittaa. Esimerkki t�st� l�ytyy C++:n standardikirjastosta (STL:st�), jossa algoritmit kuten j�rjestely ovat yhteydess� tietorakenteisiin erillisten iteraattorien avulla.\n\nMalleja ja perimist� on mahdollista yhdist��. Malliluokka voi peri� tavallisen luokan tai malliluokan, tavallinen luokka ei tietenk��n voi peri� malliluokkaa. Mutta mik�li periminen laajennetaan t�ysimittaiseksi olio-ohjelmoinniksi (mukaanlukien virtuaalifunktioiden k�ytt�), ei malleja kannata sotkea en�� mukaan. Parametrisoiduista virtuaalifunktioista tehdyt \"tuplapolymorfiset\" rakennelmat ovat hyvin vaikeita hahmottaa. Yleisesti ottaen olio-ohjelmointia ja geneerist� ohjelmointia ei kannatta yhdist�� - oliorakennelmat voivat kyll� k�ytt�� geneerist� kirjastoa (kuten STL:��) tai geneerinen ohjelma voi k�ytt�� oliopohjaista j�rjestelm��, kunhan niiden v�linen raja on selke�.\n\n# Geneerinen ohjelmointi *\n\nGeneeriseen ohjelmointiin voi pureutua vertaamalla sit� olio-ohjelmointiin. Toki geneeriset ohjelmatkin sis�lt�v�t olioita ja luokkia, mutta olio-ohjelmoinnilla tarkoitan t�ss� koko konseptia, periytymist�, virtuaalifunktioita, luokkahierarkioita ja yleens� kaiken mallintamista olioiden avulla. Olio-ohjelmoinnissa abstraktit k�sitteet mallinnetaan kantaluokkien avulla (esim. Ajoneuvo). Geneerisess� ohjelmoinnissa taas abstraktiot eiv�t ole niin konkreettisia, vaan vaatimuksia siit� mit� operaatioita parametrisoidun tyypin tulee tukea (esimerkiksi taulukkomuotoisen tietorakenteen tulee tukea indeksointia eli []-operaattoria - eli taulukkomuotoisen tietorakenteen abstraktioon kuuluu vaatimus indeksoinnin tukemisesti).\n\nMik�li vaatimusta ei t�ytet�, johtaa se virheeseen k��nn�ksess�. Kaikkia vaatimuksia ei kuitenkaan voida mallintaa C++:n rakenteiden avulla. Esimerkiksi jos j�rjestelyfunktiolle annetaan j�rjestelt�v�n alueen alku- ja loppupiste, se ei pysty havaitsemaan jos pisteet sijaitsevat eri tietorakenteissa. Oliomallissa luokka Indeksi sis�lt�isi tiedon siit� mihin tietorakenteeseen se kuuluu, joten tarkistaminen olisi paljon helpompaa. Niinp� geneerisest� ohjelmoinnista voidaankin havaita hyvin yleinen ilmi�: mit� laajemmin joku asia on sovellettavissa, sit� voimattomampi se on. Sellainen perustuslaki, jonka kaikki maailman maat voisivat allekirjoittaa, saisi sis�lt�� vain harmaas�vyisen kansilehden.\n\nLaajamittaisessa geneerisess� ohjelmoinnissa tuleekin soveltaa k�yt�nt��, jolla abstraktioiden vaatimukset voidaan dokumentoida selke�sti. Mit� vaaditaan tietorakenteelta? Ent� taulukolta? Geneerisen ohjelmoinnin yhteydess� puhutaan konsepteista, eli m��ritelmist� jotka kuvaavat kuinka eri osat ovat yhteydess� toisiinsa ja kuinka j�rjestelm��n voidaan lis�t� uusia ominaisuuksia. Jotta suurta geneerist� j�rjestelm�� voi hallita ja kehitt��, tulee konseptit dokumentoida selke�sti.\n\nGeneerisess� ohjelmoinnissa p��roolissa eiv�t ole luokat. Esimerkiksi algoritmit - siis k�yt�nn�ss� mallifunktiot - ovat keskeisi�. Luokkien v�lill� ei my�sk��n ole juurikaan riippuvuuksia, kuten olio-ohjelmoinnissa. Jotta yleisi� operaatioita voidaan soveltaa luokkiin, luokkien tulee olla yksinkertaisia - joten niiden yhdistely, periytt�minen ja muut vastaavat monimutkaisuudet eiv�t ole k�ytett�viss�. J�rjestelm�n �lykkyys ei ole luokkien sis�ll�, vaan siin� miten algoritmeja sovelletaan tietorakenteisiin.\n\nGeneerisille j�rjestelmille on yleist� k�yt�nt�jen parametrisointi. Toisaalta luokat ovat kapseloituja yksikk�j�, mutta toisaalta niist� on erotettu tiettyj� k�yt�nt�j�, jotka on parametrisoitu. K�yt�nn�t ovatkin luokan kapseloimaan k�sitteeseen verrattuna eri ulottuvuudessa - siis sill� miten tietorakenteita j�rjestell��n ei ole merkityst� erilaisten tietorakenteiden muodostamassa ulottuvuudessa. K�yt�nn�t ovatkin hyvin samantyyppinen ratkaisu kuin aspektit olio-ohjelmoinnissa.\n\nYhteenvetona voisi todeta, ett� geneerinen ohjelmointi ei ole er�s olio-ohjelmoinnin erityistapaus. Geneerinen tapa k�sitell� abstraktioita on erilainen ja huonommin C++-kielen tukema kuin oliomallinnuksessa. Niinp� geneerist� ohjelmointia ei tulisikaan soveltaa suuriin sovelluksiin: oliomallinnuksen on todettu auttavan suurten sovelluksien mallintamisessa, mutta geneerinen ohjelmointi ei sis�ll� yht� voimakkaita ominaisuuksia. Yleisk�ytt�isten kirjastojen tai alij�rjestelmien toteuttamiseen geneerinen ohjelmointi soveltuu hyvin, josta oiva esimerkki ovat yleiset tietorakenteet ja algoritmit, jotka C++:n STL-standardikirjastossa on toteutettu geneerisen ohjelmoinnin avulla.\n\n# Standard Template Libraryn idea\n\nSTL on C++:n oma kirjasto, joka sis�lt�� kaikenlaista yleishy�dyllist� kivaa. Se on toteutettu pitk�lti mallien avulla, geneerisen ohjelmoinnin periaatteiden mukaan. STL ei ole pelk�st��n kokoelma hy�dyllisi� ohjelmanp�tki�, vaan laajennettava kehysj�rjestelm� (framework), jonka avulla voidaan luoda uusia geneerisi� j�rjestelmi�.\n\nSTL:n ytimen muodostovat tietorakenteet (containerit tai suomettuneesti \"kontit\") ja niihin sovellettavat algoritmit. Niiden v�liss� ovat iteraattorit. Voidaan ajatella, ett� iteraattori on abstraktio tietorakenteiden k�sittelyst�, samalla tavalla kuten naulaaminen on abstraktio naulan ja naulaajan v�lisest� toiminnasta. Iteraattoreiden avulla voidaan erottaa toiminnallisuus (algoritmit) ja data (tietorakenteet) - kun vertaat t�t� l�hestymistapaa oliosuunnitteluun, huomaat kuinka se eroaa \"luokassa on kapseloitu toiminnallisuus ja data\" -ajattelusta.\n\n# Tietorakenteet ja l�hes tietorakenteet\n\nContainerit, kontit, tietorakenteet - miksi niit� haluaakaan kutsua - ovat STL:n ydin. STL:n tietorakenteet astuvat kuvaan kun taulukot eiv�t riit�. Geneerisen ohjelmoinnin periaatteiden mukaan eri tietorakenteiden v�lill� ei ole juurikaan yhteyksi�: mit��n tietorakenteiden hierarkiaa ei ole. Koska suorituskyky on hyvin t�rke�� yleisk�ytt�isess�, suuria tietom��ri� k�sittelev�ss� koodissa, ei rakenteisiin ole toteutettu sellaisia ominaisuuksia jotka eiv�t ole niille ominaisia - eli sellaiset ominaisuudet jotka olisi ollut mahdollista toteuttaa, mutta jotka olisivat toimineet hitaasti, on j�tetty pois (esimerkkin� listan indeksointi).\n\nT�rkeimm�t containerit ovat: vector<...>, joka on vektori eli taulukko jonka koko voi muuttua; list<...> eli linkitetty lista, k�tev� kun alkiota lis�t��n ja poistetaan paljon; stack<...> eli pino ja queue<...> eli jono, ensimm�isen� laitettu alkio tulee pinosta viimeisen�, jonosta ensimm�isen� (kuten nimist� voikin p��tell�); map<...> eli sanakirja eli hakupuu, josta alkiota voidaan hakea nopeasti avaimen perusteella (kuten nimi numeron perusteella) ja set<...> eli joukko, jossa samanarvoisia alkioita voi olla vain yksi. Hyvin pitk�lle p��see jo vector<...>, list<...> ja map<...> -kolmikolla. Lis�ksi l�ytyv�t puoliveriset tietorakenteet, kuten string eli merkkijono ja array eli normaali taulukko, jotka tukevat osittain containerien operaatioita.\n\n# Iteraattorit\n\nSTL:n tietorakenteet eiv�t ole samasta tyypist� periytettyj�, joten jotta algoritmej� (kuten j�rjestely) ei tarvitse toteuttaa erikseen niille kaikille, tulee v�liss� olla jotakin. Se jotakin on iteraattorit. Iteraattorit ovat abstrahoituja iteroimisen eli plaraamisen tapahtumia: jos tietorakenteet olisivat kirjoja, niin iteraattorit olisivat \"sivunk��ntimi�\". Iteraattoreilla ei my�sk��n ole yhteist� kantaluokkaa, mutta ne tukevat samoja operaatioita. T�rkeimpi� ovat kasvatus (i++, ++i, i += 4) ja vastaavat v�hennykset sek� alkion arvon haku (*i). Kuten huomaat, normaali osoitin taulukon alkioon on my�s iteraattori: sit� voidaan kasvattaa, jolloin se siirtyy alkion koon mukaisilla askelilla ja *-operaattorilla saadaan sen osoittama arvo.\n\nKun iteraattori luodaan, tulee luonnollisesti tiet�� sen tyyppi. Sen l�ytyy m��riteltyn� (typedefin avulla) tietorakenteen luokasta, nimell� iterator. Mik�li iteraattorin avulla vain luetaan tietoja, voimme k�ytt�� tyyppi� const_iterator. Koska tyypin m��rittely tietorakenneluokan kautta on kohtuullisen vaivalloinen kirjoittaa, kannattaa usein m��ritell� uusi tyyppinimi sille (eli k�ytt�� typedefi�). T�ss�p� esimerkki, toivottavasti n�et kuinka takana olevien tietorakenteiden erot h�vi�v�t kun niit� k�sitell��n iteraattorien kautta:\n#include<iostream> #include<vector> #include<list> #include<string> int main() { // otetaan kaksi containeria vector<string> vec; list<string> lis; // ty�nnet��n niihin tietoa (vec:ss� on tuplasti enemm�n alkioita) vec.push_back(string(\"Satu\")); vec.push_back(string(\"meni\")); lis.push_back(string(\"saunaan,\")); vec.push_back(string(\"pani\")); vec.push_back(string(\"laukun\")); lis.push_back(string(\"naulaan.\")); // Otetaan iteraattorit, huomaa ett� iteraattorien tyyppi tulee aina // ottaa luokan tyyppim��rittelyist�, yleens� kannattaa m��ritell� typedef // helpottamaan kirjoittamista - kuten j�lkimm�isess� on tehty vector<string>::iterator vi = vec.begin(); typedef list<string>::iterator list_iter; list_iter li = lis.begin(); // Kunnes vektorin iteraattori tulee loppuun... while (vi != vec.end()) { // Ensin otetaan iteraattorin osoittama arvo (*-operaattori), sitten // kasvatetaan sit� std::cout << *vi++ << \" \"; std::cout << *vi++ << \" \"; std::cout << *li++ << \" \"; } return EXIT_SUCCESS; } \n\n# Algoritmit\n\nOlen v�sym�tt�m�sti toistanut, kuinka iteraattorit toimivat tietorakenteiden ja algoritmien v�liss�. Ja nyt se n�hd��n: algoritmit eiv�t sy� tietorakenteita, vaan tarvitsevat iteraattorin tietorakenteen alkuun ja loppuun. Eli vektori (mik� tahansa muu tietorakenne) j�rjestell��n:\nsort(vektori.begin(), vektori.end()); \nT�rkeimpi� algoritmeja ovat: sort, joka j�rjestelee tietorakenteen (ei voi k�ytt�� listaan!); merge joka yhdist�� kaksi j�rjestelty� rakennetta s�ilytt�en j�rjestyksen; unique joka siirt�� duplikaatit (samat alkiot) j�rjestellyst� rakenteesta loppuun ja palauttaa iteraattorin uniikkien alkioiden alueen loppuun; find joka etsii jonkin alkion ja palauttaa iteraattorin siihen; count joka laskee tiettyjen alkioiden lukum��r�n ja max_element (tai min_element vastaavasti) joka paluttaa iteraattorin suurimpaan elementtiin. Allapa on henkil�stohallinnollinen esimerkki, huomaa kuinka n�ps�k�sti algoritmit toimivat ihan tavallisten C-taulukoiden kanssa:\n#include<string> #include<vector> #include<algorithm> #include<iostream> using std::cout; using std::endl; int main() { vector<string> tyontekijat; tyontekijat.push_back(string(\"Raimo\")); tyontekijat.push_back(string(\"Liisa\")); tyontekijat.push_back(string(\"Kalle\")); tyontekijat.push_back(string(\"Liisa\")); tyontekijat.push_back(string(\"Benjamin\")); // j�rjestell��n ty�ntekij�t sort(tyontekijat.begin(), tyontekijat.end()); // Liisoja on kaksi, erotetaan toinen kun ei koskaan muista // ett� kumpi on kumpi vector<string>::iterator new_end = unique(tyontekijat.begin(), tyontekijat.end()); // Hesekiel tulee Kallen tilalle *find(tyontekijat.begin(), new_end, string(\"Kalle\")) = string(\"Hesekiel\"); for (vector<string>::const_iterator i = tyontekijat.begin(); i != new_end; ++i) cout << *i << endl; int palkat[] = {17000, 11000, 9000, 9000}; cout << \"Yhdeks�� tonnia saa \" << count(&palkat[0], &palkat[4], 9000) << \", suurin palkka on \" << *max_element(&palkat[0], &palkat[2]) << endl; return EXIT_SUCCESS; } \n\n# Virrat\n\nC++:n virrat ovat hyvin monipuolisia vekkuleita. Kaikki on parametrisoitu: esimerkiksi sovittaminen uuteen merkist��n on t�ysin mahdollista. Normaali kuolevainen ohjelmoija kuitenkin harvoin tarvitsee tuonkaltaisia ominaisuuksia. Peruskoodaajan kannalta t�rkein asia on mahdollisuus omien tyyppien sovittamiseen mukaan virtoihin. Se tapahtuu m��rittelem�lle operaattori <<, joka saa parametrikseen virran ja sinne pukattavan kanootin. Hyvin n�pp�r� apu ovat my�s stringstreamit, virrat jotka tulostavat merkkijonoon. Niit� on kiva k�ytell� lukujen muuttamiseen merkkijonoiksi, t�h�n tyyliin:\n#include<iostream> #include<sstream> #include<string> // oma lukutyyppimme, ei viel� vakiintunut normaalik�yt�ss� class huuhaaluku { public: int hups; int hips; }; ostream& operator<<(ostream& o, const huuhaaluku h) { stringstream ss; ss << h.hups * 5 + h.hips << \"!!\" << h.hips; return o << ss.str(); } int main() { huuhaaluku h; h.hips = 5; h.hups = 3; std::cout << \"Huuhaa: \" << h << std::endl; return EXIT_SUCCESS; } \n\n# Numerot ja matematiikka\n\nSTL tarjoaa moninaisia ominaisuuksia my�s numeerisiin karkeloihin. Tavallisimpia on numeric_limits<...>-malli, jolla saa selville eri numerotyyppien lukualueiden rajoja ja perinteiset matemaattiset funktiot kuten sini, kosini, tangentti ja neli�juuri. Paletista l�ytyy my�s matemaattisiin vektorioperaatioihin suunniteltu val_array ja matriisien esitt�mist� varten slice. T�ss� pieni esittelykierros:\n#include<cmath> #include<limits> #include<iostream> using namespace std; // jotta esimerkki s�ilyisi lyhyen�... int main() { cout << \"intin lukualue on \" << numeric_limits<int>::min() << \" - \" << numeric_limits<int>::max() << endl; cout << \"unsigned intin lukualue on \" << numeric_limits<unsigned int>::min() << \" - \" << numeric_limits<unsigned int>::max() << endl; double i = -1.0; // otetaan i:n itseisarvon neli�n neli�juuren sinin arkussinin vastaluku double r = -asin(sin(sqrt(pow(abs(i), 2)))); cout << \"r on \" << r << endl; // pit�isi tulla -1.0, py�ristysvirheet poislukien return EXIT_SUCCESS; } \nTakaisin\n\n# Oliosuunnittelu\n\nJoku risupartainen ja kyynisen kieroutunut vanha jäärä saattaisi sanoa, että kaikki mitä tässä oppaassa on tähän mennessä kerrottu ei edes mitään ohjelmointia olekaan. Vain yksinkertaisia ohjeita siitä miten eräs ohjelmointikieli toimii.\n\nSe on kyllä totta, että ohjelmoinnissa on paljon muutakin kuin ohjelmointikielen osaaminen. C++-kielen kehittäjä Bjarne Stroustrup kirjoittaa kirjassaan, että hän pyrkii opettamaan olio-ohjelmointia eikä C++-kieltä. Joten nyt minäkin vaatimattomasti yritän summata niitä olio-ohjelmointiin liittyviä suuria totuuksia, joihin olen törmännyt varsinkin työelämässä suurempien projektien yhteydessä. Tätä kappaletta voisi kuvata muutamaksi omakohtaiseksi tarinaksi oliosuunnittelusta ja siihen liittyvistä ongelmista.\n\nKappaleet lähtevät jossakin mielessä konkreettisista asioista ja kohoavat yhä käsitteellisemmälle ja myös ristiriitaisemmalle tasolle. Ota siis itseäsi niskasta kiinni ja sinkoa henkinen minäsi maata kiertävälle radalla. Irrottaudumme C++-kielen kiekuroista ja otamme hieman lintuperspektiiviä olio-ohjelmointiin!\n # Luokan kaksi liittymää\n\nKuten tiedät, oliossa yhdistyy tiedot ja toiminnallisuus. Tiedot, ohjelman muuttujat, ovat kapseloituja. Tätä kutsutaan informaation piilotukseksi, information hiding. Huomaa että en puhu tiedoista, ohjelman konkreettisesta datasta, vaan informaatiosta. Informaatiolla tarkoitetaan tietoa siitä, miten luokka oikeasti toimii. Luokka on musta laatikko, informaatio luokan - eli sen olioiden - toiminnasta on piilotettu. Tiedon rakenne, siis muuttujat ja niiden tyypit, kertoo hyvin paljon luokan toiminnasta ja niinpä se pitää piilottaa käyttäjältä, jotta pystymme kätkemään luokan todellisen toiminnan.\n\nNiinpä - käyttäjän näkökulmasta - kaikkein tärkeintä luokassa on sen liittymä. Liittymän muodostavat luokan julkiset metodit: ne ovat mitä ulkopuolinen käyttäjä näkee (huomaa että ystäviksi määritellyt oliot ja funktiot näkevät luokan yksityisenkin tiedon). Julkisen liittymän suunnittelu on tärkeämpää kuin sisäisen toteutuksen: virhe sisäisessä toteutuksessa voidaan korjata lennossa, kulissien takana, käyttäjät eivät huomaa mitään. Mutta mikäli luokan liittymä muuttuu, joutuvat luokan käyttäjät muuttamaan omaa koodiaan. Pahimmassa tapauksessa käyttäjät ovat rakentaneet oman ohjelmansa jonkin ominaisuuden päälle, joka katoaa tai muuttuu - ja käyttäjät ovat silloin todella pulassa.\n\nKun puhun käyttäjistä, ei se tarkoita että tämä koskisi vain yleisesti käytettävien luokkakirjastojen suunnittelijoita. Käyttäjä voi olla ja lähes aina on luokan suunnittelija, sinä! Huomenna tai viikon päästä tai ensi vuonna et muista enää miten tekemäsi luokka tarkkaan ottaen toimii. Mutta muistat kyllä miten sitä käytetään, jos liittymä on taidokkaasti suunniteltu. Kirjoitat luokan tänään ja otat sen käyttöön suuremmassa kokonaisuudessa huomenna. Mikäli luokkasi ei ole kunnolla suunniteltu ja kapseloitu, joudut pohtimaan sitä jatkuvasti, etkä pysty keskittymään muun kokonaisuuden suunnitteluun. Hyvä ohjelmoija on nero, joka luo mahtavia, oivaltavia ja uskomattomia luokkia, kapseloi ne ja unohtaa seuraavana päivänä.\n\nKun suunnittelee luokkaa, on siis ensiarvoisen tärkeää millaisen liittymän luokka julkistaa muille luokille. Eikä siinä kaikki. Luokalla ei nimittäin ole vain yhtä liittymää ulkomaailmaan, vaan itseasiassa kaksi. Luokan näkökulmasta katsottuna ulkomaailma jakautuu kahteen osaan. Keksitkö mihin kahteen?\n\nMitkä luokat ovat erityisasemassa muihin verratuna? No, luonnollisesti kantaluokat. Mutta itseasiassa kantaluokat eivät ole osa ulkomaailmaa, vaan ne ovat osa itse periytettyä luokkaa. Kantaluokat eivät ole vastaus, mutta liippaavat läheltä. Oikea vastaus on lapsiluokat. Lapsiluokat näkevät enemmän kantaluokastaan kuin muut. private-tieto on niille näkymätöntä ja public julkista, kuten kaikille muillekin. Mutta on kolmaskin vaihtoehto, protected eli suojattu näkyvyys. Muistathan? protected on avainsana, jolla määritelty tieto ei näy julkisesti, mutta näkyy kantaluokille.\n\nMilloin tulisi siis käyttää private-näkyvyyttä, milloin vähemmän rajattua protected-näkyvyyttä? En tiedä, en todellakaan tiedä. Olemme nyt nimittäin niin kurjan pitkällä C++:n ominaisuuksissa, että jykeviä totuuksia ei tahdo oikein enää löytyä. Asian tekee erittäin hankalaksi se, että kantaluokka harvemmin tietää lapsiluokistaan - ja vastaavasti luokan ohjelmoija ei voi ennustaa miten luokkaa tullaan periyttämään. Tässä esimerkki tilanteesta:\n > class MuotoiltuAika { private: int sekunteja; public: string annaMuotoiltuAika(); }; string MuotoiltuAika::annaMuotoiltuAika() { string p; int tunteja = sekunteja / 3600; int minuutteja = (sekunteja - (3600 * tunteja)) / 60; if (tunteja % 12 > 0) { p = \"PM\"; tunteja -= 12; } else p = \"AM\"; stringstream ma; ma << tunteja << \":\" << minuutteja << \" \" << p; return ma.str(); } class SuomalainenMuotoiltuAika : public MuotoiltuAika { public: string annaMuotoiltuAika(); }; string SuomalainenMuotoiltuAika::annaMuotoiltuAika() { // ei voi kääntää, koska sekunteja ei näy tähän lapsiluokkaan string p; int tunteja = sekunteja / 3600; int minuutteja = (sekunteja - (3600 * tunteja)) / 60; stringstream ma; ma << tunteja << \":\" << minuutteja; return ma.str(); }\n\nLuokkaa SuomalainenMuotoiltuAika ei voi toteuttaa, koska sekunteja on yksityinen. MuotoiltuAika-luokkaa ei siis voi järkevästi periyttää, siitä ei voi rakentaa erikoistuneita versioita. Se on lajinsa viimeinen. Mikäli sekunteja olisi suojattu (protected), se olisi näkyvissä lapsiluokille ja eri maihin sopivia muotuiluja voitaisiin lisätä. Ja mikäli annaMuotoiltuAika olisi virtuaalinen, voitaisiin muotoiluja käyttää polymorfisesti ja siis ohjelman lokalisointi eli maan merkintätapoihin mukauttaminen olisi erittäin helppoa. MuotoiltuAika-luokan liittymä täysin ulkopuolisiin luokkiin on onnistunut, mutta liittymä lapsiluokkiin on mennyt pieleen.\n\nAinoa resepti näihin tilanteisiin on: mieti! Kun teet luokkaa, jota et itse juuri nyt aio periyttää, niin mieti silti olisiko sitä edes mahdollista järkevästi periyttää. Se on helpommin sanottu kuin tehty, mutta erilaisia tulevaisuuden käyttömalleja miettimällä lopputulos on ainakin parempi kuin keskittymällä pelkästään julkiseen liiittymään - joka toki taas on parempi kuin luokan liittymien suunnittelun unohtaminen kokonaan. Mietintöjen lopputulos ei automaattisesti ole, että luokka avataan lapsiluokille suojatun näkyvyyden avulla ja mahdollinen polymorfinen käyttö otetaan huomioon. Tulos voi hyvinkin olla, että luokkaa ei pidä periyttää - sen sisuskalut ovat sellaisia, että niitä ei voi avata lapsiluokille. Syynä voi olla esimerkiksi se, että luokka tulee ehkä radikaalisti muuttumaan tai että luokan metodit muodostavat monimutkaisen kokonaisuuden jonka muokkaaminen lapsiluokissa johtaisi helposti virheisiin. Tosin kannattaa kysyä, olisiko tällaisessa tapauksessa parempi pilkkoa monimutkainen luokka osiin. Kuitenkin: syvällisten pohdintojen perusteella voi olla perusteltu ratkaisu sulkea luokka periyttämiseltä kokonaan.\n\nOnko tähän olemassa muita niksejä tai suuria teorioita? Niksejä kyllä. Niihin voit tutustua perehtymällä suunnittelumalleihin (design patterns). Suuria teorioita ei ole. Periyttäminen on mielestäni kiinnostava asia myös teoreettisessa mielessä. Yllä esiteltyä ongelmaa pidetään oliomallin suurimpana heikkoutena, tosin yleensä ajateltuna toisin päin: miten lapsiluokka voi suojautua kantaluokan muutoksilta. Mikäli minulta kysyttäisiin mikä olisi paras ratkaisu näissä perintään liittyvissä ongelmassa, voisi vastaukseni hyvinkin olla: hankkiutua periytymisestä kokonaan eroon. Miksikö? Se on pitkä tarina, en sitä tässä yhteydessä käsittele. Mutta voit ajatusleikkinä miettiä millaista olio-ohjelmointi olisi ilman yhteisen toiminnallisuuden jakamista luokkahierarkioiden avulla.\n # Ohjelmoinnin ihmissuhdeteoria\n\nHyvät ystävät ovat ihmisiä, joihin voi luottaa. Hyvälle ystävälle voi vaikka antaa oman pankkikorttinsa tunnuslukuineen. Mattobasaarin kauppiaalle sen sijaan en suosittelisi kovin luottamuksellisten luottotietojen luovuttamista. Miten tämä sitten liittyy ohjelmointiin?\n\nOhjelmien maailmassa ei ole ystäviä. Kaikki ovat helppoheikkejä ja kepuliveivareita, jotka yrittävät huijata sinua. Puhun nyt luonnollisesti olioista ja muista ohjelman osista. Ohjelmia suunnittellessa pitäisi lähteä siitä, että olio tai muu ohjelman osa ei saa kertoa itsestään muille mitään, mitä voitaisiin käyttää sitä vastaan. Käännän äskeisen esimerkin C++-kielelle, jossa kaikki ovat ystäviä keskenään ja luottavat toisiinsa:\n > class CreditCard // luottokortti { public: void transferMoney(int amount, string secretNumber, string destAccount); void bill(int amount, string destAccount); }; class Person // henkilö { public: CreditCard* getCreditCard(); string getSecretNumber(); private: CreditCard card; string secretNumber; }; class AnotherPerson // toinen henkilö, paras kaveri { void bill(Person& bestFriend); private: string myAccount; }; void AnotherPerson::bill(Person& bestFriend) // laskuta toisen luottokorttia { // laskuta luottokorttia, tämän metodin tarkoitus bestFriend.getCreditCard()->bill(100, myAccount); // AnotherPerson voisi myös kavalasti nostaa rahaa kaverinsa tililtä // bestFriend.getCreditCard()->transferMoney(10000, bestFriend.getSecretNumber(), myAccount); // tai hävittää (tai vaihtaa) kaverinsa luottokortin // delete bestFriend.getCreditCard(); }\n\nTämä rakenne toimii, mutta ei ole hyvä. Se rikkoo informaation piilotuksen periaatetta vastaan. Periaatteen voisi muotoilla myös informaation paikallisuuden periaatteeksi: ohjelman osan rakenteesta ja toiminnasta kertova informaatio tulee pitää mahdollisimman paikallisena. Ystäville voit kertoa kaikki salaisuutesi - mutta ohjelmoinnin maailmassa sinulla pitäisi olla mahdollisimman vähän ystäviä. Rakenteellisesti parempi versio äskeisestä esimerkistä olisi tällainen:\n > class CreditCard // luottokortti (sama kuin äsken) { public: void transferMoney(int amount, string secretNumber, string destAccount); void bill(int amount, string destAccount); }; class billingException {}; // virhe laskutuksessa class Person // henkilö { public: void bill(int amount, string account); protected: CreditCard& getCreditCard(); string getSecretNumber(); private: CreditCard card; string secretNumber; static const int MAX_BILL; }; const int Person::MAX_BILL = 25000; // suurin laskutettava summa class AnotherPerson // toinen henkilö, epäluotettava { void bill(Person& bestFriend); private: string myAccount; }; void Person::bill(int amount, string account) { if (amount < MAX_BILL) card.bill(amount, account); else throw billingException(); } void AnotherPerson::bill(Person& bestFriend) { bestFriend.bill(10000, myAccount); }\n\nTässä versiossa AnotherPerson ei saa CreditCard-oliota haltuunsa eikä voi tehdä sille mitään pahaa. CreditCardin saavat vain Person-luokan alaluokat. Myöskin tunnusnumero on suojattu vain alaluokille. Kun laskutusta ei tehdä suoraan luottokortilla, vaan Person-luokan bill(..)-metodin kautta, voi Person valvoa tapahtumaa ja tarvittaessa heittää poikkeuksen ja estää laskutuksen.\n\nNyt verryttelemme visuaalista hahmotuskykyä: kuvittele ohjelman rakenne verkostona - vaikka ihmissuhteiden verkostona. Huono ohjelma on sellainen, jossa voidaan lähteä jostain kohti verkkoa ja kulkea verkon linkkejä pitkin mihin halutaan. Mikäli jostain ohjelman osasta voidaan saavuttaa tarpeetonta tietoa jonkin toisen osan toiminnasta, ovat nämä kaksi osaa kytkettyjä toisiinsa. Ja kun yksi osa muuttuu, niin joudutaan toistakin muuttamaan. Kun kyseessä ovat verkostot, jossa jokaisen linkin takana on useita uusia, johtaa tämä suunnitteluvirhe työmäärän eksponentiaaliseen räjähtämiseen ja käytännössä siihen, että osa työstä unohtuu ja jää tekemättä eli ohjelmaan tulee virheitä - mikä taas aiheuttaa hankaluuksia.\n\nHyvä ohjelma onkin kuin kartano, joka on täynnä lukittuja huoneita. Huoneesta toiseen näkee pelkästään avaimenreiän kautta. Ja voit kuvitella, että avaimenreiästä ei enää näe toisen huoneen avaimenreikää ja sitä kautta kolmatta huonetta. Siis jos sinun makuuhuoneesi ja uima-altaan välissä on pukuhuone, et koskaan saa tietää mikäli uima-allas jäädytetään ja siihen rakennetaan iglu. Uima-altaan rakenteesta kertova tieto on paikallista, eikä kuulu sinulle, koska et asu siinä. Jos siis hyvää ohjelmaa ajatellaan verkkona, ovat sen linkit kapenevia - niitä ei pysty seuraamaan kuin korkeintaan parin eri ohjelman osan läpi. Koitan havainnollistaa tätä toteamusta pienellä esimerkillä, joka ei onneksi liity millään tavalla igluihin. Siinä on eri funktioita, jotka muodostavat kutsuketjun ja joissa aina seuraava kutsuja saa kapeamman näkymän tietoalkioon - toisinsanoen jokainen saa sellaisen liittymän tietoon, joka on juuri ja juuri riittävä.\n > #include<iostream> using std::cout; using std::endl; void j(const int luku) { // luku++; // tämä olisi laiton, koska luku on vakio tälle metodille (const-parametri) cout << \"j() vain tulostaa luvun: \" << luku << endl; } void i(int luku) { luku++; // luvun paikallinen kopio on 5 cout << \"i(): luku: \" << luku << endl; j(luku); } void h(int* luku) { (*luku)++; // muutan alkuperäistä lukua, tarvitsen siihen osoittimen i(*luku); // *luku on 4 } void g(int** luku) { (*luku)++; // siirrän osoitinta, joten tarvitsen osoittimen osoittimeen h(*luku); // **luku on nyt 3 } int main() { int taulu[] = {1, 2, 3}; int* luku = taulu + 1; // osoittaa lukuun 2 cout << \"*luku \" << *luku << endl; // pitäisi olla 2 g(&luku); cout << \"*luku \" << *luku << endl; // pitäisi olla 4 return EXIT_SUCCESS; }\n\nHuomaa kuinka ketjun ensimmäinen metodi saa kaksoisosoittimen, jonka avulla se voi muuttaa main():ssa olevaa osoitinta. Seuraava saa osoittimen, jolla se voi muuttaa alkuperäistä lukua, seuraava pelkän kopion arvosta jota se voi kasvattaa (mutta se ei vaikuta alkuperäiseen) ja viimeinen pelkästään arvon, jota se ei voi kasvattaa edes paikallisesti. Yksikään metodi ei voisi tehdä enempää kuin nyt tekee. Jokainen metodi siis katsoo aina vaan pienemmästä avainmenreiästä alkuperäistä tietoa eli main()-metodin luku-osoitinta.\n # Oliosuunnittelun pyhä kolminaisuus\n\nOliosuunnittelu on käsitteenä suuri mutta venyvä kuin ohjuskauppiaan omatunto. Nyt kuitenkin ajan mutkat suoriksi ja vedän kulmat pyöreiksi ja yritän summata koko kupletti juonen niin tiiviiksi paketiksi, että se mahtuisi vaikka tekstiviestiin. Opeta itsellesi oliosuunnittelu viidessätoista minuutissa, ole hyvä!\n\nAsian voi parhaiten aukaista pohdiskelemalla käytännön esimerkkiä ja siihen liittyviä ongelmia. Kuvitelkaamme ampumasimulaattori, jossa on kaksi maalityyppiä, ihminen ja nukke, luokat Human ja Dummy. Molempiin voi ampua, mutta Dummyn voi nostaa ylös osuman jälkeen. Molemmat luokat käyttävät samanlaista osumametodia ohjelman ensimmäisessä versiossa. Ohjelmakoodina asia voitaisiin esittää näin:\n > class Human { public: void hit(int precision); }; class Dummy { public: void hit(int precision); void liftUp(); };\n\nMutta hyi hyi! Kyseessähän on selvä ohjelmakoodin kopiointi, täysin samanlainen hit(int)-metodi on koodattu kahteen kertaan. Otetaanpa uudelleen, käyttäen periytymistä avuksi:\n > class Human { public: void hit(int precision); }; class Dummy : public Human { public: void liftUp(); };\n\nSilmää jää hieman kirvelemään nuken periyttäminen ihmisestä, koska nukkehan ei liene ihminen. No, se lienee vain allerginen reaktio, ei sen kummempaa. Yksi todellinen käytännön ongelma koodissa kuitenkin on: kapselointi ei ole täysin kunnossa. Simulaattorin ensimmäisessä versiossa ei ole osumakohtien mallinnusta, mutta sellainen tulee jo seuraavaan versioon. Pohdiskelemalla tätä tulevaisuuden visiota näemme, kuinka kapselointi ei todellakaan ole kohdallaan: pahvisella nukella ei ole osumakohtia, mutta ihmisellä on ja metodia joudutaan muuttamaan, jolloin muutos virheellisesti heijastuu myös nukkeen. Ajatus periyttää ihminen nukesta olikin käytännössä mätä - tarkka silmä ja delikantti vainu ei koskaan erehdy!\n\nVoi itkujen itku ja surkeuksien kurjuus, joudumme ilmeisesti tässä tilanteessa valitsemaan pienemmän kahdesta pahasta. Periytyminen ei vie puusta pitkään, pyörittelipä sitä miten vaan. Nuken periyttäminen ihmisestä ei ainakaan paranna tilannetta. Ihmisolion voisi myös laittaa osaksi nukkeoliota, jolloin nukke voisi delegoida osumien käsittelyn ihmiselle ja ohjelman jatkokehityksessä viritelmä voitaisiin purkaa. Mutta silloinhan jos kentällä olisi enää yksi nukke, laskisi simulaattori siellä olevan myös ihmisen ja se johtaisi määrittelemättömiin ongelmiin. Tämäkin ajatus oli surkea viritelmä jo syntyessään. Lienee parasta tyytyä ensimmäisenä esitettyyn, pieni koodin kopioiminen ei haittaa, kun asia tullaan kakkosversioon kuitenkin muuttamaan.\n\nRatkaisu ei kuitenkaan ole tyydyttävä. Kokemuksestani voin antaa vinkin: jos joku ratkaisu jää hieman kaivelemaan sinua, on se ollut väärä. Toki toisaalta pitäähän ohjelman valmistua ja jotkut ongelmat eivät vaan ratkea. Mutta se johtuu hyvin usein siitä, että olet etsinyt ratkaisua väärältä tasolta. Muista! Kolme tärkeintä oliosuunnittelun menetelmää ovat abstraktio, abstraktio ja abstraktio. Näin on joku alan guru joskus todennyt. Mikä tahansa noista kolmesta ratkaisee tämänkin ongelman.\n\nVoimme luoda abstraktion, yläluokan Target, jossa hit()-metodi on. Siis kun asiaa oikein miettii, niin ihmiset ja nukethan ovat maaleja. Maali on abstrakti käsite, joka yhdistää molempia. Kun kapseloinnin ja uudelleenkäytön ristitulessa yrittää sommitella palasi kohdalleen, on abstraktio juuri se temppu jolla ne loksahtavat. Muuten saa jatkaa venkuilua vaikka maailmanloppuun asti, siltikään ei päädy kuin välttävään ratkaisuun. Ongelma on ratkaistu, opetus opittu, tässä on koodi:\n > class Target { protected: Target(); // suojattu muodostin public: virtual void hit(int precision); }; class Human : public Target { }; class Dummy : public Target { public: void liftUp(); };\n\nKakkosversio ei synny ongelma, Human vain esittelee oman osumametodinsa joka korvaa Target-luokan metodin - ja ehkä jopa käyttää sitä hyväkseen, mikäli uudessa osumankäsittelyssä tarvitaan vanhankin toiminnallisuutta. Käsitteellisellä tasolla luokkahierarkia on myös selkeä eikä mikään jää häiritsemään kokonaisuutta. Kun kapselointi ja uudelleenkäyttö riitelee, niin abstraktio palaset kohdalleen siirtelee. Siinä oliosuunnitteluun mielestäni tärkein idea, pyhä kolminaisuus.\n\nMuodostinfunktio on määritelty suojatuksi, jotta Target-olioita ei voida luoda. Target on abstrakti käsite, mutta koska luokassa ei ole yhtään puhdasta virtuaalifunktioita, voitaisiin sellainen luoda - ellei muodostinta olisi suojattu. Lapsiluokat korvaavat suojatun muodostimen oletuksena julkisella muodostimella ja niinpä lapsiluokkaan voi luoda normaalisti olioita. Suojaus ei ole täydellinen, koska uusi olio voidaan luoda myös kopiomuodostimella tai sijoitusoperaattorilla. Ne olisi pitänyt suojata myöskin, mutta esimerkin selkeyden vuoksi jätettiin väliin.\n\nNäin muuten ohimennen, esimerkki ei ollut täysin tuulesta temmattu. On aika ironista (tai lähinnä valitettavaa), että usea hyvä ohjelmistosuunnitteluun liittyvä keksintö on syntynyt sotateollisuuden tarpeisiin. Nykyajan pommit vaativat järjestelmän rakenteelta enemmän kuin tavalliset mikronkäyttäjät ja rahaahan sillä alalla on aina piisannut. Siviilisuunnittelijan kannattaakin ottaa oppia armeijan järjestelmistä - olisihan sääli jos kaikille niille hyville ideoille ei olisi mitään hyötykäyttöä.\n # Oliomallinnuksen heikkoudet\n\nKuten varmasti huomaat, on tämän kappaleen sävy erilainen kuin aikaisemmissa. En lauo suuria totuuksia ja höystä niitä jalkaproteesivitseillä, vaan päivittelen vaan että näin ne asiat ovat eivätkä siitä paljon paremmaksi muutu. Se johtuu yksinkertaisesti siitä, että olemme jättäneet perusasiat taaksemme ja purjehdimme aika tuntemattomilla vesillä.\n\nTuntemattomilla vesillä purjehtiessa saattaa nähdä peräti hämmentäviä näkyjä. Jopa sellaisia, joissa epäillään että onko oliomallinnus sittenkään vastaus kaikkeen. Ja kyseessä ei ole pelkkä harhanäky ja illuusio, vaan tosiasia joka jokaiselle ohjelmistosuunnittelijalle on uurtunut selkärankaan: oliomallinnus ei tosiaankaan ole ratkaisu kaikkeen.\n\nMillaiset ongelmat ovat erityisen hankalia oliomallinnuksen kannalta? Kokemuksesta voin luetella: ohjelman lokikirjanpito, käyttäjien oikeuksien valvonta, ohjelman osien asetusten hallinta, transaktiot jne... Mikä esimerkiksi lokista tekee niin hankalan? Se, että se koskettaa koko ohjelmaa. Tarpeeksi pitkälle mentäessä joka ikisen luokan tulee pystyä kirjaamaan toimenpiteitään ylös yhteiseen lokiin. Ja siitähän syntyy ongelmia - kuvittele vaikka miten vaikea on muuttaa lokijärjestelmää, kun se koskettaa koko ohjelmaa. Mitään erityisen hyvää ratkaisu ongelmaan ei ole, lokin on pakko liittyä koko ohjelmaan - rajaamalla lokikirjanpito vain pieneen alijärjestelmään ei saada tietoa koko järjestelmän käyttäytymisestä ja lokista tulee lähes hyödytön. Sama koskee käyttäjien oikeuksia ja asetusten hallintaa: ohjelmassa voidaan tehdä hyvin monenlaisia operaatioita hyvin monissa eri ohjelman kohdissa, ja jokaisen yhteydessä tulee tarkistaa onko käyttäjällä oikeuksia toimenpiteeseen - samoin asetuksia (tiedostojen nimet, verkko-osoitteet, tietokantojen asetukset...) tarvitaan joka puolella ohjelmaa.\n\nHavaitsemme, että nämä murheenkryynit leikkaavat poikittain ohjelmaa, ne siis eivät ole pilkottavissa oliohierarkioiksi samalla tavalla kuin muut ohjelman ominaisuudet ovat. Niitä voisi kuvata aspekteiksi, ohjelman toimintaa kuvaaviksi asioiksi joita ei voi paikallistaa mihinkään tiettyyn luokkaan tai luokkakokoelmaan. Jotta tätä ongelmaa pohtiessa voi saavuttaa valaistumisen, on hyvä tuntea hyperavaruusmalli. Se on IBM:n <NAME>.tutkimuskeskuksesta peräisin oleva malli, jossa ohjelman vaatimukset ajatellaan hyperavaruudeksi, moniulotteiseksi tilaksi. Ohjelman suunnittelu on tuon vaatimusavaruuden jäsentämistä, lokerointia. Jotta avarruutta voi kunnollisesti jäentää, tulee ohjelmointityökalun mahdollistaa ohjelman rakentaminen monessa eri ulottuvuudessa, siis monien eri näkökulmien avulla. Puhutaan moniulotteisesta vaatimusten jäsentämisestä (multidimensional separation of concerns).\n\nOliomaailmassa moniulotteinen jäsentäminen ei ole mahdollista. Tämän vuoksi ne asiat, jotka ovat hyperavaruudessa samalla tasolla oliomallin kanssa jäsentyvät helposti, mutta oliomallin kanssa eri ulottuvuudessa olevat asiat eivät. Tätä kutsututaan hallitsevan mallin tyranniaksi (tyranny of dominant decomposition). Kyse ei ole pelkästään oliomallia vaivaavasta ongelmasta, vaan minkä tahansa ohjelmointimallin valitseminen johtaa joidenkin ohjelman kannalta ehkä oleellistenkin ulottuvuuksien laiminlyöntiin.\n\nMutta toisaalta, jokin tapa jäsentää on parempi kuin ei jäsentämistä ollenkaan. Niinpä oliomalli on varsin hyvä ratkaisu monissa tilanteissa - ja tulee myös muistaa, että uudet ulottuvuudet tekevät ohjelmasta hankalamman hahmottaa. Merkittävin hallitsevan mallin tyranniasta johtuva ongelma oliomaailmassa ovat aspektit. Erityisen yleisiä aspektimaiset ominaisuudet ovat suurissa monen käyttäjän palvelinohjelmistoissa, kuten verkkokaupoissa ja intranet-sovelluksissa. Mitä enemmän voidaan olettaa tiettyjä vakioita (sama ympäristö, sama käyttäjä, vain yksi yhtäaikainen käyttäjä), sitä vähemmän ulottuvuuksia ohjelman vaatimuksissa on. Siis konkreettisesti, tavallisen Windows-sovelluksen suunnittelu on siksi helppoa, että liikkuvia osia on vähän. Ehkäpä juuri sen takia tasapäistävä Windows onkin menestynyt niin hyvin. Verkkomaailma, jossa hyvin harvojen asioiden voidaan olettaa pysyvän vakioina, on haastavampi mallinnettava. Eikä pelkästään siksi, että se on uusi asia, vaan juuri teoreettisen pohjan vuoksi. Verkkosovellusten vaatimuksissa on enemmän ulottuvuuksia, joten niiden hallitsemiseen tarvitaan moniulotteisempaa mallinnusta.\n\nVerkkoympäristöjen monitahoisuus ei ole jäänyt huomaamatta ohjelmistoteollisuudelta. Vaikka harva tuntee hyperavaruusmallia, niin silti mallin hengessä olevia teknologioita on syntynyt jo useita. Merkittävin kehityslinja ovat komponenttiteknologiat (CORBA, EJB, COM+), joissa yksi avainsana ovat nk. komponentin deklaratiiviset ominaisuudet. Komponentti on oliota tiiviimmin paketoitu ohjelman osa. Komponenttiin liittyy määrittelytiedosto, jolla se säädetään toimimaan siinä ympäristössä missä sitä milloinkin käytetään. Määrittelytiedostoissa määritellään deklaratiivisia ominaisuuksia, kuten se, että miten komponentti osallistuu transaktioihin - eli jos joku menee pieleen, niin miten järjestelmä peruu keskeneräisen toimenpiteen. Siis osa ohjelman älystä on siirretty määrittelytiedostoihin. Määriteltävät asiat ovat hyvin aspektimaisia - kuten esimerkiksi transaktiot. Ne koskevat koko järjestelmää. Mielestäni merkittävin komponenttiteknologioiden tarjoama etu on vaatimuksen moniulotteinen jäsentäminen, eli aspektien parempi kapselointi.\n\nMyös puhtaasti aspekti- ja hyperavaruusajattelun pohjalta on syntynyt konkreettisia teknologisia ratkaisuja. Aspektiohjelmointi on eräs tutkimussuunta, joka on tuottanut AspectJ-ohjelmointikielen (Javaan perustuva). AspectJ:n avulla tehdään jo jonkinverran oikeitakin ohjelmia ja myös C-versio on kehitteillä. Hyperavaruusmallia, joka on aspektiajattelua laajempi malli, voi kokeilla Hyper/J-ohjelman avulla. Hyper/J tukee hyperavaruuksia Java-ohjelmoinnisssa. Totuus kuitenkin on, että mihinkään todella vakavaan työhön ei näistä tutkimusprojektien tuotoksista vielä ole. Sen sijaan komponenttiteknologiat ovat jo ihan arkipäivää.\n\nDate: 1998-01-01\nCategories: \nTags: \n\nNumeerinen matematiikka on se osa-alue, jossa ei pyöritellä kaavoja ja symboleja, vaan lasketaan raakasti luvuilla. Eli juuri se alue, jossa tietokone on hakannut ihmisen mennen tullen keksimisestään lähtien. Koska C/C++:n ominaisuudet numeerisen matematiikan käsittelyyn eivät ole aivan huippua, toisin kuin esimerkiksi sellaisessa kielessä kuin Fortran, ajattelin teidän opetuslapsien tarvitsevan jonkinlaista avustusta tässä asiassa - vaikka tarkasti ottaen eihän tämä enää C++-kieleen liitykään.\n\nNäitä numeerisen matematiikan labyrinttejä harhaillessa lyhtynäni on heilunut alan suuri opus; Numerical Recipes in C, Second Edition [Press, Teukolsky, Vetterling, Flannery]. Se on suositeltava hankinta jokaiselle numeroita pyörittelevälle C++-ohjelmoijalle, tosin vaikean sisältönsä vuoksi ei mikään ensimmäinen hankinta aloittelijalle.\n # Sattuu ja tapahtuu - satunnaislukugeneraattorit\n\nKuten lupasin, nyt pureudumme syvemmälle satunnaisuuden olemukseen. Käytännönläheisempi tarinointi löytyy Standardikirjastot-osiosta. Aluksi meidän pitää pohtia satunnaisuuden todellista luonnetta - emmehän voi tyytä mihinkään sattumanvaraisiin satunnaisuuden määritelmiin. Tietokoneen toiminta ei ole satunnaista - se kaikki irrationaalinen Windowsin kaatuilu ei oikeasti ole satunnaista, vaan pelkästään vaikuttaa siltä. Tietokoneeseen voi kytkeä kuitenkin kaikenlaisia analogisia vatkaimia, joiden avulla yhteys todelliseen ja (mahdollisesti) satunnaiseen maailmaan on mahdollinen.\n\nKovin paljon tätä mahdollisuutta kytkeä ulkoisia satunnaislähteitä ei ole hyödynnetty - ymmärrettävästi, onhan se sen verran työlästä. Joidenkin salausprojektien yhteydessä, kun on tarvittu aivan äärimmäistä satunnaisuutta, on käytetty hyvin omaperäistä ja jopa hippiaikoja sivuavaa järjestelmää. Kaiken ytimenä on toiminut laavalamppu, tuo yltäkylläisesti hinnoiteltu sisustuselementti. Lamppu koostuu valaistusta säiliöstä, jossa kiinteämpää ainetta olevat möykyt vellovat ja muuttavat muotoaan. Liikkeet ovat hyvin satunnaisia. Sitten tarvitsemme vain digitaalikameran, joka kuvaa laavan liikkeitä. Nyt meillä on digitaalista tietoa analogisesta ja satunnaisesta tapahtumasta. Sitä käsittelemällä voimme luoda todella satunnaisen satunnaislukugeneraattorin. Tiettävästi lamppuja oli vielä useita ja niiden tuottamaa satunnaisdataa yhdistettiin.\n\nMikäli tällainen askartelu ei kiinnosta, pitää tyytyä tietokoneen näennäiseen satunnaisuuteen (pseudo random). Ensimmäinen esimerkki pseudosatunnaislukugeneraattorista on kääntäjän mukana seuraava rand(). Lähes kaikissa kääntäjissä käytetään yksinkertaista lineaarisen yhtenevyyden generaattoria (onko suom. oikein? suom. huom.) (linear congruential generator). Kun edellinen luotu luku on I, saadaan seuraava luku X kaavasta:\n\nX=(aI + c) mod m\n\na, c ja m ovat huolella valittuja vakioita. Siis edellinen luku kerrotaan a:lla, lisätään siihen c ja otetaan jakojäännös osamäärästä luvun m kanssa. Kaava on hyvin yksinkertainen ja tietokone suorittaa satunnaislukujen luonnin nopeasti ja tuottaa säädyllisen satunnaisia lukuja, mutta systeemi on silti ihan syvältä vaativammissa tehtävissä. Jos siis tarvitsemme todellista satunnaisuutta, kuten asianlaita on mm. simuloidussa jäähdytyksessä (simulated annealing), pitää rand() jättää väliin. Sen pahin teoreettinen puute on satunnaislukujen jaksollisuus. Käytännössä suurin vika on pieni m:n arvo.\n\nMillaista sitten on hyvä satunnaisuus? Satunnaislukugeneraattorien tuottamien lukujen tulisi pidemmän päälle noudattaa tasajakaumaa (uniform deviation). Kun siis arvotaan monta lukua, pitäisi jokaista lukua tulla lähes yhtä paljon. Myös muunlaisia jakaumia voi käyttää, normaalijakauma tärkeimpänä. Normaalijakauma noudattaa Gaussin käyrää, siis suurin osa arvoista on keskittyneenä keskivaiheille ja aivan äärilaidoissa arvoja on vähän. Normaalijakaumaa noudattelee moni luontoon ja todellisuuteen liittyvä asia, kuten ihmisten pituus. Se onkin sopiva väline simuloidessa vaikka sääolosuhteita lentopelissä - yleensä on normaalisää, mutta myrskytkään eivät ole täysi mahdottomuus. Kaiken pohjana yleensä kuitenkin on tasajakauma, josta erilaisilla operaatioilla saadan erikoistuneempia satunnaislukujen jakaumia.\n\nJaksollisuudestaan johtuen rand() voi sopivissa olosuhteissa tuottaa hyvin heikkoa jakaumaa - tietyt arvot ovat toisia yleisempiä. Tietyt olosuhteet ovat voimassa esimerkiksi silloin, kun satunnaisluvut jaetaan järjestelmällisesti joka kierroksella: huonolla tuurilla tietty jaksollisuus luvuissa voi moninkertaistua - näin on esimerkiksi koulutettaessa neuroverkkoja simulated annealing algoritmilla. Suurempi ongelma varsinkin arkiohjelmoijalle on kuitenkin m, kääntäjän vakio RAND_MAX. Generaattori palauttaa luvun väliltä 0 - RAND_MAX. 16-bittisten aikojen perintönä RAND_MAX hyvin yleisesti on 2^15=32767. Se ei itseasiassa ole paljon. Mikäli mielii saada suurempia satunnaislukuja, joutuu monta generoitua satunnaislukua yhdistämään ja siinä touhussa saa olla tarkka, ettei hävitä sitä satunnaisuutta mitä generaattorista saa.\n\nOtin sitten ja tein pienen ohjelman satunnaislukugeneraattorien testaamiseen. Se tuottaa lukuja kääntäjän mukana tulleella generaattorilla ja toisella, Minimal Standard -algoritmiin perustuvalla generaattorilla. Tulokset kirjataan tiedostoon, josta sitten syötin ne Excelille ja piirtelin jakaumat. Kyseessä tulisi olla tasajakauma, siis viivan pitäisi olla mahdollisimman suora ja tasainen.\n\nKuten huomaat, ran0 (Minimal Standard) tuottaa ihan hivenen tasaisempaa jälkeä. Kun lukuja arvottiin 2 300 000 kappaletta väliltä 0 - 230, jokaisen luvun tulisi siis toistua keskimäärin 10 000 kertaa, olivat poikkeamien keskiarvot: rand: 82,7 ja ran0: 78,4. Siis ran0 oli hivenen parempi. Tosin voi spekuloida, olisiko ero tullut selvemmäksi mikäli suorituskertojen määrää olisi vielä lisätty. Mikäli vaikka haluat kokeilla sitä tai muuten vaan tutustua testikalustoon, on käyttämäni ohjelman listaus saatavilla - samoin kuin aiheesta tuherrettu Excel-taulukko. Ohjelma kertoo myös RAND_MAX:in arvon. [rands.cpp - rands.xls]\n\nPitää kuitenkin muistaa, että on epätodennäköistä, että \"täydellinen\" satunnaislukugeneraattori tuottaa täysin tasaista jälkeä rajallisella otosten määrällä. Siksi jakaumien tarkastelu ei ole paras tai edes mitenkään erityisen hyvä tapa tarkastella generaattorien paremmuutta - toki sillä löytää pahat mokat mikäli esimerkiksi joutuu itse kehittelemään oman generaattorinsa johonkin erityistarkoitukseen. <NAME> niminen satunnaisuusmies on kehittänyt joukon testejä, joilla erotetaan jyvät apinoista (puhumme siis yhä erilaisista satunnaislukugeneraattoista). Tasajakauman lisäksi niihin kuuluu parien, kolmikoiden jne... esiintymisten tasaisuus, pitkien jonojen esiintymättömyys rajatuissa otoksissa ja monia muita menetelmiä. Lisää aiheesta voi lukea vaikka kirjasta Satunnaisuuden viidakot [Terra Cognita 1998: Peterson, suom. Pietiläinen].\n\n# Hyvän koodin kirjoitus\n\nTämä on tärkeää! Ellet halua, että koodisi on lukukelvotonta spagettia, ota tästä parit neuvot onkeesi. Toki koodin kirjoitustapoja on yhtä paljon kuin ohjelmoijiakin, joten nämä pohdiskelut ovat hieman yksilöllisiä asioita.\n\nItse kirjoitin melko vakiintuneella tavalla koodia parin vuoden ajan, kunnes lopulta taivuin enemmistön tahtoon ja muutin hieman kirjoitustyyliäni (kuvitelkaapa senaikaisia ohjelmiani; puolet kirjoitettu vanhaan tyyliin ja puolet uuteen...). Esittelen nyt käyttämäni tyylin tässä. Se on ehkä kaikista standardein tapa, mutta ei suinkaan mitenkään parempi kuin muut. Parasta tapaa ei ole. Kannattaa käyttää sellaista tapaa mikä tuntuu itselle mukavimmalta. Tietenkin omaksumalla melko yleisen tyyliin pääsee ehkä vähän helpommalla. Tärkeintä on kuitenkin noudattaa tyyliään orjallisesti joka paikassa.\n\nC++:ssa on mahdollista laittaa koodin sekaan ns. näkymättömiä merkkejä, joita ovat välilyönnit, tabuloinnit ja rivinvaihdot. Eli lause:\n > if (a < b);\n\nvoidaan myös esittää:\n > if ( a < b ) ;\n\n..jos välttämättä halutaan. Tätä ominaisuutta voidaan hyötykäyttää näin: Huono pätkä:\n > if(a<b&&b==10||b+k==0){a = 10;cout<<\"Terve\";}\n\nSama pätkä paremmassa muodossa:\n > if (a < b && b == 10 || b+k == 0) { a = 10; cout << \"Terve\"; }\n\nNäin. Kumpi on selvempi? Välilyöntiä kannattaa käyttää ahkerasti. if:ssä jätin b+k:n yhteen, koska minusta se on selvempi niin. Lohkot on tapana sisentää näin:\n > if (a == 10) { a = 5; b = 8; }\n\nTai näin:\n > if (a == 10) { a = 5; b = 8; }\n\nLis�ksi yleens� on tapana kirjoittaa ensimm�inen aaltosulku samalle riville:\n > if (a == 10) { a = 5; b = 8; }\n\nTuo lieneekin nyky��n yleisin tapa kirjoittaa lohkoja.\n\nMuuttujille kannattaa antaa selvät nimet, ab-tyylisiä muuttujia kannattaa välttää. Laskurimuuttujina ne kyllä kelpaavat, mutta pidemmät nimet ovat silti pitkän päälle parempia: ne eivät vie enempää muistia tai ole hitaampia, niitä on vaan hitaampi kirjoittaa. Mutta on aika tylsää selailla koodia läpi ja selvittää, että mitäs siinä xp-nimisessä muuttujassa taas olikaan.\n\nMuuttujien ja funktioiden nimissä kirjoitan eri osat isolla kirjaimella, siis vaikka muuttujat keskiArvo ja poistoputkenValisuodattimenKriittinenLampotila ja funktiot Liiku() ja AmmuAleksi(). Kuten huomaat, funktiot aloitan isolla kun taas muuttujat pienellä. Näin ne ainakin erottaa nopeasti. Luokan nimen kirjoitan isolla, mutta luokkaan kuuluvan olion pienellä - sehän on periaatteessa vain muuttuja. Miksi luokat isolla? Luokan muodostinfunktio on funktio, joten se isolla. Luokalla on sama nimi kuin muodostinfunktiolla, joten senkin pitää alkaa isolla.\n\nMuutamat wanhat parrat käyttävät muuttujien nimessä unkarilaista notaatiota. Se tarkoittaa, että muuttujien alkuun laitetaan yksi merkki kertomaan muuttujan tyypistä. iNopeus tarkoittaisi int-muuttujaa, jossa pidetään nopeutta. Unkarilainen notaatio auttaa muistamaan muuttujan tyypin ja olemaan käyttämättä sitä väärin. C++ hoitaa kuitenkin muuttujien tyyppitarkastuksen niin hyvin, että unkarilaisen notaation käyttö on melko turhaa C++-ohjelmissa. Poikkeuksena kuitenkin on melko yleinen tapa laittaa osoitinmuuttujien eteen pieni p (pointer) ja viittauksien eteen pieni r (reference).\n\nTässä oli melko löyhä esitys siistin koodin kirjoituksesta. Jos kaipaat tarkkaa ja mahdottoman laajaa ehdotelmaa C++-standardista, siis siitä miten vaikka firman sisällä pitäisi kaikkien kirjoittaa ohjelmansa, jotta muut niitä ymmärtäisivät, niin katso ihan asiallisen oloinen selostus osoitteesta:\n\nhttp://www.possibility.com/Cpp/CppCodingStandard.html\n\nEn voi olla vielä painottamatta sitä, että siisti merkintätapa on vasta ensimmäinen askel hyvään ohjelmointiin. Ohjelman todellinen selkeys ei tule kivasti laitetuista sulkumerkeistä, vaan hyvin tehdystä, selkeästä ja yksinkertaisesta luokkarakenteesta. Mutta merkitseminen on myös tärkeää, ja kokeneilla ohjelmoijilla se on jo niin verissä, että ohjelmakoodi ei tunnu kotoisalta ennen kuin siinä on merkinnät kohdallaan.\n # Muistialueet\n\nTietokoneessa on muistia, johon se säilöö tietoa. Siinä perusteet. Sitten vähän syvällisempää tietoa. Muisti voidaan jakaa eri alueisiin. C++-kielen kannalta alueet ovat seuraavat:\n\nEnsiksi mainittakoon pino (stack). Se on muistialue, joka toimii LIFO-periaatteella, Last In First Out. Siis mitä sinne on viimeksi laittanut, sen sieltä myös saakin. Tieto kasataan pinoon kuin lautaset kasaan. Pinoa käytetään paikallisten muuttujien ja funktion parametrien säilyttämiseen ja sen koko on rajattu - ympäristöstä, kääntäjästä ja sen asetuksista riippuen.\n\nGlobaali muistialue pitää sisällään kaikki globaalit muuttujat ja koodialue itse ohjelmakoodin. Prosessorin sisällä olevat rekisterit (register), joita on muutama, mutta jotka ovat myös ihan käsittämättömän nopeita, voidaan laskea tavallaan myös muistiksi. Niiden käyttö riippuu prosessorista ja kääntäjästä, yleensä niitä käytetään pinon kaverina pienen ja väliaikaisen tiedon säilyttämiseen.\n\nKaikki loppu onkin sitten villiä ja vapaata muistia. Vapaan muistin alueelta voi ohjelma varata muistia käyttöönsä. Vapaata muistia käytetään sen osoitteiden avulla - siis osoitinmuuttujien avulla.\n # C++:n varatut sanat\n\nVaratut sanat vaihtelevat hieman kääntäjittäin, mutta melko yleispätevä lista on tässä:\n > auto break case catch char class const continue default delete do double else enum extern float for friend goto if inline int long mutable new operator private protected public register return short signed sizeof static struct switch template this throw typedef union unsigned virtual void volatile while\n\nMonissa kääntäjissä on käytössä myös mm. nämä varatut sanat:\n > asm far huge interrupt near\n # volatile ja register\n\nMuistia on montaa plaatua ja eri nopeutta - ja ehdottomasti nopeimpia ovat prosessorin sisäiset rekisterit. Niitä ei ole paljon, joten muuttujien jaottelu rekisterien ja itse keskusmuistin välillä on hankala homma, joka yleensä kannattaa jättää kääntäjän tehtäväksi. Jotain vaikutusta voi ohjelmoijalla näissä henkimaailman asioissa kuitenkin olla. Kun kääntäjä saa sijoittaa haluamiaan muuttujia rekistereihin, nopeuttaa se ohjelmaa joskus huomattavastikin. Joskus kuitenkin tämmöinen temppuilu voi aiheuttaa ongelmia. Tällainen esimerkki ovat keskeytykset.\n\nKeskeytyksiä löytyy lähinnä DOS-ympäristöstä. Ne ovat ohjelmanpätkiä, jotka jonkun tietyn tapahtuman laukaisemana (esim. näppäimen painallus) keskeyttävät itse ohjelman ja tekevät jotakin. Kun kääntäjä on siirtänyt jonkun muuttujan rekisteriin ja kesken kaiken hyppää arvaamatta keskeytys, joka käsittelee muuttujaa - siis sen muistissa olevaa versiota - on tuloksena hyvin epämiellyttävä sekasotku. Mutta onneksi on volatile: varattu sana, joka voidaan kirjoittaa muuttujamäärittelyn eteen ja joka kertoo kääntäjälle, että kyseistä muuttujaa voi joku taustaohjelmista yllättäen muuttaa. Kääntäjä antaa muuttujan olla koko ajan muistissa eikä yritäkään nopeuttaa sen käyttöä rekisterikikoilla.\n\nregister tekee sitten mitä lupaakin: käskee kääntäjän sijoittaa muuttuja rekistereihin, mikäli vaan mahdollista. Joskus tämä voi johtaa nopeampaan ohjelmaan. Nyrkkisääntö on kuitenkin: älä käytä registeria. Se yleensä vaan sotkee kääntäjän optimointipasmat - nykyajan kääntäjät kuitenkin tekevät hommansa vähintääkin vuosien taidolla ja kokemuksella.\n # Komentoriviparametrit\n\n > #include <iostream.h> int main(int argc, char* argv[]) { cout << \"Parametreja annettiin \" << argc << \" kipaletta.\" << endl; for (int i=0; i< argc; i++) cout << i << \". parametri on \" << argv[i] << endl; return EXIT_SUCCESS; }\n\nEsimerkki oli kopioitu melkein suoraan Libertyn kirjasta. Se vaan iskee selkeydellään kuin miljoona volttia, joten turha sitä on mitenkään sotkea. Juttuhan on siis komentoriviparametrit, se litania mitä käynnistettävän ohjelman perään monissa käyttöjärjestelmissä voi kirjoittaa. Niihin pureudutaan kiinni kahdella muuttujalla, arcg ja argv, jotka main(..) saa osakseen. argc tulee sanoista argument count ja argv on argument vector. Nimet voivat olla mitä vaan, mutta nämä kaksi kaverusta ovat vakiinnuttaneet itsensä jo standardiksi. argc kertoo paljonko parametrejä on - itse ohjelman nimi mukaanlukien. Siis argc on aina ainakin yksi. argv on taas taulukollinen osoittimia parametrimerkkijonojen alkuun (siis määrittelyn char* argv[] sijasta kävisi myös char** argv tai char argv[][]). argv[0] osoittaa ensimmäisen merkkijonoon, joka on ohjelman nimi. argv[1] on sitten ensimmäinen parametri, jos sellainen on, jne..\n\n# Sanasto\n\nSlangisanat ja englanninkieliset termit voivat hämmentää aloittelijan, mutta ei hätää! Tähän niitä on kerätty ihan mukava lajitelma. Ja jos ei tästä listasta löydy, niin ei kun vaan sähköinen kirjekyyhky matkaan, niin pian löytyy. Osoite on siellä jossakin alkusivulla. Rajoituksena kuitenkin termin pitää kuulua ohjelmoinnin perustermeihin tai C++:n erikoistermeihin. Ihan joka ikistä jollain tavalla ohjelmointiin liittyvää termiä ei täällä ole: ovathan nämä C++-ohjelmoinnin sivut, eivät signaalinkäsittelyn tai 3D-ohjelmoinnin. Linkit heittävät siihen kohti opasta missä termi on tarkemmin selostettu, ne siis vastaavat kirjojen sisällysluetteloiden sivunumeroviitteitä. Rennot slangisanat on kursivoitu.\n +, -, *, %Kiinalaisen miehen repliikki, kun hän on vahingossa tökännyt syömäpuikon nenäänsä. No okei, katso \"Matemaattinen operaattori\"... Abstrakti luokka (kts. myös[ilman puhtaita virtuaalifunktioita])Luokka joka vastaa abstraktia käsitettä (esim. Lähde) ja johon ei voi luoda olioita. Toteutetaan puhtailla virtuaalifunktioilla, vastaava vaikutus saadaan ilman puhtaita virtuaalifunktioita aikaan suojaamalla muodostin, kopiomuodostin ja sijoitusoperaattori. AspektiOhjelman ominaisuus, jota ei voi rajata tiettyyn osaan ohjelmaa. Hankala mallintaa oliokielen avulla. Assembler, Assembly, AssySymbolinen konekieli. Hyvin koneläheinen ohjelmointikieli, jossa konekielikäskyt on korvattu helpommin muistettavilla lyhennyksillä, kuten MOV (move, siirrä). Assemblylla voidaan tehdä nopeaa koodia ja kieli on sinänsä on hyvin yksinkertainen, mutta prosessorit eivät ole kovin yksinkertaisia, joten Assemblylla koodaaminen on työlästä touhua. Assembly on kielen nimi, kun taas Assembler on Assembly-kielen kääntäjä. assertMakro, joka varmistaa muuttujien oikean arvon ohjelman kehitysversiossa. Kts. \"makro\" ja \"esikääntäjä\". atoiMuuntaa merkkijonon luvuksi. Kts. myös \"stringstream\". Avoin funktioFunktio, jonka sisällön kääntäjä asettaa jokaiseen kohtaan jossa sitä kutsutaan. Kasvattaa ohjelman kokoa, mutta on nopea. BASICMuinainen ja legendaarinen ohjelmointikieli, kehittyneemmät versiot vieläkin käytössä joissain paikoissa. BinäärilukuLuku, joka on esitetty ykkösinä ja nollina (001010), niinkuin tietokone lukuja käsittelee. Kaksikantainen luku. BittiBinääriluvun osa; arvo voi olla 1 tai 0. (mikron virtapiireissä virtaa tai ei virtaa) Bittien käsittelyBittien kanssa touhuilu onnistuu hyvinkin C++:lla, koska siinä on säilytetty C:n laiteläheisyys. Kts. bittioperaattorit. Bittioperaattorit (|, &, ^, ~, !, <<, >>)Bittioperaattoreilla päästään käsiksi muuttujan bitteihin. breakHyppää pois toistorakenteesta. BugiVirhe ohjelmassa. charMuuttujatyyppi, merkki. cinTiedon lukemisen hoitava olio. classVarattu sana, jolla määritellaan luokka. Kts. myös \"luokka\" ja \"olio\". clrscr()Borlandin DOS-kääntäjien tukema funktio, jolla saa ruudun tyhjennettyä. CompilerKts. \"Kääntäjä\". ConstantKts. \"Vakio\". continueJättää toistorakenteen lopun suorittamatta. cosKts. \"trigonometriset funktiot\". coutTulostusta hoitava olio. DebugataEtsiä virheitä ohjelmasta, yleensä erillisellä hommaan tarkoitetulla ohjelmalla eli debuggerilla. DebuggerOhjelma, jolla voidaan tehtyä ohjelmaa ajaa askel askeleelta ja tutkia eri muuttujien arvoa. Hyvin kätevä etsittäessä virheitä. deleteVapauttaa osoittimen osoittaman muistialueen. Katso myös \"delete []\". delete []Vapauttaa taulukon, jonka ensimmäiseen alkioon osoitin osoittaa. do..whileSuorittaa silmukan kerran ja sen jälkeen niin kauan kun ehto on tosi. DokuDokumentti, ohjetiedosto. doubleMuuttujatyyppi, liukuluku. EditorHieman tekstinkäsittelyohjelmaa vastaava ohjelma, jolla ohjelma kirjoitetaan. EhtolauseKts. \"if\". elseJos if ei toteudu, niin else toteutuu. Kts. \"if\". EngineJotakin tiettyä tehtävää hoitava ohjelman osa; puhutaan esim. 3D-engineistä. enumKts. \"lueteltu tyyppi\". EsikääntäjäKäsittelee koodin ennen kääntäjää. Voidaan usein hyödyntää virheiden paikallistamiseen. EtuliiteoperaattoriMatemaattisista operaattoreista värkätty kätevä erikoisoperaattori tiettyihin tilanteisiin. Katso myös \"Matemaattinen operaattori\". externKertoo otsikkotiedostossa, että kyseinen muuttuja on määritelty muualla. File, FileeTiedosto. float (kts. myös)Muuttujatyyppi, liukuluku. forKätevä käsky toistorakenteiden tekoon Funktio, functionOhjelman osa, jota voidaan kutsua tietyillä lähtöarvoilla ja joka voi palauttaa arvon. Kts. \"oletusparametri\" ja \"paluuarvo\". Funktion uudelleenmäärittelyTehdään samannimisestä funktiosta monta eri versiota eri parametreilla ja paluuarvoilla. Globaali muuttuja, global variableJokaisesta ohjelman osasta käytettävissä oleva muuttuja. GrafiikkaC++:lla saa aikaan maatajärisyttäviä graafisia efektejä ja silmiä vinouttavia visuaalisia illuusioita. Tie grafiikkaguruksi on kuitenkin pitkä ja kivetty yhteensopimattomilla näytönohjaimilla. Hallitsevan mallin tyranniaKaikki ohjelmointiparadigmat (mallit) lähestyvät ongelmaa omasta näkökulmastaa, minkä vuoksi jotkut asiat on helpompi mallintaa kuin toiset. Hyvä ohjelmoijaHyvä ohjelmoija noudattaa hyvän ohjelmoinnin sääntöjä ja saa siitä palkinnoksi hyvän elämän. IDEIntegrated Development Environment, kehitysympäristö. Editori, debuggeri, kääntäjä, linkkeri ja muut vermeet yhdistettynä käteväksi graafiseksi kokonaisuudeksi. Monissa nykyajan kääntäjissä on hyvin kehittyneet ja mukavanoloiset IDE:t. ifSuorittaa seuraavan lauseen tai lohkon, jos ehto on tosi. Kts. myös \"else\". ifdef, ifndefEsikääntäjän käsky. Jättää/ottaa merkityn koodialueen mukaan, mikäli annettu sana on määritelty. includeEsikääntäjän käsky, joka käskee laittamaan annetun tiedoston sisällön siihen kohden ohjelmakoodia. inlineKatso \"avoin funktio\". intMuuttujatyyppi, kokonaisluku. itoaMuuntaa luvun merkkijonoksi. Kts. myös \"stringstream\". JäsenfunktioOlioon määritelty funktio. Käytetään myös nimitystä metodi. KaatuaOhjelman jumittuminen kesken toiminnan. Kapselointi (kts. myös)Suojataan tieto sitä käyttävien osien yhteyteen, niin ettei sitä voida sorkkia muualta. Onnistuu parhaiten ohjelmoidessa oliopohjaisesti. Kirjasto, libraryYhteen kerätty kasa ohjelmakoodia, joka voidaan ottaa omaan ohjelmaan mukaan. KomentoriviparametriParametri, joka ohjelmalle ajettaessa voidaan syöttää. KommentointiKun lisätään ihmisten kielellä olevia huomautuksia ohjelmakoodin sekaan. KoodiJoko ohjelman lähdekoodi eli kääntämätön muoto tai jo käännetty konekieli. Kääntäjä, compilerOhjelma, joka kääntää lähdekielisen tiedoston konekieleksi. LaavalamppuKeski-iän kriisiä potevan yritys palata villiin nuoruuteen. LajittelualgoritmiLaittaa tietoa nopeasti järjestykseen jonkun ehdon perusteella. Kts. \"qsort\". LaskutoimitusKatso \"Matemaattinen operaattori\". LausePuolipisteeseen päättyvä ohjelmakoodin pätkä. LausekeArvon palauttava ohjelmakoodin pätkä. LIFOLast In, First Out -periaate, käytetään yleensä tietorakenteista. Toimii kuin pino käytettyjä vauvanvaippoja: minkä olet päällimmäiseksi laittanut, se ensimmäisenä käteesi tarttuu (ihan kirjaimellisesti). Liittymä, interfaceLuokkaa ei voi käyttää miten haluaa, vaan sille pitää suunnitella huolella ja taiten hyvä liittymä, joka piilottaa sen toteutuksen likaiset yksityiskohdat. Linkkeri, linkerOhjelma, joka yhdistää aliohjelmakirjastot mukaan konekieliseen ohjelmaan. LohkoAaltosulkeiden väliin kirjoitettu ohjelman osa. Looginen operaattoriKäytetään ehtolauseissa vertailuoperaattoreiden yhdistelemiseen. LoopKts. \"silmukka\". Lueteltu tyyppiNumeromuuttuja, jonka arvoille voi antaa havainnollisempia nimiä. Lukujen merkitseminenKun koodin sekaan kirjoitetaan lukuarvoja, tulee huomioida lukujen merkitsemiseen liittyvät säännöt ja vipstaakkelit. LuokkaOliot kuuluvat johonkin luokkaan, jotka määrittelevät olioiden ominaisuudet. Kts. myös \"Periytyminen\". main(void)Funktio, jota kutsutaan ohjelman alussa. Voi olla paluuarvoltaan void tai int, hyvä tapa olisi määritellä paluuarvoksi int ja palauttaa vakio EXIT_SUCCESS mikäli ohjelman suorituksessa ei tullut mitään häikkää. MakroEsikääntäjän \"funktio\", siis esikääntäjä korvaa tietyn sanan lyhyellä koodinpätkällä. Malli, templateOminaisuus, jonka avulla C++-kääntäjä luo automaattisesti tyyppikohtaiset versiot mallitetusta koodista. C++:n käännöksenaikaista polymorfismia. Käytetään C++:n standardinmukaisessa STL-kirjastossa. Kts. myös \"polymorfismi\". Matemaattinen operaattoriNäillä hoidetaan laskutoimitukset C++-kielessä. MerkkijonoC-tyylinen merkkijono on char-muuttujien taulukko, C++-tyylinen merkkijono on elegantisti oma luokkansa. Kts. myös \"nollatavu\". MetodiKts. \"jäsenfunktio\". Moniperintä, multiple inheritanceLuokka perii monta kantaluokkaa. Moniulotteinen taulukko.Kts. \"Taulukko\". Moniulotteinen vaatimukset jäsentäminenOliomalli ei onnistu mallintamaan kaikkea mitä ohjelman pitää tehdä - ainakaan helposti. Muisti, memorySiellä muuttujat asustavat. MuistinhallintaJokaisen kunnollisen ohjelman perusjuttu. Ei riekuta muistinkäytön kanssa miten sattuu. Muodostinfunktio, constructor (kts. myös[periytettäessä])Kutsutaan oliota luodessa. MuuttujaPaikka muistissa, jolle annetaan kiva nimi. Siis tieto säilötään muuttujiin. Kts. myös \"näkyvyys\". newVaraa halutun kokoisen muistialueen ja palauttaa osoittimen siihen. Nollatavu, null byte (kts. myös)C-tyyppisen merkkijonon päättävä merkki. NäkyvyysMuuttujat ovat käytettävissä vain tietyissä kohdissa ohjelmaa. Kts. \"paikallinen muuttuja\" ja \"globaali muuttuja\". Ohjausmerkki (kts. myös)Syöteen ulkoasua voidaan ohjata erilaisilla \\-alkuisilla merkeillä, kuten \\n eli rivinvaihto. OletusparametriFunktion parametrin arvo, jota käytetään mikäli muuta arvoa ei anneta kutsussa. OlioOlio-ohjelman perushiukkanen. Ohjelman osa, joka sisältää muuttujia ja jäsenfunktioita. Kts. myös \"jäsenfunktio\" ja \"luokka\". Oliosuunnittelu (kts. myös[ongelmat])On olioita ja luokkia ja periytymistä, mutta miten näistä vihanneksista syntyy maukas soppa? OptimointiOhjelman viilaaminen niin, että se toimii mahdollisimman nopeasti tai vie mahdollisimman vähän tilaa tai mahdollisimman vähän muistia suorituksen aikana. Käytetään yleensä ensimmäisestä. Osoitin, pointer, pointteri (kts. myös[muistia varattaessa], myös[taulukot], myös[funktioon], myös[taulukollinen funktioon] ja myös[jäsenfunktioon])Muuttuja, joka on osoite muistissa. Voi osoittaa muuttujaan, funktioon tai olioon. Paikallinen muuttuja, local variableMuuttuja, joka on käytettävissä vain luontialueensa sisällä. Paluuarvo (kts. myös[main])Funktion palauttama muuttuja. Parametri (kts. myös[viittaus])Funktiolle annettava lähtöarvo. Voi olla myös ohjelmalle annettava, kts. siis \"komentoriviparametri\". Periytyminen, inheritanceLuokka perii toisen luokan tai luokkien ominaisuuksia. Pino, stackMuistialue, joka toimii LIFO-periaatteella. Kts. siis \"LIFO\". Poikkeus, exceptionC++:n mekanismi virheiden käsittelyyn. Virhetilanteessa heitetään poikkeus, jolloin ohjelman suoritus pysähtyy ja funktiokutsupinoa aletaan purkaa, kunnes törmätään lohkoon joka ottaa poikkeuksen kiinni. PolymorfismiOhjelman osan monimuotoisuus. Osaa, esim. oliota, voidaan käyttää eri yhteyksissä tietämättä sen tarkkaa toteutusta eli \"muotoa\". Kts. myös \"funktion uudelleenmäärittely\" ja \"malli\". PreprocessorEsikääntäjä private (kts. myös[periytettäessä])Yksityinen näkyvyys. Muuttuja tai metodi on näkyvissä vain luokan sisällä. Kantaluokka voidaan myös periä yksityisesti. ProfilerOhjelma, joka analysoi tehdyn ohjelman ja ilmoittaa kuinka kauan eri funktioiden suorittaminen kestää. Käytetään ohjelman nopeuden parantamisessa. Projekti (kts. myös[extern])Sivistynyt tapa järjestää isompi ohjelma moneen eri lähdekooditiedostoon. protectedSuojattu näkyvyys. Muuttuja tai metodi on näkyvissä lapsiluokille, mutta ei muille ulkopuolisille. Kantaluokka voidaan myös periä suojatusti. public (kts. myös[periytettäessä])Julkinen näkyvyys. Muuttuja tai metodi on näkyvissä kaikille. Kantaluokka peritään usein julkisesti. Pyhä kolminaisuusKirjoittajan näkemys ohjelmistosuunnittelun olemuksesta: kapselointi, uudelleenkäyttö ja kaikista suurimpana abstraktio. qsortMonien kääntäjien mukana tuleva kätevä quicksort-lajittelualgoritmin toteutus rand (kts. myös)C/C++-kääntäjän mukana tuleva satunnaislukugeneraattori. Kts. myös \"satunnaislukugeneraattori\". registerPyytää kääntäjää optimoimaan muuttujaan rekisteriin. Rekisteri, registerProsessorin sisäisiä \"muuttujia\". Nopeinta muistia mitä tietokoneesta löytyy. Roskien keruu, garbage collectionAutomaattinen muistin vapauttaminen. Ei kuulu standardiin C++:n. RutiiniJoku ohjelmanpätkä, joka tekee jonkun tietyn asian, esim. tiedostonlukurutiini. Ruudun tyhjennysEi onnistu mitenkään yleispätevästi, yksi vaihtoehto on clrscr. Kts. \"clrscr()\". SaantifunktioFunktio, jonka kautta ulkopuoliset voivat käyttää luokan sisäisiä muuttujia. Näin voidaan muuttujat suojata muilta pölvästeiltä. Monesti saantifunktio ovat get/set-alkuisia. Satunnaislukugeneraattori, random number generatorOhjelma, joka luo lähes täysin sattumanvaraisia (siis pseudosatunnaisia) lukuja. Kts. myös \"rand\" ja \"satunnaisuus\". SatunnaisuusVoi sen kun osaisin pätevästi määritellä, niin Nobelin kisat voittaisin... SilmukkaMontaa kertaa toistettava ohjelman osa. sinKts. \"trigonometriset funktiot\". Source, source code, SorsaLähdekoodi, ohjelman kääntämätön versio. strcatYhdistelee merkkijonoja. Kts. \"merkkijono\". strcmpVertailee merkkijonoja. Kts. \"merkkijono\". strcpyKopioi merkkijonoja. Kts. \"merkkijono\". stringLuokka merkkijonojen käsittelyyn. Kts. \"merkkijono\". stringstream (kts. myös[esimerkki käytöstä])Tietovirta, joka onkin merkkijono. Voidaan kätevästi käyttää numeroiden muuttamiseksi merkkijonomuotoon ja toisinpäin. SuunnitteluKts. \"Oliosuunnittelu\". switch..case -rakenneValitsee muuttujan arvon perusteella tietyn vaihtoehdon. sizeofPalauttaa tietotyypin koon tavuina. säie, thread, thread of executionYksi ohjelman suorituksen kohta. Säikeistettyä ohjelmaa voidaan suorittaa useasta kohdasta yhtä aikaa. Yleistä mm. palvelinohjelmoinnissa jossa käsitellään useita yhtäaikaisia käyttäjiä. tanKts. \"trigonometriset funktiot\". Taulukko, array (kts. myös[vapauttaminen] ja myös[osoittimena])Monta peräkkäistä muuttujaa, jotka on indeksoitu yhden taulukon alle. ToistolauseRakenne jolla sama asia tehdään kunnes tietty ehto täyttyy. Trigonometriset funktiotKolmion kulmien kanssa koheltaessa käytettävät sin, cos ja tan kaikkine versioineen. Tuhoajafunktio, destructorKutsutaan oliota hävitettäessä. Tutorial, TuttiJostain aiheesta tehty ohjetiedosto. typedefMuuttujatyyppien peitenimien määrittely. Tyyppimuunnos, typecastMuuttujan muuttaminen toisentyyppiseksi. unionEhkä turhin asia C++:ssa. Unionin avulla voivat kaksi eri muuttujaa jakaa saman muistialueen. Pärjäät erittäin hyvin ilmankin. UudelleenkäyttöVain tyhmä koodaa saman asian kahteen kertaan. Vakio, constantMuuttuja jonka arvo ei muutu, tai esikääntäjälle määritelty korvattava merkkijono. Varattu sanaEi kelpaa muuttujanimeksi, koska on C++-kielessä pyhitetty muuhun käyttöön. VertailuoperaattoriKäytetään muuttujien vertailemiseen ehtolauseissa. Kts. \"if\". Viittaus, referenceOsoittaa muuttujaan, osoitettua muuttujaa ei voi muuttaa. Virtuaalinen metodi, virtual methodJäsenfunktio, jonka toteutus valitaan aina olion todellisen luokan mukaan. voidTietotyyppi: ei arvoa tai tyyppi määrittelemätön. volatileKieltää kääntäjää optimoimasta muuttujaa rekistereihin. whileSuorittaa lausetta tai lohkoa niin kauan kun ehto on tosi. [oppaan vanhemmissa versioissa selitys oli epäselvä ja harhaanjohtava. kirj. huom.] Ystävä, friendLuokka voi määritellä toisen luokan, luokan metodin tai funktion ystäväkseen ( \n\n```\nfriend ToinenLuokka::erasMetodi();\n```\n\n), jolloin se pääsee käsiksi luokan yksityiseen tietoon. Määrittely on yksisuuntainen. Ystävä-määrittelyjä ei tulisi käyttää paljon, tai välttämättä ollenkaan, koska ne huonontavat kapselointia. \nTakaisin\n\n# Kysymykset ja vastaukset\n\nTälle sivulle on kerätty lähinnä asioita, jotka ovat liian hankalia asiayhteydessään mainittavaksi. Niin, ja sinäkin saat sitten kysyä. Tuntuu hieman skitsofreniselta esittää itselleen kysymyksiä.\n\nK: Luen tiedostosta/muusta syötteestä tietoa merkkitaulukkoon merkki kerrallaan. Kun vertailen sitten merkkijonoa: strcmp(input, \"wiihaa\"); tulee tulokseksi false, vaikka input onkin \"wiihaa\" kuten pitääkin. Mikä pissii?\n\nV: Jos alustat merkkijonon char mjono[]=\"Moikkelis koikkelis.\"; tai luet siihen sisältöä käyttäjältä cin >> mjono; niin lisätään nollatavu merkkijonon perään automaattisesti. Jos kuitenkin luet itse syötettä merkki kerrallaan ja lopetat nollatavun sattuessa kohdalle, kopioimatta nollatavua, homma ei tietenkään toimi. mjono sisältää tekstin \"wiihaa\" ja toinen vertailtava merkkijono on \"wiihaa\\0\", siis päättyy nollatavuun; tällöin ne eivät ole vastaavia ja vertailut eivät ole koskaan tosia. Ongelman saat ratkaistua yksinkertaisesti sijoittamalla ennen vertailua nollatavun lukemasi merkkijonon loppuun, siis mjono[loppuKohta]=NULL;. Toinen vaihtoehto on lukea syötteestä myös nollatavu mukaan, jos se sellaisen sisältää. Mutta esimerkiksi kun luetaan tiedostosta yksittäisiä sanoja keskeltä lausetta, ei niissä ole nollatavua valmiina perässä ja sinun pitää se itse lisätä.\n\nK: Kun käsken ifstream file(\"files\\file.txt\") ei tiedostoa löydy. Alihakemistossa on kuitenkin tuollainen tiedosto kuten pitääkin. Onko minua huijattu?\n\nV: C++ käyttää merkkijonoissa ohjausmerkkejä, jotka alkavat \\ -merkillä. Jotta kääntäjä tajuaa sinun haluavan \\ -merkin eikä mitään ohjausmerkkiä, pitää sinun käyttää \\\\ -ohjausmerkkiä, joka siis vastaa \\ -merkkiä. Oikea syntaksi on siis ifstream file(\"files\\\\file.txt\").\n\nK: Kuinka voin käyttää tekemääni funktiota toisessa ohjelmassa? Kuinka tehdään kirjastoja C++:lla?\n\nV: Jos haluat päästä tosi helpolla, niin kirjoitat funktion kokonaan omaan tiedostoon (funktio.h) ja sitten laitat sinne missä funktiota tarvitaan:\n > #include\"funktio.h\"\n\nTuossa on se vika, että kun include heittää funktion kohdallaan, niin se käännetään aina uudelleen - vaikka sitä ei mitenkään olisi muuteltukaan. Kun on kysymys isommasta projektista ja jos kääntäjä ei vielä ole niin hirveän nopea, niin sillä on tosissaan väliä. Oikein se tehdään niin, että funktion määrittely kirjoitetaan .h tai .hpp-tiedostoksi (funktio.h) ja itse funktion runko erilliseen tiedostoon (funktio.cpp) (katso seuraava kysymys, jossa on arvokas vinkki tähän).\n Sitten voidaan joko:a) Kääntää funktio kirjastoksi (.lib tai .a) ja ottaa kirjasto mukaan sinne missä sitä tarvitaan. Näin on tehty kääntäjän mukana tulevien funktioiden kanssa. Tällä tavalla funktiota voi levittää binäärimuodossa, joten voit laittaa oman apuohjelmakirjastosi levitykseen niin että kukaan ei voi muutella sitä, koska lähdekoodia ei tarvita mukana. Menetelmän heikkous on siinä, että binääri toimii vain yhdessä ympäristössä: joudut kääntämään monta eri versiota kirjastosta, mikäli haluat laajan käyttäjäkunnan (dos, win32, linux, kaikista debug- ja normaaliversio). Kirjaston tekeminen on kääntäjäkohtaista, yleensä se tapahtuu valitsemalla asetuksista projektin kohteeksi (target) kirjasto (library). b) Tehdä projekti, jossa on mukana monta tiedostoa, siis vaikka main.cpp ja funktio.cpp. Kääntäjä automaattisesti kääntää ne, ja vain ne, osat uudelleen mitä olet muuttanut. Tämä on ehdottomasti kätevämpi tapa kun tarvitset apuohjelmanpätkiä vain itse. Myös julkiseen levitykseen erilliset lähdekooditiedostot ovat käteviä, koska ei tarvita erillisiä binäärejä eri alustoille (jokainen kääntää omansa) ja lähdekoodi yleensä vie vähemmän tilaa ja kopiointiaikaa kuin binäärikoodi. \nK: Olen tehnyt oman juttuja.h-tiedoston. Käytän sitä monissa paikoissa ja sisällytän sen myös erääseen toiseen vibat.h-tiedostoon. Kun sisällytän ohjelmaani molemmat tiedostot, juttuja.h ja vibat.h, tulee juttuja.h kahdesti, koska se sisällytetään yksinään ja vielä vibat.h:n mukana. Ja sehän ei mene kääntäjästä läpi. Miten homma hoidetaan elegantisti?\n\nV: Kun tehdään .h-tiedostoja on tapana tehdä näin - tai pikemminkin kun teet .h-tiedostoja, tee aina näin:\n > #ifndef _OMA_H #define _OMA_H // sitten itse tiedoston sisalto #endif\n\nIdea siis on, että ekalla kerralla _OMA_H ei tietenkään ole määritelty. Siis if-not-defined (#ifndef) toteutuu ja _OMA_H määritellään ja tiedoston sisältö käsitellään. Mutta tokalla kerralla kun riviin törmätään, _OMA_H on jo määritelty ja loput tiedostosta jätetään käsittelemättä. Näin itse sisältö ei tule määritellyksi kahdesti missään yhteydessä ja ongelma on ratkaistu ja kaikilla on kivaa ja serpentiiniä ja vappuneniä riittää kaikille.\n\nK: Miten saa määriteltyä sellaisen globaalin muuttujan, joka toimii myös toisissa tiedostoissa olevassa koodissa?\n\nV: Ensimmäinen vastaus on: globaaleja muuttujia ei tarvita. Ne ovat yleensä merkki huonosta suunnittelusta. Globaali muuttuja on saatavilla joka puolella, joten sellainen voidaan myös sotkea mistä vaan. Hyvin suunnitellussa oliopohjaisessa C++-ohjelmassa ei ainakaan törmää koskaan globaalin muuttujan tarpeeseen. Poikkeuksena voisi mainita tietyt laitteistoläheiset toimenpiteet, joissa teknisistä syistä on pakko käyttää globaaleja muuttujia. Jos haluat globaaleja käyttää, niin perässä seuraa esimerkki. Maaginen sana on extern, joka siis ilmoittaa muuttujan olevan määritelty jossain muualla. Ohjelma on ihan teennäinen, ei noin oikeasti tietenkään saisi turhaan käyttää globaaleja. Mikäli #ifndef hämää, niin katso edellinen esimerkki.\n\nTiedosto main.cpp:\n > #include \"program.hpp\" int luku; int main() { luku = 0; while (luku < 100) { TulostaLuku(); luku++; } return EXIT_SUCCESS; }\n\nTiedosto program.hpp:\n > #ifndef _program_hpp #define _program_hpp void TulostaLuku(); extern int luku; #endif\n\nTiedosto tl.cpp:\n > #include <iostream.h> #include \"program.hpp\" void TulostaLuku() { cout << luku << \" \"; }\n\nK: Miten saan lisättyä C++-ohjelmiini kuvia? Miten teen animaatioita C++:lla?\n\nV: Tämä on ehdottomasti yleisin asia mitä minulta kysytään. C++ on kieli, jonka suunnittelussa on ollut päämääränä mm.: C++:aa voi käyttää kaikissa ohjelmointiympäristöissä ja C++ on suoraan yhteydessä tietokonelaitteistoon. Monissa eri ympäristöissä toimimisesta suoraa se, että ominaisuuksia, jotka ovat erilaisia eri ympäristöissä, kuten grafiikka, ei ole C++:n otettu mukaan. Kaikissa laitteissa kun ei ole edes näyttöä.\n\nToisaalta voi kysyä, että miksi Java, joka on vielä helpommin siirrettävissä laiteympäristöstä toiseen, mahdollistaa grafiikan käsittelyn kielen omilla kirjastoilla. Vastaus on siinä, että Java ei ole suorassa yhteydessä laitteistoon ja niinpä välissä oleva virtuaalikone voi tulkita ohjelman tekemät grafiikkaoperaatiot alustana toimivan laitteiston ymmärtämään muotoon. Tulkitseminen luonnollisesti vie aikaa ja niinpä Javalla ei kovin hämmentävään nopeuteen grafiikanpyörittelyssä pääsekään.\n\nMutta se, että C++-kielessä ei ole valmiita grafiikkaominaisuuksia, ei tarkoita sitä, että C++:lla ei voi käsitellä grafiikkaa. Päinvastoin, suurin osa hyvin graafisista sovelluksista, peleistä ja kuvankäsittelyohjelmista, on tehty C++:lla. Mitään standardia tapaa ei ole, vaan grafiikan käyttö riippuu aina siitä laiteympäristöstä missä toimitaan. Ja kun C++:lla tehdään alustalle räätälöityä grafiikkakoodia, on meno niin nopeata että varmasti karstat karisevat näytönohjaimesta!\n\nHelpoiten grafiikka-asioissa pääsee liikkeelle käyttämällä valmista grafiikkakirjastoa. DOS/Windows/Unix-ympäristössä löytyy Allegro, joka on erittäin hyvä kirjasto grafiikan käsittelyyn - ja sovellukset ovat siirrettävissä ympäristöstä toiseen. Windowsissa voi käyttää Windowsin C-ohjelmointirajapintaa tai C++-tyylistä MFC-oliokirjastoa, jolla sama asia hoituu oliomaisesti - todellinen Windows-peliohjelmointi tosin vaatii jo DirectX-rajapinnan käyttöä. Mikäli haluaa kirjoittaa monessa eri ympäristössä toimivaa grafiikkakoodia, niin Prometheus TrueColor (PTC) -kirjasto on hyvä valinta. Tai on se hyvä grafiikkakirjasto, vaikka siirrettävyys ei kiinnostakaan. Joidenkin kääntäjien mukana tulee yksinkertaisia grafiikkakirjastoja, mutta ne ovat yleensä enemmän tai vähemmän kökköjä.\n\nK: Olen lukenut erästä C++-kirjaa ja eteeni tuli seuraava kummallinen koodinpätkä. Mitäköhän mahtaa tarkoittaa tuo \"TAI ja sijoitus\" -operaatio?\n > #define CLIP_CODE_N 0x0008 int p1_code = 0; p1_code |= CLIP_CODE_N; // rivi 1\n\nV: Rivi 1 suorittaa bitti-TAI-operaation p1_code:n ja CLIP_CODE literaalivakion välillä ja sijoittaa tuloksen p1_code:en. Eli |= on samaa veljessarjaa kuin esimerkiksi +=. Eli toisin asia sanoiksi asetellen rivi 1 voitaisiin kirjoittaa myös:\n > p1_code = p1_code | CLIP_CODE_N;\n\nBitti-TAI tekee TAI:n jokaisen bitin välillä, eli jos toinen tai molemmat biteistä on 1 niin lopputulos on 1. Kyseessä on inklusiivinen TAI, olemassa on myös ekslusiivinen TAI jossa vain toinen saa olla 1 jotta lopputulos on 1 (ekslusiivinen tai merkitään \"hatulla\" eli: ^).\n\nKäytännössä |-operaatiota käytetään yleensä bittien kytkemiseen päälle, niinkuin tuossakin koodissa. Ensin tehdään bittimaski, jolla valitaan että mikä bitti halutaan päälle. Esimerkissä maski on 0x0008 eli binäärinä 0000000000001000. Kun suoritetaan TAI, niin niissä kohdin missä maskin bitti on 0, kopioituu alkuperäisen arvon (p1_code) bitti semmoisenaan. Siellä missä maskin arvo on 1, tulee tulokseen myös yksi. Siis koodi laittaa p1_code:n neljännen bitin päälle, jättäen muut alkuperäisiksi (eli nolliksi, koska p1_code alustettiin nollaksi).\n\n# Lähteitä\n\nIhan kaikkea mitä sinun pitää tietää C++-ohjelmoinnista ja yleensä ohjelmoinnista ei löydy näiltä sivuilta. Tässäpä vähän siis suuntaviisaria tutkimusmatkoillesi ohjelmointitietouden maailmaan. Linkeissä olen koittanut panostaa laatuun, en määrään.\n\nWWW:\n\nhttp://users.utu.fi/sisasa/oasis/cppfaq/ - C++ FAQ, siis ennenkin kysytyt asiat C++-ohjelmoinnista\n\nhttp://www.inquiry.com/techtips/cpp_pro/ - Voit kysyä C++-gurulta tai selailla muiden kysymyksiä. Suosittelen.\n\nhttp://www.possibility.com/Cpp/CppCodingStandard.html - Yksi näkemys siitä, miten tehdään yhtenäistä C++-koodia.\n\nhttp://www.csci.csusb.edu/dick/c++std#Drafts - Uusin (ollut ainakin joskus) julkinen C++-kielen standardi. Ei mitään aloittelijan materiaalia.\n\nhttp://www.comeaucomputing.com/tryitout/ - Online-kääntäjä, joka on hyvin standardinmukainen ja tuottaa pirun hyviä virheilmoituksia. Ohjelmoijan paras apu tilanteessa jossa epäilee oman kääntäjänsä toimintaa. Suosittelen.\n\nhttp://www.sgi.com/tech/stl - Oppia Standard Template Libraryn (STL) k�yt�st�.\n Usenet news: \nsfnet.atk.ohjelmointi.alkeet - Voit kysellä alkeellisiakin kysymyksiä ihan vapaasti (suomeksi).\n\nsfnet.atk.ohjelmointi - Vähän kehittyneempää juttua (suomeksi).\n\ncomp.lang.c++.moderated - Täällä pyöriikin todella ammattitaitoista C++-väkeä, tosin kieli on englanti.\n Muu kiinnostava ohjelmointimateriaali: \nhttp://www.talula.demon.co.uk/allegro - P�tev� peliohjelmointikirjasto, toimii hyvin monessa ymp�rist�ss�\n\nhttp://www.gaffer.org/ptc - Pätevä grafiikkaohjelmointikirjasto, mahdollistaa ohjelman siirtämisen ympäristöstä toiseen.\n\nhttp://msdn.microsoft.com - Ehdoton paikka Windows-tietouden hakemiseen. Suosittelen.\n\nKirjat:\n\nMikäli sinä haluat kommentoida jotakin lukemaasi C++-kirjaa, niin senkun sähköpostitat vaan. Merkittävimpiä tästä puuttuvia kirjoja ovat Deitel&Deitelin C++-opus ja Bruce Eckelin Thinking in C++.\n\nC++ ja olio-ohjelmointi - <NAME> (Teknolit, 1998, ISBN: 952-9823-45-2)\n\nPaljon asiaa ja selkeästi esitetty. Ei sellaisia ympäripyöreyksiä mitä alkeisoppaissa valitettavan usein tapaa. Lähestymistapa on mielestäni liiankin perusteellinen ja tarpeettomiin yksityiskohtiin (esim. union) puututaan turhan tarkasti, joten aloittelija voi tuntea itsensä välillä tukahtuneeksi ja turhautuneeksi.\n\nOpeta itsellesi C++-ohjelmointi - <NAME> (Satku, 1996, ISBN: 951-762-335-6)\n\nOikein perinteinen C++-opas: asiaa riittävästi, asiallisesti esitettynä. Toisaalta juuri yhtään ei vaivauduta selittämään miksi asiat pitää tehdä kuten on neuvottu, joten syvällinen asioiden ymmärtäminen jää vähän heikoksi. Teksti on melko kuivaa ja ne vähätkin mehut haihtuvat lukiessa pitkiä ja mielikuvituksettomia esimerkkejä, joita minun makuun on aivan liian paljon. Pikaisen selailun perusteella kirjan uudempi painos ei ole juurikaan parantunut.\n\nThe C++ Programming Language, 3rd Edition - Bjarne Stroustrup: (Addison-Wesley, 1997, ISBN: 0-201-88954-4)\n\nBjarne on C++:n kehittäjä, Bjarne tietää mistä puhuu. Lisäksi Bjarne on hyvä kirjoittaja. Kirjasta paistaa läpi C++:n täydellinen hallitseminen ja olennaisen erottaminen joutenpäiväisestä. Kuten Stroustrup itse sanoo, tärkeintä on opettaa oikeaa ohjelmointia eikä kielen koukeroita. En suosittelisi tätä erinomaista teosta kuitenkaan aivan aloittelijoille. Kirjasta on myös Special Edition, joka ei ilmeisesti sisällä mitään erityisen hyödyllistä uutta ja siinä olevat lisäkappaleet on saatavilla myös Stroustrupin www-sivuilta. Kirja on myös suomennettu ja suomennos on tiettävästi peräti hyvä.\n\nIntroduction to C++ Programming - <NAME>: (Prentice Hall , 1999, ISBN: 0-13-88801-9)\n\nKirja on kerännyt mainetta erityisen onnettoma yritelmänä - tosin itse en ole kirjaa lukenut. Ilmeisesti suurin osa C++:n hyvistä tavoista ja kirjoittamattomista säännöistä on unohdettu esimerkkejä laadittaessa ja muutenkin asian käsittely on hyvin suppeaa. Liekö taustalla ollut pedagoginen ajattelu ja aloittelijalähtöinen lähestymistapa, mutta liika on liikaa.\n\nOliosuunnittelukirjat:\n\nTässä esitelty kolmikko tarjoaa hyvän menetelmän (eli minun suosikkimenetelmäni) olio-ohjelmoinnin soveltamiseen todelliseen ohjelmointityöskentelyyn.\n\nDesign Patterns - <NAME>, <NAME>, <NAME>, <NAME>: (Addison-Wesley, 1995, ISBN: 0201633612)\n\nOliomaailman ehdoton klassikko. Esittelee suunnittelumallit, hyvät oliosuunniteluratkaisut yleisesti esiintyviin ongelmiin. Sisältää esimerkkejä C++:lla ja Smalltalkilla toteutettuna. On myös suomennettu nimellä Suunnittelumallit, pikaisen tutkistelun jälkeen suomennos vaikutti pääasiassa hassulta.\n\nExtreme Programming Explained - <NAME> (Addison-Wesley, 2000, ISBN: 0201616416)\n\nEsittelee Extreme Programming (XP) -menetelmän. XP-projekteissä keskitytään vähemmän turhaan dokumentointiin ja enemmän ohjelman tekemiseen ja kehittämiseen. Mielestäni erittäin hyvä tapa organisoida ohjelmointityötä.\n\nRefactoring: Improving the Design of Existing Code - <NAME> (Addison-Wesley, 1999, ISBN: 0201485672)\n\nJotkut ihmiset uskovat, että hyvä ohjelma suunnitellaan niin huolella, että sitä ei tarvitse jälkeenpäin muuttaa. Minä en kuulu tuohon kiihkomieliseen joukkoon. Tulevaisuuden ennustaminen vaatii yli-ihnimillisiä kykyjä, niinpä sellaisen varaan ei kannata ohjelmistoprojektia rakentaa. Parempi vaihtoehto on tunnustaa, että ennustaminen on kaappinostradamusten hommaa ja järjestää ohjelmointityöskentely niin, että sovelluksen rakenteen muokkaaminen on mahdollisimman helppoa. Refaktorointi on keskeinen elementti myös XP-menetelmässä.\n Takaisin"}}},{"rowIdx":597,"cells":{"project":{"kind":"string","value":"FastImputation"},"source":{"kind":"string","value":"cran"},"language":{"kind":"string","value":"R"},"content":{"kind":"string","value":"Package ‘FastImputation’\n September 25, 2023\nType Package\nTitle Learn from Training Data then Quickly Fill in Missing Data\nVersion 2.2.1\nDate 2023-09-25\nAuthor <NAME>\nMaintainer <NAME> <<EMAIL>>\nDescription TrainFastImputation() uses training data to describe a\n multivariate normal distribution that the data approximates or\n can be transformed into approximating and stores this information\n as an object of class 'FastImputationPatterns'. FastImputation()\n function uses this 'FastImputationPatterns' object to impute (make\n a good guess at) missing data in a single line or a whole data frame\n of data. This approximates the process used by 'Amelia'\n <https://gking.harvard.edu/amelia> but is much faster when\n filling in values for a single line of data.\nLicense GPL (>= 2)\nDepends R (>= 4.0)\nCollate 'FastImputation.R' 'TrainFastImputation.R' 'UnfactorColumns.R'\n 'BoundNormalizedVariable.R' 'NormalizeBoundedVariable.R'\n 'CovarianceWithMissing.R' 'FI_train.R' 'FI_test.R' 'FI_true.R'\nRoxygenNote 7.2.3\nImports methods, Matrix\nSuggests testthat, caret, e1071\nNeedsCompilation no\nEncoding UTF-8\nRepository CRAN\nDate/Publication 2023-09-25 15:10:02 UTC\nR topics documented:\nBoundNormalizedVariabl... 2\nCovarianceWithMissin... 3\nFastImputatio... 3\nFI_tes... 5\nFI_trai... 6\nFI_tru... 7\nNormalizeBoundedVariabl... 8\nTrainFastImputatio... 9\nUnfactorColumn... 10\n BoundNormalizedVariable\n Take a normalized variable and transform it back to a bounded vari-\n able.\nDescription\n This takes variables on the real line and constrains them to be on a half-line (constrained above\n or below) or a segment (constrained both above and below). This is approximately the inverse of\n NormalizeBoundedVariable; this does not completely reverse the effect of NormalizeBoundedVariable\n because NormalizeBoundedVariable first forces values away from the bounds, and this informa-\n tion is lost.\nUsage\n BoundNormalizedVariable(x, constraints)\nArguments\n x A vector, matrix, array, or dataframe with value to be coerced into a range or\n set.\n constraints A list of constraints. See the examples below for formatting details.\nValue\n An object of the same class as x with the values transformed into the desired half-line or segment.\nAuthor(s)\n <NAME> <<EMAIL>>\nExamples\n constraints=list(lower=5) # lower bound when constrining to an interval\n constraints=list(upper=10) # upper bound when constraining to an interval\n constraints=list(lower=5, upper=10) # both lower and upper bounds\n CovarianceWithMissing Estimate covariance when data is missing\nDescription\n Ignoring missing values can lead to biased estimates of the covariance. Lounici (2012) gives an\n unbiased estimator when the data has missing values.\nUsage\n CovarianceWithMissing(x)\nArguments\n x matrix or data.frame, data with each row an observation and each column a\n variable.\nValue\n matrix, unbiased estimate of the covariance.\nAuthor(s)\n <NAME> <<EMAIL>>\nReferences\n High-dimensional covariance matrix estimation with missing observations. Karim Lounici. 2012.\n FastImputation Use the pattern learned from the training data to impute (fill in good\n guesses for) missing values.\nDescription\n Like Amelia, FastImputation assumes that the columns of the data are multivariate normal or can\n be transformed into approximately multivariate normal.\nUsage\n FastImputation(x, patterns, verbose = TRUE)\nArguments\n x Dataframe, possibly with some missing (NA) values.\n patterns An object of class ’FastImputationPatterns’ generated by TrainFastImputation.\n verbose If TRUE then the progress in imputing the data will be shown.\nValue\n x, but with missing values filled in (imputed)\nAuthor(s)\n <NAME> <<EMAIL>>\nReferences\n https://gking.harvard.edu/amelia\nSee Also\n TrainFastImputation\nExamples\n data(FI_train) # provides FItrain dataset\n patterns <- TrainFastImputation(\n FI_train,\n constraints=list(list(\"bounded_below_2\", list(lower=0)),\n list(\"bounded_above_5\", list(upper=0)),\n list(\"bounded_above_and_below_6\", list(lower=0, upper=1))\n ),\n idvars=\"user_id_1\",\n categorical=\"categorical_9\")\n data(FI_test)\n FI_test # note there is missing data\n imputed_data <- FastImputation(FI_test, patterns)\n imputed_data # good guesses for missing values are filled in\n data(FI_true)\n continuous_cells_imputed <- is.na(FI_test[,2:8])\n continuous_imputed_values <- imputed_data[,2:8][continuous_cells_imputed]\n continuous_true_values <- FI_true[,2:8][continuous_cells_imputed]\n rmse <- sqrt(median((continuous_imputed_values-continuous_true_values)^2))\n rmse\n median_relative_error <- median( abs((continuous_imputed_values - continuous_true_values) /\n continuous_true_values) )\n median_relative_error\n imputed_data_column_means <- FI_test[,2:8]\n for(j in 1:ncol(imputed_data_column_means)) {\n imputed_data_column_means[is.na(imputed_data_column_means[,j]),j] <-\n mean(imputed_data_column_means[,j], na.rm=TRUE)\n }\n cont_imputed_vals_col_means <- imputed_data_column_means[continuous_cells_imputed]\n rmse_column_means <- sqrt(median((cont_imputed_vals_col_means-continuous_true_values)^2))\n rmse_column_means # much larger error than using FastImputation\n median_relative_error_col_means <- median( abs((cont_imputed_vals_col_means -\n continuous_true_values) / continuous_true_values) )\n median_relative_error_col_means # larger error than using FastImputation\n # Let's look at the accuracy of the imputation of the categorical variable\n library(\"caret\")\n categorical_rows_imputed <- which(is.na(FI_test$categorical_9))\n confusionMatrix(data=imputed_data$categorical_9[categorical_rows_imputed],\n reference=FI_true$categorical_9[categorical_rows_imputed])\n # Compare to imputing with the modal value\n stat_mode <- function(x) {\n unique_values <- unique(x)\n unique_values <- unique_values[!is.na(unique_values)]\n unique_values[which.max(tabulate(match(x, unique_values)))]\n }\n categorical_rows_imputed_col_mode <- rep(stat_mode(FI_test$categorical_9),\n length(categorical_rows_imputed))\n confusionMatrix(data=categorical_rows_imputed_col_mode,\n reference=FI_true$categorical_9[categorical_rows_imputed])\n # less accurate than using FastImputation\n FI_test Imputation Test Data\nDescription\n Smaller simulated dataset drawn from the same distribution as FI_train and FI_true. This dataset is\n entirely the same as FI_true except this one has 5% of its values missing. Used with FastImputation.\nUsage\n data(FI_test)\nFormat\n A data frame with 9 variables and 250 observations.\n user_id_1 Sequential user ids\n bounded_below_2 Multivariate normal, transformed using exp(x)\n unbounded_3 Multivariate normal\n unbounded_4 Multivariate normal\n bounded_above_5 Multivariate normal, transformed using -exp(x)\n bounded_above_and_below_6 Multivariate normal, transformed using pnorm(x)\n unbounded_7 Multivariate normal\n unbounded_8 Multivariate normal\n categorical_9 \"A\" if the first of three multivariate normal draws is greatest; \"B\" if the second is\n greatest; \"C\" if the third is greatest\nAuthor(s)\n <NAME> <<EMAIL>>\nSource\n All columns start as multivariate normal draws. Columns 2, 5, and 6 are transformed. Column\n 9 is the result of three multivariate normal columns being interpreted as one-hot encoding of a\n three-valued categorical variable.\n FI_train Imputation Training Data\nDescription\n Larger simulated dataset drawn from the same distribution as FI_test and FI_true and used to train\n the imputation algorithm. 5% of the values are missing. Used with TrainFastImputation.\nUsage\n data(FI_train)\nFormat\n A data frame with 9 variables and 10000 observations.\n user_id_1 Sequential user ids\n bounded_below_2 Multivariate normal, transformed using exp(x)\n unbounded_3 Multivariate normal\n unbounded_4 Multivariate normal\n bounded_above_5 Multivariate normal, transformed using -exp(x)\n bounded_above_and_below_6 Multivariate normal, transformed using pnorm(x)\n unbounded_7 Multivariate normal\n unbounded_8 Multivariate normal\n categorical_9 \"A\" if the first of three multivariate normal draws is greatest; \"B\" if the second is\n greatest; \"C\" if the third is greatest\nAuthor(s)\n <NAME> <<EMAIL>>\nSource\n All columns start as multivariate normal draws. Columns 2, 5, and 6 are transformed. Column\n 9 is the result of three multivariate normal columns being interpreted as one-hot encoding of a\n three-valued categorical variable.\n FI_true Imputation \"True\" Data\nDescription\n Smaller simulated dataset drawn from the same distribution as FI_train and FI_test. This dataset is\n entirely the same as FI_test except FI_test has 5% of its values missing. Used to evaluate the quality\n of the values imputed in FI_test.\nUsage\n data(FI_true)\nFormat\n A data frame with 9 variables and 250 observations.\n user_id_1 Sequential user ids\n bounded_below_2 Multivariate normal, transformed using exp(x)\n unbounded_3 Multivariate normal\n unbounded_4 Multivariate normal\n bounded_above_5 Multivariate normal, transformed using -exp(x)\n bounded_above_and_below_6 Multivariate normal, transformed using pnorm(x)\n unbounded_7 Multivariate normal\n unbounded_8 Multivariate normal\n categorical_9 \"A\" if the first of three multivariate normal draws is greatest; \"B\" if the second is\n greatest; \"C\" if the third is greatest\nAuthor(s)\n <NAME> <<EMAIL>>\nSource\n All columns start as multivariate normal draws. Columns 2, 5, and 6 are transformed. Column\n 9 is the result of three multivariate normal columns being interpreted as one-hot encoding of a\n three-valued categorical variable.\n NormalizeBoundedVariable\n Take a variable bounded above/below/both and return an unbounded\n (normalized) variable.\nDescription\n This transforms bounded variables so that they are not bounded. First variables are coerced away\n from the boundaries. by a distance of tol. The natural log is used for variables bounded either\n above or below but not both. The inverse of the standard normal cumulative distribution function\n (the quantile function) is used for variables bounded above and below.\nUsage\n NormalizeBoundedVariable(x, constraints, tol = stats::pnorm(-5), trim = TRUE)\nArguments\n x A vector, matrix, array, or dataframe with value to be coerced into a range or\n set.\n constraints A list of constraints. See the examples below for formatting details.\n tol Variables will be forced to be at least this far away from the boundaries.\n trim If TRUE values in x < lower and values in x > upper will be set to lower and\n upper, respectively, before normalizing.\nValue\n An object of the same class as x with the values transformed so that they spread out over any part\n of the real line.\n A variable x that is bounded below by lower is transformed to log(x - lower).\n A variable x that is bounded above by upper is transformed to log(upper - x).\n A variable x that is bounded below by lower and above by upper is transformed to qnorm((x-lower)/(upper\n - lower)).\nAuthor(s)\n <NAME> <<EMAIL>>\nExamples\n constraints=list(lower=5) # lower bound when constrining to an interval\n constraints=list(upper=10) # upper bound when constraining to an interval\n constraints=list(lower=5, upper=10) # both lower and upper bounds\n TrainFastImputation Learn from the training data so that later you can fill in missing data\nDescription\n Like Amelia, FastImputation assumes that the columns of the data are multivariate normal or can\n be transformed into approximately multivariate normal.\nUsage\n TrainFastImputation(x, constraints = list(), idvars, categorical)\nArguments\n x Dataframe containing training data. Can have incomplete rows.\n constraints A list of constraints. See the examples below for formatting details.\n idvars A vector of column numbers or column names to be ignored in the imputation\n process.\n categorical A vector of column numbers or column names of varaibles with a (small) set of\n possible values.\nValue\n An object of class ’FastImputationPatterns’ that contains information needed later to impute on a\n single row.\nAuthor(s)\n <NAME> <<EMAIL>>\nReferences\n https://gking.harvard.edu/amelia\nSee Also\n FastImputation\nExamples\n data(FI_train) # provides FI_train dataset\n patterns_with_constraints <- TrainFastImputation(\n FI_train,\n constraints=list(list(\"bounded_below_2\", list(lower=0)),\n list(\"bounded_above_5\", list(upper=0)),\n list(\"bounded_above_and_below_6\", list(lower=0, upper=1))\n ),\n idvars=\"user_id_1\",\n categorical=\"categorical_9\")\n UnfactorColumns Convert columns of a dataframe from factors to character or numeric.\nDescription\n Convert columns of a dataframe from factors to character or numeric.\nUsage\n UnfactorColumns(x)\nArguments\n x A dataframe\nValue\n A dataframe containing the same data but any factor columns have been replaced with numeric or\n character columns.\nAuthor(s)\n <NAME> <<EMAIL>>"}}},{"rowIdx":598,"cells":{"project":{"kind":"string","value":"ogp"},"source":{"kind":"string","value":"hex"},"language":{"kind":"string","value":"Erlang"},"content":{"kind":"string","value":"ogp\n===\n\nThe [Open Graph protocol](https://ogp.me/) library in Elixir.\n\n[](https://github.com/goofansu/ogp/actions/workflows/ci.yml)\n[](https://coveralls.io/github/goofansu/ogp?branch=main)\n\n Installation\n---\n```\ndef deps do\n [\n {:ogp, \"~> 1.0.0\"}\n ]\nend\n```\n Usage\n---\n\nI recommend to run [ogp.livemd](./ogp.livemd) in [Livebook](https://github.com/elixir-nx/livebook) for detail.\n\n### \n\n Parse HTML\n```\niex> html = \"\"\"\n<meta property=\"og:title\" content=\"The Rock\" />\n<meta property=\"og:type\" content=\"video.movie\" />\n<meta property=\"og:url\" content=\"https://www.imdb.com/title/tt0117500/\" />\n<meta property=\"og:image\" content=\"https://ia.media-imdb.com/images/rock.jpg\" />\n<meta property=\"og:image\" content=\"https://ia.media-imdb.com/images/rock2.jpg\" />\n<meta property=\"og:audio\" content=\"https://example.com/bond/theme.mp3\" />\n<meta property=\"og:description\" \n content=\"<NAME> found fame and fortune as the\n suave, sophisticated British agent, <NAME>.\" />\n<meta property=\"og:determiner\" content=\"the\" />\n<meta property=\"og:locale\" content=\"en_GB\" />\n<meta property=\"og:locale:alternate\" content=\"fr_FR\" />\n<meta property=\"og:site_name\" content=\"IMDb\" />\n<meta property=\"og:video\" content=\"https://example.com/bond/trailer.swf\" />\n\"\"\"\niex> OpenGraph.parse(html) \n%OpenGraph{\n audio: \"https://example.com/bond/theme.mp3\",\n description: \"<NAME> found fame and fortune as the\\n suave, sophisticated British agent, <NAME>.\",\n determiner: \"the\",\n image: \"https://ia.media-imdb.com/images/rock.jpg\",\n locale: \"en_GB\",\n site_name: \"IMDb\",\n title: \"The Rock\",\n type: \"video.movie\",\n url: \"https://www.imdb.com/title/tt0117500/\",\n video: \"https://example.com/bond/trailer.swf\"\n}\n```\n### \n\n Fetch URL\n```\niex> OpenGraph.fetch!(\"https://github.com\")\n%OpenGraph{\n audio: nil,\n description: \"GitHub is where over 65 million developers shape the future of software, together. Contribute to the open source community, manage your Git repositories, review code like a pro, track bugs and feat...\",\n determiner: nil,\n image: \"https://github.githubassets.com/images/modules/site/social-cards/github-social.png\",\n locale: nil,\n site_name: \"GitHub\",\n title: \"GitHub: Where the world builds software\",\n type: \"object\",\n url: \"https://github.com/\",\n video: nil\n}\n```\nRedirect is followed automatically, see the following example:\n```\niex> OpenGraph.fetch!(\"https://producthunt.com\")\n%OpenGraph{\n audio: nil,\n description: \"Product Hunt is a curation of the best new products, every day. Discover the latest mobile apps, websites, and technology products that everyone's talking about.\",\n determiner: nil,\n image: \"https://ph-static.imgix.net/ph-logo-1.png\",\n locale: \"en_US\",\n site_name: \"Product Hunt\",\n title: \" Product Hunt – The best new products in tech. \",\n type: \"article\",\n url: \"https://www.producthunt.com/\",\n video: nil\n}\n```\n[API Reference](api-reference.html)\n\nOpenGraph\n===\n\n Summary\n===\n\n[Types](#types)\n---\n\n[t()](#t:t/0)\n\n[value()](#t:value/0)\n\n[Functions](#functions)\n---\n\n[fetch(url)](#fetch/1)\n\nFetch URL and parse Open Graph protocol.\n\n[fetch!(url)](#fetch!/1)\n\nSimilar to [`fetch/1`](#fetch/1) but raises a [`OpenGraph.Error`](OpenGraph.Error.html) exception if request failed.\n\n[parse(html)](#parse/1)\n\nParse Open Graph protocol.\n\n[Link to this section](#types)\nTypes\n===\n\n[Link to this section](#functions)\nFunctions\n===\n\nOpenGraph.Error exception\n===\n\n Summary\n===\n\n[Types](#types)\n---\n\n[reason()](#t:reason/0)\n\n[status_code()](#t:status_code/0)\n\n[t()](#t:t/0)\n\n[Link to this section](#types)\nTypes\n===\n\nAPI Reference\n===\n\n Modules\n---\n\n[OpenGraph](OpenGraph.html)\n\n[OpenGraph.Error](OpenGraph.Error.html)\n\n[ogp](readme.html)"}}},{"rowIdx":599,"cells":{"project":{"kind":"string","value":"multcomp"},"source":{"kind":"string","value":"cran"},"language":{"kind":"string","value":"R"},"content":{"kind":"string","value":"Package ‘multcomp’\n June 20, 2023\nTitle Simultaneous Inference in General Parametric Models\nVersion 1.4-25\nDate 2023-06-20\nDescription Simultaneous tests and confidence intervals\n for general linear hypotheses in parametric models, including\n linear, generalized linear, linear mixed effects, and survival models.\n The package includes demos reproducing analyzes presented\n in the book ``Multiple Comparisons Using R'' (Bretz, Hothorn,\n Westfall, 2010, CRC Press).\nDepends stats, graphics, mvtnorm (>= 1.0-10), survival (>= 2.39-4),\n TH.data (>= 1.0-2)\nImports sandwich (>= 2.3-0), codetools\nSuggests lme4 (>= 0.999375-16), nlme, robustbase, coin, MASS, foreign,\n xtable, lmtest, coxme (>= 2.2-1), SimComp, ISwR, tram (>=\n 0.2-5), fixest (>= 0.10), glmmTMB\nURL http://multcomp.R-forge.R-project.org The publishers web page is\n http://www.crcpress.com/product/isbn/9781584885740\nLazyData yes\nLicense GPL-2\nNeedsCompilation no\nAuthor <NAME> [aut, cre] (<https://orcid.org/0000-0001-8301-0471>),\n <NAME> [aut],\n <NAME> [aut],\n <NAME> [ctb],\n <NAME> [ctb],\n <NAME> [ctb]\nMaintainer <NAME> <<EMAIL>>\nRepository CRAN\nDate/Publication 2023-06-20 17:30:06 UTC\nR topics documented:\nadeven... 2\ncftes... 4\ncholestero... 5\ncl... 6\ncm... 8\ncontrMa... 9\ndetergen... 10\nfattyaci... 11\nglh... 12\nglht-method... 16\nlitte... 20\nmm... 21\nmodelpar... 25\nmtep... 26\npar... 27\nplot.cl... 28\nrecover... 30\nsb... 31\ntrees51... 32\nwast... 33\n adevent Adverse Events Data\nDescription\n Indicators of 28 adverse events in a two-arm clinical trial.\nUsage\n data(adevent)\nFormat\n A data frame with 160 observations on the following 29 variables.\n E1 a factor with levels no event event\n E2 a factor with levels no event event\n E3 a factor with levels no event event\n E4 a factor with levels no event event\n E5 a factor with levels no event event\n E6 a factor with levels no event event\n E7 a factor with levels no event event\n E8 a factor with levels no event event\n E9 a factor with levels no event event\n E10 a factor with levels no event event\n E11 a factor with levels no event event\n E12 a factor with levels no event event\n E13 a factor with levels no event event\n E14 a factor with levels no event event\n E15 a factor with levels no event event\n E16 a factor with levels no event event\n E17 a factor with levels no event event\n E18 a factor with levels no event event\n E19 a factor with levels no event event\n E20 a factor with levels no event event\n E21 a factor with levels no event event\n E22 a factor with levels no event event\n E23 a factor with levels no event event\n E24 a factor with levels no event event\n E25 a factor with levels no event event\n E26 a factor with levels no event event\n E27 a factor with levels no event event\n E28 a factor with levels no event event\n group group indicator.\nDetails\n The data is provided by Westfall et al. (1999, p. 242) and contains binary indicators of 28 adverse\n events (E1,..., E28) for two arms (group).\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc.\n cftest Testing Estimated Coefficients\nDescription\n A convenience function for univariate testing via z- and t-tests of estimated model coefficients\nUsage\n cftest(model, parm, test = univariate(), ...)\nArguments\n model a fitted model.\n parm a vector of parameters to be tested, either a character vector of names or an\n integer.\n test a function for computing p values, see summary.glht.\n ... additional arguments passed to summary.glht.\nDetails\n The usual z- or t-tests are tested without adjusting for multiplicity.\nValue\n An object of class summary.glht.\nSee Also\n coeftest\nExamples\n lmod <- lm(dist ~ speed, data = cars)\n summary(lmod)\n cftest(lmod)\n cholesterol Cholesterol Reduction Data Set\nDescription\n Cholesterol reduction for five treatments.\nUsage\n data(\"cholesterol\")\nFormat\n This data frame contains the following variables\n trt treatment groups, a factor at levels 1time, 2times, 4times, drugD and drugE.\n response cholesterol reduction.\nDetails\n A clinical study was conducted to assess the effect of three formulations of the same drug on reduc-\n ing cholesterol. The formulations were 20mg at once (1time), 10mg twice a day (2times), and 5mg\n four times a day (4times). In addition, two competing drugs were used as control group (drugD\n and drugE). The purpose of the study was to find which of the formulations, if any, is efficacious\n and how these formulations compare with the existing drugs.\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc., page 153.\nExamples\n ### adjusted p-values for all-pairwise comparisons in a one-way layout\n ### set up ANOVA model\n amod <- aov(response ~ trt, data = cholesterol)\n ### set up multiple comparisons object for all-pair comparisons\n cht <- glht(amod, linfct = mcp(trt = \"Tukey\"))\n ### cf. Westfall et al. (1999, page 171)\n summary(cht, test = univariate())\n summary(cht, test = adjusted(\"Shaffer\"))\n summary(cht, test = adjusted(\"Westfall\"))\n ### use only a subset of all pairwise hypotheses\n K <- contrMat(table(cholesterol$trt), type=\"Tukey\")\n Ksub <- rbind(K[c(1,2,5),],\n \"D - test\" = c(-1, -1, -1, 3, 0),\n \"E - test\" = c(-1, -1, -1, 0, 3))\n ### reproduce results in Westfall et al. (1999, page 172)\n ### note: the ordering of our estimates here is different\n amod <- aov(response ~ trt - 1, data = cholesterol)\n summary(glht(amod, linfct = mcp(trt = Ksub[,5:1])),\n test = adjusted(\"Westfall\"))\n cld Set up a compact letter display of all pair-wise comparisons\nDescription\n Extract information from glht, summary.glht or confint.glht objects which is required to create\n and plot compact letter displays of all pair-wise comparisons.\nUsage\n ## S3 method for class 'summary.glht'\n cld(object, level = 0.05, decreasing = FALSE, ...)\n ## S3 method for class 'glht'\n cld(object, level = 0.05, decreasing = FALSE, ...)\n ## S3 method for class 'confint.glht'\n cld(object, decreasing = FALSE, ...)\nArguments\n object An object of class glht, summary.glht or confint.glht.\n level Significance-level to be used to term a specific pair-wise comparison significant.\n decreasing logical. Should the order of the letters be increasing or decreasing?\n ... additional arguments.\nDetails\n This function extracts all the information from glht, summary.glht or confint.glht objects that\n is required to create a compact letter display of all pair-wise comparisons. In case the contrast\n matrix is not of type \"Tukey\", an error is issued. In case of confint.glht objects, a pair-wise\n comparison is termed significant whenever a particular confidence interval contains 0. Otherwise,\n p-values are compared to the value of \"level\". Once, this information is extracted, plotting of all\n pair-wise comparisons can be carried out.\nValue\n An object of class cld, a list with items:\n y Values of the response variable of the original model.\n yname Name of the response variable.\n x Values of the variable used to compute Tukey contrasts.\n weights Weights used in the fitting process.\n lp Predictions from the fitted model.\n covar A logical indicating whether the fitted model contained covariates.\n signif Vector of logicals indicating significant differences with hyphenated names that\n identify pair-wise comparisons.\nReferences\n Hans-<NAME> (2004), An Algorithm for a Letter-Based Representation of All-Pairwise Com-\n parisons, Journal of Computational and Graphical Statistics, 13(2), 456–466.\nSee Also\n glht plot.cld\nExamples\n ### multiple comparison procedures\n ### set up a one-way ANOVA\n data(warpbreaks)\n amod <- aov(breaks ~ tension, data = warpbreaks)\n ### specify all pair-wise comparisons among levels of variable \"tension\"\n tuk <- glht(amod, linfct = mcp(tension = \"Tukey\"))\n ### extract information\n tuk.cld <- cld(tuk)\n ### use sufficiently large upper margin\n old.par <- par(mai=c(1,1,1.25,1), no.readonly = TRUE)\n ### plot\n plot(tuk.cld)\n par(old.par)\n ### now using covariates\n data(warpbreaks)\n amod2 <- aov(breaks ~ tension + wool, data = warpbreaks)\n ### specify all pair-wise comparisons among levels of variable \"tension\"\n tuk2 <- glht(amod2, linfct = mcp(tension = \"Tukey\"))\n ### extract information\n tuk.cld2 <- cld(tuk2)\n ### use sufficiently large upper margin\n old.par <- par(mai=c(1,1,1.25,1), no.readonly = TRUE)\n ### plot using different colors\n plot(tuk.cld2, col=c(\"black\", \"red\", \"blue\"))\n par(old.par)\n ### set up all pair-wise comparisons for count data\n data(Titanic)\n mod <- glm(Survived ~ Class, data = as.data.frame(Titanic), weights = Freq, family = binomial())\n ### specify all pair-wise comparisons among levels of variable \"Class\"\n glht.mod <- glht(mod, mcp(Class = \"Tukey\"))\n ### extract information\n mod.cld <- cld(glht.mod)\n ### use sufficiently large upper margin\n old.par <- par(mai=c(1,1,1.5,1), no.readonly = TRUE)\n ### plot\n plot(mod.cld)\n par(old.par)\n cml Chronic Myelogenous Leukemia survival data.\nDescription\n Survival in a randomised trial comparing three treatments for Chronic Myelogeneous Leukemia\n (simulated data).\nUsage\n data(\"cml\")\nFormat\n A data frame with 507 observations on the following 7 variables.\n center a factor with 54 levels indicating the study center.\n treatment a factor with levels trt1, trt2, trt3 indicating the treatment group.\n sex sex (0 = female, 1 = male)\n age age in years\n riskgroup risk group (0 = low, 1 = medium, 2 = high)\n status censoring status (FALSE = censored, TRUE = dead)\n time survival or censoring time in days.\nDetails\n The data are simulated according to structure of the data by the German CML Study Group used in\n Hehlmann (1994).\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, <NAME>-\n effler, <NAME>, <NAME> (1994), Randomized comparison of interferon-alpha with busul-\n fan and hydroxyurea in chronic myelogenous leukemia. The German CML study group. Blood\n 84(12):4064-4077.\nExamples\n if (require(\"coxme\")) {\n data(\"cml\")\n ### one-sided simultaneous confidence intervals for many-to-one\n ### comparisons of treatment effects concerning time of survival\n ### modeled by a frailty Cox model with adjustment for further\n ### covariates and center-specific random effect.\n cml_coxme <- coxme(Surv(time, status) ~ treatment + sex + age + riskgroup + (1|center),\n data = cml)\n glht_coxme <- glht(model = cml_coxme, linfct = mcp(treatment = \"Dunnett\"),\n alternative = \"greater\")\n ci_coxme <- confint(glht_coxme)\n exp(ci_coxme$confint)[1:2,]\n }\n contrMat Contrast Matrices\nDescription\n Computes contrast matrices for several multiple comparison procedures.\nUsage\n contrMat(n, type = c(\"Dunnett\", \"Tukey\", \"Sequen\", \"AVE\",\n \"Changepoint\", \"Williams\", \"Marcus\",\n \"McDermott\", \"UmbrellaWilliams\", \"GrandMean\"),\n base = 1)\nArguments\n n a (possibly named) vector of sample sizes for each group.\n type type of contrast.\n base an integer specifying which group is considered the baseline group for Dunnett\n contrasts.\nDetails\n Computes the requested matrix of contrasts for comparisons of mean levels.\nValue\n The matrix of contrasts with appropriate row names is returned.\nReferences\n <NAME>, <NAME> and <NAME> (2010), Multiple Comparisons Using R, CRC\n Press, Boca Raton.\n <NAME>, <NAME> and <NAME> (2001), On the numerical availability of multiple\n comparison procedures. Biometrical Journal, 43(5), 645–656.\nExamples\n n <- c(10,20,30,40)\n names(n) <- paste(\"group\", 1:4, sep=\"\")\n contrMat(n) # Dunnett is default\n contrMat(n, base = 2) # use second level as baseline\n contrMat(n, type = \"Tukey\")\n contrMat(n, type = \"Sequen\")\n contrMat(n, type = \"AVE\")\n contrMat(n, type = \"Changepoint\")\n contrMat(n, type = \"Williams\")\n contrMat(n, type = \"Marcus\")\n contrMat(n, type = \"McDermott\")\n ### Umbrella-protected Williams contrasts, i.e. a sequence of\n ### Williams-type contrasts with groups of higher order\n ### stepwise omitted\n contrMat(n, type = \"UmbrellaWilliams\")\n ### comparison of each group with grand mean of all groups\n contrMat(n, type = \"GrandMean\")\n detergent Detergent Durability Data Set\nDescription\n Detergent durability in an incomplete two-way design.\nUsage\n data(\"detergent\")\nFormat\n This data frame contains the following variables\n detergent detergent, a factor at levels A, B, C, D, and E.\n block block, a factor at levels B_1, ..., B_10.\n plates response variable: number of plates washed before the foam disappears.\nDetails\n Plates were washed with five detergent varieties, in ten blocks. A complete design would have 50\n combinations, here only three detergent varieties in each block were applied in a balanced incom-\n plete block design. Note that there are six observations taken at each detergent level.\nSource\n <NAME> (1959). The Analysis of Variance. New York: John Wiley & Sons, page 189.\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc., page 189.\nExamples\n ### set up two-way ANOVA without interactions\n amod <- aov(plates ~ block + detergent, data = detergent)\n ### set up all-pair comparisons\n dht <- glht(amod, linfct = mcp(detergent = \"Tukey\"))\n ### see Westfall et al. (1999, p. 190)\n confint(dht)\n ### see Westfall et al. (1999, p. 192)\n summary(dht, test = univariate())\n ## Not run:\n summary(dht, test = adjusted(\"Shaffer\"))\n summary(dht, test = adjusted(\"Westfall\"))\n ## End(Not run)\n fattyacid Fatty Acid Content of Bacillus simplex.\nDescription\n Fatty acid content of different putative ecotypes of Bacillus simplex.\nUsage\n data(\"fattyacid\")\nFormat\n A data frame with 93 observations on the following 2 variables.\n PE a factor with levels PE3, PE4, PE5, PE6, PE7, PE9 indicating the putative ecotype (PE).\n FA a numeric vector indicating the content of fatty acid (FA).\nDetails\n The data give the fatty acid content for different putative ecotypes of Bacillus simplex. Variances\n of the values of fatty acid are heterogeneous among the putative ecotypes.\nSource\n <NAME>, <NAME>, <NAME>, <NAME> (2008), The temperature adaptive fatty\n acid content in Bacillus simplex strains from ”Evolution Canyon“, Israel. Microbiology 154, 2416-\n 2426.\nExamples\n if (require(\"sandwich\")) {\n data(\"fattyacid\")\n ### all-pairwise comparisons of the means of fatty acid content\n ### FA between different putative ecotypes PE accounting for\n ### heteroscedasticity by using a heteroscedastic consistent\n ### covariance estimation\n amod <- aov(FA ~ PE, data = fattyacid)\n amod_glht <- glht(amod, mcp(PE = \"Tukey\"), vcov = vcovHC)\n summary(amod_glht)\n ### simultaneous confidence intervals for the differences of\n ### means of fatty acid content between the putative ecotypes\n confint(amod_glht)\n }\n glht General Linear Hypotheses\nDescription\n General linear hypotheses and multiple comparisons for parametric models, including generalized\n linear models, linear mixed effects models, and survival models.\nUsage\n ## S3 method for class 'matrix'\n glht(model, linfct,\n alternative = c(\"two.sided\", \"less\", \"greater\"),\n rhs = 0, ...)\n ## S3 method for class 'character'\n glht(model, linfct, ...)\n ## S3 method for class 'expression'\n glht(model, linfct, ...)\n ## S3 method for class 'mcp'\n glht(model, linfct, ...)\n ## S3 method for class 'mlf'\n glht(model, linfct, ...)\n mcp(..., interaction_average = FALSE, covariate_average = FALSE)\nArguments\n model a fitted model, for example an object returned by lm, glm, or aov etc. It is\n assumed that coef and vcov methods are available for model. For multiple\n comparisons of means, methods model.matrix, model.frame and terms are\n expected to be available for model as well.\n linfct a specification of the linear hypotheses to be tested. Linear functions can be\n specified by either the matrix of coefficients or by symbolic descriptions of one\n or more linear hypotheses. Multiple comparisons in AN(C)OVA models are\n specified by objects returned from function mcp.\n .\n alternative a character string specifying the alternative hypothesis, must be one of ’\"two.sided\"’\n (default), ’\"greater\"’ or ’\"less\"’. You can specify just the initial letter.\n rhs an optional numeric vector specifying the right hand side of the hypothesis.\n interaction_average\n logical indicating if comparisons are averaging over interaction terms. Experi-\n mental!\n covariate_average\n logical indicating if comparisons are averaging over additional covariates. Ex-\n perimental!\n ... additional arguments to function modelparm in all glht methods. For func-\n tion mcp, multiple comparisons are defined by matrices or symbolic descriptions\n specifying contrasts of factor levels where the arguments correspond to factor\n names.\nDetails\n A general linear hypothesis refers to null hypotheses of the form H0 : Kθ = m for some parametric\n model model with parameter estimates coef(model).\n The null hypothesis is specified by a linear function Kθ, the direction of the alternative and the right\n hand side m. Here, alternative equal to \"two.sided\" refers to a null hypothesis H0 : Kθ = m,\n whereas \"less\" corresponds to H0 : Kθ ≥ m and \"greater\" refers to H0 : Kθ ≤ m. The right\n hand side vector m can be defined via the rhs argument.\n The generic method glht dispatches on its second argument (linfct). There are three ways, and\n thus methods, to specify linear functions to be tested:\n 1) The matrix of coefficients K can be specified directly via the linfct argument. In this case, the\n number of columns of this matrix needs to correspond to the number of parameters estimated by\n model. It is assumed that appropriate coef and vcov methods are available for model (modelparm\n deals with some exceptions).\n 2) A symbolic description, either a character or expression vector passed to glht via its linfct\n argument, can be used to define the null hypothesis. A symbolic description must be interpretable as\n a valid R expression consisting of both the left and right hand side of a linear hypothesis. Only the\n names of coef(model) must be used as variable names. The alternative is given by the direction\n under the null hypothesis (= or == refer to \"two.sided\", <= means \"greater\" and >= indicates\n \"less\"). Numeric vectors of length one are valid values for the right hand side.\n 3) Multiple comparisons of means are defined by objects of class mcp as returned by the mcp func-\n tion. For each factor, which is included in model as independent variable, a contrast matrix or a\n symbolic description of the contrasts can be specified as arguments to mcp. A symbolic description\n may be a character or expression where the factor levels are only used as variables names. In\n addition, the type argument to the contrast generating function contrMat may serve as a symbolic\n description of contrasts as well.\n 4) The lsm function in package lsmeans offers a symbolic interface for the definition of least-\n squares means for factor combinations which is very helpful when more complex contrasts are of\n special interest.\n The mcp function must be used with care when defining parameters of interest in two-way ANOVA\n or ANCOVA models. Here, the definition of treatment differences (such as Tukey’s all-pair compar-\n isons or Dunnett’s comparison with a control) might be problem specific. Because it is impossible\n to determine the parameters of interest automatically in this case, mcp in multcomp version 1.0-0\n and higher generates comparisons for the main effects only, ignoring covariates and interactions\n (older versions automatically averaged over interaction terms). A warning is given. We refer to\n Hsu (1996), Chapter 7, and Searle (1971), Chapter 7.3, for further discussions and examples on this\n issue.\n glht extracts the number of degrees of freedom for models of class lm (via modelparm) and the\n exact multivariate t distribution is evaluated. For all other models, results rely on the normal ap-\n proximation. Alternatively, the degrees of freedom to be used for the evaluation of multivariate t\n distributions can be given by the additional df argument to modelparm specified via ....\n glht methods return a specification of the null hypothesis H0 : Kθ = m. The value of the linear\n function Kθ can be extracted using the coef method and the corresponding covariance matrix is\n available from the vcov method. Various simultaneous and univariate tests and confidence intervals\n are available from summary.glht and confint.glht methods, respectively.\n A more detailed description of the underlying methodology is available from Hothorn et al. (2008)\n and Bretz et al. (2010).\nValue\n An object of class glht, more specifically a list with elements\n model a fitted model, used in the call to glht\n linfct the matrix of linear functions\n rhs the vector of right hand side values m\n coef the values of the linear functions\n vcov the covariance matrix of the values of the linear functions\n df optionally, the degrees of freedom when the exact t distribution is used for in-\n ference\n alternative a character string specifying the alternative hypothesis\n type optionally, a character string giving the name of the specific procedure\n with print, summary, confint, coef and vcov methods being available. When called with linfct\n being an mcp object, an additional element focus is available storing the names of the factors under\n test.\nReferences\n <NAME>, <NAME> and <NAME> (2010), Multiple Comparisons Using R, CRC\n Press, Boca Raton.\n <NAME> (1971), Linear Models. John Wiley & Sons, New York.\n <NAME> (1996), Multiple Comparisons. Chapman & Hall, London.\n <NAME>, <NAME> and <NAME> (2008), Simultaneous Inference in General Para-\n metric Models. Biometrical Journal, 50(3), 346–363; See vignette(\"generalsiminf\", package\n = \"multcomp\").\nExamples\n ### multiple linear model, swiss data\n lmod <- lm(Fertility ~ ., data = swiss)\n ### test of H_0: all regression coefficients are zero\n ### (ignore intercept)\n ### define coefficients of linear function directly\n K <- diag(length(coef(lmod)))[-1,]\n rownames(K) <- names(coef(lmod))[-1]\n K\n ### set up general linear hypothesis\n glht(lmod, linfct = K)\n ### alternatively, use a symbolic description\n ### instead of a matrix\n glht(lmod, linfct = c(\"Agriculture = 0\",\n \"Examination = 0\",\n \"Education = 0\",\n \"Catholic = 0\",\n \"Infant.Mortality = 0\"))\n ### multiple comparison procedures\n ### set up a one-way ANOVA\n amod <- aov(breaks ~ tension, data = warpbreaks)\n ### set up all-pair comparisons for factor `tension'\n ### using a symbolic description (`type' argument\n ### to `contrMat()')\n glht(amod, linfct = mcp(tension = \"Tukey\"))\n ### alternatively, describe differences symbolically\n glht(amod, linfct = mcp(tension = c(\"M - L = 0\",\n \"H - L = 0\",\n \"H - M = 0\")))\n ### alternatively, define contrast matrix directly\n contr <- rbind(\"M - L\" = c(-1, 1, 0),\n \"H - L\" = c(-1, 0, 1),\n \"H - M\" = c(0, -1, 1))\n glht(amod, linfct = mcp(tension = contr))\n ### alternatively, define linear function for coef(amod)\n ### instead of contrasts for `tension'\n ### (take model contrasts and intercept into account)\n glht(amod, linfct = cbind(0, contr %*% contr.treatment(3)))\n ### mix of one- and two-sided alternatives\n warpbreaks.aov <- aov(breaks ~ wool + tension,\n data = warpbreaks)\n ### contrasts for `tension'\n K <- rbind(\"L - M\" = c( 1, -1, 0),\n \"M - L\" = c(-1, 1, 0),\n \"L - H\" = c( 1, 0, -1),\n \"M - H\" = c( 0, 1, -1))\n warpbreaks.mc <- glht(warpbreaks.aov,\n linfct = mcp(tension = K),\n alternative = \"less\")\n ### correlation of first two tests is -1\n cov2cor(vcov(warpbreaks.mc))\n ### use smallest of the two one-sided\n ### p-value as two-sided p-value -> 0.0232\n summary(warpbreaks.mc)\n ### more complex models: Continuous outcome logistic\n ### regression; parameters are log-odds ratios\n if (require(\"tram\", quietly = TRUE, warn.conflicts = FALSE)) {\n confint(glht(Colr(breaks ~ wool + tension,\n data = warpbreaks),\n linfct = mcp(\"tension\" = \"Tukey\")))\n }\n glht-methods Methods for General Linear Hypotheses\nDescription\n Simultaneous tests and confidence intervals for general linear hypotheses.\nUsage\n ## S3 method for class 'glht'\n summary(object, test = adjusted(), ...)\n ## S3 method for class 'glht'\n confint(object, parm, level = 0.95, calpha = adjusted_calpha(),\n ...)\n ## S3 method for class 'glht'\n coef(object, rhs = FALSE, ...)\n ## S3 method for class 'glht'\n vcov(object, ...)\n ## S3 method for class 'confint.glht'\n plot(x, xlim, xlab, ylim, ...)\n ## S3 method for class 'glht'\n plot(x, ...)\n univariate()\n adjusted(type = c(\"single-step\", \"Shaffer\", \"Westfall\", \"free\",\n p.adjust.methods), ...)\n Ftest()\n Chisqtest()\n adjusted_calpha(...)\n univariate_calpha(...)\nArguments\n object an object of class glht.\n test a function for computing p values.\n parm additional parameters, currently ignored.\n level the confidence level required.\n calpha either a function computing the critical value or the critical value itself.\n rhs logical, indicating whether the linear function K θ̂ or the right hand side m (rhs\n = TRUE) of the linear hypothesis should be returned.\n type the multiplicity adjustment (adjusted) to be applied. See below and p.adjust.\n x an object of class glht or confint.glht.\n xlim the x limits (x1, x2) of the plot.\n ylim the y limits of the plot.\n xlab a label for the x axis.\n ... additional arguments, such as maxpts, abseps or releps to pmvnorm in adjusted\n or qmvnorm in confint. Note that additional arguments specified to summary,\n confint, coef and vcov methods are currently ignored.\nDetails\n The methods for general linear hypotheses as described by objects returned by glht can be used\n to actually test the global null hypothesis, each of the partial hypotheses and for simultaneous\n confidence intervals for the linear function Kθ.\n The coef and vcov methods compute the linear function K θ̂ and its covariance, respectively.\n The test argument to summary takes a function specifying the type of test to be applied. Classical\n Chisq (Wald test) or F statistics for testing the global hypothesis H0 are implemented in functions\n Chisqtest and Ftest. Several approaches to multiplicity adjusted p values for each of the lin-\n ear hypotheses are implemented in function adjusted. The type argument to adjusted specifies\n the method to be applied: \"single-step\" implements adjusted p values based on the joint nor-\n mal or t distribution of the linear function, and \"Shaffer\" and \"Westfall\" implement logically\n constraint multiplicity adjustments (Shaffer, 1986; Westfall, 1997). \"free\" implements multiple\n testing procedures under free combinations (Westfall et al, 1999). In addition, all adjustment meth-\n ods implemented in p.adjust are available as well.\n Simultaneous confidence intervals for linear functions can be computed using method confint.\n Univariate confidence intervals can be computed by specifying calpha = univariate_calpha()\n to confint. The critical value can directly be specified as a scalar to calpha as well. Note that\n plot(a) for some object a of class glht is equivalent to plot(confint(a)).\n All simultaneous inference procedures implemented here control the family-wise error rate (FWER).\n Multivariate normal and t distributions, the latter one only for models of class lm, are evaluated us-\n ing the procedures implemented in package mvtnorm. Note that the default procedure is stochastic.\n Reproducible p-values and confidence intervals require appropriate settings of seeds.\n A more detailed description of the underlying methodology is available from Hothorn et al. (2008)\n and Bretz et al. (2010).\nValue\n summary computes (adjusted) p values for general linear hypotheses, confint computes (adjusted)\n confidence intervals. coef returns estimates of the linear function Kθ and vcov its covariance.\nReferences\n <NAME>, <NAME> and <NAME> (2010), Multiple Comparisons Using R, CRC\n Press, Boca Raton.\n <NAME> (1986), Modified sequentially rejective multiple test procedures. Journal of the\n American Statistical Association, 81, 826–831.\n <NAME> (1997), Multiple testing of general contrasts using logical constraints and correla-\n tions. Journal of the American Statistical Association, 92, 299–306.\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc.\n <NAME>, <NAME> and <NAME> (2008), Simultaneous Inference in General Para-\n metric Models. Biometrical Journal, 50(3), 346–363; See vignette(\"generalsiminf\", package\n = \"multcomp\").\nExamples\n ### set up a two-way ANOVA\n amod <- aov(breaks ~ wool + tension, data = warpbreaks)\n ### set up all-pair comparisons for factor `tension'\n wht <- glht(amod, linfct = mcp(tension = \"Tukey\"))\n ### 95% simultaneous confidence intervals\n plot(print(confint(wht)))\n ### the same (for balanced designs only)\n TukeyHSD(amod, \"tension\")\n ### corresponding adjusted p values\n summary(wht)\n ### all means for levels of `tension'\n amod <- aov(breaks ~ tension, data = warpbreaks)\n glht(amod, linfct = matrix(c(1, 0, 0,\n 1, 1, 0,\n 1, 0, 1), byrow = TRUE, ncol = 3))\n ### confidence bands for a simple linear model, `cars' data\n plot(cars, xlab = \"Speed (mph)\", ylab = \"Stopping distance (ft)\",\n las = 1)\n ### fit linear model and add regression line to plot\n lmod <- lm(dist ~ speed, data = cars)\n abline(lmod)\n ### a grid of speeds\n speeds <- seq(from = min(cars$speed), to = max(cars$speed),\n length = 10)\n ### linear hypotheses: 10 selected points on the regression line != 0\n K <- cbind(1, speeds)\n ### set up linear hypotheses\n cht <- glht(lmod, linfct = K)\n ### confidence intervals, i.e., confidence bands, and add them plot\n cci <- confint(cht)\n lines(speeds, cci$confint[,\"lwr\"], col = \"blue\")\n lines(speeds, cci$confint[,\"upr\"], col = \"blue\")\n ### simultaneous p values for parameters in a Cox model\n if (require(\"survival\") && require(\"MASS\")) {\n data(\"leuk\", package = \"MASS\")\n leuk.cox <- coxph(Surv(time) ~ ag + log(wbc), data = leuk)\n ### set up linear hypotheses\n lht <- glht(leuk.cox, linfct = diag(length(coef(leuk.cox))))\n ### adjusted p values\n print(summary(lht))\n }\n litter Litter Weights Data Set\nDescription\n Dose response of litter weights in rats.\nUsage\n data(\"litter\")\nFormat\n This data frame contains the following variables\n dose dosages at four levels: 0, 5, 50, 500.\n gesttime gestation time as covariate.\n number number of animals in litter as covariate.\n weight response variable: average post-birth weights in the entire litter.\nDetails\n Pregnant mice were divided into four groups and the compound in four different doses was admin-\n istered during pregnancy. Their litters were evaluated for birth weights.\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc., page 109.\n <NAME> (1997). Multiple Testing of General Contrasts Using Logical Constraints and Corre-\n lations. Journal of the American Statistical Association, 92(437), 299–306.\nExamples\n ### fit ANCOVA model to data\n amod <- aov(weight ~ dose + gesttime + number, data = litter)\n ### define matrix of linear hypotheses for `dose'\n doselev <- as.integer(levels(litter$dose))\n K <- rbind(contrMat(table(litter$dose), \"Tukey\"),\n otrend = c(-1.5, -0.5, 0.5, 1.5),\n atrend = doselev - mean(doselev),\n ltrend = log(1:4) - mean(log(1:4)))\n ### set up multiple comparison object\n Kht <- glht(amod, linfct = mcp(dose = K), alternative = \"less\")\n ### cf. Westfall (1997, Table 2)\n summary(Kht, test = univariate())\n summary(Kht, test = adjusted(\"bonferroni\"))\n summary(Kht, test = adjusted(\"Shaffer\"))\n summary(Kht, test = adjusted(\"Westfall\"))\n summary(Kht, test = adjusted(\"single-step\"))\n mmm Simultaneous Inference for Multiple Marginal Models\nDescription\n Calculation of correlation between test statistics from multiple marginal models using the score\n decomposition\nUsage\n mmm(...)\n mlf(...)\nArguments\n ... A names argument list containing fitted models (mmm) or definitions of linear\n functions (mlf). If only one linear function is defined for mlf, it will be applied\n to all models in mmm by glht.mlf.\nDetails\n Estimated correlations of the estimated parameters of interest from the multiple marginal models\n are obtained using a stacked version of the i.i.d. decomposition of parameter estimates by means of\n score components (first derivatives of the log likelihood). The method is less conservative than the\n Bonferroni correction. The details are provided by Pipper, Ritz and Bisgaard (2012).\n The implementation assumes that the model were fitted to the same data, i.e., the rows of the matri-\n ces returned by estfun belong to the same observations for each model.\n The reference distribution is always multivariate normal, if you want to use the multivariate t, please\n specify the corresponding degrees of freedom as an additional df argument to glht.\n Observations with missing values contribute zero to the score function. Models have to be fitted\n using na.exclude as na.action argument.\nValue\n An object of class mmm or mlf, basically a named list of the arguments with a special method for\n glht being available for the latter. vcov, estfun, and bread methods are available for objects of\n class mmm.\nAuthor(s)\n Code for the computation of the joint covariance and sandwich matrices was contributed by Chris-\n <NAME> and <NAME>.\nReferences\n <NAME>, <NAME> and <NAME> (2012), A Versatile Method for Confir-\n matory Evaluation of the Effects of a Covariate in Multiple Models, Journal of the Royal Statistical\n Society, Series C (Applied Statistics), 61, 315–326.\nExamples\n ### replicate analysis of Hasler & Hothorn (2011),\n ### A Dunnett-Type Procedure for Multiple Endpoints,\n ### The International Journal of Biostatistics: Vol. 7: Iss. 1, Article 3.\n ### DOI: 10.2202/1557-4679.1258\n library(\"sandwich\")\n ### see ?coagulation\n if (require(\"SimComp\")) {\n data(\"coagulation\", package = \"SimComp\")\n ### level \"S\" is the standard, \"H\" and \"B\" are novel procedures\n coagulation$Group <- relevel(coagulation$Group, ref = \"S\")\n ### fit marginal models\n (m1 <- lm(Thromb.count ~ Group, data = coagulation))\n (m2 <- lm(ADP ~ Group, data = coagulation))\n (m3 <- lm(TRAP ~ Group, data = coagulation))\n ### set-up Dunnett comparisons for H - S and B - S\n ### for all three models\n g <- glht(mmm(Thromb = m1, ADP = m2, TRAP = m3),\n mlf(mcp(Group = \"Dunnett\")), alternative = \"greater\")\n ### joint correlation\n cov2cor(vcov(g))\n ### simultaneous p-values adjusted by taking the correlation\n ### between the score contributions into account\n summary(g)\n ### simultaneous confidence intervals\n confint(g)\n ### compare with\n ## Not run:\n library(\"SimComp\")\n SimCiDiff(data = coagulation, grp = \"Group\",\n resp = c(\"Thromb.count\",\"ADP\",\"TRAP\"),\n type = \"Dunnett\", alternative = \"greater\",\n covar.equal = TRUE)\n ## End(Not run)\n ### use sandwich variance matrix\n g <- glht(mmm(Thromb = m1, ADP = m2, TRAP = m3),\n mlf(mcp(Group = \"Dunnett\")),\n alternative = \"greater\", vcov = sandwich)\n summary(g)\n confint(g)\n }\n ### attitude towards science data\n data(\"mn6.9\", package = \"TH.data\")\n ### one model for each item\n mn6.9.y1 <- glm(y1 ~ group, family = binomial(),\n na.action = na.omit, data = mn6.9)\n mn6.9.y2 <- glm(y2 ~ group, family = binomial(),\n na.action = na.omit, data = mn6.9)\n mn6.9.y3 <- glm(y3 ~ group, family = binomial(),\n na.action = na.omit, data = mn6.9)\n mn6.9.y4 <- glm(y4 ~ group, family = binomial(),\n na.action = na.omit, data = mn6.9)\n ### test all parameters simulaneously\n summary(glht(mmm(mn6.9.y1, mn6.9.y2, mn6.9.y3, mn6.9.y4),\n mlf(diag(2))))\n ### group differences\n summary(glht(mmm(mn6.9.y1, mn6.9.y2, mn6.9.y3, mn6.9.y4),\n mlf(\"group2 = 0\")))\n ### alternative analysis of Klingenberg & Satopaa (2013),\n ### Simultaneous Confidence Intervals for Comparing Margins of\n ### Multivariate Binary Data, CSDA, 64, 87-98\n ### http://dx.doi.org/10.1016/j.csda.2013.02.016\n ### see supplementary material for data description\n ### NOTE: this is not the real data but only a subsample\n influenza <- structure(list(\n HEADACHE = c(1L, 0L, 0L, 1L, 0L, 0L, 1L, 1L, 1L,\n 0L, 0L, 1L, 0L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L,\n 1L, 1L), MALAISE = c(0L, 0L, 1L, 1L, 0L, 1L, 1L, 1L, 0L, 1L,\n 0L, 0L, 1L, 1L, 0L, 0L, 1L, 0L, 1L, 0L, 1L, 0L, 1L, 1L, 0L, 1L,\n 0L), PYREXIA = c(0L, 0L, 0L, 0L, 0L, 1L, 0L, 1L, 0L, 0L, 1L,\n 1L, 1L, 1L, 0L, 0L, 0L, 0L, 0L, 1L, 1L, 1L, 0L, 0L, 0L, 1L, 1L\n ), ARTHRALGIA = c(0L, 0L, 0L, 0L, 1L, 0L, 1L, 0L, 1L, 1L, 0L,\n 0L, 1L, 1L, 0L, 1L, 0L, 0L, 1L, 0L, 0L, 0L, 0L, 1L, 1L, 1L, 1L\n ), group = structure(c(2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L,\n 2L, 2L, 2L, 2L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L,\n 1L), .Label = c(\"pla\", \"trt\"), class = \"factor\"), Freq = c(32L,\n 165L, 10L, 23L, 3L, 1L, 4L, 2L, 4L, 2L, 1L, 1L, 1L, 1L, 167L,\n 1L, 11L, 37L, 7L, 7L, 5L, 3L, 3L, 1L, 2L, 4L, 2L)), .Names = c(\"HEADACHE\",\n \"MALAISE\", \"PYREXIA\", \"ARTHRALGIA\", \"group\", \"Freq\"), row.names = c(1L,\n 2L, 3L, 5L, 9L, 36L, 43L, 50L, 74L, 83L, 139L, 175L, 183L, 205L,\n 251L, 254L, 255L, 259L, 279L, 281L, 282L, 286L, 302L, 322L, 323L,\n 366L, 382L), class = \"data.frame\")\n influenza <- influenza[rep(1:nrow(influenza), influenza$Freq), 1:5]\n ### Fitting marginal logistic regression models\n (head_logreg <- glm(HEADACHE ~ group, data = influenza,\n family = binomial()))\n (mala_logreg <- glm(MALAISE ~ group, data = influenza,\n family = binomial()))\n (pyre_logreg <- glm(PYREXIA ~ group, data = influenza,\n family = binomial()))\n (arth_logreg <- glm(ARTHRALGIA ~ group, data = influenza,\n family = binomial()))\n ### Simultaneous inference for log-odds\n xy.sim <- glht(mmm(head = head_logreg,\n mala = mala_logreg,\n pyre = pyre_logreg,\n arth = arth_logreg),\n mlf(\"grouptrt = 0\"))\n summary(xy.sim)\n confint(xy.sim)\n ### Artificial examples\n ### Combining linear regression and logistic regression\n set.seed(29)\n y1 <- rnorm(100)\n y2 <- factor(y1 + rnorm(100, sd = .1) > 0)\n x1 <- gl(4, 25)\n x2 <- runif(100, 0, 10)\n m1 <- lm(y1 ~ x1 + x2)\n m2 <- glm(y2 ~ x1 + x2, family = binomial())\n ### Note that the same explanatory variables are considered in both models\n ### but the resulting parameter estimates are on 2 different scales\n ### (original and log-odds scales)\n ### Simultaneous inference for the same parameter in the 2 model fits\n summary(glht(mmm(m1 = m1, m2 = m2), mlf(\"x12 = 0\")))\n ### Simultaneous inference for different parameters in the 2 model fits\n summary(glht(mmm(m1 = m1, m2 = m2),\n mlf(m1 = \"x12 = 0\", m2 = \"x13 = 0\")))\n ### Simultaneous inference for different and identical parameters in the 2\n ### model fits\n summary(glht(mmm(m1 = m1, m2 = m2),\n mlf(m1 = c(\"x12 = 0\", \"x13 = 0\"), m2 = \"x13 = 0\")))\n ### Examples for binomial data\n ### Two independent outcomes\n y1.1 <- rbinom(100, 1, 0.45)\n y1.2 <- rbinom(100, 1, 0.55)\n group <- factor(rep(c(\"A\", \"B\"), 50))\n m1 <- glm(y1.1 ~ group, family = binomial)\n m2 <- glm(y1.2 ~ group, family = binomial)\n summary(glht(mmm(m1 = m1, m2 = m2),\n mlf(\"groupB = 0\")))\n ### Two perfectly correlated outcomes\n y2.1 <- rbinom(100, 1, 0.45)\n y2.2 <- y2.1\n group <- factor(rep(c(\"A\", \"B\"), 50))\n m1 <- glm(y2.1 ~ group, family = binomial)\n m2 <- glm(y2.2 ~ group, family = binomial)\n summary(glht(mmm(m1 = m1, m2 = m2),\n mlf(\"groupB = 0\")))\n ### use sandwich covariance matrix\n summary(glht(mmm(m1 = m1, m2 = m2),\n mlf(\"groupB = 0\"), vcov = sandwich))\n modelparm Generic Accessor Function for Model Parameters\nDescription\n Extract model parameters and their covariance matrix as well as degrees of freedom (if available)\n from a fitted model.\nUsage\n modelparm(model, coef., vcov., df, ...)\nArguments\n model a fitted model, for example an object returned by lm, glm, aov, survreg, fixest,\n or lmer etc.\n coef. an accessor function for the model parameters. Alternatively, the vector of co-\n efficients.\n vcov. an accessor function for the covariance matrix of the model parameters. Alter-\n natively, the covariance matrix directly.\n df an optional specification of the degrees of freedom to be used in subsequent\n computations.\n ... additional arguments, currently ignored.\nDetails\n One can’t expect coef and vcov methods for arbitrary models to return a vector of p fixed effects\n model parameters (coef) and corresponding p × p covariance matrix (vcov).\n The coef. and vcov. arguments can be used to define modified coef or vcov methods for a specific\n model. Methods for lmer, fixest, and survreg objects are available (internally).\n For objects inheriting from class lm the degrees of freedom are determined from model and the\n corresponding multivariate t distribution is used by all methods to glht objects. By default, the\n asymptotic multivariate normal distribution is used in all other cases unless df is specified by the\n user.\nValue\n An object of class modelparm with elements\n coef model parameters\n vcov covariance matrix of model parameters\n df degrees of freedom\n mtept Multiple Endpoints Data\nDescription\n Measurements on four endpoints in a two-arm clinical trial.\nUsage\n data(mtept)\nFormat\n A data frame with 111 observations on the following 5 variables.\n treatment a factor with levels Drug Placebo\n E1 endpoint 1\n E2 endpoint 2\n E3 endpoint 3\n E4 endpoint 4\nDetails\n The data (from Westfall et al., 1999) contain measurements of patients in treatment (Drug) and\n control (Placebo) groups, with four outcome variables.\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc.\n parm Model Parameters\nDescription\n Directly specify estimated model parameters and their covariance matrix.\nUsage\n parm(coef, vcov, df = 0)\nArguments\n coef estimated coefficients.\n vcov estimated covariance matrix of the coefficients.\n df an optional specification of the degrees of freedom to be used in subsequent\n computations.\nDetails\n When only estimated model parameters and the corresponding covariance matrix is available for\n simultaneous inference using glht (for example, when only the results but not the original data are\n available or, even worse, when the model has been fitted outside R), function parm sets up an object\n glht is able to compute on (mainly by offering coef and vcov methods).\n Note that the linear function in glht can’t be specified via mcp since the model terms are missing.\nValue\n An object of class parm with elements\n coef model parameters\n vcov covariance matrix of model parameters\n df degrees of freedom\nExamples\n ## example from\n ## <NAME>, and Westfall (2002).\n ## On multiple comparisons in R. R News, 2(3):14-17.\n beta <- c(V1 = 14.8, V2 = 12.6667, V3 = 7.3333, V4 = 13.1333)\n Sigma <- 6.7099 * (diag(1 / c(20, 3, 3, 15)))\n confint(glht(model = parm(beta, Sigma, 37),\n linfct = c(\"V2 - V1 >= 0\",\n \"V3 - V1 >= 0\",\n \"V4 - V1 >= 0\")),\n level = 0.9)\n plot.cld Plot a cld object\nDescription\n Plot information of glht, summary.glht or confint.glht objects stored as cld objects together\n with a compact letter display of all pair-wise comparisons.\nUsage\n ## S3 method for class 'cld'\n plot(x, type = c(\"response\", \"lp\"), ...)\nArguments\n x An object of class cld.\n type Should the response or the linear predictor (lp) be plotted. If there are any covari-\n ates, the lp is automatically used. To use the response variable, set type=\"response\"\n and covar=FALSE of the cld object.\n ... Other optional print parameters which are passed to the plotting functions.\nDetails\n This function plots the information stored in glht, summary.glht or confint.glht objects. Prior\n to plotting, these objects have to be converted to cld objects (see cld for details). All types of\n plots include a compact letter display (cld) of all pair-wise comparisons. Equal letters indicate no\n significant differences. Two levels are significantly different, in case they do not have any letters in\n common. If the fitted model contains any covariates, a boxplot of the linear predictor is generated\n with the cld within the upper margin. Otherwise, three different types of plots are used depending on\n the class of variable y of the cld object. In case of class(y) == \"numeric\", a boxplot is generated\n using the response variable, classified according to the levels of the variable used for the Tukey\n contrast matrix. Is class(y) == \"factor\", a mosaic plot is generated, and the cld is printed above.\n In case of class(y) == \"Surv\", a plot of fitted survival functions is generated where the cld is\n plotted within the legend. The compact letter display is computed using the algorithm of Piepho\n (2004). Note: The user has to provide a sufficiently large upper margin which can be used to depict\n the compact letter display (see examples).\nReferences\n Hans-<NAME> (2004), An Algorithm for a Letter-Based Representation of All-Pairwise Com-\n parisons, Journal of Computational and Graphical Statistics, 13(2), 456–466.\nSee Also\n glht cld cld.summary.glht cld.confint.glht cld.glht boxplot mosaicplot plot.survfit\nExamples\n ### multiple comparison procedures\n ### set up a one-way ANOVA\n data(warpbreaks)\n amod <- aov(breaks ~ tension, data = warpbreaks)\n ### specify all pair-wise comparisons among levels of variable \"tension\"\n tuk <- glht(amod, linfct = mcp(tension = \"Tukey\"))\n ### extract information\n tuk.cld <- cld(tuk)\n ### use sufficiently large upper margin\n old.par <- par(mai=c(1,1,1.25,1), no.readonly=TRUE)\n ### plot\n plot(tuk.cld)\n par(old.par)\n ### now using covariates\n amod2 <- aov(breaks ~ tension + wool, data = warpbreaks)\n tuk2 <- glht(amod2, linfct = mcp(tension = \"Tukey\"))\n tuk.cld2 <- cld(tuk2)\n old.par <- par(mai=c(1,1,1.25,1), no.readonly=TRUE)\n ### use different colors for boxes\n plot(tuk.cld2, col=c(\"green\", \"red\", \"blue\"))\n par(old.par)\n ### get confidence intervals\n ci.glht <- confint(tuk)\n ### plot them\n plot(ci.glht)\n old.par <- par(mai=c(1,1,1.25,1), no.readonly=TRUE)\n ### use 'confint.glht' object to plot all pair-wise comparisons\n plot(cld(ci.glht), col=c(\"white\", \"blue\", \"green\"))\n par(old.par)\n ### set up all pair-wise comparisons for count data\n data(Titanic)\n mod <- glm(Survived ~ Class, data = as.data.frame(Titanic),\n weights = Freq, family = binomial())\n ### specify all pair-wise comparisons among levels of variable \"Class\"\n glht.mod <- glht(mod, mcp(Class = \"Tukey\"))\n ### extract information\n mod.cld <- cld(glht.mod)\n ### use sufficiently large upper margin\n old.par <- par(mai=c(1,1,1.5,1), no.readonly=TRUE)\n ### plot\n plot(mod.cld)\n par(old.par)\n ### set up all pair-wise comparisons of a Cox-model\n if (require(\"survival\") && require(\"MASS\")) {\n ### construct 4 classes of age\n Melanoma$Cage <- factor(sapply(Melanoma$age, function(x){\n if( x <= 25 ) return(1)\n if( x > 25 & x <= 50 ) return(2)\n if( x > 50 & x <= 75 ) return(3)\n if( x > 75 & x <= 100) return(4) }\n ))\n ### fit Cox-model\n cm <- coxph(Surv(time, status == 1) ~ Cage, data = Melanoma)\n ### specify all pair-wise comparisons among levels of \"Cage\"\n cm.glht <- glht(cm, mcp(Cage = \"Tukey\"))\n # extract information & plot\n old.par <- par(no.readonly=TRUE)\n ### use mono font family\n if (dev.interactive())\n old.par <- par(family = \"mono\")\n plot(cld(cm.glht), col=c(\"black\", \"red\", \"blue\", \"green\"))\n par(old.par)\n }\n if (require(\"nlme\") && require(\"lme4\")) {\n data(\"ergoStool\", package = \"nlme\")\n stool.lmer <- lmer(effort ~ Type + (1 | Subject),\n data = ergoStool)\n glme41 <- glht(stool.lmer, mcp(Type = \"Tukey\"))\n old.par <- par(mai=c(1,1,1.5,1), no.readonly=TRUE)\n plot(cld(glme41))\n par(old.par)\n }\n recovery Recovery Time Data Set\nDescription\n Recovery time after surgery.\nUsage\n data(\"recovery\")\nFormat\n This data frame contains the following variables\n blanket blanket type, a factor at four levels: b0, b1, b2, and b3.\n minutes response variable: recovery time after a surgical procedure.\nDetails\n A company developed specialized heating blankets designed to help the body heat following a\n surgical procedure. Four types of blankets were tried on surgical patients with the aim of comparing\n the recovery time of patients. One of the blanket was a standard blanket that had been in use already\n in various hospitals.\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc., page 66.\nExamples\n ### set up one-way ANOVA\n amod <- aov(minutes ~ blanket, data = recovery)\n ### set up multiple comparisons: one-sided Dunnett contrasts\n rht <- glht(amod, linfct = mcp(blanket = \"Dunnett\"),\n alternative = \"less\")\n ### cf. Westfall et al. (1999, p. 80)\n confint(rht, level = 0.9)\n ### the same\n rht <- glht(amod, linfct = mcp(blanket = c(\"b1 - b0 >= 0\",\n confint(rht, level = 0.9)\n sbp Systolic Blood Pressure Data\nDescription\n Systolic blood pressure, age and gender of 69 people.\nUsage\n data(\"sbp\")\nFormat\n A data frame with 69 observations on the following 3 variables.\n gender a factor with levels male female\n sbp systolic blood pressure in mmHg\n age age in years\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, A. (1998), Applied Regression Analysis\n and Other Multivariable Methods, Duxbury Press, North Scituate, MA.\n trees513 Frankonian Tree Damage Data\nDescription\n Damages on young trees caused by deer browsing.\nUsage\n data(\"trees513\")\nFormat\n A data frame with 2700 observations on the following 4 variables.\n damage a factor with levels yes and no indicating whether or not the trees has been damaged by\n game animals, mostly roe deer.\n species a factor with levels spruce, fir, pine, softwood (other), beech, oak, ash/maple/elm/lime,\n and hardwood (other).\n lattice a factor with levels 1, ..., 53, essentially a number indicating the position of the sampled\n area.\n plot a factor with levels x_1, ..., x_5 where x is the lattice. plot is nested within lattice and is\n a replication for each lattice point.\nDetails\n In most parts of Germany, the natural or artificial regeneration of forests is difficult due to a high\n browsing intensity. Young trees suffer from browsing damage, mostly by roe and red deer. In order\n to estimate the browsing intensity for several tree species, the Bavarian State Ministry of Agriculture\n and Foresty conducts a survey every three years. Based on the estimated percentage of damaged\n trees, suggestions for the implementation or modification of deer management plans are made.\n The survey takes place in all 756 game management districts (‘Hegegemeinschaften’) in Bavaria.\n The data given here are from the game management district number 513 ‘Unterer Aischgrund’\n (located in Frankonia between Erlangen and H\\\"ochstadt) in 2006. The data of 2700 trees include\n the species and a binary variable indicating whether or not the tree suffers from damage caused by\n deer browsing.\nSource\n Bayerisches Staatsministerium fuer Landwirtschaft und Forsten (2006), Forstliche Gutachten zur\n Situation der Waldverjuengung 2006. https://www.stmelf.bayern.de/wald/\n <NAME>, <NAME> and <NAME> (2008), Simultaneous Inference in General Para-\n metric Models. Biometrical Journal, 50(3), 346–363; See vignette(\"generalsiminf\", package\n = \"multcomp\").\nExamples\n summary(trees513)\n waste Industrial Waste Data Set\nDescription\n Industrial waste output in a manufactoring plant.\nUsage\n data(\"waste\")\nFormat\n This data frame contains the following variables\n temp temperature, a factor at three levels: low, medium, high.\n envir environment, a factor at five levels: env1 . . . env5.\n waste response variable: waste output in a manufacturing plant.\nDetails\n The data are from an experiment designed to study the effect of temperature (temp) and environment\n (envir) on waste output in a manufactoring plant. Two replicate measurements were taken at each\n temperature / environment combination.\nSource\n <NAME>, <NAME>, <NAME>, <NAME>, <NAME> (1999). Multiple Comparisons\n and Multiple Tests Using the SAS System. Cary, NC: SAS Institute Inc., page 177.\nExamples\n ### set up two-way ANOVA with interactions\n amod <- aov(waste ~ temp * envir, data=waste)\n ### comparisons of main effects only\n K <- glht(amod, linfct = mcp(temp = \"Tukey\"))$linfct\n K\n glht(amod, K)\n ### comparisons of means (by averaging interaction effects)\n low <- grep(\"low:envi\", colnames(K))\n med <- grep(\"medium:envi\", colnames(K))\n K[1, low] <- 1 / (length(low) + 1)\n K[2, med] <- 1 / (length(low) + 1)\n K[3, med] <- 1 / (length(low) + 1)\n K[3, low] <- - 1 / (length(low) + 1)\n K\n confint(glht(amod, K))\n ### same as TukeyHSD\n TukeyHSD(amod, \"temp\")\n ### set up linear hypotheses for all-pairs of both factors\n wht <- glht(amod, linfct = mcp(temp = \"Tukey\", envir = \"Tukey\"))\n ### cf. Westfall et al. (1999, page 181)\n summary(wht, test = adjusted(\"Shaffer\"))"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":5,"numItemsPerPage":100,"numTotalItems":59733,"offset":500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3ODUzOTU1NSwic3ViIjoiL2RhdGFzZXRzL1NpdmlsVGFyYW0vc3RhcmNvZGVyMi1kb2N1bWVudGF0aW9uIiwiZXhwIjoxNzc4NTQzMTU1LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.kfMiOgtkDFKsQ9w5X3_SbrAVIYB3yqNiNa1lu8Pz5sOB-cZFCNxz0HJFaEnxoIu1jbxhtgoNPxlj7siB52x7Cw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":59733,"numBytesParquet":1850870873}]},"discussionsStats":{"closed":0,"open":2,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[{"views":[{"key":"default/train","displayName":"train","viewName":"train"}],"sql":"-- The SQL console is powered by DuckDB WASM and runs entirely in the browser.\n-- Get started by typing a query or selecting a view from the options below.\nSELECT *\nFROM train\nWHERE source = 'free_programming_book'\n AND lower(content) LIKE '%python%'\n AND LOWER(content) LIKE '%algorithms%';","title":"Python Algorithms in Free Books","createdAt":"2025-04-03T17:17:56.697Z","slug":"RUf2lH9","private":false,"justification":"Retrieves entries related to both Python and algorithms from a specific source, providing a filtered dataset but lacking broader analytical depth.","viewNames":["train"]},{"views":[{"key":"default/train","displayName":"train","viewName":"train"}],"sql":"-- The SQL console is powered by DuckDB WASM and runs entirely in the browser.\n-- Get started by typing a query or selecting a view from the options below.\nSELECT *\nFROM train\nWHERE source = 'free_programming_book'\n AND language = 'Python'\nLIMIT 100;","title":"Python Code from Free Books","createdAt":"2025-04-03T11:27:46.424Z","slug":"WGn_NVw","private":false,"justification":"This query retrieves a limited number of records related to Python programming books, providing basic filtering but minimal analytical insight.","viewNames":["train"]}],"user":[]}}">
Search is not available for this dataset
project stringlengths 1 235 | source stringclasses 16
values | language stringclasses 48
values | content stringlengths 909 64.8M |
|---|---|---|---|
github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datafactory/armdatafactory | go | Go | README
[¶](#section-readme)
---
### Azure Data Factory Module for Go
[](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datafactory/armdatafactory)
The `armdatafactory` modu... |
@easepick/lock-plugin | npm | JavaScript | @easepick/lock-plugin
===
> This package does not need to be installed if you are using [@easepick/bundle](https://easepick.com/packages/bundle).
Adds the ability to disable days for selection.
Documentation
---
<https://easepick.com/packages/lock-pluginOptions
---
| Name | Type | Default | Description |
| --- | --... |
aslib | cran | R | Package ‘aslib’
October 12, 2022
Title Interface to the Algorithm Selection Benchmark Library
Description Provides an interface to the algorithm selection benchmark library
at <http://www.aslib.net> and the 'LLAMA' package
(<https://cran.r-project.org/package=llama>)... |
deldir | cran | R | Package ‘deldir’
May 17, 2023
Version 1.0-9
Date 2023-05-17
Title Delaunay Triangulation and Dirichlet (Voronoi) Tessellation
Author <NAME>
Maintainer <NAME> <<EMAIL>>
Depends R (>= 3.5.0)
Suggests polyclip
Imports graphics, grDevices
Description Calculates the Delaunay t... |
c_comments | ctan | TeX | Copyright.
Copyright (c) <NAME> 1998 - 2015
_Rc_comments_ rule.
Rc_comments
Rslash_asterisk
R2slash
1.1
10. **Rc_comments op directive.**
(Rc_comments op directive 10) \(\equiv\)
_Cc_comments \(*\)fsm =_ (_Cc_comments \(*\)_) _rule_info_parser_\(\_\_\)-fsm_tbl_;
_T_comment \(*\)com =_new _T_comment_((**const ... |
fdi | readthedoc | Unknown | fdi Release v0.18c <NAME>
Nov 22, 2022
CONTENTS:
2.1 Install FD... 5 2.2 dataset: Model for Data Containe... 5 2.3 pal: Product Access Laye... 9 2.4 pns: Processing Node Serve... 12 2.5 fdi Quick Star... 17 3.1 API Referenc... 33
... |
rusoto_credential | rust | Rust | Crate rusoto_credential
===
Types for loading and managing AWS access credentials for API requests.
Modules
---
claimsCredential Claims module.
Structs
---
AutoRefreshingProviderWrapper for `ProvideAwsCredentials` that caches the credentials returned by the wrapped provider. Each time the credentials are accessed,... |
RcppInt64 | cran | R | Package ‘RcppInt64’
September 19, 2023
Type Package
Title 'Rcpp'-Based Helper Functions to Pass 'Int64' and 'nanotime'
Values Between 'R' and 'C++'
Version 0.0.3
Date 2023-09-19
Description 'Int64' values can be created and accessed via the 'bit64' package and its 'integer... |
mostly-adequate_gitbooks_io_mostly-adequate-guide_content | free_programming_book | Unknown | Date: 2021-02-08
Categories:
Tags:
This is a book on the functional paradigm in general. We'll use the world's most popular functional programming language: JavaScript. Some may feel this is a poor choice as it's against the grain of the current culture which, at the moment, feels predominately imperative. However, ... |
simpleplugins | readthedoc | Unknown | SimplePlugins Documentation
Release 1.5.2-2
liketechnik
Apr 23, 2018
Topics:
7.1 Setup SimplePlugin... 15 7.2 Commands with SimplePlugin... 17 7.3 Javado... 17
... |
Twinkle | cocoapods | Objective-C | Twinkle
===
Welcome to the documentation for Twinkle, a powerful tool for iOS developers. Twinkle is a library that provides a variety of useful features and functionalities for enhancing your iOS app development.
Navigation
---
1. [Getting Started](#getting-started)
2. [Installation](#installation)
3. [Features](#f... |
dispatchr | npm | JavaScript | Dispatchr
===
A [Flux](http://facebook.github.io/flux/docs/overview.html) dispatcher for applications that run on the server and the client.
Usage
---
For a more detailed example, see our [example applications](https://github.com/yahoo/fluxible/examples).
```
var ExampleStore = require('./stores/ExampleStore.js');
v... |
kas-theme | rust | Rust | Crate kas_theme
===
KAS theme support
This crate provides the `Theme` trait, `MultiTheme` adapter, color schemes, some supporting items, and the themes `FlatTheme` and
`ShadedTheme`.
Custom themes may be built over this crate, optionally including custom draw routines (e.g. `DrawShaded`), provided that the shell imp... |
ggetho | cran | R | Package ‘ggetho’
November 24, 2022
Title Visualisation of High-Throughput Behavioural (i.e. Ethomics)
Data
Date 2022-11-17
Version 0.3.7
Description Extension of 'ggplot2' providing layers, scales and preprocessing functions
useful to represent behavioural variables... |
oceanspy | readthedoc | Unknown | ## OceanDataset
### Import
### Attributes
### Set
### Methods
### Shortcuts
## Opening
## Subsampling
## Computing
### Smart-name
Computed variables are dynamically named. Names depend on input and operation.
### Fixed-name
Computed variables have a hard-coded name.
## Plotting
## Animating
## Utilities
... |
My | cran | R | Package ‘My.stepwise’
October 12, 2022
Type Package
Title Stepwise Variable Selection Procedures for Regression Analysis
Version 0.1.0
Author International-Harvard Statistical Consulting Company <<EMAIL>>
Maintainer <NAME> <<EMAIL>>
Description The stepwise variable selection... |
github.com/hajimehoshi/ebiten/v2 | go | Go | README
[¶](#section-readme)
---
### Ebitengine (v2)
[](https://pkg.go.dev/github.com/hajimehoshi/ebiten/v2)
[](https://github.com/hajimehoshi/ebiten... |
django-modelqueryform | readthedoc | Python | django-modelqueryform 3.0 documentation
[django-modelqueryform](index.html#document-index)
---
django-modelqueryform[¶](#django-modelqueryform)
===
**django-modelqueryform** is a flexible app that helps you build Q object generating forms.
It is a great tool if you want you users to be able to do filtered searches... |
pyautocad | readthedoc | Python | pyautocad 0.2.0 documentation
[pyautocad](index.html#document-index)
---
Welcome to pyautocad’s documentation
===
[pyautocad](http://pypi.python.org/pypi/pyautocad/) - library aimed to simplify writing [ActiveX](http://wikipedia.org/wiki/ActiveX) [Automation](http://en.wik... |
nfcpy | readthedoc | Python | nfcpy 1.0.4 documentation
[nfcpy](index.html#document-index)
---
Python module for near field communication[¶](#python-module-for-near-field-communication)
===
> This documentation covers the ‘1.0.4’ version of
> **nfcpy**. There are also other [versions](https://readthedocs.org/projects/nfcpy/versions).
The **nfc... |
rcheology | cran | R | Package ‘rcheology’
June 29, 2023
Version 4.3.1.0
Title Data on Base Packages for Current and Previous Versions of R
Description Provides a dataset of functions in all base packages of R versions 1.0.1 onwards.
License CC0
URL https://github.com/hughjonesd/rcheology
BugReports... |
github.com/sozercan/kubectl-ai | go | Go | README
[¶](#section-readme)
---
### Kubectl OpenAI plugin ✨
This project is a `kubectl` plugin to generate and apply Kubernetes manifests using OpenAI GPT.
My main motivation is to avoid finding and collecting random manifests when dev/testing things.
#### Demo
[.
Version 0.1.1
Date 2019-07-1
Author <NAME> and <NAME>... |
python-redis-lock | readthedoc | Python | redis-lock 4.0.0 documentation
### Navigation
* [☰](#sidebar-anchor)
* [redis-lock-4.0.0](index.html#document-index) »
[Fork me on GitHub](https://github.com/ionelmc/python-redis-lock/)
Contents[¶](#contents)
===
Overview[¶](#overview)
---
| docs | |
| tests |
|
| package |
|
Lock context manager i... |
unqlite | readthedoc | Python | unqlite-python 0.9.3 documentation
[unqlite-python](index.html#document-index)
---
unqlite-python[¶](#unqlite-python)
===
Fast Python bindings for [UnQLite](http://unqlite.org/), a lightweight, embedded NoSQL database and JSON document store.
Warning
Read the issue tracker for [this database](https://github.com/s... |
salem | readthedoc | Markdown | salem 0.2.1 documentation
[salem](index.html#document-index)
---
Salem[¶](#salem)
===
Salem is a small library to do geoscientific data processing and plotting. It extends [xarray](http://xarray.pydata.org/en/stable/) to add geolocalised subsetting, masking, and plotting operations to xarray’s [DataArray](http://xa... |
github.com/ovh/cds | go | Go | README
[¶](#section-readme)
---
### CDS: Continuous Delivery Service
[](https://goreportcard.com/report/github.com/ovh/cds)
[](https://godoc.org/github.com/ovh/cds/sdk/cdsclient)... |
spinnman | readthedoc | Unknown | SpiNNMan Documentation
Release
April 23, 2015
Contents 3.1 spinnman packag... 7
i
ii
SpiNNMan Documentation, Release Used to communicate with a SpiNNaker Board. ... |
image | cran | R | Package ‘image.Otsu’
October 13, 2022
Type Package
Title Otsu's Image Segmentation Method
Description An implementation of the Otsu's Image Segmentation Method described in the pa-
per: ``A C++ Implementation of Otsu's Image Segmentation Method''. The algorithm is ex-
... |
github.com/GoogleCloudPlatform/golang-samples/run/grpc-server-streaming | go | Go | README
[¶](#section-readme)
---
### Cloud Run gRPC Server Streaming sample application
For a general introduction to gRPC on Go, see the [official gRPC quickstart](https://grpc.io/docs/quickstart/go/).
This sample presents:
* `./server`: a gRPC server application with an RPC that streams the current time in the re... |
@syncfusion/ej2-lists | npm | JavaScript | [ej2-lists](#ej2-lists)
===
The listview control allows you to select an item or multiple items from a list-like interface and represents the data in interactive hierarchical structure across different layouts or views. Lists are used for displaying data, data navigation, and data entry.
> This is a commercial produc... |
receipt_verifier | hex | Erlang | ReceiptVerifier
===
Verify iTunes receipt with the Apple Store
Example
---
```
iex> ReceiptVerifier.verify(base64_encoded_receipt_data)
{:ok, %ReceiptVerifier.ResponseData{app_receipt: %ReceiptVerifier.AppReceipt{adam_id: 0,
app_item_id: 0, application_version: "1241",
bundle_id: "com.sumiapp.GridDiary", download_... |
curl | rust | Rust | Crate curl
===
Rust bindings to the libcurl C library
This crate contains bindings for an HTTP/HTTPS client which is powered by libcurl, the same library behind the `curl` command line tool. The API currently closely matches that of libcurl itself, except that a Rustic layer of safety is applied on top.
The “Easy” A... |
gclm | cran | R | Package ‘gclm’
October 13, 2022
Type Package
Title Graphical Continuous Lyapunov Models
Version 0.0.1
Description Estimation of covariance matrices as solutions of
continuous time Lyapunov equations.
Sparse coefficient matrix and diagonal noise are estimated
... |
scikit-rf | readthedoc | Markdown | * Installation
* Introduction
* Networks
* Connecting Networks
* Plotting
* NetworkSet
* Circuits
* Calibration
* De-embedding
* Quality Factors
* Media
* Vector Fitting
* Virtual Instruments
## Network Theory¶
* Balanced Network De-embedding
* CPW media example
* Correlating microstripline model to mea... |
@fadomire/shaka-player | npm | JavaScript | Shaka Player is an open-source JavaScript library for adaptive media. It plays adaptive media formats (such as [DASH](http://dashif.org/) and [HLS](https://developer.apple.com/streaming/)) in a browser, without using plugins or Flash. Instead, Shaka Player uses the open web standards
[MediaSource Extensions](https://ww... |
weightQuant | cran | R | Package ‘weightQuant’
October 12, 2022
Type Package
Title Weights for Incomplete Longitudinal Data and Quantile Regression
Version 1.0.1
Date 2022-01-05
Author <NAME>
Maintainer <NAME> <<EMAIL>>
Description Estimation of observation-specific weights for incomplete longitudinal... |
libadwaita | rust | Rust | Crate libadwaita
===
Rust Adwaita bindings
---
This library contains safe Rust bindings for Adwaita, a library that offers building blocks for modern GNOME applications.
See also
* GTK 4 Rust bindings documentation
* Libadwaita documentation
* gtk-rs project overview
* Report bindings related issues
* Report upstre... |
PCAmixdata | cran | R | Package ‘PCAmixdata’
October 12, 2022
Type Package
Title Multivariate Analysis of Mixed Data
Version 3.1
Author <NAME> [aut, cre],
<NAME> [aut],
<NAME> [aut],
<NAME> [aut],
<NAME> [aut]
Maintainer <NAME> <<EMAIL>>
Description Implements principal compo... |
github.com/cloudnativer/kube-install | go | Go | README
[¶](#section-readme)
---
The highly available multiple kubernetes cluster can be installed offline with one click in binary mode, as well as schedule installation, addition of kubernetes node, deletion of kubernetes node, destruction of kubernetes master, rebuild of kubernetes master, and uninstallation of clu... |
ObjectMapper | cocoapods | Objective-C | objectmapper
===
About ObjectMapper
---
ObjectMapper is an open-source framework for Objective-C and Swift that simplifies the process of converting objects between different representations, such as JSON and native Swift/Obj-C objects. It provides a simple and convenient way to map JSON data to model objects (an... |
github.com/containers/conmon-rs | go | Go | README
[¶](#section-readme)
---
[](https://github.com/containers/conmon-rs/actions)
[
---
暴走皮皮虾之代码发布系统,是现代的持续集成发布系统,由后台管理系统和agent两部分组成,一个运行着的agent就是一个节点,本系统并不是造轮子,是"鸟枪"到"大炮"的创新,对"前朝遗老"的革命.
[](https://github.com/bzppx/... |
chatter | rust | Rust | Crate chatter
===
Chatter provides a macro that translates a human-readable script into a format that can be easily used in Rust.
Basic Usage
---
The following is an example of a basic chatter script:
```
This is an example line This line is followed by a choice:
- continue to branch 1
- switch to branch 2 -> branch... |
tetra | rust | Rust | Crate tetra
===
Tetra is a simple 2D game framework written in Rust. It uses SDL2 for event handling and OpenGL 3.2+ for rendering.
* Website
* Tutorial
* API Docs
* FAQ
### Status
Tetra is no longer being actively developed, as of January 2022. Bug fixes and dependency updates may still happen from time to time, b... |
golang_org_doc_effective_go_html | free_programming_book | Go | Date: 2013-01-01
Categories:
Tags:
* Documentation
* Effective Go
## Introduction
Go is a new language. Although it borrows ideas from existing languages, it has unusual properties that make effective Go programs different in character from programs written in its relatives. A straightforward translation of a C++... |
pyneng_readthedocs_io_en_latest | free_programming_book | Markdown | The book covers Python basics with examples and tasks built around networking topics.
On the one hand, this book is basic enough to be mastered by anyone, and on the other hand, covers all the main topics that will allow you to further grow on your own. This book is not intended to be an in-depth look at Python. The p... |
repolr | cran | R | Package ‘repolr’
October 14, 2022
Type Package
Title Repeated Measures Proportional Odds Logistic Regression
Version 3.4
Date 2016-02-26
Author <NAME>
Maintainer <NAME> <<EMAIL>>
Description Fits linear models to repeated ordinal scores using GEE methodology.
License GPL-3
Impo... |
xkcd | cran | R | Package ‘xkcd’
October 14, 2022
Type Package
Title Plotting ggplot2 Graphics in an XKCD Style
Version 0.0.6
Date 2018-07-10
Author <NAME>
Maintainer <NAME> <<EMAIL>>
Description Plotting ggplot2 graphs using the XKCD style.
License GPL-3
Depends ggplot2 (>= 3.0), extrafont
Impo... |
robustfa | cran | R | Package ‘robustfa’
April 16, 2023
Type Package
Title Object Oriented Solution for Robust Factor Analysis
Version 1.1-0
Date 2023-03-21
Author <NAME> [cre] (<https://orcid.org/0000-0002-0837-8281>),
Ying-Ying Zhang (Robert) [aut]
Maintainer <NAME> <<EMAIL>>
Description... |
test_components_idx | ctan | TeX | ### Grammar symbols: Used cross reference
Reference of each grammar's symbol used within each rule's productions. The index uses the tripple: rule name, its subrule no, and the symbol's position within the symbol string.
### # ***.
Rtoken_grp1 1.2
### # Ab:.
Rtoken_grp3 5.2
### # AD:.
Rtoken_grp3 4.2
### # NULL... |
odo | readthedoc | YAML | odo 0.4.0 documentation
[odo](index.html#document-index)
---
Odo: Shapeshifting for your data[¶](#odo-shapeshifting-for-your-data)
===
`odo` takes two arguments, a source and a target for a data transfer.
```
>>> from odo import odo
>>> odo(source, target) # load source into target
```
It efficiently migrates data... |
strong_csv | ruby | Ruby | strong_csv
===
[](https://rubygems.org/gems/strong_csv)
Type checker for a CSV file inspired by [strong_json](https://github.com/soutaro/strong_json).
Motivation
---
Some applications have a feature to receive a CSV file uploaded by a user,
and in general, it ne... |
mrbin | cran | R | Package ‘mrbin’
April 11, 2023
Title Metabolomics Data Analysis Functions
Version 1.7.4
Description A collection of functions for processing and analyzing metabolite data.
The namesake function mrbin() converts 1D
or 2D Nuclear Magnetic Resonance data into a matri... |
keylime-docs | readthedoc | JSON | Keylime Documentation 6.4.2 documentation
[Keylime Documentation](#)
---
Keylime Documentation[¶](#keylime-documentation)
===
Warning
This documentation is still under development and not complete. It will be so until this warning is removed.
Welcome to the Keylime Documentation site!
Keylime is a TPM-based high... |
wusuopu_gitbooks_io_symfony2_tutorial_content | free_programming_book | PHP | Date: 2014-08-24
Categories:
Tags:
Symfony是一款功能强大的PHP框架，最近在折腾它。发现中文资料比较少，当时我是通过symblog这个教程进行学习的。symblog这个教程使用的Symfony版本有些低，有些内容已过时，不过用来学习还是有参考价值的。
本文是在symblog的基础上，并结合自己的笔记整理而来的。本文通过制作一个简单的博客系统来讲解Symfony框架的用法。本文完整的示例代码可以从 https://github.com/wusuopu/symfony2-tutorial-sample 获取到。
Symfony2与Symfony1变化比较大，这里使用的是Symfony2... |
sigs.k8s.io/service-apis | go | Go | README
[¶](#section-readme)
---
### Kubernetes Service APIs
The Service APIs is a part of the [SIG Network](https://github.com/kubernetes/community/tree/master/sig-network), and this repository contains the specification and Custom Resource Definitions (CRDs).
#### Documentation
##### Website
The API specificatio... |
wasmtime-wasi | rust | Rust | Crate wasmtime_wasi
===
`wasmtime-wasi` now supports using multiple snapshots to interface to the same `WasiCtx`!
`wasmtime_wasi::Wasi::new(&Store, WasiCtx)` is a struct which owns your
`WasiCtx` and provides linkage to every available snapshot.
Individual snapshots are available through
`wasmtime_wasi::snapshots::p... |
git-branchless-init | rust | Rust | Crate git_branchless_init
===
Install any hooks, aliases, etc. to set up `git-branchless` in this repo.
Enums
---
* HookA specification for installing a Git hook on disk.
Constants
---
* ALL_HOOKSThe contents of all Git hooks to install.
Functions
---
* command_install_man_pagesInstall the man-pages for `git-bra... |
github.com/evertras/bubble-table | go | Go | README
[¶](#section-readme)
---
### Bubble-table
[](https://github.com/Evertras/bubble-table/releases)
[](https://pkg.go.dev/github.com/evertras/bubble-table/table?tab=doc)
[... |
bignum | cran | R | Package ‘bignum’
May 4, 2023
Title Arbitrary-Precision Integer and Floating-Point Mathematics
Version 0.3.2
Description Classes for storing and manipulating arbitrary-precision
integer vectors and high-precision floating-point vectors. These
extend the range an... |
config-decorator | readthedoc | Markdown | To install system-wide, run as superuser:
To install user-local, simply run:
To install within a `virtualenv` , try:
```
$ mkvirtualenv config-decorator
(config-decorator) $ pip install config-decorator
```
To develop on the project, link to the source files instead:
```
(config-decorator) $ deactivate
$ rmvirtu... |
aimsir17 | cran | R | Package ‘aimsir17’
October 12, 2022
Title Irish Weather Observing Stations Hourly Records for 2017
Version 0.0.2
Description Named after the Irish name for weather, this package contains
tidied data from the Irish Meteorological Service's hourly observations for 2017.
... |
forImage | cran | R | Package ‘forImage’
October 13, 2022
Type Package
Title Foraminiferal Image Analysis and Test Measurement
Version 0.1.0
Maintainer <NAME> <<EMAIL>>
Description The goal of this collection of functions is to provide an easy to use tool for the measure-
ment of foraminifera... |
@amv-hub/amv-vue-slick | npm | JavaScript | Slick for Vue.js
===
ATTENTION!
===
This package is no longer supported by its main contributor (@staskjs). If you would like to work on it, I will gladly add you as a collaborator. Please reach me on telegram @staskjs.
Vue support
---
Supports only Vue >= 2
Installation and usage
---
See official documentation [... |
arsenal | cran | R | Package ‘arsenal’
October 12, 2022
Title An Arsenal of 'R' Functions for Large-Scale Statistical
Summaries
Version 3.6.3
Date 2021-06-04
Description An Arsenal of 'R' functions for large-scale statistical summaries,
which are streamlined to work within the latest r... |
r0man_alumbra.js | hex | Erlang | alumbra.js.ast
===
---
#### alumbra->jsclj/s
```
(alumbra->js document)
```
Transform the Alumbra GraphQL `document` AST to JavaScript.
```
Transform the Alumbra GraphQL `document` AST to JavaScript.
```
[source](https://github.com/r0man/alumbra.js/blob/0.1.0/src/alumbra/js/ast.cljc#L5)[raw docstring](#)
---
#### j... |
anesrake | cran | R | Package ‘anesrake’
October 12, 2022
Version 0.80
Date 2018-04-27
Title ANES Raking Implementation
Author <NAME> [aut, cre]
Maintainer <NAME> <<EMAIL>>
Depends Hmisc, weights
Description Provides a comprehensive system for selecting
variables and weighting data to match ... |
MTDates | cocoapods | Objective-C | mtdates
===
The mtdates library is a powerful toolkit for working with dates and times in your Cocoa projects. With its comprehensive suite of features, it simplifies the complexities of date calculations, formatting, and localization, allowing you to focus on building great applications. This documentation will guide... |
rusoto_signature | rust | Rust | Crate rusoto_signature
===
AWS API request signatures.
Follows AWS Signature 4 algorithm.
If needed, the request will be re-issued to a temporary redirect endpoint. This can happen with newly created S3 buckets not in us-standard/us-east-1.
Please note that this module does not expect URIs to already be encoded.
R... |
kraftkit.sh/cmdfactory | go | Go | None
Documentation
[¶](#section-documentation)
---
### Overview [¶](#pkg-overview)
SPDX-License-Identifier: MIT Copyright (c) 2019, 2019 GitHub Inc.
Copyright (c) 2022, Unikraft GmbH and The KraftKit Authors.
Licensed under the MIT License (the "License").
You may not use this file expect in compliance with the L... |
gaphas | readthedoc | Python | Gaphas
Hide navigation sidebar
Hide table of contents sidebar
Toggle site navigation sidebar
[Gaphas](#)
Toggle Light / Dark / Auto color theme
Toggle table of contents sidebar
[Gaphas](#)
The basics
* [Class diagram](index.html#document-diagram)
* [Interacting with diagrams](index.html#document-tools)
* [Conn... |
cowplot | cran | R | Package ‘cowplot’
October 12, 2022
Title Streamlined Plot Theme and Plot Annotations for 'ggplot2'
Version 1.1.1
Description Provides various features that help with creating publication-quality figures
with 'ggplot2', such as a set of themes, functions to align plots a... |
sidewalk | hex | Erlang | Toggle Theme
sidewalk v0.4.0
API Reference
===
Modules
---
[Sidewalk](Sidewalk.html)
Sidewalk is an Elixir client which is compatible with Sidekiq, the »efficient background processing library for Ruby«.
It can be used to enqueue jobs for later processing alongside e.g. with an already existing Ruby application.
F... |
freegs | readthedoc | Python | FreeGS 0.2.0 documentation
Welcome to FreeGS’s documentation
===
Creating equilibria[¶](#creating-equilibria)
---
To generate a Grad-shafranov solution from scratch FreeGS needs some physical parameters:
1. The locations of the coils 2. Plasma profiles (typically pressure and... |
rmq | hex | Erlang | RMQ
===
A set of tools for convenient work with RabbitMQ.
Based on [`AMQP`](https://hexdocs.pm/amqp/AMQP.html) library.
It includes:
* [`RMQ.Connection`](RMQ.Connection.html) - for holding a robust connection to the server.
* [`RMQ.Consumer`](RMQ.Consumer.html) - for implementing consumers.
* [`RMQ.RPC`](RMQ.RPC.ht... |
CNPS | cran | R | Package ‘CNPS’
October 12, 2022
Type Package
Title Nonparametric Statistics
Version 1.0.0
Author <NAME> [aut,cre] (<<EMAIL>>),
<NAME> [aut],
<NAME> [aut],
<NAME> [aut]
Maintainer <NAME> <<EMAIL>>
Description
We unify various nonparametric hypothesis tes... |
popupmenu | ctan | TeX | ## The manual for the popupmenu package
D. P. StoryTable of Contents
* 1 Introduction
* 1.1 Sample files
* 1.2 Options, requirements, and workflows
* 2 The popupmenu environment
* 3 The popupmenu environment
* 4 Executing a pop-up menu
* 4.1 Declaring popupmenu in the body
* 4.2 Declaring popupmenu in the preamble... |
GITHUB_papers-we-love_papers-we-love.zip_unzipped_the-dining-cryptographers-problem.pdf | free_programming_book | Unknown | J. Cryptology (1988) 1:65-75 Journal of Cryptology 9 1988 International Association for Cryptologic Research The Dining Cryptographers Problem:
Unconditional Sender and Recipient Untraceability David C h a u m Centre for Mathematics and Computer Science, Kruislan 413, 1098SJ Amsterdam,The Netherlands Abstract. Keeping ... |
makeunique | cran | R | Package ‘makeunique’
October 13, 2022
Title Make Character Strings Unique
Version 1.0.0
Description Make all elements of a character vector unique.
Differs from 'make.unique' by starting at 1 and allowing users to customise suffix format.
License MIT + file LICENSE
Suggest... |
bb8 | rust | Rust | Crate bb8
===
A full-featured connection pool, designed for asynchronous connections
(using tokio). Originally based on r2d2.
Opening a new database connection every time one is needed is both inefficient and can lead to resource exhaustion under high traffic conditions. A connection pool maintains a set of open conn... |
github.com/sigstore/sigstore/pkg/signature/kms/aws | go | Go | None
Documentation
[¶](#section-documentation)
---
### Overview [¶](#pkg-overview)
Package aws implement the interface with amazon aws kms service
Package aws contains utilities related to AWS KMS.
### Index [¶](#pkg-index)
* [Constants](#pkg-constants)
* [func ParseReference(resourceID string) (endpoint, keyI... |
performance | cran | R | Package ‘performance’
September 12, 2023
Type Package
Title Assessment of Regression Models Performance
Version 0.10.5
Maintainer <NAME> <<EMAIL>>
Description Utilities for computing measures to assess model quality,
which are not directly provided by R's 'base' or 'stats... |
sharded-slab | rust | Rust | Crate sharded_slab
===
A lock-free concurrent slab.
Slabs provide pre-allocated storage for many instances of a single data type. When a large number of values of a single type are required,
this can be more efficient than allocating each item individually. Since the allocated items are the same size, memory fragment... |
pyramid-auth | readthedoc | Python | pyramid_auth 0.4 documentation
### Navigation
* [pyramid_auth 0.4 documentation](index.html#document-index) »
pyramid_auth’s documentation
===
Introduction[¶](#introduction)
---
This is a plugin for pyramid which provides a simple authentication system. The idea was to use exisin... |
MAd | cran | R | Package ‘MAd’
October 12, 2022
Type Package
Title Meta-Analysis with Mean Differences
Version 0.8-3
Date 2022-08-07
Maintainer <NAME> <<EMAIL>>
Description A collection of functions for conducting a meta-
analysis with mean differences data. It uses recommended procedure... |
@clack/prompts | npm | JavaScript | `@clack/prompts`
===
Effortlessly build beautiful command-line apps 🪄 [Try the demo](https://stackblitz.com/edit/clack-prompts?file=index.js)
---
`@clack/prompts` is an opinionated, pre-styled wrapper around [`@clack/core`](https://www.npmjs.com/package/@clack/core).
* 🤏 80% smaller than other options
* 💎 Beauti... |
doRedis | cran | R | Package ‘doRedis’
May 2, 2023
Type Package
Title 'Foreach' Parallel Adapter Using the 'Redis' Database
Version 3.0.2
Date 2023-5-1
Author <NAME> <<EMAIL>>
Maintainer <NAME> <<EMAIL>>
Description Create and manage fault-
tolerant task queues for the 'foreach' package u... |
carla | readthedoc | Markdown | Welcome to the CARLA documentation.
This home page contains an index with a brief description of the different sections in the documentation. Feel free to read in whatever order preferred. In any case, here are a few suggestions for newcomers.
* Install CARLA. Either follow the Quick start installation to get a CARLA... |
classmap | cran | R | Package ‘classmap’
April 23, 2023
Type Package
Title Visualizing Classification Results
Date 2023-04-23
Version 1.2.3
Author <NAME> [aut, cre],
<NAME> [aut]
Depends R (>= 4.1.0)
Suggests knitr, reshape2, svd, rpart.plot, nnet, robCompositions
Imports stats, graphics, g... |
timely | hex | Erlang | API Reference
===
Modules
---
[Timely](Timely.html)
Provides functions for converting, comparing and shifting Elixir date & times.
[Timely.TimeZone](Timely.TimeZone.html)
Provides time zone convenience functions.
[Timely.Year](Timely.Year.html)
Provides functions for manipulating year numbers.
Timely
===
Prov... |
flow | hex | Erlang |
Flow
===
Computational flows with stages.
[`Flow`](Flow.html#content) allows developers to express computations on collections, similar to the [`Enum`](https://hexdocs.pm/elixir/Enum.html) and [`Stream`](https://hexdocs.pm/elixir/Stream.html) modules,
although computations will be executed in parallel using multiple... |
sarsop | cran | R | Package ‘sarsop’
January 10, 2023
Type Package
Title Approximate POMDP Planning Software
Version 0.6.14
Description A toolkit for Partially Observed Markov Decision Processes (POMDP). Provides
bindings to C++ libraries implementing the algorithm SARSOP (Successive Approxi... |
www_nic_funet_fi_c++opas | free_programming_book | Unknown | # :n hämmästyttävä maailma
## :n hämmästyttävä maailma
### - hassun hauska C++-opas -
copyright (c) 1997-2002 <NAME>
Tervetuloa vaatimattoman C++-oppaani pariin. Ihan näin aluksi varottaisin, että tämä sepustus ei ole eikä haluakaan olla perinteinen ohjelmointiopas. Siis jos etsit kompaktia ja koherenttia opasta C+... |
FastImputation | cran | R | Package ‘FastImputation’
September 25, 2023
Type Package
Title Learn from Training Data then Quickly Fill in Missing Data
Version 2.2.1
Date 2023-09-25
Author <NAME>
Maintainer <NAME> <<EMAIL>>
Description TrainFastImputation() uses training data to describe a
multivaria... |
ogp | hex | Erlang | ogp
===
The [Open Graph protocol](https://ogp.me/) library in Elixir.
[](https://github.com/goofansu/ogp/actions/workflows/ci.yml)
[](https://coveralls.io/gi... |
multcomp | cran | R | Package ‘multcomp’
June 20, 2023
Title Simultaneous Inference in General Parametric Models
Version 1.4-25
Date 2023-06-20
Description Simultaneous tests and confidence intervals
for general linear hypotheses in parametric models, including
linear, generalized lin... |
Subsets and Splits
Python Algorithms in Free Books
Retrieves entries related to both Python and algorithms from a specific source, providing a filtered dataset but lacking broader analytical depth.
Python Code from Free Books
This query retrieves a limited number of records related to Python programming books, providing basic filtering but minimal analytical insight.