`all.equal(x, y)`

is a utility to compare R objects `x`

and `y`

testing ‘near equality’. If they are different,
comparison is still made to some extent, and a report of the
differences is returned. Do not use `all.equal`

directly in
`if`

expressions---either use `isTRUE(all.equal(....))`

or
`identical`

if appropriate.

`all.equal(target, current, …)`# S3 method for numeric
all.equal(target, current,
tolerance = sqrt(.Machine$double.eps), scale = NULL,
countEQ = FALSE,
formatFUN = function(err, what) format(err),
…, check.attributes = TRUE)

# S3 method for list
all.equal(target, current, …,
check.attributes = TRUE, use.names = TRUE)

# S3 method for environment
all.equal(target, current, all.names=TRUE, …)

# S3 method for POSIXt
all.equal(target, current, …, tolerance = 1e-3, scale)

attr.all.equal(target, current, …,
check.attributes = TRUE, check.names = TRUE)

target

R object.

current

other R object, to be compared with `target`

.

…

further arguments for different methods, notably the following two, for numerical comparison:

tolerance

numeric \(\ge\) 0. Differences smaller than
`tolerance`

are not reported. The default value is close to
`1.5e-8`

.

scale

`NULL`

or numeric > 0, typically of length 1 or
`length(target)`

. See ‘Details’.

countEQ

logical indicating if the `target == current`

cases should be counted when computing the mean (absolute or
relative) differences. The default, `FALSE`

may seem
misleading in cases where `target`

and `current`

only
differ in a few places; see the extensive example.

formatFUN

a `function`

of two arguments,
`err`

, the relative, absolute or scaled error, and
`what`

, a character string indicating the *kind* of error;
maybe used, e.g., to format relative and absolute errors differently.

check.attributes

logical indicating if the
`attributes`

of `target`

and `current`

(other than the names) should be compared.

use.names

logical indicating if `list`

comparison
should report differing components by name (if matching) instead of
integer index. Note that this comes after `…`

and so must
be specified by its full name.

all.names

logical passed to `ls`

indicating if
“hidden” objects should also be considered in the environments.

check.names

logical indicating if the `names(.)`

of `target`

and `current`

should be compared.

Either `TRUE`

(`NULL`

for `attr.all.equal`

) or a vector
of `mode`

`"character"`

describing the differences
between `target`

and `current`

.

`all.equal`

is a generic function, dispatching methods on the
`target`

argument. To see the available methods, use
`methods("all.equal")`

, but note that the default method
also does some dispatching, e.g.using the raw method for logical
targets.

Remember that arguments which follow `…`

must be specified by
(unabbreviated) name. It is inadvisable to pass unnamed arguments in
`…`

as these will match different arguments in different
methods.

Numerical comparisons for `scale = NULL`

(the default) are
typically on *relative difference* scale unless the target values
are close to zero: First, the mean absolute difference of the two
numerical vectors is computed. If this is smaller than
`tolerance`

or not finite, absolute differences are used,
otherwise relative differences scaled by the mean absolute
`target`

value.
Note that these comparisons are computed only for those vector elements
where `target`

is not `NA`

and differs from `current`

.
If `countEQ`

is true, the equal and `NA`

cases are
*counted* in determining “sample” size.

If `scale`

is numeric (and positive), absolute comparisons are
made after scaling (dividing) by `scale`

.

For complex `target`

, the modulus (`Mod`

) of the
difference is used: `all.equal.numeric`

is called so arguments
`tolerance`

and `scale`

are available.

The `list`

method compares components of
`target`

and `current`

recursively, passing all other
arguments, as long as both are “list-like”, i.e., fulfill
either `is.vector`

or `is.list`

.

The `environment`

method works via the `list`

method,
and is also used for reference classes (unless a specific
`all.equal`

method is defined).

The methods for the date-time classes by default allow a tolerance of
`tolerance = 0.001`

seconds, and ignore `scale`

.

`attr.all.equal`

is used for comparing
`attributes`

, returning `NULL`

or a
`character`

vector.

Chambers, J. M. (1998)
*Programming with Data. A Guide to the S Language*.
Springer (for `=`

).

# NOT RUN { all.equal(pi, 355/113) # not precise enough (default tol) > relative error d45 <- pi*(1/4 + 1:10) stopifnot( all.equal(tan(d45), rep(1, 10))) # TRUE, but all (tan(d45) == rep(1, 10)) # FALSE, since not exactly all.equal(tan(d45), rep(1, 10), tolerance = 0) # to see difference ## advanced: equality of environments ae <- all.equal(as.environment("package:stats"), asNamespace("stats")) stopifnot(is.character(ae), length(ae) > 10, ## were incorrectly "considered equal" in R <= 3.1.1 all.equal(asNamespace("stats"), asNamespace("stats"))) ## A situation where 'countEQ = TRUE' makes sense: x1 <- x2 <- (1:100)/10; x2[2] <- 1.1*x1[2] ## 99 out of 100 pairs (x1[i], x2[i]) are equal: plot(x1,x2, main = "all.equal.numeric() -- not counting equal parts") all.equal(x1,x2) ## "Mean relative difference: 0.1" mtext(paste("all.equal(x1,x2) :", all.equal(x1,x2)), line= -2) ##' extract the 'Mean relative difference' as number: all.eqNum <- function(...) as.numeric(sub(".*:", '', all.equal(...))) set.seed(17) ## When x2 is jittered, typically all pairs (x1[i],x2[i]) do differ: summary(r <- replicate(100, all.eqNum(x1, x2*(1+rnorm(x1)*1e-7)))) mtext(paste("mean(all.equal(x1, x2*(1 + eps_k))) {100 x} Mean rel.diff.=", signif(mean(r), 3)), line = -4, adj=0) ## With argument countEQ=TRUE, get "the same" (w/o need for jittering): mtext(paste("all.equal(x1,x2, countEQ=TRUE) :", signif(all.eqNum(x1,x2, countEQ=TRUE), 3)), line= -6, col=2) # }

Run the code above in your browser using DataCamp Workspace