एक वेक्टर

Question

के सभी तत्वों के बीच समानता के लिए परीक्षण मैं परीक्षण करने की कोशिश कर रहा हूं कि वेक्टर के सभी तत्व एक-दूसरे के बराबर हैं या नहीं। जिन समाधानों के साथ मैं आया हूं, वे कुछ हद तक चौराहे लगते हैं, जिनमें length() की जांच शामिल है।

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

unique() के साथ:

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

rle() के साथ:

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

एक समाधान है कि मुझे तत्वों के बीच 'समानता' का आकलन करने के लिए एक सहिष्णुता मूल्य शामिल FAQ 7.31 से बचने के लिए आदर्श होगा दिया जाएगा मुद्दे।

क्या परीक्षण के प्रकार के लिए एक अंतर्निहित फ़ंक्शन है जिसे मैंने पूरी तरह अनदेखा कर दिया है? identical() और all.equal() दो आर वस्तुओं की तुलना करें, इसलिए वे यहां काम नहीं करेंगे।

संपादित करें 1

यहाँ कुछ बेंच मार्किंग परिणाम हैं। परिणाम के साथ

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) 

: कोड का उपयोग करना

  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 

तो यह लग रहा है diff(range(x)) < .Machine$double.eps^0.5 की तरह सबसे तेज है।

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> 

इस तरह आप के रूप में की जरूरत के लिए किसी भी identical() एप्सिलॉन जोड़ सकते हैं:

Answer 1

मैं इस विधि है, जो न्यूनतम और अधिकतम तुलना मतलब से विभाजित करने के बाद, का उपयोग करें:

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

यदि आप उपयोग कर रहे थे यह अधिक गंभीरता से, आप सीमा और माध्य की गणना करने से पहले लापता मूल्यों को हटाना चाहते हैं।

Answer 2

आप सभी दूसरों के लिए पहला तत्व की तुलना, प्रभावी रूप से भर में तुलना व्यापक द्वारा identical() और all.equal() उपयोग कर सकते हैं।

Answer 3

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

उसी तर्ज पर एक और

:

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

Answer 4

वे तो सभी संख्यात्मक मान रहे हैं, तो सहने अपने सहिष्णुता फिर ...

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

आपकी समस्या का हल है।

संपादित करें:

इस पर देख रहे हैं, और अन्य उत्तर, और कुछ बातें निम्नलिखित DWin जवाब के रूप में दो बार के रूप में तेजी से बाहर के ऊपर आता है बेंचमार्किंग के बाद।

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

इसमें कुछ समय में आश्चर्यजनक रूप से तेजी से diff(range(x))diff के बाद से बहुत अलग हो - से और दो नंबर के साथ abs नहीं मानना ​​चाहिए। सीमा का अनुरोध करना न्यूनतम और अधिकतम प्राप्त करने के अनुकूल होना चाहिए। diff और range दोनों प्राचीन कार्य हैं। लेकिन समय झूठ नहीं बोलता है।

Answer 5

जब से मैं अधिक से अधिक इस सवाल सेवाएं लेने आते हैं, यहाँ एक Rcpp समाधान है कि आम तौर पर बहुत ज्यादा R समाधान के किसी भी तुलना में तेजी से हो सकता है अगर इस सवाल का जवाब वास्तव में FALSE है (क्योंकि यह पल बंद हो जाएगा यह एक बेमेल का सामना करना पड़ता) और यदि उत्तर TRUE है तो सबसे तेज़ आर समाधान के समान गति होगी। उदाहरण के लिए ओपी बेंचमार्क के लिए, system.time इस फ़ंक्शन का उपयोग करके बिल्कुल 0 पर घड़ियों।

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 

Answer 6

आपको वास्तव में न्यूनतम, माध्य या अधिकतम उपयोग करने की आवश्यकता नहीं है। जॉन जवाब के आधार पर:

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

Answer 7

मैं इसके लिए विशेष रूप से एक समारोह में लिखा था, एक सदिश में न केवल तत्वों की जांच कर सकते हैं, लेकिन पता चल सके कि एक सूची के सभी तत्वों समान हैं की भी सक्षम। बेशक यह चरित्र वैक्टर और अन्य सभी प्रकार के वेक्टर अच्छी तरह से संभालता है। इसमें उचित त्रुटि प्रबंधन भी है।

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

अब कुछ उदाहरणों को आजमाएं।

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 

Answer 8

यहां न्यूनतम, अधिकतम चाल का उपयोग करने वाला एक विकल्प है लेकिन डेटा फ्रेम के लिए। उदाहरण में मैं कॉलम की तुलना कर रहा हूं लेकिन apply से मार्जिन पैरामीटर पंक्तियों के लिए 1 में बदला जा सकता है।

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

valid == 0 तो सभी तत्वों को कर रहे हैं एक ही

Answer 9

क्यों बस विचरण का उपयोग नहीं:

var(x) == 0 

सभी x के तत्वों के बराबर हैं, तो आप 0 के विचरण मिल जाएगा ।