all.equal {base}  R Documentation 
Test if Two Objects are (Nearly) Equal
Description
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.
Usage
all.equal(target, current, ...)
## Default S3 method:
all.equal(target, current, ..., check.class = TRUE)
## S3 method for class 'numeric'
all.equal(target, current,
tolerance = sqrt(.Machine$double.eps), scale = NULL,
countEQ = FALSE,
formatFUN = function(err, what) format(err),
..., check.attributes = TRUE, check.class = TRUE, giveErr = FALSE)
## S3 method for class 'list'
all.equal(target, current, ...,
check.attributes = TRUE, use.names = TRUE)
## S3 method for class 'environment'
all.equal(target, current, all.names = TRUE,
evaluate = TRUE, ...)
## S3 method for class 'function'
all.equal(target, current, check.environment=TRUE, ...)
## S3 method for class 'POSIXt'
all.equal(target, current, ..., tolerance = 1e3, scale,
check.tzone = TRUE)
attr.all.equal(target, current, ...,
check.attributes = TRUE, check.names = TRUE)
Arguments
target 
R object. 
current 
other R object, to be compared with 
... 
further arguments for different methods, notably the following two, for numerical comparison: 
tolerance 
numeric 
scale 

countEQ 
logical indicating if the 
formatFUN 
a 
check.attributes 
logical indicating if the

check.class 
logical indicating if the 
giveErr 

use.names 
logical indicating if 
all.names 
logical passed to 
evaluate 
for the 
check.environment 
logical requiring that the

check.tzone 
logical indicating if the 
check.names 
logical indicating if the 
Details
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 a relative difference scale unless the
target
values are close to zero or infinite. Specifically,
the scale is computed as the mean absolute value of target
.
If this scale is finite and exceeds tolerance
, differences
are expressed relative to it; otherwise, absolute differences are used.
Note that this scale and all further steps 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 the “sample” size.
If scale
is numeric (and positive), absolute comparisons are
made after scaling (dividing) by scale
. Note that if all of
scale is close to 1 (specifically, within 1e7), the difference is still
reported as being on an absolute 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 “listlike”, 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 method for datetime objects uses all.equal.numeric
to
compare times (in "POSIXct"
representation) with a
default tolerance
of 0.001 seconds, ignoring scale
.
A time zone mismatch between target
and current
is
reported unless check.tzone = FALSE
.
attr.all.equal
is used for comparing
attributes
, returning NULL
or a
character
vector.
Value
Either TRUE
(NULL
for attr.all.equal
) or a vector
of mode
"character"
describing the differences
between target
and current
.
References
Chambers, J. M. (1998)
Programming with Data. A Guide to the S Language.
Springer (for =
).
See Also
identical
, isTRUE
, ==
, and
all
for exact equality testing.
Examples
all.equal(pi, 355/113)
# not precise enough (default tol) > relative error
quarts < 1/4 + 1:10 # exact
d45 < pi*quarts ; one < rep(1, 10)
tan(d45) == one # mostly FALSE, as typically exact; embarrassingly,
tanpi(quarts) == one # (is always FALSE (Fedora 34; gcc 11.2.1))
stopifnot(all.equal(
tan(d45), one)) # TRUE, but not if we are picky:
all.equal(tan(d45), one, tolerance = 0) # to see difference
all.equal(tan(d45), one, tolerance = 0, scale = 1)# "absolute diff.."
all.equal(tan(d45), one, tolerance = 0, scale = 1+(2:2)/1e9) # "absolute"
all.equal(tan(d45), one, tolerance = 0, scale = 1+(2:2)/1e6) # "scaled"
## 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)*1e7))))
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)
## Using giveErr=TRUE :
x1. < x1 * (1+ 1e9*rnorm(x1))
str(all.equal(x1, x1., giveErr=TRUE))
## logi TRUE
##  attr(*, "err")= num 8.66e10
##  attr(*, "what")= chr "relative"
## Used with stopifnot(), still *showing* diff:
all.equalShow < function (...) {
r < all.equal(..., giveErr=TRUE)
cat(attr(r,"what"), "err:", attr(r,"err"), "\n")
c(r) # can drop attributes, as not used anymore
}
# checks, showing error in any case:
stopifnot(all.equalShow(x1, x1.)) # > relative err: 8.66002e10
tryCatch(error=identity, stopifnot(all.equalShow(x1, 2*x1))) > eAe
stopifnot(inherits(eAe, "error"))
# stopifnot(all.equal....()) giving smart msg:
cat(conditionMessage(eAe), "\n")
two < structure(2, foo = 1, class = "bar")
all.equal(two^20, 2^20) # lots of diff
all.equal(two^20, 2^20, check.attributes = FALSE)# "target is bar, current is numeric"
all.equal(two^20, 2^20, check.attributes = FALSE, check.class = FALSE) # TRUE
## comparison of datetime objects
now < Sys.time()
stopifnot(
all.equal(now, now + 1e4) # TRUE (default tolerance = 0.001 seconds)
)
all.equal(now, now + 0.2)
all.equal(now, as.POSIXlt(now, "UTC"))
stopifnot(
all.equal(now, as.POSIXlt(now, "UTC"), check.tzone = FALSE) # TRUE
)