Kiểm tra xem số có phải là số nguyên không

Tôi rất ngạc nhiên khi biết rằng R không đi kèm với một chức năng tiện dụng để kiểm tra xem số có phải là số nguyên hay không.

is.integer(66) # FALSE

Các tệp trợ giúp cảnh báo :

is.integer(x)không kiểm tra nếu x chứa số nguyên! Đối với điều đó, hãy sử dụng round, như trong hàm is.wholenumber(x)trong các ví dụ.

Ví dụ có chức năng tùy chỉnh này như một "giải pháp thay thế"

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

Nếu tôi phải viết một hàm để kiểm tra các số nguyên, giả sử tôi chưa đọc các nhận xét ở trên, tôi sẽ viết một hàm sẽ đi theo dòng của

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

Cách tiếp cận của tôi sẽ thất bại ở đâu? Công việc của bạn sẽ thế nào nếu bạn ở trong đôi giày giả định của tôi?

Một cách thay thế khác là kiểm tra phần phân số:

x%%1==0

hoặc, nếu bạn muốn kiểm tra trong một dung sai nhất định:

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

Đây là một giải pháp sử dụng các chức năng đơn giản hơn và không có hack:

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

Hơn nữa, bạn có thể kiểm tra toàn bộ vectơ cùng một lúc, nếu muốn. Đây là một chức năng:

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

Bạn có thể thay đổi nó để sử dụng *applytrong trường hợp vectơ, ma trận, v.v.

Việc đọc tài liệu ngôn ngữ R as.integercó liên quan nhiều hơn đến cách số được lưu trữ hơn là nếu nó thực tế tương đương với một số nguyên. is.integerkiểm tra nếu số được khai báo là số nguyên. Bạn có thể khai báo một số nguyên bằng cách đặt Lsau nó.

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

Ngoài ra, các hàm như roundsẽ trả về một số nguyên đã khai báo, đó là những gì bạn đang làm với x==round(x). Vấn đề với cách tiếp cận này là những gì bạn cho là thực tế là một số nguyên. Ví dụ này sử dụng độ chính xác thấp hơn để kiểm tra tính tương đương.

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

Vì vậy, tùy thuộc vào ứng dụng của bạn, bạn có thể gặp rắc rối theo cách đó.

Đây là một cách, có vẻ đáng tin cậy:

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

Giải pháp này cũng cho phép các số nguyên trong ký hiệu khoa học:

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

Có vẻ như bạn không thấy cần phải kết hợp một số khả năng chịu lỗi. Sẽ không cần thiết nếu tất cả các số nguyên được nhập dưới dạng số nguyên, tuy nhiên, đôi khi chúng đến là kết quả của các phép toán số học làm mất độ chính xác. Ví dụ:

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

Lưu ý rằng đây không phải là điểm yếu của R, tất cả các phần mềm máy tính đều có một số giới hạn về độ chính xác.

Từ Hmisc::spss.get:

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

tùy chọn an toàn hơn nhiều, IMHO, vì nó "bỏ qua" vấn đề về độ chính xác của máy. Nếu bạn cố gắng is.integer(floor(1)), bạn sẽ nhận được FALSE. BTW, số nguyên của bạn sẽ không được lưu dưới dạng số nguyên nếu nó lớn hơn .Machine$integer.maxgiá trị, theo mặc định là 2147483647, vì vậy hãy thay đổi integer.maxgiá trị hoặc thực hiện các kiểm tra thay thế ...

bạn có thể sử dụng đơn giản nếu điều kiện như:

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

Trong R, một số là số hay số nguyên có thể được xác định bằng hàm lớp. Nói chung, tất cả các số được lưu trữ dưới dạng số và để xác định rõ ràng một số là số nguyên, chúng ta cần chỉ định 'L' sau số.

Thí dụ:

x <- 1

lớp (x)

[1] "số"

x <- 1L

lớp (x)

[1] "số nguyên"

Tôi hy vọng đây là những gì cần thiết. Cảm ơn :)

[CẬP NHẬT] ================================================= ===============

Tôn trọng câu trả lời [CŨ] ở đây dưới đây, tôi đã phát hiện ra rằng nó hoạt động vì tôi đã đặt tất cả các số trong một vectơ nguyên tử; một trong số họ là một nhân vật, vì vậy mọi người đều trở thành nhân vật.

Nếu chúng ta sử dụng một danh sách (do đó, sự ép buộc không xảy ra) thì tất cả các bài kiểm tra đều vượt qua chính xác ngoại trừ một 1/(1 - 0.98):, cái vẫn là a numeric. Điều này bởi vì toltham số là theo mặc định 100 * .Machine$double.epsvà con số đó 50không nhỏ hơn gấp đôi. Vì vậy, về cơ bản, đối với loại con số này, chúng ta phải quyết định khả năng chịu đựng của mình!

Vì vậy, nếu bạn muốn tất cả các thử nghiệm trở thành TRUE, bạn có thểassertive::is_whole_number(x, tol = 200 * .Machine$double.eps)

Dù sao, tôi xác nhận rằng IMO khẳng định vẫn là giải pháp tốt nhất.

Dưới đây là bản đại diện cho [CẬP NHẬT] này.

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

^{Được tạo vào 2019-07-23 bởi gói reprex (v0.3.0)}

[CŨ] ================================================= ==================

IMO giải pháp tốt nhất đến từ assertivegói (hiện tại, giải quyết tất cả các ví dụ tích cực và tiêu cực trong chuỗi này):

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

^{Được tạo vào 2019-07-23 bởi gói reprex (v0.3.0)}

Nếu bạn không muốn viết hàm của riêng mình, hãy thử check.integertừ trình cài đặt gói . Hiện tại nó sử dụng câu trả lời của VitoshKa.

Ngoài ra, hãy thử check.numeric(v, only.integer=TRUE)từ gói varhandle , có lợi ích là được vector hóa.

Một lần cũng có thể sử dụng dplyr::near:

library(dplyr)

near(a, as.integer(a))

Nó áp dụng cho bất kỳ vectơ nào avà có tham số dung sai tùy chọn.

Tôi không chắc bạn đang cố gắng hoàn thành điều gì. Nhưng đây là một số suy nghĩ:
1. Chuyển đổi thành số nguyên:
num = as.integer(123.2342)
2. Kiểm tra xem một biến có phải là số nguyên hay không:
is.integer(num)
typeof(num)=="integer"