1994 + 27## [1] 202128 / 365 * 100## [1] 7.6712332 ** 3## [1] 8(((1+2)*3)**2)/3## [1] 27#Actualizar valor asignado
resultado <- (((1+2)*3)**2)/3resultado +3## [1] 30resultado <- resultado +3v_logical <- TRUE
v_double <- 3.1416
v_integer <- 5L
v_character <- "Hola mundo"##Comprobar tipo
is.logical(v_logical)## [1] TRUEis.numeric(v_double)## [1] TRUEis.integer(v_double)## [1] FALSEtypeof(v_character)## [1] "character"typeof(v_integer)## [1] "integer"typeof(TRUE)## [1] "logical"test_tipo <- typeof(1)test_tipo## [1] "double"typeof(test_tipo)## [1] "character"typeof("double")## [1] "character"letters## [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"length(v_logical)## [1] 1Sirve para saber la longitud de un vector.
length(letters)## [1] 26mi_vector_largo <- c("elemento1",
"elemento2",
"elemento3",
"elemento4")mi_vector_largo## [1] "elemento1" "elemento2" "elemento3" "elemento4"mi_vector_numerico1 <- 1:6
mi_vector_numerico1
mi_vector_numerico1 <- 1:6mi_vector_numerico1## [1] 1 2 3 4 5 6mi_vector_numerico2 <- 11:16mi_vector_muy_largo <- c(mi_vector_numerico1,
mi_vector_numerico2,
21:26)mi_vector_muy_largo## [1] 1 2 3 4 5 6 11 12 13 14 15 16 21 22 23 24 25 26typeof(mi_vector_muy_largo)## [1] "integer"mi_vector_numerico3 <- 100:200mi_vector_numerico3## [1] 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
## [19] 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
## [37] 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
## [55] 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
## [73] 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
## [91] 190 191 192 193 194 195 196 197 198 199 200typeof(mi_vector_numerico3)## [1] "integer"mi_nombre <- c("Maria", "Fernanda", "Castro", "Rivas")mi_nombre## [1] "Maria" "Fernanda" "Castro" "Rivas"typeof(mi_nombre)## [1] "character"mi_secuencia1 <- 1:10
mi_secuencia2 <- 11:20length(mi_secuencia1)## [1] 10length(mi_secuencia2)## [1] 10mi_secuencia1 + mi_secuencia2## [1] 12 14 16 18 20 22 24 26 28 30mi_secuencia2 - mi_secuencia1## [1] 10 10 10 10 10 10 10 10 10 10mi_secuencia1 * mi_secuencia2## [1] 11 24 39 56 75 96 119 144 171 200mi_secuencia1## [1] 1 2 3 4 5 6 7 8 9 10mi_secuencia1 + 1## [1] 2 3 4 5 6 7 8 9 10 11mi_secuencia1 * 5## [1] 5 10 15 20 25 30 35 40 45 50mi_secuencia1 ** 2## [1] 1 4 9 16 25 36 49 64 81 100vector_combinado <- c(mi_vector_muy_largo, "1")typeof (vector_combinado)## [1] "character"typeof (mi_vector_muy_largo)## [1] "integer"Aunque suena complicado, las reglas de coerción son bastante sencillas. R le dará prioridad a mantener el tipo de vector según el siguiente orden:
Es decir, ante cualquier conflicto en el tipo de vectores a combinar se preservará el tipo que tenga más alta prioridad.
Si nos detenemos a analizar por qué sucede, es bastante evidente. Los valores logical son en realidad leídos por la computadora como 1 cuando son TRUE y como 0 cuando son FALSE. Es por ello que la siguiente operación no nos arroja un error.
1L + TRUE## [1] 2Del mismo modo, sabemos que cualquier número entero también puede ser expresado como número racional. Es por ello que los integer son coercionados a double cuando hay conflicto entre ellos.
typeof(1L + 3.1416)## [1] "double"¿Es posible convertir texto a números en R? No. Es por ello que cuando un vector tipo character se combina con cualquier otro tipo de vector, prevalece el tipo character, como en el ejemplo que vimos al inicio de esta sección.
En todos los casos de coerción que hemos mencionado hasta el momento R ha decidido mediante sus propias reglas qué tipo de vector debe prevalecer, aplicando coerción implícita. Este procedimiento puede ocasionar problemas cuando el usuario no tiene suficientemente claras las reglas de coerción.
La coerción explícita permite decidir de antemano qué tipo de vector queremos obtener. Para ello se hace uso de una función de la forma as.() donde representa el tipo deseado.
vector_true_integer <- as.integer(TRUE)
typeof(vector_true_integer)## [1] "integer"vector_true_integer## [1] 1En este ejemplo, hemos usado as.integer() para cambiar el tipo de nuestro vector, de logical a integer. Es posible hacer lo mismo para otros tipos de vectores. Tomemos en cuenta que la transformación se realiza de manera directa, sin respetar el orden de prioridad.
as.character(TRUE)## [1] "TRUE"Es por ello que TRUE se convierte directamente en el character “TRUE” sin convertirse primero en el integer 1L, luego en el double 1 y luego en el character “1”. De aquí viene el verdadero poder de la coerción explícita, porque nos permite incluso “revertir” el orden de prioridad que R usa en la coerción implícita. Es decir, podemos convertir cualquier tipo de vector a otro.
as.logical("TRUE")## [1] TRUEtypeof(as.logical("TRUE"))## [1] "logical"typeof(as.integer("10"))## [1] "integer"typeof(as.integer(5.0))## [1] "integer"typeof(as.double("6.108"))## [1] "double"De todos modos, esto se debe usar con precaución. Sabemos que todo logical puede convertirse a integer, estos a su vez pueden convertirse a double y estos a character sin perder ninguna información. No sucede lo mismo en el procedimiento reverso. Por ejemplo, esto sucede cuando queremos convertir un double con cifras decimales a integer.
as.integer(5.4234)## [1] 5El contenido decimal se pierde, porque R no lo necesita en el integer, y no es posible recuperarlo aún retransformando el valor a double en la misma línea de código.
as.double(as.integer(5.4234))## [1] 5Algo similar sucede cuando intentamos convertir a logical valores numéricos diferentes a 0.
as.logical(8)## [1] TRUEas.logical(-0.000000135)## [1] TRUEPara los logical todo valor diferente a cero (0) es TRUE, solo 0 es FALSE.
test1 <- c(10:15, TRUE)
test2 <- c(10:15, 16)
test3 <- c(10:15, "FALSE")
test4 <- c("10:15", 16L)typeof (test1)## [1] "integer"typeof (test2)## [1] "double"typeof (test3)## [1] "character"typeof (test4)## [1] "character"