Kiểm tra sự bình đẳng giữa tất cả các phần tử của một vectơ duy nhất

Tôi đang cố gắng kiểm tra xem tất cả các phần tử của vectơ có bằng nhau hay không. Các giải pháp tôi đưa ra có vẻ hơi vòng vo, cả hai đều liên quan đến việc kiểm tra length().

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

Với unique():

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

Với rle():

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

Một giải pháp cho phép tôi bao gồm một giá trị dung sai để đánh giá 'sự bình đẳng' giữa các phần tử sẽ là lý tưởng để tránh các vấn đề Câu hỏi thường gặp 7.31 .

Có một chức năng tích hợp cho loại bài kiểm tra mà tôi đã hoàn toàn bỏ qua không? identical()và all.equal()so sánh hai đối tượng R, vì vậy chúng sẽ không hoạt động ở đây.

Chỉnh sửa 1

Dưới đây là một số kết quả điểm chuẩn. Sử dụng mã:

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)

Với kết quả:

          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

Vì vậy, nó có vẻ như diff(range(x)) < .Machine$double.eps ^ 0.5là nhanh nhất.

Tôi sử dụng phương pháp này, so sánh giá trị tối thiểu và giá trị lớn nhất, sau khi chia cho giá trị trung bình:

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

Nếu bạn đang sử dụng điều này nghiêm túc hơn, bạn có thể muốn xóa các giá trị bị thiếu trước khi tính toán phạm vi và giá trị trung bình.

Tại sao không chỉ đơn giản sử dụng phương sai:

var(x) == 0

Nếu tất cả các phần tử của xbằng nhau, bạn sẽ nhận được phương sai của 0.

Nếu chúng đều là giá trị số thì nếu tol là dung sai của bạn thì ...

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

là giải pháp cho vấn đề của bạn.

BIÊN TẬP:

Sau khi xem xét câu trả lời này, và các câu trả lời khác, và đo điểm chuẩn một số điều, phần sau sẽ nhanh hơn câu trả lời DWin gấp đôi.

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

Điều này nhanh hơn một chút đáng ngạc nhiên diff(range(x))vì diffkhông nên khác nhiều so với -và absvới hai con số. Yêu cầu phạm vi phải tối ưu hóa để nhận được tối thiểu và tối đa. Cả hai diffvà rangeđều là các hàm nguyên thủy. Nhưng thời gian không nói dối.

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

Khác cùng dòng:

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

Bạn có thể sử dụng identical()và all.equal()bằng cách so sánh yếu tố đầu tiên với tất cả các yếu tố khác, quét qua so sánh một cách hiệu quả:

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> 

Bằng cách đó, bạn có thể thêm bất kỳ epsilon nào vào identical()nếu cần.

Bạn chỉ cần kiểm tra all(v==v[1])

Vì tôi tiếp tục quay lại câu hỏi này lặp đi lặp lại, đây là một Rcppgiải pháp nói chung sẽ nhanh hơn nhiều so với bất kỳ Rgiải pháp nào nếu câu trả lời thực sự là FALSE(vì nó sẽ dừng lại ngay khi nó gặp sự không khớp) và sẽ có cùng tốc độ là giải pháp R nhanh nhất nếu câu trả lời là TRUE. Ví dụ đối với điểm chuẩn OP, system.timeđồng hồ ở chính xác 0 bằng cách sử dụng chức năng này.

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

Tôi đã viết một hàm dành riêng cho việc này, hàm này có thể kiểm tra không chỉ các phần tử trong một vectơ mà còn có thể kiểm tra xem tất cả các phần tử trong danh sách có giống hệt nhau hay không . Tất nhiên nó cũng xử lý tốt các vectơ ký tự và tất cả các loại vectơ khác. Nó cũng có xử lý lỗi thích hợp.

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

Bây giờ hãy thử một số ví dụ.

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

Bạn thực sự không cần sử dụng giá trị tối thiểu, trung bình hoặc tối đa. Dựa trên câu trả lời của John:

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

Đây là một giải pháp thay thế sử dụng thủ thuật tối thiểu, tối đa nhưng dành cho khung dữ liệu. Trong ví dụ, tôi đang so sánh các cột nhưng tham số lề từ applycó thể được thay đổi thành 1 cho các hàng.

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

Nếu valid == 0sau đó tất cả các phần tử đều giống nhau