সংখ্যাটি পূর্ণসংখ্যা কিনা তা পরীক্ষা করে দেখুন


104

আমি অবাক হয়ে জানতে পেরেছিলাম যে সংখ্যাটি পূর্ণসংখ্যা কিনা তা পরীক্ষা করতে আর কোনও কার্যকর ফাংশন নিয়ে আসে না।

is.integer(66) # FALSE

সাহায্যের ফাইল সতর্ক :

is.integer(x)x পূর্ণসংখ্যার সংখ্যা রয়েছে কিনা তা পরীক্ষা করে না ! তার জন্য, উদাহরণ roundহিসাবে ফাংশন হিসাবে ব্যবহার করুন is.wholenumber(x)

উদাহরণটিতে একটি "workaround" হিসাবে এই কাস্টম ফাংশন আছে

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

আমার পন্থা কোথায় ব্যর্থ হবে? আপনি যদি আমার অনুমানের জুতোতে থাকতেন তবে আপনার চারপাশের কী কাজ হবে?


আমি আশাবাদী যে যদি round(x)সঠিকভাবে প্রয়োগ করা হয় তবে এটি পূর্ণসংখ্যার সাথে প্রয়োগের ফলাফল সর্বদা সেই পূর্ণসংখ্যার ...
স্টিফেন


5
> check.integer (9.0) [1] সত্য নয়।
পেং পেং

@ পেংপেং, বিতোষকা এটি গৃহীত উত্তরে স্থির করেছেন।
রোমান Luštrik

4
আমি মনে করি পূর্ণসংখ্যার গাণিতিক এবং গণনা সংক্রান্ত ধারণা সম্পর্কে একটি বিভ্রান্তি রয়েছে। ফাংশন is.integerগণনা ধারণা পরীক্ষা করে, check.integerব্যবহারকারী ফাংশন গাণিতিক দর্শন পরীক্ষা করে।
জোও ড্যানিয়েল

উত্তর:


126

আর একটি বিকল্প হ'ল ভগ্নাংশের অংশটি পরীক্ষা করা:

x%%1==0

বা, যদি আপনি একটি নির্দিষ্ট সহনশীলতার মধ্যে পরীক্ষা করতে চান:

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

1
সহনশীলতা-পরীক্ষার পরামর্শটি আসলেই কাজ করে ?? x <- 5-1e-8; x%%1দেয় 0.9999999 (সূচিত করা হবে যা যদি tol==1e-5উদাহরণস্বরূপ) যে xহয় না একটি পূর্ণসংখ্যা।
বেন বলকার 24'14

@ বেনবোলকার ভাল ক্যাচ, এটি আমার মনে হয় ইতিবাচক কলহের জন্য কাজ করে। আমি এটিকে পরিবর্তিত করেছি বিকল্প সমাধানে কাজ করা উচিত।
জেমস

2
@ জেমস, আমি মনে করি এটি অন্যথায় min(abs(c(x%%1, x%%1-1))) < tolপরিবর্তে হওয়া উচিত abs(min(x%%1, x%%1-1)) < tol, আপনি FALSEকোনও পূর্ণসংখ্যার জন্য পাবেন ...
ক্যাথ

3
এর সাথে কী হয়েছে as.integer(x) == x? এটি 3 বা 3.0 পছন্দ মতো প্রত্যাখ্যান করবে না is.integer(x)এবং এটি 3.1 কে ধরবে।
গাবি

34

সহজ ফাংশন এবং কোনও হ্যাক ব্যবহার করে এখানে একটি সমাধান রয়েছে:

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ভেক্টর, ম্যাট্রিকেস ইত্যাদির ক্ষেত্রে ব্যবহার করতে পরিবর্তন করতে পারেন


11
শেষটি if elseসহজভাবে করা যেতে পারে isTRUE(test)। প্রকৃতপক্ষে এটিই আপনাকে if elseক্লজ এবং returnবিবৃতিগুলি প্রতিস্থাপন করতে হবে কারণ আর হিসাবে স্বয়ংক্রিয়ভাবে শেষ মূল্যায়নের ফলাফলটি ফিরে আসে।
গ্যাভিন সিম্পসন

7
testInteger(1.0000001)[1] মিথ্যা testInteger(1.00000001)[1] সত্য
প্যাট্রিকটি 25'15

3
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

11

আর ল্যাংগুয়েজ ডকুমেন্টেশন পড়ার 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

সুতরাং আপনার আবেদনের উপর নির্ভর করে আপনি সেভাবে সমস্যায় পড়তে পারেন।


