Comprueba si el número es entero

Me sorprendió saber que R no viene con una función útil para verificar si el número es entero.

is.integer(66) # FALSE

Los archivos de ayuda advierten :

is.integer(x)¡no prueba si x contiene números enteros! Para eso, use round, como en la función is.wholenumber(x)en los ejemplos.

El ejemplo tiene esta función personalizada como "solución alternativa"

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

Si tuviera que escribir una función para verificar los números enteros, suponiendo que no haya leído los comentarios anteriores, escribiría una función que iría en la línea de

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

¿Dónde fallaría mi enfoque? ¿Cuál sería tu trabajo si estuvieras en mi hipotético lugar?

Otra alternativa es verificar la parte fraccionaria:

x%%1==0

o, si desea verificar dentro de una cierta tolerancia:

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

Aquí hay una solución que usa funciones más simples y sin trucos:

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

Además, puede probar un vector completo a la vez, si lo desea. Aquí tienes una función:

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

Puede cambiarlo para usarlo *applyen el caso de vectores, matrices, etc.

Leer la documentación en lenguaje R as.integertiene más que ver con cómo se almacena el número que si es prácticamente equivalente a un entero. is.integercomprueba si el número se declara como un entero. Puede declarar un número entero colocando un Ldespués de él.

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

También funciones como rounddevolverán un entero declarado, que es lo que estás haciendo x==round(x). El problema con este enfoque es lo que considera que es prácticamente un número entero. El ejemplo usa menos precisión para probar la equivalencia.

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

Entonces, dependiendo de su aplicación, podría tener problemas de esa manera.

Aquí hay una forma aparentemente confiable:

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

Esta solución también permite números enteros en notación científica:

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

Parece que no ve la necesidad de incorporar alguna tolerancia a errores. No sería necesario si todos los enteros vinieran ingresados ​​como enteros, sin embargo, a veces vienen como resultado de operaciones aritméticas que pierden algo de precisión. Por ejemplo:

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

Tenga en cuenta que esta no es la debilidad de R, todo software de computadora tiene algunos límites de precisión.

De Hmisc::spss.get:

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

opción mucho más segura, en mi humilde opinión, ya que "pasa por alto" el problema de precisión de la máquina. Si lo intenta is.integer(floor(1)), lo obtendrá FALSE. Por cierto, su número entero no se guardará como entero si es mayor que el .Machine$integer.maxvalor, que es, por defecto, 2147483647, así que cambie el integer.maxvalor o realice las verificaciones alternativas ...

Puede usar una condición if simple como:

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

En R, la función de clase puede determinar si un número es numérico o entero. Generalmente, todos los números se almacenan como numéricos y para definir explícitamente un número como entero, necesitamos especificar 'L' después del número.

Ejemplo:

x <- 1

clase (x)

[1] "numérico"

x <- 1L

clase (x)

[1] "entero"

Espero que esto sea lo que se necesitaba. Gracias :)

[ACTUALIZAR] ============================================= ===============

Con respecto a la respuesta [VIEJA] aquí abajo, descubrí que funcionaba porque puse todos los números en un solo vector atómico; uno de ellos era un personaje, por lo que todos se convierten en personajes.

Si usamos una lista (por lo tanto, la coerción no ocurre) todas las pruebas pasan correctamente menos una:, 1/(1 - 0.98)que sigue siendo un numeric. Esto se debe a que el tolparámetro está por defecto 100 * .Machine$double.epsy ese número está lejos de ser un 50poco menos del doble. Entonces, básicamente, para este tipo de números, ¡ tenemos que decidir nuestra tolerancia!

Entonces, si desea que todas las pruebas se conviertan TRUE, puedeassertive::is_whole_number(x, tol = 200 * .Machine$double.eps)

De todos modos, confirmo que IMO asertivo sigue siendo la mejor solución.

A continuación, un reprex para esta [ACTUALIZACIÓN].

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

^{Creado el 2019-07-23 por el paquete reprex (v0.3.0)}

[ANTIGUO] ============================================= ==================

En mi opinión, la mejor solución proviene del assertivepaquete (que, por el momento, resuelve todos los ejemplos positivos y negativos en este hilo):

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

^{Creado el 2019-07-23 por el paquete reprex (v0.3.0)}

Si prefiere no escribir su propia función, intente check.integerdesde el instalador de paquetes . Actualmente usa la respuesta de VitoshKa.

Pruebe también check.numeric(v, only.integer=TRUE)con el paquete varhandle , que tiene la ventaja de estar vectorizado.

Once también puede usar dplyr::near:

library(dplyr)

near(a, as.integer(a))

Se aplica a cualquier vector ay tiene un parámetro de tolerancia opcional.

No estoy seguro de lo que está tratando de lograr. Pero aquí hay algunas ideas:
1. Convierta a un número entero:
num = as.integer(123.2342)
2. Compruebe si una variable es un número entero:
is.integer(num)
typeof(num)=="integer"