जाँचें कि क्या संख्या पूर्णांक है

Question

मुझे यह जानकर आश्चर्य हुआ कि संख्या पूर्णांक है या नहीं, यह जांचने के लिए R एक काम नहीं करता है।

is.integer(66) # FALSE

मदद फ़ाइलों को चेतावनी देते हैं :

is.integer(x)x पूर्णांक संख्याओं का परीक्षण नहीं करता है ! उस के लिए round, is.wholenumber(x)उदाहरण में फ़ंक्शन के रूप में उपयोग करें ।

उदाहरण में "वर्कअराउंड" के रूप में यह कस्टम फ़ंक्शन है

is.wholenumber <- function(x, tol = .Machine$double.eps^0.5)  abs(x - round(x)) < tol
is.wholenumber(1) # is TRUE

यदि मुझे पूर्णांक की जांच करने के लिए एक फ़ंक्शन लिखना होगा, तो मुझे लगता है कि मैंने उपरोक्त टिप्पणियों को नहीं पढ़ा है, मैं एक फ़ंक्शन लिखूंगा जो कुछ की तर्ज पर जाना होगा

check.integer <- function(x) {
    x == round(x)
}

मेरा दृष्टिकोण कहाँ असफल होगा? यदि आप मेरे काल्पनिक जूते में होते हैं तो आपके आसपास क्या काम होगा?

Comments

मुझे आशा है कि अगर round(x)इसे ठीक से लागू किया जाता है, तो इसे पूर्णांक पर लागू करने का परिणाम हमेशा पूर्णांक होगा ...

— स्टीफन

R cran.r-project.org/doc/FAQ/…

— रिची कॉटन

> check.integer (9.0) [1] सही नहीं है।

— पेंग जूल

@PengPeng, VitoshKa ने इसे स्वीकार किए गए उत्तर में तय किया।

— रोमन लुसट्रिक

मुझे लगता है कि पूर्णांक की गणितीय और कम्प्यूटेशनल अवधारणाओं के बारे में एक भ्रम है। फ़ंक्शन is.integerकम्प्यूटेशनल अवधारणा की जांच करता है, check.integerउपयोगकर्ता फ़ंक्शन गणितीय बिंदु को देखता है।

— जोहो डैनियल

Answer 1

एक अन्य विकल्प आंशिक भाग की जांच करना है:

x%%1==0

या, यदि आप एक निश्चित सहिष्णुता के भीतर जांचना चाहते हैं:

min(abs(c(x%%1, x%%1-1))) < tol

Comments

क्या सहिष्णुता-जाँच का सुझाव वास्तव में काम करता है ?? x <- 5-1e-8; x%%1देता 0.9999999 (अर्थ होगा जो अगर tol==1e-5उदाहरण के लिए) है कि xहै नहीं एक पूर्णांक।

— बेन बोल्कर

@BenBolker अच्छा पकड़, यह मेरे विचार से सकारात्मक गड़बड़ियों के लिए काम करता है। मैंने इसे एक वैकल्पिक समाधान में बदल दिया है जो काम करना चाहिए।

— जेम्स

@ नाम, मुझे लगता है कि यह अन्यथा के min(abs(c(x%%1, x%%1-1))) < tolबजाय होना चाहिए abs(min(x%%1, x%%1-1)) < tol, आप FALSEकिसी भी पूर्णांक के लिए प्राप्त करेंगे ...

— कैथेड्रल

इसमें गलत क्या है as.integer(x) == x? यह 3 या 3.0 को अस्वीकार नहीं is.integer(x)करेगा, और यह 3.1 को पकड़ लेगा।

— गाबी

Answer 2

यहाँ सरल कार्यों और कोई हैक का उपयोग कर समाधान है:

all.equal(a, as.integer(a))

क्या अधिक है, आप एक बार में एक पूरे वेक्टर का परीक्षण कर सकते हैं, यदि आप चाहें। यहाँ एक समारोह है:

testInteger <- function(x){
  test <- all.equal(x, as.integer(x), check.attributes = FALSE)
  if(test == TRUE){ return(TRUE) }
  else { return(FALSE) }
}

आप इसे *applyवैक्टर, मैट्रेस आदि के मामले में उपयोग करने के लिए बदल सकते हैं ।

Comments

