Pruebe la igualdad entre todos los elementos de un solo vector

Estoy tratando de probar si todos los elementos de un vector son iguales entre sí. Las soluciones que he encontrado parecen algo indirectas, y ambas implican verificación length().

x <- c(1, 2, 3, 4, 5, 6, 1)  # FALSE
y <- rep(2, times = 7)       # TRUE

Con unique():

length(unique(x)) == 1
length(unique(y)) == 1

Con rle():

length(rle(x)$values) == 1
length(rle(y)$values) == 1

Una solución que me permitiera incluir un valor de tolerancia para evaluar la 'igualdad' entre elementos sería ideal para evitar problemas de la pregunta frecuente 7.31 .

¿Existe una función incorporada para el tipo de prueba que he pasado por alto por completo? identical()y all.equal()compare dos objetos R, para que no funcionen aquí.

Editar 1

A continuación, se muestran algunos resultados de evaluación comparativa. Usando el código:

library(rbenchmark)

John <- function() all( abs(x - mean(x)) < .Machine$double.eps ^ 0.5 )
DWin <- function() {diff(range(x)) < .Machine$double.eps ^ 0.5}
zero_range <- function() {
  if (length(x) == 1) return(TRUE)
  x <- range(x) / mean(x)
  isTRUE(all.equal(x[1], x[2], tolerance = .Machine$double.eps ^ 0.5))
}

x <- runif(500000);

benchmark(John(), DWin(), zero_range(),
  columns=c("test", "replications", "elapsed", "relative"),
  order="relative", replications = 10000)

Con los resultados:

          test replications elapsed relative
2       DWin()        10000 109.415 1.000000
3 zero_range()        10000 126.912 1.159914
1       John()        10000 208.463 1.905251

Entonces parece que diff(range(x)) < .Machine$double.eps ^ 0.5es el más rápido.

Utilizo este método, que compara el mínimo y el máximo, después de dividir por la media:

# Determine if range of vector is FP 0.
zero_range <- function(x, tol = .Machine$double.eps ^ 0.5) {
  if (length(x) == 1) return(TRUE)
  x <- range(x) / mean(x)
  isTRUE(all.equal(x[1], x[2], tolerance = tol))
}

Si estuviera usando esto más en serio, probablemente querría eliminar los valores faltantes antes de calcular el rango y la media.

¿Por qué no simplemente usar la variación?

var(x) == 0

Si todos los elementos de xson iguales, obtendrá una variación de 0.

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

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

es la solución a tu problema.

EDITAR:

Después de ver esta y otras respuestas, y comparar algunas cosas, lo siguiente resulta dos veces más rápido que la respuesta de DWin.

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

Esto es un poco sorprendentemente más rápido que diff(range(x))ya diffque no debería ser muy diferente de -y abscon dos números. Solicitar el rango debe optimizar obteniendo el mínimo y el máximo. Ambos diffy rangeson funciones primitivas. Pero el momento no miente.

> 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 épsilon identical()según sea necesario.

Solo puedes comprobar all(v==v[1])

Como sigo volviendo a esta pregunta una y otra vez, aquí hay una Rcppsolución que generalmente será mucho más rápida que cualquiera de las Rsoluciones si la respuesta es realmente FALSE(porque se detendrá en el momento en que encuentre una falta de coincidencia) y tendrá la misma velocidad como la solución R más rápida si la respuesta es TRUE. Por ejemplo, para el punto de referencia OP, marca system.timeexactamente 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 verificar no solo los elementos en un vector, sino que también es capaz de verificar si todos los elementos de 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 pruebe 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 es necesario utilizar min, mean o max. Basado en la respuesta de John:

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

Aquí una alternativa que usa el truco mínimo, máximo pero para un marco de datos. En el ejemplo, estoy comparando columnas, pero el parámetro de margen de applyse puede cambiar a 1 para las filas.

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

Si valid == 0entonces todos los elementos son iguales