Prueba de igualdad entre todos los elementos de un único vector

Si son todos valores numéricos entonces si tol es su tolerancia entonces...

all( abs(y - mean(y)) < tol ) 

Es la solución a su problema.

EDITAR:

Después de mirar esto, y otras respuestas, y la evaluación comparativa de algunas cosas, lo siguiente sale más del doble de rápido que la respuesta de disminución.

abs(max(x) - min(x)) < tol

Esto es un poco sorprendentemente más rápido que diff(range(x)) ya que diff no debería ser muy diferente de - y abs con dos números. Solicitar el rango debe optimizar la obtención de mínimo y máximo. Tanto diff como range son funciones primitivas. Pero el momento no miente.

Por qué no simplemente usar la varianza:

var(x) == 0

Si todos los elementos de x son iguales, obtendrá una varianza de 0.

> isTRUE(all.equal( max(y) ,min(y)) )
[1] TRUE
> isTRUE(all.equal( max(x) ,min(x)) )
[1] FALSE

Otro en la misma línea:

> diff(range(x)) < .Machine$double.eps ^ 0.5
[1] FALSE
> diff(range(y)) < .Machine$double.eps ^ 0.5
[1] TRUE

Puede usar identical() y all.equal() comparando el primer elemento con todos los demás, barriendo efectivamente la comparación a través de:

R> compare <- function(v) all(sapply( as.list(v[-1]), 
+                         FUN=function(z) {identical(z, v[1])}))
R> compare(x)
[1] FALSE
R> compare(y)
[1] TRUE
R> 

De esa manera puede agregar cualquier epsilon a identical() según sea necesario.

Dado que sigo volviendo a esta pregunta una y otra vez, aquí hay una solución Rcpp que generalmente será mucho más rápida que cualquiera de las soluciones R si la respuesta es realmente FALSE (porque se detendrá en el momento en que encuentre un desajuste) y tendrá la misma velocidad que la solución R más rápida si la respuesta es TRUE. Por ejemplo, para el punto de referencia OP, system.time se registra exactamente en 0 usando esta función.

library(inline)
library(Rcpp)

fast_equal = cxxfunction(signature(x = 'numeric', y = 'numeric'), '
  NumericVector var(x);
  double precision = as<double>(y);

  for (int i = 0, size = var.size(); i < size; ++i) {
    if (var[i] - var[0] > precision || var[0] - var[i] > precision)
      return Rcpp::wrap(false);
  }

  return Rcpp::wrap(true);
', plugin = 'Rcpp')

fast_equal(c(1,2,3), 0.1)
#[1] FALSE
fast_equal(c(1,2,3), 2)
#[2] TRUE

Escribí una función específicamente para esto, que puede comprobar no solo los elementos en un vector, sino también capaz de comprobar si todos los elementos en una lista son idénticos. Por supuesto, también maneja bien los vectores de caracteres y todos los demás tipos de vectores. También tiene un manejo de errores apropiado.

all_identical <- function(x) {
  if (length(x) == 1L) {
    warning("'x' has a length of only 1")
    return(TRUE)
  } else if (length(x) == 0L) {
    warning("'x' has a length of 0")
    return(logical(0))
  } else {
    TF <- vapply(1:(length(x)-1),
                 function(n) identical(x[[n]], x[[n+1]]),
                 logical(1))
    if (all(TF)) TRUE else FALSE
  }
}

Ahora prueba algunos ejemplos.

x <- c(1, 1, 1, NA, 1, 1, 1)
all_identical(x)       ## Return FALSE
all_identical(x[-4])   ## Return TRUE
y <- list(fac1 = factor(c("A", "B")),
          fac2 = factor(c("A", "B"), levels = c("B", "A"))
          )
all_identical(y)     ## Return FALSE as fac1 and fac2 have different level order

En realidad no necesita usar min, mean o max. Basado en la respuesta de Juan:

all(abs(x - x[[1]]) < tolerance)

Aquí una alternativa usando el truco min, max pero para un marco de datos. En el ejemplo estoy comparando columnas, pero el parámetro margin de apply se puede cambiar a 1 para filas.

valid = sum(!apply(your_dataframe, 2, function(x) diff(c(min(x), max(x)))) == 0)

Si valid == 0 entonces todos los elementos son los mismos