अंतिम if elseबस के साथ किया जा सकता है isTRUE(test)। दरअसल, आपको सभी if elseखंडों और returnकथनों को बदलने की जरूरत है क्योंकि R अपने आप अंतिम मूल्यांकन का परिणाम देता है।

— गैविन सिम्पसन

testInteger(1.0000001)[१] FALSE testInteger(1.00000001)[१] सही

— पैट्रिक

all(a == as.integer(a))इस समस्या के आसपास हो जाता है! '

— एलेक्स

यह ठीक से काम नहीं कर रहा है! निम्नलिखित प्रति-उदाहरण देखें: frac_test <- 1 / (1-0.98), all.equal (frac_test, as.integer (frac_test)), isTRUE (all.equal (frac_test, as.integer (frac_test)))

— tstudio

Answer 3

आर भाषा प्रलेखन पढ़ना, as.integerसंख्या के साथ यह करने के लिए और अधिक है कि संख्या कैसे संग्रहीत की जाती है अगर यह व्यावहारिक रूप से पूर्णांक के बराबर है। is.integerयदि संख्या पूर्णांक के रूप में घोषित की जाती है तो परीक्षण। आप Lइसके बाद एक पूर्णांक घोषित कर सकते हैं ।

> is.integer(66L)
[1] TRUE
> is.integer(66)
[1] FALSE

इसके अलावा फ़ंक्शन roundएक घोषित पूर्णांक लौटाएगा, जो कि आप के साथ कर रहे हैं x==round(x)। इस दृष्टिकोण के साथ समस्या यह है कि आप व्यावहारिक रूप से पूर्णांक मानते हैं। उदाहरण परीक्षण तुल्यता के लिए कम परिशुद्धता का उपयोग करता है।

> is.wholenumber(1+2^-50)
[1] TRUE
> check.integer(1+2^-50)
[1] FALSE

तो आपके आवेदन के आधार पर आप इस तरह से परेशानी में पड़ सकते हैं।

Comments

दूसरी पंक्ति कहती है "as.integer परीक्षण यदि संख्या को पूर्णांक घोषित किया जाता है।" लेकिन मुझे पूरा यकीन है कि आपका मतलब "is.integer" है। यह केवल एक चरित्र का संपादन है इसलिए मैं इसे आसानी से नहीं बदल सकता।

— पीटरवर्मोंट

Answer 4

यहाँ एक है, जाहिरा तौर पर विश्वसनीय तरीका:

check.integer <- function(N){
    !grepl("[^[:digit:]]", format(N,  digits = 20, scientific = FALSE))
}

check.integer(3243)
#TRUE
check.integer(3243.34)
#FALSE
check.integer("sdfds")
#FALSE

यह समाधान वैज्ञानिक संकेतन में पूर्णांक के लिए भी अनुमति देता है:

> check.integer(222e3)
[1] TRUE

Comments

यह मेरे लिए बहुत विश्वसनीय नहीं लगता: check.integer(1e4)TRUE है, जबकि check.integer(1e5)FALSE है।

— 18

-1 यह is.wholenumberअन्य उत्तरों में उपलब्ध कराए गए किसी भी समाधान से भी बदतर है। ये अलग नहीं होना चाहिए check.integer(1e22); check.integer(1e23):। आप इसे ठीक करने के लिए रीगेक्स को स्पष्ट रूप से बदल सकते हैं, लेकिन यह दृष्टिकोण भयानक है। (टिप्पणी इंस्टॉलर पैकेज में एट्रिब्यूशन से आती है।)

— जोशुआ उलरिच

@ पैट्रिक, मैं देख रहा हूं। यह डिफ़ॉल्ट अंक का तर्क है। format(40, scientific = FALSE, digits = 20)इसके बजाय का उपयोग करें । मैंने जवाब अपडेट कर दिया है। इसे जगह देने के लिए धन्यवाद।

— वितोषका २ Vit

@PatrickT आप मशीन आश्रित गोलाई त्रुटियों के दायरे में हैं। उस संबंध में मेरा समाधान वही है जो स्वीकृत है 1.0000000000000001 == 1L [1] TRUE। लेकिन मेरा समाधान बेहतर है यदि आप पहले से ही स्ट्रिंग रूप में एक संख्या प्राप्त करते हैंcheck.integer("1000000000000000000000000000000000001") [1] TRUE

