Package 'cluster' reference manual

Title:	"Finding Groups in Data": Cluster Analysis Extended Rousseeuw et al.
Description:	Methods for Cluster analysis. Much extended the original from Peter Rousseeuw, Anja Struyf and Mia Hubert, based on Kaufman and Rousseeuw (1990) "Finding Groups in Data".
Authors:	Martin Maechler [aut, cre] , Peter Rousseeuw [aut] (Fortran original, <https://orcid.org/0000-0002-3807-5353>), Anja Struyf [aut] (S original), Mia Hubert [aut] (S original, <https://orcid.org/0000-0001-6398-4850>), Kurt Hornik [trl, ctb] (port to R; maintenance(1999-2000), <https://orcid.org/0000-0003-4198-9911>), Matthias Studer [ctb], Pierre Roudier [ctb], Juan Gonzalez [ctb], Kamil Kozlowski [ctb], Erich Schubert [ctb] (fastpam options for pam(), <https://orcid.org/0000-0001-9143-4880>), Keefe Murphy [ctb] (volume.ellipsoid({d >= 3}))
Maintainer:	Martin Maechler <[email protected]>
License:	GPL (>= 2)
Version:	2.1.6
Built:	2024-03-27 22:42:19 UTC
Source:	CRAN

Agglomerative Nesting (Hierarchical Clustering)

Description

Computes agglomerative hierarchical clustering of the dataset.

Usage

agnes(x, diss = inherits(x, "dist"), metric = "euclidean",
      stand = FALSE, method = "average", par.method,
      keep.diss = n < 100, keep.data = !diss, trace.lev = 0)

Arguments

`x`	data matrix or data frame, or dissimilarity matrix, depending on the value of the `diss` argument. In case of a matrix or data frame, each row corresponds to an observation, and each column corresponds to a variable. All variables must be numeric. Missing values (NAs) are allowed. In case of a dissimilarity matrix, `x` is typically the output of `daisy` or `dist`. Also a vector with length n*(n-1)/2 is allowed (where n is the number of observations), and will be interpreted in the same way as the output of the above-mentioned functions. Missing values (NAs) are not allowed.
`diss`	logical flag: if TRUE (default for `dist` or `dissimilarity` objects), then `x` is assumed to be a dissimilarity matrix. If FALSE, then `x` is treated as a matrix of observations by variables.
`metric`	character string specifying the metric to be used for calculating dissimilarities between observations. The currently available options are `"euclidean"` and `"manhattan"`. Euclidean distances are root sum-of-squares of differences, and manhattan distances are the sum of absolute differences. If `x` is already a dissimilarity matrix, then this argument will be ignored.
`stand`	logical flag: if TRUE, then the measurements in `x` are standardized before calculating the dissimilarities. Measurements are standardized for each variable (column), by subtracting the variable's mean value and dividing by the variable's mean absolute deviation. If `x` is already a dissimilarity matrix, then this argument will be ignored.
`method`	character string defining the clustering method. The six methods implemented are `"average"` ([unweighted pair-]group [arithMetic] average method, aka ‘UPGMA’), `"single"` (single linkage), `"complete"` (complete linkage), `"ward"` (Ward's method), `"weighted"` (weighted average linkage, aka ‘WPGMA’), its generalization `"flexible"` which uses (a constant version of) the Lance-Williams formula and the `par.method` argument, and `"gaverage"` a generalized `"average"` aka “flexible UPGMA” method also using the Lance-Williams formula and `par.method`. The default is `"average"`.
`par.method`	If `method` is `"flexible"` or `"gaverage"`, a numeric vector of length 1, 3, or 4, (with a default for `"gaverage"`), see in the details section.
`keep.diss`, `keep.data`	logicals indicating if the dissimilarities and/or input data `x` should be kept in the result. Setting these to `FALSE` can give much smaller results and hence even save memory allocation time.
`trace.lev`	integer specifying a trace level for printing diagnostics during the algorithm. Default `0` does not print anything; higher values print increasingly more.

Details

agnes is fully described in chapter 5 of Kaufman and Rousseeuw (1990). Compared to other agglomerative clustering methods such as hclust, agnes has the following features: (a) it yields the agglomerative coefficient (see agnes.object) which measures the amount of clustering structure found; and (b) apart from the usual tree it also provides the banner, a novel graphical display (see plot.agnes).

The agnes-algorithm constructs a hierarchy of clusterings.
At first, each observation is a small cluster by itself. Clusters are merged until only one large cluster remains which contains all the observations. At each stage the two nearest clusters are combined to form one larger cluster.

For method="average", the distance between two clusters is the average of the dissimilarities between the points in one cluster and the points in the other cluster.
In method="single", we use the smallest dissimilarity between a point in the first cluster and a point in the second cluster (nearest neighbor method).
When method="complete", we use the largest dissimilarity between a point in the first cluster and a point in the second cluster (furthest neighbor method).

The method = "flexible" allows (and requires) more details: The Lance-Williams formula specifies how dissimilarities are computed when clusters are agglomerated (equation (32) in K&R(1990), p.237). If clusters $C_1$ and $C_2$ are agglomerated into a new cluster, the dissimilarity between their union and another cluster $Q$ is given by

$D(C_1 \cup C_2, Q) = \alpha_1 * D(C_1, Q) + \alpha_2 * D(C_2, Q) + \beta * D(C_1,C_2) + \gamma * |D(C_1, Q) - D(C_2, Q)|,$

where the four coefficients $(\alpha_1, \alpha_2, \beta, \gamma)$ are specified by the vector par.method, either directly as vector of length 4, or (more conveniently) if par.method is of length 1, say $= \alpha$ , par.method is extended to give the “Flexible Strategy” (K&R(1990), p.236 f) with Lance-Williams coefficients $(\alpha_1 = \alpha_2 = \alpha, \beta = 1 - 2\alpha, \gamma=0)$ .
Also, if length(par.method) == 3, $\gamma = 0$ is set.

Care and expertise is probably needed when using method = "flexible" particularly for the case when par.method is specified of longer length than one. Since cluster version 2.0, choices leading to invalid merge structures now signal an error (from the C code already). The weighted average (method="weighted") is the same as method="flexible", par.method = 0.5. Further, method= "single" is equivalent to method="flexible", par.method = c(.5,.5,0,-.5), and method="complete" is equivalent to method="flexible", par.method = c(.5,.5,0,+.5).

The method = "gaverage" is a generalization of "average", aka “flexible UPGMA” method, and is (a generalization of the approach) detailed in Belbin et al. (1992). As "flexible", it uses the Lance-Williams formula above for dissimilarity updating, but with $\alpha_1$ and $\alpha_2$ not constant, but proportional to the sizes $n_1$ and $n_2$ of the clusters $C_1$ and $C_2$ respectively, i.e,

$\alpha_j = \alpha'_j \frac{n_1}{n_1+n_2},$

where $\alpha'_1$ , $\alpha'_2$ are determined from par.method, either directly as $(\alpha_1, \alpha_2, \beta, \gamma)$ or $(\alpha_1, \alpha_2, \beta)$ with $\gamma = 0$ , or (less flexibly, but more conveniently) as follows:

Belbin et al proposed “flexible beta”, i.e. the user would only specify $\beta$ (as par.method), sensibly in

$-1 \leq \beta < 1,$

and $\beta$ determines $\alpha'_1$ and $\alpha'_2$ as

$\alpha'_j = 1 - \beta,$

and $\gamma = 0$ .

This $\beta$ may be specified by par.method (as length 1 vector), and if par.method is not specified, a default value of -0.1 is used, as Belbin et al recommend taking a $\beta$ value around -0.1 as a general agglomerative hierarchical clustering strategy.

Note that method = "gaverage", par.method = 0 (or par.method = c(1,1,0,0)) is equivalent to the agnes() default method "average".

Value

an object of class "agnes" (which extends "twins") representing the clustering. See agnes.object for details, and methods applicable.

BACKGROUND

Cluster analysis divides a dataset into groups (clusters) of observations that are similar to each other.

Hierarchical methods: like agnes, diana, and mona construct a hierarchy of clusterings, with the number of clusters ranging from one to the number of observations.
Partitioning methods: like pam, clara, and fanny require that the number of clusters be given by the user.

Author(s)

Method "gaverage" has been contributed by Pierre Roudier, Landcare Research, New Zealand.

References

Kaufman, L. and Rousseeuw, P.J. (1990). (=: “K&R(1990)”) Finding Groups in Data: An Introduction to Cluster Analysis. Wiley, New York.

Anja Struyf, Mia Hubert and Peter J. Rousseeuw (1996) Clustering in an Object-Oriented Environment. Journal of Statistical Software 1. doi:10.18637/jss.v001.i04

Struyf, A., Hubert, M. and Rousseeuw, P.J. (1997). Integrating Robust Clustering Techniques in S-PLUS, Computational Statistics and Data Analysis, 26, 17–37.

Lance, G.N., and W.T. Williams (1966). A General Theory of Classifactory Sorting Strategies, I. Hierarchical Systems. Computer J. 9, 373–380.

Belbin, L., Faith, D.P. and Milligan, G.W. (1992). A Comparison of Two Approaches to Beta-Flexible Clustering. Multivariate Behavioral Research, 27, 417–433.

Examples

data(votes.repub)
agn1 <- agnes(votes.repub, metric = "manhattan", stand = TRUE)
agn1
plot(agn1)

op <- par(mfrow=c(2,2))
agn2 <- agnes(daisy(votes.repub), diss = TRUE, method = "complete")
plot(agn2)
## alpha = 0.625 ==> beta = -1/4  is "recommended" by some
agnS <- agnes(votes.repub, method = "flexible", par.meth = 0.625)
plot(agnS)
par(op)

## "show" equivalence of three "flexible" special cases
d.vr <- daisy(votes.repub)
a.wgt  <- agnes(d.vr, method = "weighted")
a.sing <- agnes(d.vr, method = "single")
a.comp <- agnes(d.vr, method = "complete")
iC <- -(6:7) # not using 'call' and 'method' for comparisons
stopifnot(
  all.equal(a.wgt [iC], agnes(d.vr, method="flexible", par.method = 0.5)[iC])   ,
  all.equal(a.sing[iC], agnes(d.vr, method="flex", par.method= c(.5,.5,0, -.5))[iC]),
  all.equal(a.comp[iC], agnes(d.vr, method="flex", par.method= c(.5,.5,0, +.5))[iC]))

## Exploring the dendrogram structure
(d2 <- as.dendrogram(agn2)) # two main branches
d2[[1]] # the first branch
d2[[2]] # the 2nd one  { 8 + 42  = 50 }
d2[[1]][[1]]# first sub-branch of branch 1 .. and shorter form
identical(d2[[c(1,1)]],
          d2[[1]][[1]])
## a "textual picture" of the dendrogram :
str(d2)

data(agriculture)

## Plot similar to Figure 7 in ref
## Not run: plot(agnes(agriculture), ask = TRUE)


data(animals)
aa.a  <- agnes(animals) # default method = "average"
aa.ga <- agnes(animals, method = "gaverage")
op <- par(mfcol=1:2, mgp=c(1.5, 0.6, 0), mar=c(.1+ c(4,3,2,1)),
          cex.main=0.8)
plot(aa.a,  which.plot = 2)
plot(aa.ga, which.plot = 2)
par(op)


## Show how "gaverage" is a "generalized average":
aa.ga.0 <- agnes(animals, method = "gaverage", par.method = 0)
stopifnot(all.equal(aa.ga.0[iC], aa.a[iC]))

Dissimilarity Matrix Calculation

Description

Compute all the pairwise dissimilarities (distances) between observations in the data set. The original variables may be of mixed types. In that case, or whenever metric = "gower" is set, a generalization of Gower's formula is used, see ‘Details’ below.

Usage

daisy(x, metric = c("euclidean", "manhattan", "gower"),
      stand = FALSE, type = list(), weights = rep.int(1, p),
      warnBin = warnType, warnAsym = warnType, warnConst = warnType,
      warnType = TRUE)

Arguments

`x`	numeric matrix or data frame, of dimension $n\times p$ , say. Dissimilarities will be computed between the rows of `x`. Columns of mode `numeric` (i.e. all columns when `x` is a matrix) will be recognized as interval scaled variables, columns of class `factor` will be recognized as nominal variables, and columns of class `ordered` will be recognized as ordinal variables. Other variable types should be specified with the `type` argument. Missing values (`NA`s) are allowed.
`metric`	character string specifying the metric to be used. The currently available options are `"euclidean"` (the default), `"manhattan"` and `"gower"`. Euclidean distances are root sum-of-squares of differences, and manhattan distances are the sum of absolute differences. “Gower's distance” is chosen by metric `"gower"` or automatically if some columns of `x` are not numeric. Also known as Gower's coefficient (1971), expressed as a dissimilarity, this implies that a particular standardisation will be applied to each variable, and the “distance” between two units is the sum of all the variable-specific distances, see the details section.
`stand`	logical flag: if TRUE, then the measurements in `x` are standardized before calculating the dissimilarities. Measurements are standardized for each variable (column), by subtracting the variable's mean value and dividing by the variable's mean absolute deviation. If not all columns of `x` are numeric, `stand` will be ignored and Gower's standardization (based on the `range`) will be applied in any case, see argument `metric`, above, and the details section.
`type`	list for specifying some (or all) of the types of the variables (columns) in `x`. The list may contain the following components: `"asymm"` Asymmetric binary variable, aka `"A"` in result `Types`, see `dissimilarity.object`. `"symm"` Symmetric binary variable, aka `"S"`. `"factor"` Nominal – the default for `factor` variables, aka `"N"`. When the factor has 2 levels, this is equivalent to `type = "S"` for a (symmetric) binary variable. `"ordered"` Ordinal – the default for `ordered` (factor) variables, aka `"O"`, see `dissimilarity.object`. `"logratio"` ratio scaled numeric variables that are to be logarithmically transformed (`log10`) and then treated as numeric (`"I"`): must be positive numeric variable. `"ordratio"` “raTio”-like variable to be treated as `ordered` (using the factor codes `unclass(as.ordered(x[,j]))`), aka `"T"`. `"numeric"`/`"integer"` Interval scaled – the default for all numeric (incl `integer`) columns of `x`, aka `"I"` in result `Types`, see `dissimilarity.object`. Each component is a (character or numeric) vector, containing either the names or the numbers of the corresponding columns of `x`. Variables not mentioned in `type` are interpreted as usual, see argument `x`, and also ‘default’ above. Consequently, the default `type = list()` may often be sufficient.
`weights`	an optional numeric vector of length $p$ (=`ncol(x)`); to be used in “case 2” (mixed variables, or `metric = "gower"`), specifying a weight for each variable (`x[,k]`) instead of $1$ in Gower's original formula.
`warnBin`, `warnAsym`, `warnConst`	logicals indicating if the corresponding type checking warnings should be signalled (when found).
`warnType`	logical indicating if all the type checking warnings should be active or not.

Details

The original version of daisy is fully described in chapter 1 of Kaufman and Rousseeuw (1990). Compared to dist whose input must be numeric variables, the main feature of daisy is its ability to handle other variable types as well (e.g. nominal, ordinal, (a)symmetric binary) even when different types occur in the same data set.

The handling of nominal, ordinal, and (a)symmetric binary data is achieved by using the general dissimilarity coefficient of Gower (1971). If x contains any columns of these data-types, both arguments metric and stand will be ignored and Gower's coefficient will be used as the metric. This can also be activated for purely numeric data by metric = "gower". With that, each variable (column) is first standardized by dividing each entry by the range of the corresponding variable, after subtracting the minimum value; consequently the rescaled variable has range $[0,1]$ , exactly.

Note that setting the type to symm (symmetric binary) gives the same dissimilarities as using nominal (which is chosen for non-ordered factors) only when no missing values are present, and more efficiently.

Note that daisy signals a warning when 2-valued numerical variables do not have an explicit type specified, because the reference authors recommend to consider using "asymm"; the warning may be silenced by warnBin = FALSE.

In the daisy algorithm, missing values in a row of x are not included in the dissimilarities involving that row. There are two main cases,

If all variables are interval scaled (and metric is not "gower"), the metric is "euclidean", and $n_g$ is the number of columns in which neither row i and j have NAs, then the dissimilarity d(i,j) returned is $\sqrt{p/n_g}$ ( $p=$ ncol(x)) times the Euclidean distance between the two vectors of length $n_g$ shortened to exclude NAs. The rule is similar for the "manhattan" metric, except that the coefficient is $p/n_g$ . If $n_g = 0$ , the dissimilarity is NA.
When some variables have a type other than interval scaled, or if metric = "gower" is specified, the dissimilarity between two rows is the weighted mean of the contributions of each variable. Specifically,

$d_{ij} = d(i,j) = \frac{\sum_{k=1}^p w_k \delta_{ij}^{(k)} d_{ij}^{(k)}}{ \sum_{k=1}^p w_k \delta_{ij}^{(k)}}.$

In other words, $d_{ij}$ is a weighted mean of $d_{ij}^{(k)}$ with weights $w_k \delta_{ij}^{(k)}$ , where $w_k$ = weigths[k], $\delta_{ij}^{(k)}$ is 0 or 1, and $d_{ij}^{(k)}$ , the k-th variable contribution to the total distance, is a distance between x[i,k] and x[j,k], see below.

The 0-1 weight $\delta_{ij}^{(k)}$ becomes zero when the variable x[,k] is missing in either or both rows (i and j), or when the variable is asymmetric binary and both values are zero. In all other situations it is 1.

The contribution $d_{ij}^{(k)}$ of a nominal or binary variable to the total dissimilarity is 0 if both values are equal, 1 otherwise. The contribution of other variables is the absolute difference of both values, divided by the total range of that variable. Note that “standard scoring” is applied to ordinal variables, i.e., they are replaced by their integer codes 1:K. Note that this is not the same as using their ranks (since there typically are ties).

As the individual contributions $d_{ij}^{(k)}$ are in $[0,1]$ , the dissimilarity $d_{ij}$ will remain in this range. If all weights $w_k \delta_{ij}^{(k)}$ are zero, the dissimilarity is set to NA.

Value

an object of class "dissimilarity" containing the dissimilarities among the rows of x. This is typically the input for the functions pam, fanny, agnes or diana. For more details, see dissimilarity.object.

Background

Dissimilarities are used as inputs to cluster analysis and multidimensional scaling. The choice of metric may have a large impact.

Author(s)

Anja Struyf, Mia Hubert, and Peter and Rousseeuw, for the original version.
Martin Maechler improved the NA handling and type specification checking, and extended functionality to metric = "gower" and the optional weights argument.

References

Gower, J. C. (1971) A general coefficient of similarity and some of its properties, Biometrics 27, 857–874.

Kaufman, L. and Rousseeuw, P.J. (1990) Finding Groups in Data: An Introduction to Cluster Analysis. Wiley, New York.

Struyf, A., Hubert, M. and Rousseeuw, P.J. (1997) Integrating Robust Clustering Techniques in S-PLUS, Computational Statistics and Data Analysis 26, 17–37.

Examples

data(agriculture)
## Example 1 in ref:
##  Dissimilarities using Euclidean metric and without standardization
d.agr <- daisy(agriculture, metric = "euclidean", stand = FALSE)
d.agr
as.matrix(d.agr)[,"DK"] # via as.matrix.dist(.)
## compare with
as.matrix(daisy(agriculture, metric = "gower"))

## Example 2 in reference, extended  ---  different ways of "mixed" / "gower":

example(flower) # -> data(flower) *and* provide 'flowerN'

summary(d0    <- daisy(flower))  # -> the first 3 {0,1} treated as *N*ominal
summary(dS123 <- daisy(flower,  type = list(symm = 1:3))) # first 3 treated as *S*ymmetric
stopifnot(dS123 == d0) # i.e.,  *S*ymmetric <==> *N*ominal {for 2-level factor}
summary(dNS123<- daisy(flowerN, type = list(symm = 1:3)))
stopifnot(dS123 == d0)
## by default, however ...
summary(dA123 <- daisy(flowerN)) # .. all 3 logicals treated *A*symmetric binary (w/ warning)
summary(dA3  <- daisy(flower, type = list(asymm = 3)))
summary(dA13 <- daisy(flower, type = list(asymm = c(1, 3), ordratio = 7)))
## Mixing variable *names* and column numbers (failed in the past):
summary(dfl3 <- daisy(flower, type = list(asymm = c("V1", "V3"), symm= 2,
                                          ordratio= 7, logratio= 8)))

## If we'd treat the first 3 as simple {0,1}
Nflow <- flower
Nflow[,1:3] <- lapply(flower[,1:3], \(f) as.integer(as.character(f)))
summary(dN <- daisy(Nflow)) # w/ warning: treated binary .. 1:3 as interval
## Still, using Euclidean/Manhattan distance for {0-1} *is* identical to treating them as "N" :
stopifnot(dN == d0)
stopifnot(dN == daisy(Nflow, type = list(symm = 1:3))) # or as "S"

`order`	a vector giving a permutation of the original observations to allow for plotting, in the sense that the branches of a clustering tree will not cross.
`order.lab`	a vector similar to `order`, but containing observation labels instead of observation numbers. This component is only available if the original observations were labelled.
`height`	a vector with the distances between merging clusters at the successive stages.
`ac`	the agglomerative coefficient, measuring the clustering structure of the dataset. For each observation i, denote by m(i) its dissimilarity to the first cluster it is merged with, divided by the dissimilarity of the merger in the final step of the algorithm. The `ac` is the average of all 1 - m(i). It can also be seen as the average width (or the percentage filled) of the banner plot. Because `ac` grows with the number of observations, this measure should not be used to compare datasets of very different sizes.
`merge`	an (n-1) by 2 matrix, where n is the number of observations. Row i of `merge` describes the merging of clusters at step i of the clustering. If a number j in the row is negative, then the single observation \|j\| is merged at this stage. If j is positive, then the merger is with the cluster formed at stage j of the algorithm.
`diss`	an object of class `"dissimilarity"` (see `dissimilarity.object`), representing the total dissimilarity matrix of the dataset.
`data`	a matrix containing the original or standardized measurements, depending on the `stand` option of the function `agnes`. If a dissimilarity matrix was given as input structure, then this component is not available.

[ , 1]	`x`	numeric	per capita GNP
[ , 2]	`y`	numeric	percentage in agriculture

[ , 1]	war	warm-blooded
[ , 2]	fly	can fly
[ , 3]	ver	vertebrate
[ , 4]	end	endangered
[ , 5]	gro	live in groups
[ , 6]	hai	have hair

`x`	a list with components `order`, `order.lab` and `height` when `w`, the next argument is not specified.
`w`	non-negative numeric vector of bar widths.
`fromLeft`	logical, indicating if the banner is from the left or not.
`main`, `sub`	main and sub titles, see `title`.
`xlab`	x axis label (with ‘correct’ default e.g. for `plot.agnes`).
`adj`	passed to `title(main,sub)` for string adjustment.
`col`	vector of length 2, for two horizontal segments.
`border`	color for bar border; now defaults to background (no border).
`axes`	logical indicating if axes (and labels) should be drawn at all.
`frame.plot`	logical indicating the banner should be framed; mainly used when `border = 0` (as per default).
`rev.xax`	logical indicating if the x axis should be reversed (as in `plot.diana`).
`xax.pretty`	logical or integer indicating if `pretty()` should be used for the x axis. `xax.pretty = FALSE` is mainly for back compatibility.
`labels`	labels to use on y-axis; the default is constructed from `x`.
`nmax.lab`	integer indicating the number of labels which is considered too large for single-name labelling the banner plot.
`max.strlen`	positive integer giving the length to which strings are truncated in banner plot labeling.
`yax.do`	logical indicating if a y axis and banner labels should be drawn.
`yaxRight`	logical indicating if the y axis is on the right or left.
`y.mar`	positive number specifying the margin width to use when banners are labeled (along a y-axis). The default adapts to the string width and optimally would also dependend on the font.
`...`	graphical parameters (see `par`) may also be supplied as arguments to this function.

`x`	data matrix or data frame, each row corresponds to an observation, and each column corresponds to a variable. All variables must be numeric (or logical). Missing values (NAs) are allowed.
`k`	integer, the number of clusters. It is required that $0 < k < n$ where $n$ is the number of observations (i.e., n = `nrow(x)`).
`metric`	character string specifying the metric to be used for calculating dissimilarities between observations. The currently available options are "euclidean", "manhattan", "jaccard". Euclidean distances are root sum-of-squares of differences, and manhattan distances are the sum of absolute differences.
`stand`	logical, indicating if the measurements in `x` are standardized before calculating the dissimilarities. Measurements are standardized for each variable (column), by subtracting the variable's mean value and dividing by the variable's mean absolute deviation.
`cluster.only`	logical; if true, only the clustering will be computed and returned, see details.
`samples`	integer, say $N$ , the number of samples to be drawn from the dataset. The default, `N = 5`, is rather small for historical (and now back compatibility) reasons and we recommend to set `samples` an order of magnitude larger.
`sampsize`	integer, say $j$ , the number of observations in each sample. `sampsize` should be higher than the number of clusters (`k`) and at most the number of observations ( $n =$ `nrow(x)`). While computational effort is proportional to $j^2$ , see note below, it may still be advisable to set $j =$ `sampsize` to a larger value than the (historical) default.
`trace`	integer indicating a trace level for diagnostic output during the algorithm.
`medoids.x`	logical indicating if the medoids should be returned, identically to some rows of the input data `x`. If `FALSE`, `keep.data` must be false as well, and the medoid indices, i.e., row numbers of the medoids will still be returned (`i.med` component), and the algorithm saves space by needing one copy less of `x`.
`keep.data`	logical indicating if the (scaled if `stand` is true) data should be kept in the result. Setting this to `FALSE` saves memory (and hence time), but disables `clusplot()`ing of the result. Use `medoids.x = FALSE` to save even more memory.
`rngR`	logical indicating if R's random number generator should be used instead of the primitive clara()-builtin one. If true, this also means that each call to `clara()` returns a different result – though only slightly different in good situations.
`pamLike`	logical indicating if the “swap” phase (see `pam`, in C code) should use the same algorithm as `pam()`. Note that from Kaufman and Rousseeuw's description this should have been true always, but as the original Fortran code and the subsequent port to C has always contained a small one-letter change (a typo according to Martin Maechler) with respect to PAM, the default, `pamLike = FALSE` has been chosen to remain back compatible rather than “PAM compatible”.
`correct.d`	logical or integer indicating that—only in the case of `NA`s present in `x`—the correct distance computation should be used instead of the wrong formula which has been present in the original Fortran code and been in use up to early 2016. Because the new correct formula is not back compatible, for the time being, a warning is signalled in this case, unless the user explicitly specifies `correct.d`.

`sample`	labels or case numbers of the observations in the best sample, that is, the sample used by the `clara` algorithm for the final partition.
`medoids`	the medoids or representative objects of the clusters. It is a matrix with in each row the coordinates of one medoid. Possibly `NULL`, namely when the object resulted from `clara(*, medoids.x=FALSE)`. Use the following `i.med` in that case.
`i.med`	the indices of the `medoids` above: `medoids <- x[i.med,]` where `x` is the original data matrix in `clara(x,*)`.
`clustering`	the clustering vector, see `partition.object`.
`objective`	the objective function for the final clustering of the entire dataset.
`clusinfo`	matrix, each row gives numerical information for one cluster. These are the cardinality of the cluster (number of observations), the maximal and average dissimilarity between the observations in the cluster and the cluster's medoid. The last column is the maximal dissimilarity between the observations in the cluster and the cluster's medoid, divided by the minimal dissimilarity between the cluster's medoid and the medoid of any other cluster. If this ratio is small, the cluster is well-separated from the other clusters.
`diss`	dissimilarity (maybe NULL), see `partition.object`.
`silinfo`	list with silhouette width information for the best sample, see `partition.object`.
`call`	generating call, see `partition.object`.
`data`	matrix, possibibly standardized, or NULL, see `partition.object`.

`x`	numeric matrix or `data.frame`.
`FUNcluster`	a `function` which accepts as first argument a (data) matrix like `x`, second argument, say $k, k\geq 2$ , the number of clusters desired, and returns a `list` with a component named (or shortened to) `cluster` which is a vector of length `n = nrow(x)` of integers in `1:k` determining the clustering or grouping of the `n` observations.
`K.max`	the maximum number of clusters to consider, must be at least two.
`B`	integer, number of Monte Carlo (“bootstrap”) samples.
`d.power`	a positive integer specifying the power $p$ which is applied to the euclidean distances (`dist`) before they are summed up to give $W(k)$ . The default, `d.power = 1`, corresponds to the “historical” R implementation, whereas `d.power = 2` corresponds to what Tibshirani et al had proposed. This was found by Juan Gonzalez, in 2016-02.
`spaceH0`	a `character` string specifying the space of the $H_0$ distribution (of no cluster). Both `"scaledPCA"` and `"original"` use a uniform distribution in a hyper cube and had been mentioned in the reference; `"original"` been added after a proposal (including code) by Juan Gonzalez.
`verbose`	integer or logical, determining if “progress” output should be printed. The default prints one bit per bootstrap sample.
`...`	(for `clusGap()`:) optionally further arguments for `FUNcluster()`, see `kmeans` example below.
`f`	numeric vector of ‘function values’, of length $K$ , whose (“1 SE respected”) maximum we want.
`SE.f`	numeric vector of length $K$ of standard errors of `f`.
`method`	character string indicating how the “optimal” number of clusters, $\hat k$ , is computed from the gap statistics (and their standard deviations), or more generally how the location $\hat k$ of the maximum of $f_k$ should be determined. `"globalmax"`: simply corresponds to the global maximum, i.e., is `which.max(f)` `"firstmax"`: gives the location of the first local maximum. `"Tibs2001SEmax"`: uses the criterion, Tibshirani et al (2001) proposed: “the smallest $k$ such that $f(k) \ge f(k+1) - s_{k+1}$ ”. Note that this chooses $k = 1$ when all standard deviations are larger than the differences $f(k+1) - f(k)$ . `"firstSEmax"`: location of the first $f()$ value which is not smaller than the first local maximum minus `SE.factor * SE.f[]`, i.e, within an “f S.E.” range of that maximum (see also `SE.factor`). This, the default, has been proposed by Martin Maechler in 2012, when adding `clusGap()` to the cluster package, after having seen the `"globalSEmax"` proposal (in code) and read the `"Tibs2001SEmax"` proposal. `"globalSEmax"`: (used in Dudoit and Fridlyand (2002), supposedly following Tibshirani's proposition): location of the first $f()$ value which is not smaller than the global maximum minus `SE.factor * SE.f[]`, i.e, within an “f S.E.” range of that maximum (see also `SE.factor`). See the examples for a comparison in a simple case.
`SE.factor`	[When `method` contains `"SE"`] Determining the optimal number of clusters, Tibshirani et al. proposed the “1 S.E.”-rule. Using an `SE.factor` $f$ , the “f S.E.”-rule is used, more generally.
`type`, `xlab`, `ylab`, `main`	arguments with the same meaning as in `plot.default()`, with different default.
`do.arrows`	logical indicating if (1 SE -)“error bars” should be drawn, via `arrows()`.
`arrowArgs`	a list of arguments passed to `arrows()`; the default, notably `angle` and `code`, provide a style matching usual error bars.

`Tab`	a matrix with `K.max` rows and 4 columns, named "logW", "E.logW", "gap", and "SE.sim", where `gap = E.logW - logW`, and `SE.sim` corresponds to the standard error of `gap`, `SE.sim[k]=` $s_k$ , where $s_k := \sqrt{1 + 1/B} sd^(gap_j)$ , and $sd^()$ is the standard deviation of the simulated (“bootstrapped”) gap values.
`call`	the `clusGap(..)` `call`.
`spaceH0`	the `spaceH0` argument (`match.arg()`ed).
`n`	number of observations, i.e., `nrow(x)`.
`B`	input `B`
`FUNcluster`	input function `FUNcluster`

`x`	an R object, here, specifically an object of class `"partition"`, e.g. created by one of the functions `pam`, `clara`, or `fanny`.
`main`	title for the plot; when `NULL` (by default), a title is constructed, using `x$call`.
`dist`	when `x` does not have a `diss` nor a `data` component, e.g., for `pam(dist(*), keep.diss=FALSE)`, `dist` must specify the dissimilarity for the clusplot.
`...`	optional arguments passed to methods, notably the `clusplot.default` method (except for the `diss` one) may also be supplied to this function. Many graphical parameters (see `par`) may also be supplied as arguments here.

`x`	matrix or data frame, or dissimilarity matrix, depending on the value of the `diss` argument. In case of a matrix (alike), each row corresponds to an observation, and each column corresponds to a variable. All variables must be numeric. Missing values (`NA`s) are allowed. They are replaced by the median of the corresponding variable. When some variables or some observations contain only missing values, the function stops with a warning message. In case of a dissimilarity matrix, `x` is the output of `daisy` or `dist` or a symmetric matrix. Also, a vector of length $n*(n-1)/2$ is allowed (where $n$ is the number of observations), and will be interpreted in the same way as the output of the above-mentioned functions. Missing values (NAs) are not allowed.
`clus`	a vector of length n representing a clustering of `x`. For each observation the vector lists the number or name of the cluster to which it has been assigned. `clus` is often the clustering component of the output of `pam`, `fanny` or `clara`.
`diss`	logical indicating if `x` will be considered as a dissimilarity matrix or a matrix of observations by variables (see `x` arugment above).
`s.x.2d`	a `list` with components named `x` (a $n \times 2$ matrix; typically something like principal components of original data), `labs` and `var.dec`.
`stand`	logical flag: if true, then the representations of the n observations in the 2-dimensional plot are standardized.
`lines`	integer out of `0, 1, 2`, used to obtain an idea of the distances between ellipses. The distance between two ellipses E1 and E2 is measured along the line connecting the centers $m1$ and $m2$ of the two ellipses. In case E1 and E2 overlap on the line through $m1$ and $m2$ , no line is drawn. Otherwise, the result depends on the value of `lines`: If lines = 0, no distance lines will appear on the plot; lines = 1, the line segment between $m1$ and $m2$ is drawn; lines = 2, a line segment between the boundaries of E1 and E2 is drawn (along the line connecting $m1$ and $m2$ ).
`shade`	logical flag: if TRUE, then the ellipses are shaded in relation to their density. The density is the number of points in the cluster divided by the area of the ellipse.
`color`	logical flag: if TRUE, then the ellipses are colored with respect to their density. With increasing density, the colors are light blue, light green, red and purple. To see these colors on the graphics device, an appropriate color scheme should be selected (we recommend a white background).
`labels`	integer code, currently one of 0,1,2,3,4 and 5. If labels= 0, no labels are placed in the plot; labels= 1, points and ellipses can be identified in the plot (see `identify`); labels= 2, all points and ellipses are labelled in the plot; labels= 3, only the points are labelled in the plot; labels= 4, only the ellipses are labelled in the plot. labels= 5, the ellipses are labelled in the plot, and points can be identified. The levels of the vector `clus` are taken as labels for the clusters. The labels of the points are the rownames of `x` if `x` is matrix like. Otherwise (`diss = TRUE`), `x` is a vector, point labels can be attached to `x` as a "Labels" attribute (`attr(x,"Labels")`), as is done for the output of `daisy`. A possible `names` attribute of `clus` will not be taken into account.
`plotchar`	logical flag: if TRUE, then the plotting symbols differ for points belonging to different clusters.
`span`	logical flag: if TRUE, then each cluster is represented by the ellipse with smallest area containing all its points. (This is a special case of the minimum volume ellipsoid.) If FALSE, the ellipse is based on the mean and covariance matrix of the same points. While this is faster to compute, it often yields a much larger ellipse. There are also some special cases: When a cluster consists of only one point, a tiny circle is drawn around it. When the points of a cluster fall on a straight line, `span=FALSE` draws a narrow ellipse around it and `span=TRUE` gives the exact line segment.
`add`	logical indicating if ellipses (and labels if `labels` is true) should be added to an already existing plot. If false, neither a `title` or sub title, see `sub`, is written.
`col.p`	color code(s) used for the observation points.
`col.txt`	color code(s) used for the labels (if `labels >= 2`).
`col.clus`	color code for the ellipses (and their labels); only one if color is false (as per default).
`cex`, `cex.txt`	character expansion (size), for the point symbols and point labels, respectively.
`xlim`, `ylim`	numeric vectors of length 2, giving the x- and y- ranges as in `plot.default`.
`main`	main title for the plot; by default, one is constructed.
`sub`	sub title for the plot; by default, one is constructed.
`xlab`, `ylab`	x- and y- axis labels for the plot, with defaults.
`verbose`	a logical indicating, if there should be extra diagnostic output; mainly for ‘debugging’.
`...`	Further graphical parameters may also be supplied, see `par`.

`Size`	the number of observations in the dataset.
`Metric`	the metric used for calculating the dissimilarities. Possible values are "euclidean", "manhattan", "mixed" (if variables of different types were present in the dataset), and "unspecified".
`Labels`	optionally, contains the labels, if any, of the observations of the dataset.
`NA.message`	optionally, if a dissimilarity could not be computed, because of too many missing values for some observations of the dataset.
`Types`	when a mixed metric was used, the types for each variable as one-letter codes, see also `type` in `daisy()`: `A`: Asymmetric binary `S`: Symmetric binary `N`: Nominal (factor) `O`: Ordinal (ordered factor) `I`: Interval scaled, possibly after log transform `"logratio"` (numeric) `T`: raTio treated as `ordered`

`x`	the $n$ $p$ -dimensional points asnumeric $n\times p$ matrix.
`tol`	convergence tolerance for Titterington's algorithm. Setting this to much smaller values may drastically increase the number of iterations needed, and you may want to increas `maxit` as well.
`maxit`	integer giving the maximal number of iteration steps for the algorithm.
`ret.wt`, `ret.sqdist`, `ret.pr`	logicals indicating if additional information should be returned, `ret.wt` specifying the weights, `ret.sqdist` the squared distances and `ret.pr` the final probabilities in the algorithms.
`digits`, `...`	the usual arguments to `print` methods.

`cov`	$p\times p$ covariance matrix description the ellipsoid.
`loc`	$p$ -dimensional location of the ellipsoid center.
`d2`	average squared radius. Further, $d2 = t^2$ , where $t$ is “the value of a t-statistic on the ellipse boundary” (from `ellipse` in the ellipse package), and hence, more usefully, `d2 = qchisq(alpha, df = p)`, where `alpha` is the confidence level for p-variate normally distributed data with location and covariance `loc` and `cov` to lie inside the ellipsoid.
`wt`	the vector of weights iff `ret.wt` was true.
`sqdist`	the vector of squared distances iff `ret.sqdist` was true.
`prob`	the vector of algorithm probabilities iff `ret.pr` was true.
`it`	number of iterations used.
`tol`, `maxit`	just the input argument, see above.
`eps`	the achieved tolerance which is the maximal squared radius minus $p$ .
`ierr`	error code as from the algorithm; `0` means ok.
`conv`	logical indicating if the converged. This is defined as `it < maxit && ierr == 0`.

`x`	data matrix or data frame, or dissimilarity matrix, depending on the value of the `diss` argument. In case of a matrix or data frame, each row corresponds to an observation, and each column corresponds to a variable. All variables must be numeric. Missing values (NAs) are allowed. In case of a dissimilarity matrix, `x` is typically the output of `daisy` or `dist`. Also a vector of length n*(n-1)/2 is allowed (where n is the number of observations), and will be interpreted in the same way as the output of the above-mentioned functions. Missing values (NAs) are not allowed.
`k`	integer giving the desired number of clusters. It is required that $0 < k < n/2$ where $n$ is the number of observations.
`diss`	logical flag: if TRUE (default for `dist` or `dissimilarity` objects), then `x` is assumed to be a dissimilarity matrix. If FALSE, then `x` is treated as a matrix of observations by variables.
`memb.exp`	number $r$ strictly larger than 1 specifying the membership exponent used in the fit criterion; see the ‘Details’ below. Default: `2` which used to be hardwired inside FANNY.
`metric`	character string specifying the metric to be used for calculating dissimilarities between observations. Options are `"euclidean"` (default), `"manhattan"`, and `"SqEuclidean"`. Euclidean distances are root sum-of-squares of differences, and manhattan distances are the sum of absolute differences, and `"SqEuclidean"`, the squared euclidean distances are sum-of-squares of differences. Using this last option is equivalent (but somewhat slower) to computing so called “fuzzy C-means”. If `x` is already a dissimilarity matrix, then this argument will be ignored.
`stand`	logical; if true, the measurements in `x` are standardized before calculating the dissimilarities. Measurements are standardized for each variable (column), by subtracting the variable's mean value and dividing by the variable's mean absolute deviation. If `x` is already a dissimilarity matrix, then this argument will be ignored.
`iniMem.p`	numeric $n \times k$ matrix or `NULL` (by default); can be used to specify a starting `membership` matrix, i.e., a matrix of non-negative numbers, each row summing to one.
`cluster.only`	logical; if true, no silhouette information will be computed and returned, see details.
`keep.diss`, `keep.data`	logicals indicating if the dissimilarities and/or input data `x` should be kept in the result. Setting these to `FALSE` can give smaller results and hence also save memory allocation time.
`maxit`, `tol`	maximal number of iterations and default tolerance for convergence (relative convergence of the fit criterion) for the FANNY algorithm. The defaults `maxit = 500` and `tol = 1e-15` used to be hardwired inside the algorithm.
`trace.lev`	integer specifying a trace level for printing diagnostics during the C-internal algorithm. Default `0` does not print anything; higher values print increasingly more.

`membership`	matrix containing the memberships for each pair consisting of an observation and a cluster.
`memb.exp`	the membership exponent used in the fitting criterion.
`coeff`	Dunn's partition coefficient $F(k)$ of the clustering, where $k$ is the number of clusters. $F(k)$ is the sum of all squared membership coefficients, divided by the number of observations. Its value is between $1/k$ and 1. The normalized form of the coefficient is also given. It is defined as $(F(k) - 1/k) / (1 - 1/k)$ , and ranges between 0 and 1. A low value of Dunn's coefficient indicates a very fuzzy clustering, whereas a value close to 1 indicates a near-crisp clustering.
`clustering`	the clustering vector of the nearest crisp clustering, see `partition.object`.
`k.crisp`	integer ( $\le k$ ) giving the number of crisp clusters; can be less than $k$ , where it's recommended to decrease `memb.exp`.
`objective`	named vector containing the minimal value of the objective function reached by the FANNY algorithm and the relative convergence tolerance `tol` used.
`convergence`	named vector with `iterations`, the number of iterations needed and `converged` indicating if the algorithm converged (in `maxit` iterations within convergence tolerance `tol`).
`diss`	an object of class `"dissimilarity"`, see `partition.object`.
`call`	generating call, see `partition.object`.
`silinfo`	list with silhouette information of the nearest crisp clustering, see `partition.object`.
`data`	matrix, possibibly standardized, or NULL, see `partition.object`.

[ , "V1"]	factor	winters
[ , "V2"]	factor	shadow
[ , "V3"]	factor	tubers
[ , "V4"]	factor	color
[ , "V5"]	ordered	soil
[ , "V6"]	ordered	preference
[ , "V7"]	numeric	height
[ , "V8"]	numeric	distance

`x`	an agnes object.
`...`	potential further arguments (required by generic).

`x`	a clara object.
`...`	potential further arguments (require by generic).

`x`	a diana object.
`...`	potential further arguments (require by generic).

`x`	Either a data matrix or data frame, or dissimilarity matrix or object, see also `pam`.
`clustering`	an integer vector of length $n$ , the number of observations, giving for each observation the number ('id') of the cluster to which it belongs. In other words, `clustering` has values from `1:k` where `k` is the number of clusters, see also `partition.object` and `cutree()`, for examples where such clustering vectors are computed.
`diss`	see also `pam`.
`USE.NAMES`	a logical, typical false, passed to the `vapply()` call computing the medoids.
`...`	optional further argument passed to `pam(xj, k=1, ...)`, notably `metric`, or `variant="f_5"` to use a faster algorithm, or `trace.lev = k`.

`data`	matrix with the same dimensions as the original data matrix, but with factors coded as 0 and 1, and all missing values replaced.
`order`	a vector giving a permutation of the original observations to allow for plotting, in the sense that the branches of a clustering tree will not cross.
`order.lab`	a vector similar to `order`, but containing observation labels instead of observation numbers. This component is only available if the original observations were labelled.
`variable`	vector of length n-1 where n is the number of observations, specifying the variables used to separate the observations of `order`.
`step`	vector of length n-1 where n is the number of observations, specifying the separation steps at which the observations of `order` are separated.

`x`	data matrix or data frame, or dissimilarity matrix or object, depending on the value of the `diss` argument. In case of a matrix or data frame, each row corresponds to an observation, and each column corresponds to a variable. All variables must be numeric (or logical). Missing values (`NA`s) are allowed—as long as every pair of observations has at least one case not missing. In case of a dissimilarity matrix, `x` is typically the output of `daisy` or `dist`. Also a vector of length n(n-1)/2 is allowed (where n is the number of observations), and will be interpreted in the same way as the output of the above-mentioned functions. Missing values (`NA`s) are not* allowed.
`k`	positive integer specifying the number of clusters, less than the number of observations.
`diss`	logical flag: if TRUE (default for `dist` or `dissimilarity` objects), then `x` will be considered as a dissimilarity matrix. If FALSE, then `x` will be considered as a matrix of observations by variables.
`metric`	character string specifying the metric to be used for calculating dissimilarities between observations. The currently available options are "euclidean" and "manhattan". Euclidean distances are root sum-of-squares of differences, and manhattan distances are the sum of absolute differences. If `x` is already a dissimilarity matrix, then this argument will be ignored.
`medoids`	NULL (default) or length-`k` vector of integer indices (in `1:n`) specifying initial medoids instead of using the ‘build’ algorithm.
`nstart`	used only when `medoids = "random"`: specifies the number of random “starts”; this argument corresponds to the one of `kmeans()` (from R's package stats).
`stand`	logical; if true, the measurements in `x` are standardized before calculating the dissimilarities. Measurements are standardized for each variable (column), by subtracting the variable's mean value and dividing by the variable's mean absolute deviation. If `x` is already a dissimilarity matrix, then this argument will be ignored.
`cluster.only`	logical; if true, only the clustering will be computed and returned, see details.
`do.swap`	logical indicating if the swap phase should happen. The default, `TRUE`, correspond to the original algorithm. On the other hand, the swap phase is much more computer intensive than the build one for large $n$ , so can be skipped by `do.swap = FALSE`.
`keep.diss`, `keep.data`	logicals indicating if the dissimilarities and/or input data `x` should be kept in the result. Setting these to `FALSE` can give much smaller results and hence even save memory allocation time.
`pamonce`	logical or integer in `0:6` specifying algorithmic short cuts as proposed by Reynolds et al. (2006), and Schubert and Rousseeuw (2019, 2021) see below.
`variant`	a `character` string denoting the variant of PAM algorithm to use; a more self-documenting version of `pamonce` which should be used preferably; note that `"faster"` not only uses `pamonce = 6` but also `nstart = 1` and hence `medoids = "random"` by default.
`trace.lev`	integer specifying a trace level for printing diagnostics during the build and swap phase of the algorithm. Default `0` does not print anything; higher values print increasingly more.

`medoids`	the medoids or representative objects of the clusters. If a dissimilarity matrix was given as input to `pam`, then a vector of numbers or labels of observations is given, else `medoids` is a `matrix` with in each row the coordinates of one medoid.
`id.med`	integer vector of indices giving the medoid observation numbers.
`clustering`	the clustering vector, see `partition.object`.
`objective`	the objective function after the first and second step of the `pam` algorithm.
`isolation`	vector with length equal to the number of clusters, specifying which clusters are isolated clusters (L- or L-clusters) and which clusters are not isolated. A cluster is an L-cluster iff its diameter is smaller than its separation. A cluster is an L-cluster iff for each observation i the maximal dissimilarity between i and any other observation of the cluster is smaller than the minimal dissimilarity between i and any observation of another cluster. Clearly each L*-cluster is also an L-cluster.
`clusinfo`	matrix, each row gives numerical information for one cluster. These are the cardinality of the cluster (number of observations), the maximal and average dissimilarity between the observations in the cluster and the cluster's medoid, the diameter of the cluster (maximal dissimilarity between two observations of the cluster), and the separation of the cluster (minimal dissimilarity between an observation of the cluster and an observation of another cluster).
`silinfo`	list with silhouette width information, see `partition.object`.
`diss`	dissimilarity (maybe NULL), see `partition.object`.
`call`	generating call, see `partition.object`.
`data`	(possibibly standardized) see `partition.object`.

`clustering`	the clustering vector. An integer vector of length $n$ , the number of observations, giving for each observation the number ('id') of the cluster to which it belongs.
`call`	the matched `call` generating the object.
`silinfo`	a list with all silhouette information, only available when the number of clusters is non-trivial, i.e., $1 < k < n$ and then has the following components, see `silhouette` widths an (n x 3) matrix, as returned by `silhouette()`, with for each observation i the cluster to which i belongs, as well as the neighbor cluster of i (the cluster, not containing i, for which the average dissimilarity between its observations and i is minimal), and the silhouette width $s(i)$ of the observation. clus.avg.widths the average silhouette width per cluster. avg.width the average silhouette width for the dataset, i.e., simply the average of $s(i)$ over all observations $i$ . This information is also needed to construct a silhouette plot of the clustering, see `plot.partition`. Note that `avg.width` can be maximized over different clusterings (e.g. with varying number of clusters) to choose an optimal clustering.
`objective`	value of criterion maximized during the partitioning algorithm, may more than one entry for different stages.
`diss`	an object of class `"dissimilarity"`, representing the total dissimilarity matrix of the dataset (or relevant subset, e.g. for `clara`).
`data`	a matrix containing the original or standardized data. This might be missing to save memory or when a dissimilarity matrix was given as input structure to the clustering method.

`x`	an object of class `"agnes"`, typically created by `agnes(.)`.
`ask`	logical; if true and `which.plots` is `NULL`, `plot.agnes` operates in interactive mode, via `menu`.
`which.plots`	integer vector or NULL (default), the latter producing both plots. Otherwise, `which.plots` must contain integers of `1` for a banner plot or `2` for a dendrogram or “clustering tree”.
`main`, `sub`	main and sub title for the plot, with convenient defaults. See documentation for these arguments in `plot.default`.
`adj`	for label adjustment in `bannerplot()`.
`nmax.lab`	integer indicating the number of labels which is considered too large for single-name labelling the banner plot.
`max.strlen`	positive integer giving the length to which strings are truncated in banner plot labeling.
`xax.pretty`	logical or integer indicating if `pretty(*, n = xax.pretty)` should be used for the x axis. `xax.pretty = FALSE` is for back compatibility.
`...`	graphical parameters (see `par`) may also be supplied and are passed to `bannerplot()` or `pltree()` (see `pltree.twins`), respectively.

`x`	an object of class `"diana"`, typically created by `diana(.)`.
`ask`	logical; if true and `which.plots` is `NULL`, `plot.diana` operates in interactive mode, via `menu`.
`which.plots`	integer vector or NULL (default), the latter producing both plots. Otherwise, `which.plots` must contain integers of `1` for a banner plot or `2` for a dendrogram or “clustering tree”.
`main`, `sub`	main and sub title for the plot, each with a convenient default. See documentation for these arguments in `plot.default`.
`adj`	for label adjustment in `bannerplot()`.
`nmax.lab`	integer indicating the number of labels which is considered too large for single-name labelling the banner plot.
`max.strlen`	positive integer giving the length to which strings are truncated in banner plot labeling.
`xax.pretty`	logical or integer indicating if `pretty(*, n = xax.pretty)` should be used for the x axis. `xax.pretty = FALSE` is for back compatibility.
`...`	graphical parameters (see `par`) may also be supplied and are passed to `bannerplot()` or `pltree()`, respectively.

`x`	an object of class `"mona"`, typically created by `mona(.)`.
`main`, `sub`	main and sub titles for the plot, with convenient defaults. See documentation in `plot.default`.
`xlab`	x axis label, see `title`.
`col`, `adj`	graphical parameters passed to `bannerplot()`.
`axes`	logical, indicating if (labeled) axes should be drawn.
`nmax.lab`	integer indicating the number of labels which is considered too large for labeling.
`max.strlen`	positive integer giving the length to which strings are truncated in labeling.
`...`	further graphical arguments are passed to `bannerplot()` and `text`.

`x`	an object of class `"partition"`, typically created by the functions `pam`, `clara`, or `fanny`.
`ask`	logical; if true and `which.plots` is `NULL`, `plot.partition` operates in interactive mode, via `menu`.
`which.plots`	integer vector or NULL (default), the latter producing both plots. Otherwise, `which.plots` must contain integers of `1` for a clusplot or `2` for silhouette.
`nmax.lab`	integer indicating the number of labels which is considered too large for single-name labeling the silhouette plot.
`max.strlen`	positive integer giving the length to which strings are truncated in silhouette plot labeling.
`data`	numeric matrix with the scaled data; per default taken from the partition object `x`, but can be specified explicitly.
`dist`	when `x` does not have a `diss` component as for `pam(*, keep.diss=FALSE)`, `dist` must be the dissimilarity if a clusplot is desired.
`stand`, `lines`, `shade`, `color`, `labels`, `plotchar`, `span`, `xlim`, `ylim`, `main`, `...`	All optional arguments available for the `clusplot.default` function (except for the `diss` one) and graphical parameters (see `par`) may also be supplied as arguments to this function.

`x`	in general, an R object for which a `pltree` method is defined; specifically, an object of class `"twins"`, typically created by either `agnes()` or `diana()`.
`main`	main title with a sensible default.
`labels`	labels to use; the default is constructed from `x`.
`ylab`	label for y-axis.
`...`	graphical parameters (see `par`) may also be supplied as arguments to this function.

Package 'cluster'

Help Index

Agglomerative Nesting (Hierarchical Clustering)

Description

Usage

Arguments

Details

Value

BACKGROUND

Author(s)

References

See Also

Examples

Agglomerative Nesting (AGNES) Object

Description

Value

GENERATION

METHODS

INHERITANCE

See Also

Examples

European Union Agricultural Workforces

Description

Usage

Format

Details

Source

References

See Also

Examples

Attributes of Animals

Description

Usage

Format

Details

Source

References

Examples

Plot Banner (of Hierarchical Clustering)

Description

Usage

Arguments

Note

Author(s)

Examples

Subset of C-horizon of Kola Data

Description

Usage

Format

Details

Source

See Also

Examples

Clustering Large Applications

Description

Usage

Arguments

Details

Value

Note

Author(s)

See Also

Examples

Clustering Large Applications (CLARA) Object

Description

Value

Methods, Inheritance

See Also

Gap Statistic for Estimating the Number of Clusters

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Bivariate Cluster Plot (of a Partitioning Object)

Description

`object`	an object of class `ellipsoid`, typically from `ellipsoidhull()`; alternatively any list-like object with proper components, see details below.
`n.out`, `n.half`	half the number of points to create.
`A`, `d2`, `loc`	arguments of the auxilary `ellipsoidPoints`, see below.
`...`	passed to and from methods.

`x`, `object`	a `dissimilarity` object or a `summary.dissimilarity` one for `print.summary.dissimilarity()`.
`digits`	the number of digits to use, see `print.default`.
`diag`, `upper`, `justify`, `right`	optional arguments specifying how the triangular dissimilarity matrix is printed; see `print.dist`.
`...`	potential further arguments (require by generic).

`x`, `object`	a `fanny` object.
`digits`	number of significant digits for printing, see `print.default`.
`...`	potential further arguments (required by generic).

`x`	a mona object.
`...`	potential further arguments (require by generic).

`x`	a pam object.
`...`	potential further arguments (require by generic).

`x`	an object of appropriate class; for the `default` method an integer vector with $k$ different integer cluster codes or a list with such an `x$clustering` component. Note that silhouette statistics are only defined if $2 \le k \le n-1$ .
`dist`	a dissimilarity object inheriting from class `dist` or coercible to one. If not specified, `dmatrix` must be.
`dmatrix`	a symmetric dissimilarity matrix ( $n \times n$ ), specified instead of `dist`, which can be more efficient.
`full`	logical or number in $[0,1]$ specifying if a full silhouette should be computed for `clara` object. When a number, say $f$ , for a random `sample.int(n, size = fn)` of the data the silhouette values are computed. This requires $O((fn)^2)$ memory, since the full dissimilarity of the (sub)sample (see `daisy`) is needed internally.
`subset`	a subset from `1:n`, specified instead of `full` to specify the indices of the observations to be used for the silhouette computations.
`object`	an object of class `silhouette`.
`...`	further arguments passed to and from methods.
`FUN`	function used to summarize silhouette widths.
`nmax.lab`	integer indicating the number of labels which is considered too large for single-name labeling the silhouette plot.
`max.strlen`	positive integer giving the length to which strings are truncated in silhouette plot labeling.
`main`, `sub`, `xlab`	arguments to `title`; have a sensible non-NULL default here.
`col`, `border`, `cex.names`	arguments passed `barplot()`; note that the default used to be `col = heat.colors(n), border = par("fg")` instead. `col` can also be a color vector of length $k$ for clusterwise coloring, see also `do.col.sort`:
`do.col.sort`	logical indicating if the colors `col` should be sorted “along” the silhouette; this is useful for casewise or clusterwise coloring.
`do.n.k`	logical indicating if $n$ and $k$ “title text” should be written.
`do.clus.stat`	logical indicating if cluster size and averages should be written right to the silhouettes.

`x`, `object`	a `agnes` object.
`...`	potential further arguments (require by generic).

`x`, `object`	a `clara` object.
`...`	potential further arguments (require by generic).

`x`, `object`	a `diana` object.
`...`	potential further arguments (require by generic).

`x`, `object`	a `mona` object.
`...`	potential further arguments (require by generic).