R: Test if Two Objects are (Nearly) Equal

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. Don't use `all.equal` directly in `if` expressions—either use `isTRUE(all.equal(....))` or `identical` if appropriate.

### Usage

    all.equal(target, current, ...)

    ## S3 method for class 'numeric'
    all.equal(target, current,
              tolerance = .Machine$double.eps ^ 0.5,
              scale = NULL, check.attributes = TRUE, ...)

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

### Arguments

`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 ≥ 0. Differences smaller than `tolerance` are not considered.
`scale` | numeric scalar > 0 (or `NULL`). See ‘Details’.
`check.attributes` | logical indicating if the `attributes(.)` of `target` and `current` should be compared as well.
`check.names` | logical indicating if the `names(.)` of `target` and `current` should be compared as well (and separately from the `attributes`).

### 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.

Numerical comparisons for `scale = NULL` (the default) are done by first computing the mean absolute difference of the two numerical vectors. If this is smaller than `tolerance` or not finite, absolute differences are used, otherwise relative differences scaled by the mean absolute difference.

If `scale` is 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.

`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

    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), tol=0)  # to see difference

[Package base version 2.15.1 Index]