— VitoshKa

@VitoshKa को आपका जवाब पसंद आया! हालाँकि एक बिंदु है कि आप चूक गए थे, दशमलव अंक के बिना नकारात्मक संख्या भी पूर्णांक है;) मैंने तदनुसार अपने कोड को संशोधित किया।

— मेहरद महमूदियन

Answer 5

ऐसा प्रतीत होता है कि आपको कुछ त्रुटि सहिष्णुता को शामिल करने की आवश्यकता नहीं है। यदि सभी पूर्णांक पूर्णांक के रूप में आए, तो इसकी आवश्यकता नहीं होगी, हालांकि कभी-कभी वे अंकगणित संचालन के परिणामस्वरूप आते हैं जो कुछ परिशुद्धता को ढीला करते हैं। उदाहरण के लिए:

> 2/49*49
[1] 2
> check.integer(2/49*49)
[1] FALSE 
> is.wholenumber(2/49*49)
[1] TRUE

ध्यान दें कि यह आर की कमजोरी नहीं है, सभी कंप्यूटर सॉफ़्टवेयर में कुछ सीमाएं सटीक हैं।

Comments

बस अगर कुछ लोगों को यहाँ नहीं मिला तो क्या हुआ ... यदि आप as.integer (2/49 * 49) दर्ज करते हैं तो आपको 1 मिलता है !! [BTW, यह कभी इतना निराशाजनक है कि R प्रारंभिक गणना के परिणाम को 2.0 के रूप में प्रस्तुत नहीं करता है ताकि यह दर्शाया जा सके कि मूल्य में कुछ दशमलव घटक है) देखें ... stackoverflow.com/questions/1535021/…

— John

Answer 6

से Hmisc::spss.get:

all(floor(x) == x, na.rm = TRUE)

बहुत सुरक्षित विकल्प, IMHO, क्योंकि यह मशीन सटीक मुद्दे को "बायपास" करता है। यदि आप कोशिश करते हैं is.integer(floor(1)), तो आपको मिलेगा FALSE। BTW, आपके पूर्णांक को पूर्णांक के रूप में सहेजा नहीं जाएगा यदि यह .Machine$integer.maxमान से बड़ा है , जो कि डिफ़ॉल्ट रूप से 2147483647 है, इसलिए या तो integer.maxमूल्य बदलें , या वैकल्पिक जांच करें ...

Comments

अगर x <- sqrt(2)^2, फिर all(floor(x) == x, na.rm = TRUE)लौटते हैंFALSE

— कोराडो

Answer 7

अगर हालत की तरह आप सरल का उपयोग कर सकते हैं:

if(round(var) != var)­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­

Answer 8

R में, क्या कोई संख्या संख्यात्मक है या पूर्णांक वर्ग फ़ंक्शन द्वारा निर्धारित किया जा सकता है। आम तौर पर सभी संख्याओं को संख्यात्मक के रूप में संग्रहीत किया जाता है और संख्या को पूर्णांक के रूप में स्पष्ट रूप से परिभाषित करने के लिए हमें संख्या के बाद 'एल' को निर्दिष्ट करने की आवश्यकता होती है।

उदाहरण:

x <- 1

वर्ग (एक्स)

[१] "संख्यात्मक"

एक्स <- 1 एल

वर्ग (एक्स)

[१] "पूर्णांक"

मुझे उम्मीद है कि यह वही है जिसकी आवश्यकता थी। धन्यवाद :)

Answer 9

[अद्यतन] ================================================== ===============

नीचे दिए गए [OLD] उत्तर का सम्मान करें, मुझे पता चला है कि इसने काम किया क्योंकि मैंने सभी संख्याओं को एक ही परमाणु वेक्टर में रखा है; उनमें से एक चरित्र था, इसलिए हर एक पात्र बन गया।

यदि हम एक सूची का उपयोग करते हैं (इसलिए, ज़बरदस्ती नहीं होती है) सभी परीक्षण सही ढंग से पास होते हैं 1/(1 - 0.98), लेकिन एक: जो एक रहता है numeric। ऐसा इसलिए है क्योंकि tolपैरामीटर डिफ़ॉल्ट रूप से है 100 * .Machine$double.epsऔर यह संख्या 50उस के दोगुने से बहुत कम है। तो, मूल रूप से, इस तरह की संख्याओं के लिए, हमें अपनी सहनशीलता तय करनी होगी!