1
দ্বিতীয় লাইনে "as.integer পরীক্ষা করে যদি সংখ্যাটি পূর্ণসংখ্যা হিসাবে ঘোষণা করা হয়।" তবে আমি নিশ্চিত যে আপনি "is.integer" বোঝাতে চেয়েছিলেন। এটি কেবলমাত্র একটি চরিত্রের সম্পাদনা তাই আমি সহজেই এটি পরিবর্তন করতে পারিনি।
পিটারভেরমন্ট

10

এখানে একটি, আপাতভাবে নির্ভরযোগ্য উপায়:

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

1
এটি আমার কাছে খুব নির্ভরযোগ্য নয় বলে মনে হচ্ছে: check.integer(1e4)সত্য, যদিও check.integer(1e5)মিথ্যা।
wch

5
-1 এটি is.wholenumberঅন্যান্য উত্তরগুলির সরবরাহিত সমাধানগুলির চেয়ে আরও খারাপ worse এই বিভিন্ন থাকা উচিত নয়: check.integer(1e22); check.integer(1e23)। এটিকে সংশোধন করার জন্য আপনি স্পষ্টতই রেজেক্স পরিবর্তন করতে পারেন তবে এই পদ্ধতিটি ভয়ঙ্কর। (ইনস্টলার প্যাকেজে অ্যাট্রিবিউট থেকে মন্তব্য আসে comes)
জোশুয়া উলরিচ

1
@ পেট্রিকটি, আমি দেখছি। এটি ডিফল্ট অঙ্কের যুক্তি। format(40, scientific = FALSE, digits = 20)পরিবর্তে ব্যবহার করুন। আমি উত্তর আপডেট করেছি। এটি সন্ধানের জন্য ধন্যবাদ।
বিতোষকা

1
@ পেট্রিকটি আপনি মেশিননির্ভর গোলাকার ত্রুটির ক্ষেত্রের মধ্যে রয়েছেন। সেই সম্মানে আমার সমাধানটি গ্রহণযোগ্য হিসাবে একই 1.0000000000000001 == 1L [1] TRUE। তবে আমার সমাধানটি আরও ভাল যদি আপনি ইতিমধ্যে স্ট্রিং ফর্মে একটি নম্বর পেয়ে থাকেনcheck.integer("1000000000000000000000000000000000001") [1] TRUE
ভিটোশকা

4
@ বিটোশকা আপনার উত্তর পছন্দ করেছেন! যদিও আপনার একটি পয়েন্ট মিস হয়েছে, দশমিক পয়েন্ট ছাড়া negativeণাত্মক সংখ্যাগুলিও পূর্ণসংখ্যা;) আমি সেই অনুযায়ী আপনার কোডটি সংশোধন করেছি।
মেহরাদ মাহমুদিয়ান

8

এটি প্রদর্শিত হচ্ছে যে আপনি কিছু ত্রুটি সহনশীলতা সংযোজন করার প্রয়োজন দেখছেন না। এটির প্রয়োজন হয় না যদি সমস্ত পূর্ণসংখ্যার পূর্ণসংখ্যার হিসাবে প্রবেশ করে, তবে কখনও কখনও এটি পাটিগণিত ক্রিয়াকলাপের ফলে আসে যা কিছুটা নির্ভুলতা .িলা করে। উদাহরণ স্বরূপ:

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

মনে রাখবেন যে এটি আর এর দুর্বলতা নয়, সমস্ত কম্পিউটার সফ্টওয়্যারটিতে নির্ভুলতার কিছু সীমা থাকে।


