Question

假设我有五个向量：

A<-1:10
B<-1:10
C<-1:10
D<-1:10
E<-1:12

我可以使用相同的（）来一次测试两个。

identical(A,C)

但我想立刻测试所有这些，看看是否有任何不同于其他人。有一个简单的方法吗？

Answer 1

我会选择一个，说A，然后与它进行所有成对比较。

all(sapply(list(B, C, D, E), FUN = identical, A))
# [1]  FALSE

删除all()以查看不相同的

sapply(list(B, C, D, E), FUN = identical, A)
# [1]  TRUE  TRUE  TRUE FALSE

identical应该是可传递的，因此，如果A与C和D相同，则C应与D相同}。

（感谢@docendo discimus提供简化语法。）

Answer 2

首先想到的是在矢量列表上做unique并检查长度。如果有两个或多个不同的向量，则结果列表的长度将大于1.

length(unique(list(A,B,C,D))) == 1
[1] TRUE

length(unique(list(A,B,C,D,E))) == 1
[1] FALSE

Answer 3

另一种选择，只是为了好玩：

Vectorize(identical, 'x')(list(A, B, C, D, E), C)

Answer 4

这很明显，但是：如果有很多元素并且很有可能失败，那么你将希望能够缩短比较。这是一个循环，有一个例子：

A = sample(1e3)
Alist <- replicate(1e6,A,simplify=FALSE)
Alist[[2]][1e3] <- 0

system.time({brkres <- {
  ok=TRUE
  for (i in seq_along(Alist)) if( !identical(Alist[[1]],Alist[[i]]) ){
    ok=FALSE
    break
  }
  ok
}})
#    user  system elapsed 
#       0       0       0 

system.time({allres <- all(sapply(Alist[-1], FUN = identical, Alist[[1]]))})
#    user  system elapsed 
#    1.66    0.03    1.68

如果您跳过Alist[[2]][1e3] <- 0行，以便它们全部相同，则会占用相同的时间。

Answer 5

使用Rcpp的最快捷简单的解决方案：

#include <Rcpp.h>
using namespace Rcpp;

inline bool same(SEXP a, SEXP b) {
    return R_compute_identical(a, b, 0);
}

// [[Rcpp::export]]
bool identical_impl(List x) {
    std::size_t n = x.size();
    for (std::size_t i = 1; i < n; ++i)
        if (!same(x[0], x[i])) return false;
    return true;
}

/*** R
identical2 <- function(...) {
    identical_impl(list(...))
}
*/

其他解决方案的一些基准：

A <- 1:10
B <- 1:10
C <- 1:10
D <- 1:10
E <- 1:12
identical2 <- function(...) {
    identical_impl(list(...))
}
identical3 <- function(...) {
    length(unique(list(...))) == 1L
}
identical4 <- function(...) {
    l <- list(...)
    all(vapply(l[-1], l[[1]], FUN = identical,
               FUN.VALUE = logical(1L), USE.NAMES = FALSE))
}
identical5 <- function(...) {
    l <- list(...)
    Vectorize(identical, 'x')(l[-1], l[[1L]])
}
identical6 <- function(...) {
    l <- list(...)
    for (i in seq_along(l)) {
        if (!identical(l[[1]], l[[i]])) return(FALSE)
    }
    return(TRUE)
}
identical7 <- function(...) {
    l <- list(...)
    for (i in seq_along(l)) {
        for (j in seq_along(l)) {
            if (i >= j) next
            if (!identical(l[[1]], l[[i]])) return(FALSE)
        }
    }
    return(TRUE)
}
library(microbenchmark)
microbenchmark(
    identical2(A, B, C, D, E),
    identical3(A, B, C, D, E),
    identical4(A, B, C, D, E),
    identical5(A, B, C, D, E),
    identical6(A, B, C, D, E),
    identical7(A, B, C, D, E))

结果：