इसलिए यदि आप चाहते हैं कि सभी परीक्षा हो जाए TRUE, तो आप कर सकते हैंassertive::is_whole_number(x, tol = 200 * .Machine$double.eps)

वैसे भी, मैं पुष्टि करता हूं कि आईएमओ मुखरता सबसे अच्छा समाधान है।

इस [UPDATE] के लिए एक रिप्रेक्स के नीचे।

expect_trues_c <- c(
  cl = sqrt(2)^2,
  pp = 9.0,
  t = 1 / (1 - 0.98),
  ar0 = 66L,
  ar1 = 66,
  ar2 = 1 + 2^-50,
  v = 222e3,
  w1 = 1e4,
  w2 = 1e5,
  v2 = "1000000000000000000000000000000000001",
  an = 2 / 49 * 49,
  ju1 = 1e22,
  ju2 = 1e24,
  al = floor(1),
  v5 = 1.0000000000000001 # this is under machine precision!
)

str(expect_trues_c)
#>  Named chr [1:15] "2" "9" "50" "66" "66" "1" "222000" "10000" "1e+05" ...
#>  - attr(*, "names")= chr [1:15] "cl" "pp" "t" "ar0" ...
assertive::is_whole_number(expect_trues_c)
#> Warning: Coercing expect_trues_c to class 'numeric'.
#>                      2                      9                     50 
#>                   TRUE                   TRUE                   TRUE 
#>                     66                     66                      1 
#>                   TRUE                   TRUE                   TRUE 
#>                 222000                  10000                 100000 
#>                   TRUE                   TRUE                   TRUE 
#>                  1e+36                      2                  1e+22 
#>                   TRUE                   TRUE                   TRUE 
#> 9.9999999999999998e+23                      1                      1 
#>                   TRUE                   TRUE                   TRUE



expect_trues_l <- list(
  cl = sqrt(2)^2,
  pp = 9.0,
  t = 1 / (1 - 0.98),
  ar0 = 66L,
  ar1 = 66,
  ar2 = 1 + 2^-50,
  v = 222e3,
  w1 = 1e4,
  w2 = 1e5,
  v2 = "1000000000000000000000000000000000001",
  an = 2 / 49 * 49,
  ju1 = 1e22,
  ju2 = 1e24,
  al = floor(1),
  v5 = 1.0000000000000001 # this is under machine precision!
)

str(expect_trues_l)
#> List of 15
#>  $ cl : num 2
#>  $ pp : num 9
#>  $ t  : num 50
#>  $ ar0: int 66
#>  $ ar1: num 66
#>  $ ar2: num 1
#>  $ v  : num 222000
#>  $ w1 : num 10000
#>  $ w2 : num 1e+05
#>  $ v2 : chr "1000000000000000000000000000000000001"
#>  $ an : num 2
#>  $ ju1: num 1e+22
#>  $ ju2: num 1e+24
#>  $ al : num 1
#>  $ v5 : num 1
assertive::is_whole_number(expect_trues_l)
#> Warning: Coercing expect_trues_l to class 'numeric'.
#> There was 1 failure:
#>   Position              Value      Cause
#> 1        3 49.999999999999957 fractional
assertive::is_whole_number(expect_trues_l, tol = 200 * .Machine$double.eps)
#> Warning: Coercing expect_trues_l to class 'numeric'.
#>     2.0000000000000004                      9     49.999999999999957 
#>                   TRUE                   TRUE                   TRUE 
#>                     66                     66     1.0000000000000009 
#>                   TRUE                   TRUE                   TRUE 
#>                 222000                  10000                 100000 
#>                   TRUE                   TRUE                   TRUE 
#>                  1e+36     1.9999999999999998                  1e+22 
#>                   TRUE                   TRUE                   TRUE 
#> 9.9999999999999998e+23                      1                      1 
#>                   TRUE                   TRUE                   TRUE



expect_falses <- list(
  bb = 5 - 1e-8,
  pt1 = 1.0000001,
  pt2 = 1.00000001,
  v3 = 3243.34,
  v4 = "sdfds"
)

str(expect_falses)
#> List of 5
#>  $ bb : num 5
#>  $ pt1: num 1
#>  $ pt2: num 1
#>  $ v3 : num 3243
#>  $ v4 : chr "sdfds"
assertive::is_whole_number(expect_falses)
#> Warning: Coercing expect_falses to class 'numeric'.
#> Warning in as.this_class(x): NAs introduced by coercion
#> There were 5 failures:
#>   Position              Value      Cause
#> 1        1 4.9999999900000001 fractional
#> 2        2 1.0000001000000001 fractional
#> 3        3 1.0000000099999999 fractional
#> 4        4 3243.3400000000001 fractional
#> 5        5               <NA>    missing
assertive::is_whole_number(expect_falses, tol = 200 * .Machine$double.eps)
#> Warning: Coercing expect_falses to class 'numeric'.

#> Warning: NAs introduced by coercion
#> There were 5 failures:
#>   Position              Value      Cause
#> 1        1 4.9999999900000001 fractional
#> 2        2 1.0000001000000001 fractional
#> 3        3 1.0000000099999999 fractional
#> 4        4 3243.3400000000001 fractional
#> 5        5               <NA>    missing

^{2019-07-23 को रेप्रेक्स पैकेज (v0.3.0) द्वारा बनाया गया}

[OLD] ================================================== ==================

IMO सबसे अच्छा समाधान assertiveपैकेज से आता है (जो, फिलहाल, इस थ्रेड में सभी सकारात्मक और नकारात्मक उदाहरणों को हल करें):

are_all_whole_numbers <- function(x) {
  all(assertive::is_whole_number(x), na.rm = TRUE)
}

are_all_whole_numbers(c(
  cl = sqrt(2)^2,
  pp = 9.0,
  t = 1 / (1 - 0.98),
  ar0 = 66L,
  ar1 = 66,
  ar2 = 1 + 2^-50,
  v = 222e3,
  w1 = 1e4,
  w2 = 1e5,
  v2 = "1000000000000000000000000000000000001",
  an = 2 / 49 * 49,
  ju1 = 1e22,
  ju2 = 1e24,
  al = floor(1),
  v5 = 1.0000000000000001 # difference is under machine precision!
))
#> Warning: Coercing x to class 'numeric'.
#> [1] TRUE

are_all_not_whole_numbers <- function(x) {
  all(!assertive::is_whole_number(x), na.rm = TRUE)
}

are_all_not_whole_numbers(c(
  bb = 5 - 1e-8,
  pt1 = 1.0000001,
  pt2 = 1.00000001,
  v3 = 3243.34,
  v4 = "sdfds"
))
#> Warning: Coercing x to class 'numeric'.
#> Warning in as.this_class(x): NAs introduced by coercion
#> [1] TRUE

^{2019-07-23 को रेप्रेक्स पैकेज (v0.3.0) द्वारा बनाया गया}

Answer 10

यदि आप अपना स्वयं का फ़ंक्शन नहीं लिखना चाहते हैं, तो check.integerपैकेज इंस्टालर से प्रयास करें । वर्तमान में यह VitoshKa के उत्तर का उपयोग करता है ।

check.numeric(v, only.integer=TRUE)पैकेज वेरहैंडल से भी प्रयास करें , जिसमें वेक्टर होने का लाभ है।

Answer 11

एक बार भी उपयोग कर सकते हैं dplyr::near:

library(dplyr)

near(a, as.integer(a))

यह किसी भी वेक्टर पर लागू होता है a, और इसमें एक वैकल्पिक सहिष्णुता पैरामीटर होता है।

Answer 12

मुझे यकीन नहीं है कि आप क्या हासिल करने की कोशिश कर रहे हैं। लेकिन यहाँ कुछ विचार हैं:
1. पूर्णांक में परिवर्तित करें:
num = as.integer(123.2342)
2. जांचें कि क्या एक चर पूर्णांक है:
is.integer(num)
typeof(num)=="integer"

Comments

मैं सिर्फ यह सुनिश्चित कर रहा हूं कि उपयोगकर्ता एक उपयुक्त संख्या में प्रवेश करें - हम "विषयों" की संख्या के बारे में बात कर रहे हैं, जो केवल एक पूर्णांक हो सकता है।

— 17:37 पर रोमन लुसट्रिक