3
কেবলমাত্র কিছু লোকেরা এখানে যা ঘটেছিল তা পুরোপুরি না পেয়ে ... আপনি as.integer (2/49 * 49) লিখলে আপনি 1 পান! [বিটিডাব্লু, এটি কখনও হতাশাব্যঞ্জক যে আর প্রাথমিক গণনার ফলাফলটি 2.0 হিসাবে 2.0 হিসাবে উপস্থাপন করে না যে মানটির দশমিক উপাদান রয়েছে তা উপস্থাপন করুন ... দেখুন ... স্ট্যাকওভারফ্লো
জন

6

থেকে Hmisc::spss.get:

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

অনেক নিরাপদ বিকল্প, আইএমএইচও, যেহেতু এটি মেশিনের নির্ভুলতার বিষয়টি "বাইপাস" করে। যদি আপনি চেষ্টা করেন তবে আপনি is.integer(floor(1))পাবেন FALSE। বিটিডাব্লু, আপনার পূর্ণসংখ্যা যদি .Machine$integer.maxমানের চেয়ে বড় হয় তবে এটি পূর্ণসংখ্যারূপে সংরক্ষণ করা হবে না , যা ডিফল্ট হিসাবে 2147483647, সুতরাং integer.maxমানটি পরিবর্তন করুন , অথবা বিকল্প চেক করুন ...


1
যদি x <- sqrt(2)^2, তবে all(floor(x) == x, na.rm = TRUE)ফিরে যানFALSE
Corrado

3

আপনি যদি শর্ত মতো সহজ ব্যবহার করতে পারেন:

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

1

আর-তে, কোনও সংখ্যা সাংখ্যিক বা পূর্ণসংখ্যা শ্রেণীর ফাংশন দ্বারা নির্ধারণ করা যায়। সাধারণত সমস্ত সংখ্যা সংখ্যা হিসাবে সংরক্ষণ করা হয় এবং স্পষ্টভাবে সংখ্যার পূর্ণসংখ্যা হিসাবে সংজ্ঞা দিতে আমাদের সংখ্যার পরে 'এল' নির্দিষ্ট করতে হবে।

উদাহরণ:

x <- 1

বর্গ (x) এর

[1] "সংখ্যাসূচক"

এক্স <- 1 এল

বর্গ (x) এর

[1] "পূর্ণসংখ্যা"

আমি আশা করি এটি যা প্রয়োজন ছিল। ধন্যবাদ :)


0

[আপডেট] ================================================ ===============

নীচে এখানে [ওল্ড] উত্তরের সম্মান, আমি আবিষ্কার করেছি যে এটি কাজ করেছে কারণ আমি সমস্ত সংখ্যাকে একক পরমাণু ভেক্টরে রেখেছি; তাদের মধ্যে একটি চরিত্র ছিল, তাই প্রত্যেকেই চরিত্র হয়ে ওঠে।

আমরা যদি একটি তালিকা ব্যবহার করুন (অত: পর, বলপ্রয়োগ ঘটে না) সমস্ত পরীক্ষা পাস সঠিকভাবে কিন্তু এক: 1/(1 - 0.98), যা একটি অবশেষ numeric। এটি কারণ tolপ্যারামিটারটি ডিফল্টরূপে 100 * .Machine$double.epsএবং সেই সংখ্যাটি 50এর দ্বিগুণ থেকে অনেক কম। সুতরাং, মূলত, সংখ্যা এই ধরনের জন্য, আমরা আছে আমাদের সহনশীলতা সিদ্ধান্ত নিতে!

সুতরাং আপনি যদি চান সমস্ত পরীক্ষা হয়ে ওঠে TRUE, আপনি পারেনassertive::is_whole_number(x, tol = 200 * .Machine$double.eps)

যাইহোক, আমি নিশ্চিত করি যে আইএমও দৃser়রাই সর্বোত্তম সমাধান থেকে যায়।

এখানে এটির জন্য একটি আপডেটের (নীচে) আপডেট করুন UP

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) দ্বারা তৈরি করা হয়েছে

[ওল্ড] ================================================ ==================

আইএমও সেরা সমাধান 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) দ্বারা তৈরি করা হয়েছে


0

আপনি যদি নিজের ফাংশন না লিখতে পছন্দ check.integerকরেন তবে প্যাকেজ ইনস্টলার থেকে চেষ্টা করুন । বর্তমানে এটি বিতোষকের উত্তর ব্যবহার করে

check.numeric(v, only.integer=TRUE)প্যাকেজ ভারহ্যান্ডল থেকেও চেষ্টা করুন , যা ভেক্টরাইজড হওয়ার সুবিধা রয়েছে।


0

একবার ব্যবহার করতে পারেন dplyr::near:

library(dplyr)

near(a, as.integer(a))

এটি যে কোনও ভেক্টরের ক্ষেত্রে প্রযোজ্য aএবং এর একটি alচ্ছিক সহনশীলতা প্যারামিটার রয়েছে।


-3

আপনি কী অর্জন করতে চাইছেন তা আমি নিশ্চিত নই। তবে এখানে কিছু চিন্তাভাবনা রয়েছে:
1. পূর্ণসংখ্যায় রূপান্তর করুন:
num = as.integer(123.2342)
2. কোনও চলক একটি পূর্ণসংখ্যা কিনা তা পরীক্ষা করুন:
is.integer(num)
typeof(num)=="integer"


আমি কেবল নিশ্চিত হয়েছি যে ব্যবহারকারীরা একটি উপযুক্ত সংখ্যায় প্রবেশ করেছে - আমরা "বিষয়গুলির" সংখ্যা সম্পর্কে কথা বলছি, যা কেবলমাত্র পূর্ণসংখ্যা হতে পারে।
রোমান Luštrik
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.