Unit: microseconds
                     expr    min      lq     mean  median       uq     max neval   cld
identical2(A, B, C, D, E)  3.401  4.3065  5.32136  5.1245   5.5420  21.529   100 a    
identical3(A, B, C, D, E)  6.480  7.8675  9.20970  8.3875   9.0175  26.739   100  b   
identical4(A, B, C, D, E) 12.233 13.5680 15.48014 14.7755  15.5455  48.333   100   c  
identical5(A, B, C, D, E) 90.177 93.1480 98.79570 95.2685 103.2765 178.657   100     e
identical6(A, B, C, D, E) 10.683 12.0650 13.43184 12.6820  13.4060  22.314   100   c  
identical7(A, B, C, D, E) 28.202 31.0800 34.97819 32.4630  39.4960  68.902   100    d

Answer 6

我遇到了同样的问题，但决定实施基于Reduce的解决方案和基于双for循环的解决方案。

功能：

all_elements_the_same = function(list) {

  #func to compare with
  comparison_func = function(x, y) {
    if (!identical(x, y)) stop() #stop function if it finds a non-identical pair
    y #return second element
  }

  #run comparisons
  trial = try({
    Reduce(f = comparison_func, x = list, init = list[[1]])
  }, silent = T)

  #return
  if (class(trial) == "try-error") return(F)
  T
}

all_elements_the_same2 = function(list, ignore_names = F) {
  #double loop solution
  for (i in seq_along(list)) {
    for (j in seq_along(list)) {
      #skip if comparing to self or if comparison already done
      if (i >= j) next

      #check
      if (!identical(list[[i]], list[[j]])) return(F)
    }
  }
  T
}

测试对象：

l_testlist_ok = list(1:3, 1:3, 1:3, 1:3, 1:3, 1:3)
l_testlist_bad = list(1:3, 1:3, 1:4, 1:3, 1:3, 1:3)
l_testlist_bad2 = list(1:3, 1:3, 1:4, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3, 1:3)

测试功能：

> all_elements_the_same(l_testlist_ok)
[1] TRUE
> all_elements_the_same(l_testlist_bad)
[1] FALSE
> all_elements_the_same(l_testlist_bad2)
[1] FALSE
> all_elements_the_same2(l_testlist_ok)
[1] TRUE
> all_elements_the_same2(l_testlist_bad)
[1] FALSE
> all_elements_the_same2(l_testlist_bad2)
[1] FALSE

测试时间使用：

> library(microbenchmark)
> microbenchmark(all_elements_the_same(l_testlist_ok),
+ all_elements_the_same(l_testlist_bad),
+ all_elements_the_same(l_testlist_bad2),
+ all_elements_the_same2(l_testlist_ok),
+ all_elements_the_same2(l_testlist_bad),
+ all_elements_the_same2(l_testlist_bad2), times = 1e4)
Unit: microseconds
                                    expr    min      lq       mean  median      uq      max neval
    all_elements_the_same(l_testlist_ok) 19.310  25.454  28.309016  26.917  28.380 1003.228 10000
   all_elements_the_same(l_testlist_bad) 93.624 100.938 108.890823 103.863 106.497 3130.807 10000
  all_elements_the_same(l_testlist_bad2) 93.331 100.938 107.963741 103.863 106.497 1181.404 10000
   all_elements_the_same2(l_testlist_ok) 48.275  53.541  57.334095  55.881  57.930  926.866 10000
  all_elements_the_same2(l_testlist_bad)  6.144   7.315   8.437603   7.900   8.778  998.839 10000
 all_elements_the_same2(l_testlist_bad2)  6.144   7.315   8.564780   8.192   8.778 1323.594 10000

显然，try部分显着减缓了它的速度。如果有一个非常大的对象，它仍然可以节省使用Reduce变体的时间，但对于较小的对象，双for循环似乎是可行的方法。

在R中使用具有多个向量的same（）

6 个答案: