Tek bir vektörün tüm öğeleri arasında eşitliği test edin

Bir vektörün tüm elemanlarının birbirine eşit olup olmadığını test etmeye çalışıyorum. Bulduğum çözümler biraz dolambaçlı görünüyor, her ikisi de kontrol etmeyi içeriyor length().

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

İle unique():

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

İle rle():

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

Öğeler arasında 'eşitliği' değerlendirmek için bir tolerans değeri eklememe izin verecek bir çözüm, SSS 7.31 sorunlarından kaçınmak için ideal olacaktır .

Tamamen gözden kaçırdığım test türü için yerleşik bir işlev var mı? identical()ve all.equal()iki R nesnesini karşılaştırın, böylece burada çalışmazlar.

Düzenle 1

İşte bazı kıyaslama sonuçları. Kodu kullanarak:

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)

Sonuçlarla birlikte:

          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

Yani diff(range(x)) < .Machine$double.eps ^ 0.5en hızlısı gibi görünüyor .

Ortalamaya böldükten sonra min ve maks. Karşılaştıran bu yöntemi kullanıyorum:

# 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))
}

Bunu daha ciddi bir şekilde kullanıyor olsaydınız, aralığı ve ortalamayı hesaplamadan önce muhtemelen eksik değerleri kaldırmak istersiniz.

Neden varyansı kullanmıyorsunuz:

var(x) == 0

Tüm öğeleri xeşitse, bir varyans elde edersiniz 0.

Hepsi sayısal değerlerse, tol sizin toleransınızsa o zaman ...

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

probleminizin çözümü.

DÜZENLE:

Buna ve diğer yanıtlara baktıktan ve birkaç şeyi karşılaştırdıktan sonra, aşağıdakiler DWin yanıtının iki katından daha hızlı çıkıyor.

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

Bu biraz edilenden çok daha kısa olduğunu diff(range(x))beri diffçok farklı olmamalı -ve absiki numaraları ile. Aralığı talep etmek, minimum ve maksimum elde etmeyi optimize etmelidir. Hem diffve rangeilkel işlevlerdir. Ama zamanlama yalan söylemez.

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

Aynı çizgide bir başkası:

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

Kontrol edebilirsin all(v==v[1])

Kullanabilir identical()ve all.equal()ilk öğeyi diğerleriyle karşılaştırarak karşılaştırmayı etkili bir şekilde aşağıdakiler arasında gezdirebilirsiniz:

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> 

Bu şekilde identical(), gerektiği kadar epsilon ekleyebilirsiniz .

Bu soruya defalarca geri dönüp Rcppdurduğum için R, cevabın gerçekten olması durumunda genellikle çözümlerin herhangi birinden çok daha hızlı FALSEolacak (çünkü bir uyuşmazlıkla karşılaştığı anda duracaktır) ve aynı hıza sahip olacak bir çözüm var. Cevap ise en hızlı R çözümü olarak TRUE. Örneğin, OP kıyaslaması için, system.timebu işlevi kullanarak tam olarak 0'da saatler.

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

Ben bir vektör içinde sadece unsurları kontrol edebilirsiniz bunun için özel olarak bir işlev, yazdım, ama bir listedeki tüm unsurları olmadığını kontrol özelliğine sahip olmasını özdeş . Elbette karakter vektörlerini ve diğer tüm vektör türlerini de iyi idare eder. Aynı zamanda uygun hata işlemeye sahiptir.

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
  }
}

Şimdi bazı örnekler deneyin.

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

Gerçekte min, ortalama veya maks kullanmanıza gerek yoktur. John'un cevabına göre:

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

Burada min, max hilesini kullanan ancak bir veri çerçevesi için bir alternatif. Örnekte sütunları karşılaştırıyorum ancak margin parametresi applysatırlar için 1 olarak değiştirilebilir.

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

Eğer valid == 0o zaman tüm unsurları aynıdır