Test Objects for Exact Equality
The safe and reliable way to test two objects for being
exactly equal. It returns
TRUE in this case,
FALSE in every other case.
identical(x, y, num.eq = TRUE, single.NA = TRUE, attrib.as.set = TRUE, ignore.bytecode = TRUE, ignore.environment = FALSE)
- x, y
- any R objects.
- logical indicating if (
NA) numbers should be compared using
==(equal), or by bitwise comparison. The latter (non-default) differentiates between
- logical indicating if there is conceptually just one numeric
single.NA = FALSEdifferentiates bit patterns.
- logical indicating if
yshould be treated as unordered tagged pairlists (sets); this currently also applies to
slots of S4 objects. It may well be too strict to set
attrib.as.set = FALSE.
- logical indicating if byte code should be ignored when comparing closures.
- logical indicating if their environments should be ignored when comparing closures.
A call to
identical is the way to test exact equality in
while statements, as well as in logical
expressions that use
||. In all these
applications you need to be assured of getting a single logical
Users often use the comparison operators, such as
!=, in these situations. It looks natural, but it is not what
these operators are designed to do in R. They return an object like
the arguments. If you expected
y to be of length
1, but it happened that one of them was not, you will not get a
FALSE. Similarly, if one of the arguments is
the result is also
NA. In either case, the expression
if(x == y).... won't work as expected.
all.equal is also sometimes used to test equality
this way, but was intended for something different: it allows for
small differences in numeric results.
The computations in
identical are also reliable and usually
fast. There should never be an error. The only known way to kill
identical is by having an invalid pointer at the C level,
generating a memory fault. It will usually find inequality quickly.
Checking equality for two large, complicated objects can take longer
if the objects are identical or nearly so, but represent completely
independent copies. For most applications, however, the computational cost
should be negligible.
Character strings are regarded as identical if they are in different marked encodings but would agree when translated to UTF-8.
attrib.as.set is true, as by default, comparison of
attributes view them as a set (and not a vector, so order is not
ignore.bytecode is true (the default), the compiled
bytecode of a function (see
cmpfun) will be ignored in
the comparison. If it is false, functions will compare equal only if
they are copies of the same compiled object (or both are
uncompiled). To check whether two different compiles are equal, you
should compare the results of
You almost never want to use
identical on datetimes of class
"POSIXlt": not only can different times in the different
time zones represent the same time and time zones have multiple names,
but several of the components are optional.
identical(x, y, FALSE, FALSE, FALSE, FALSE) pickily
tests for exact equality.
A single logical value,
NAand never anything other than a single value.
Chambers, J. M. (1998) Programming with Data. A Guide to the S Language. Springer.
identical(1, NULL) ## FALSE -- don't try this with == identical(1, 1.) ## TRUE in R (both are stored as doubles) identical(1, as.integer(1)) ## FALSE, stored as different types x <- 1.0; y <- 0.99999999999 ## how to test for object equality allowing for numeric fuzz : (E <- all.equal(x, y)) isTRUE(E) # which is simply defined to just use identical(TRUE, E) ## If all.equal thinks the objects are different, it returns a ## character string, and the above expression evaluates to FALSE ## even for unusual R objects : identical(.GlobalEnv, environment()) ### ------- Pickyness Flags : ----------------------------- ## the infamous example: identical(0., -0.) # TRUE, i.e. not differentiated identical(0., -0., num.eq = FALSE) ## similar: identical(NaN, -NaN) # TRUE identical(NaN, -NaN, single.NA = FALSE) # differ on bit-level ## for functions: f <- function(x) x f g <- compiler::cmpfun(f) g identical(f, g) identical(f, g, ignore.bytecode = FALSE)