Operadores aritméticos elementales

En el operador de asignación si importan los espacios, en los aritméticos no.

Suma

1996 + 24
## [1] 2020

División

28/365 * 100
## [1] 7.671233

Potencia

2 ** 3
## [1] 8

Operación

(((1+2)*3)**2)/3
## [1] 27
1+2*3**2/3
## [1] 7

Operador de asignación

Este operador sirve para asignar un nombre a cualquier objeto o valor, de tal modo podamos acceder a él con mayor facilidad. Por ejemplo, podemos asignarle el nombre “resultado” al resultado de la operación que realizamos anteriormente. A simple vista, nada ha cambiado, pero cuando accedemos al objeto resultado ahora obtenemos inmediatamente la respuesta de nuestra operación.

resultado <- (((1+2)*3)**2)/3
resultado 
## [1] 27

Actualizando valor asignado

Si por algún motivo necesitamos actualizar el valor asignado a nuestro objeto, basta con volver a asignar el mismo nombre a otro valor. Incluso se puede hacer referencia al valor anterior para modificarlo. No hay un límite de veces que el valor de un objeto puede ser modificado.

resultado <- resultado + 3
resultado
## [1] 30
resultado2 <- resultado + resultado
resultado2
## [1] 60
resultado3 <- resultado2 - resultado
resultado3
## [1] 30
resultado4 <- resultado3 * resultado
resultado3 <- 10
resultado4
## [1] 900
resultado5  <- resultado3 * resultado
resultado5
## [1] 300
resultado5
## [1] 300
resultado4  <- "hola"
resultado4
## [1] "hola"

Vectores

Estos pueden ser de dos tipos: atómicos y listas. La diferencia entre ellos radica en el tipo de información que pueden contener.

Vectores atómicos 1. Los cuatro principales tipos de vectores atómicos son: logical (v f) , double (Racionales), integer (enteros) y character (Caracteres de textos).

  1. Los vectores de tipo logical pueden asumir dos valores: TRUE o FALSE(o en su forma abreviada T o F).

  2. Los de tipo double e integer asumen valores numéricos, los double pueden asumir valores racionales y los integer sólo valores enteros.

  3. Los vectores de tipo character asumen cualquier cadena de texto.

v_logical <- TRUE
v_double <- 3.1416
v_integer <- 5L
v_character <- "Hola mundo"

Comprobando tipo

is.logical(v_logical)
## [1] TRUE
is.numeric(v_double)
## [1] TRUE
is.integer(v_double)
## [1] FALSE
is.double(TRUE)
## [1] FALSE
is.integer(10)
## [1] FALSE
is.double(10)
## [1] TRUE
test <- is.integer(10)
test
## [1] FALSE

Comprobar tipo alternativo

Comprobar tipo de vector con typeof() Otra manera de verificar el tipo de vector que tenemos es con la función typeof(). Esta nos devuelve un character indicando el tipo de vector que tenemos.

typeof(v_character)
## [1] "character"
typeof(v_integer)
## [1] "integer"
typeof(TRUE)
## [1] "logical"
test_tipo <- typeof(1L)
test_tipo
## [1] "integer"
is.character(typeof(is.character(typeof(test_tipo))))
## [1] TRUE
typeof("double")
## [1] "character"
typeof("3.1415")
## [1] "character"
typeof(FALSE)
## [1] "logical"
typeof(1 + 10)
## [1] "double"
typeof(142365L)
## [1] "integer"
  1. Identificar tipo de vector

“3.1415”: “character” FALSE: “logical” 1 + 10: “double” 142365L: “integer”

  1. Descartar tipo de vector ¿Cuáles de los siguientes vectores son de tipo double?

100 - double 7.9 - double “50.0 mm” - character 1024L - integer

typeof(typeof(1+10))
## [1] "character"

Vectores con más de un elemento

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"

Nos indica la cantidad de elementos que tiene el vector que está adentro. La longitud de un vecto (número de elementos)

length(v_logical)
## [1] 1
length(letters)
## [1] 26

Para formar vectores de longitud mayor a uno (1) se utiliza la función c() agregando como argumentos todos los elementos que queremos.

mi_vector_largo <- c("elemento1", 
                     "elemento2", 
                     "elemento3", 
                     "elemento4")
mi_vector_largo2 <- c("elemento1", "elemento2", "elemento3", "elemento4")
mi_vector_largo
## [1] "elemento1" "elemento2" "elemento3" "elemento4"
mi_vector_largo2
## [1] "elemento1" "elemento2" "elemento3" "elemento4"
mi_vector_largo3 <- c(mi_vector_largo,mi_vector_largo2)
mi_vector_largo3
## [1] "elemento1" "elemento2" "elemento3" "elemento4" "elemento1" "elemento2"
## [7] "elemento3" "elemento4"

Operador de secuencia simple

mi_vector_numerico1 <- 1:6

mi_vector_numerico1
## [1] 1 2 3 4 5 6
typeof(mi_vector_numerico1)
## [1] "integer"

Concatenar vectores largos

mi_vector_numerico2  <- 11:16

mi_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 26
typeof(mi_vector_muy_largo)
## [1] "integer"
mi_vector_numerico3 <- 100:200
mi_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 200
typeof(mi_vector_numerico3)
## [1] "integer"

Crear vector de nombres

En bloques de código, ejecuta código para obtener lo siguiente:

Crea un vector en el que cada elemento es una parte de tu nombre completo.

mi_nombre <- c("Almendra", "Rodriguez", "Rivera")
typeof(mi_nombre)
## [1] "character"

Operaciones con vectores

mi_secuencia1 <- 1:10
mi_secuencia2 <- 11:20
mi_secuencia1
##  [1]  1  2  3  4  5  6  7  8  9 10
mi_secuencia2
##  [1] 11 12 13 14 15 16 17 18 19 20
length(mi_secuencia1)
## [1] 10
length(mi_secuencia2)
## [1] 10
mi_secuencia1 + mi_secuencia2
##  [1] 12 14 16 18 20 22 24 26 28 30
mi_secuencia2 - mi_secuencia1
##  [1] 10 10 10 10 10 10 10 10 10 10
mi_secuencia2 - mi_secuencia1
##  [1] 10 10 10 10 10 10 10 10 10 10
mi_secuencia1 * mi_secuencia2
##  [1]  11  24  39  56  75  96 119 144 171 200

Reciclaje de vectores

mi_secuencia1
##  [1]  1  2  3  4  5  6  7  8  9 10
mi_secuencia1 + 1
##  [1]  2  3  4  5  6  7  8  9 10 11
mi_secuencia1 * 5
##  [1]  5 10 15 20 25 30 35 40 45 50
mi_secuencia1 ** 2
##  [1]   1   4   9  16  25  36  49  64  81 100

Coerción de vectores y valores NA

Crear vectores más largos puede tener efectos inesperados para el usuario que no está atento. Veamos el siguiente ejemplo:

mi_vector_muy_largo
##  [1]  1  2  3  4  5  6 11 12 13 14 15 16 21 22 23 24 25 26
vector_combinado <- c(mi_vector_muy_largo,"1")
typeof(vector_combinado)
## [1] "character"
vector_combinado
##  [1] "1"  "2"  "3"  "4"  "5"  "6"  "11" "12" "13" "14" "15" "16" "21" "22" "23"
## [16] "24" "25" "26" "1"
typeof(mi_vector_muy_largo)
## [1] "integer"

Coerción explícita

vector_true_integer <- as.integer(TRUE)
typeof(vector_true_integer)
## [1] "integer"
as.character(TRUE)
## [1] "TRUE"
typeof(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"

Coerción puede perder información

as.integer(5.4234)
## [1] 5
as.integer(5.99999)
## [1] 5
as.double(as.integer(5.4234))
## [1] 5
as.logical(8)
## [1] TRUE
as.logical(0.0000135)
## [1] TRUE

Práctica de coerción

¿Qué tipos de vector obtenemos en los siguientes bloques de código?

Una vez que compruebes de qué tipo son los vectores creados, agrega una explicación de esa coerción antes de cada bloque de código.

test1 <- c(10:15, TRUE)
typeof(test1)
## [1] "integer"
test2 <- c(10:15, 16)
typeof(test2)
## [1] "double"
test3 <- c(10:15, "FALSE")
typeof(test3)
## [1] "character"
test4 <- c("10:15", 16L)
typeof(test4)
## [1] "character"
test5 <- c(10:15,"perro")
test5
## [1] "10"    "11"    "12"    "13"    "14"    "15"    "perro"
as.integer(test5)
## Warning: NAs introduced by coercion
## [1] 10 11 12 13 14 15 NA

#REPASO Vectores rr matrices.

##Creando secuencias

mi_secuencia1 <- 1:10
mi_secuencia2 <- 11:20

#Sumando secuencias

mi_secuencia1 + mi_secuencia2
##  [1] 12 14 16 18 20 22 24 26 28 30
mi_secuencia1 <- 21:30
mi_secuencia1 + mi_secuencia2
##  [1] 32 34 36 38 40 42 44 46 48 50
mi_secuencia1 <- mi_secuencia1 + mi_secuencia2
mi_secuencia1 + mi_secuencia2
##  [1] 43 46 49 52 55 58 61 64 67 70
mi_secuencia1 * mi_secuencia2
##  [1]  352  408  468  532  600  672  748  828  912 1000
vector_con_NA <- c(1,2,3,4,NA,6,7)
sum(vector_con_NA)
## [1] NA

Basta que exista un NA, todo será NA si se quiere crear un resumen del vector

10+NA
## [1] NA
vector_con_NA <- c(1,2,3,4,NA,6,7)
vector_con_NA2 <- c(1,2,3,4,5,6,NA)
sum(vector_con_NA)
## [1] NA
10 + NA
## [1] NA
vector_con_NA + vector_con_NA2
## [1]  2  4  6  8 NA 12 NA
mean(vector_con_NA)
## [1] NA

Repaso creando vectores

mi_secuencia <- 1:10
length(mi_secuencia)
## [1] 10
mi_secuencia <- c(1,2,3,4,5,6,7,8,9,NA)
length(mi_secuencia)
## [1] 10
mi_secuencia <- c(1:9,NA)
length(mi_secuencia)
## [1] 10
mi_secuencia  <- c(1:5,NA,1:3,"perro")
length(mi_secuencia)
## [1] 10
mi_secuencia
##  [1] "1"     "2"     "3"     "4"     "5"     NA      "1"     "2"     "3"    
## [10] "perro"

Operadores relacionales

secuencia <- 1:6

Primero vamos a utilizar los operadores de igualdad y desigualdad. Tengamos en cuenta que al igual que con las operaciones aritméticas, al comparar una costante, esta se recicla.

testeando igualdad

secuencia == 6
## [1] FALSE FALSE FALSE FALSE FALSE  TRUE

testeando diferencia

secuencia != 6
## [1]  TRUE  TRUE  TRUE  TRUE  TRUE FALSE

mayor que

secuencia > 4
## [1] FALSE FALSE FALSE FALSE  TRUE  TRUE

menor que

secuencia < 4
## [1]  TRUE  TRUE  TRUE FALSE FALSE FALSE

mayor o igual que

secuencia >= 4
## [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE
100 < "11"
## [1] TRUE
100 < 11
## [1] FALSE

Operadores relacionales

y: cumplen ambas o: cumple alguna de ellas

secuencia2 <- 1:8

Y lógico: el número debe ser mayor que tres Y menor que 6

secuencia2 > 3 & secuencia2 < 6
## [1] FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE

O lógico: el número debe ser menor que tres O mayor que 6

secuencia2 < 3 | secuencia2 > 6
## [1]  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE  TRUE

NO lógico: cambia el valor de la operación

! secuencia2 <= 6
## [1] FALSE FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE
mi_numero <- 10
mi_numero < - 10
## [1] FALSE
mi_numero <- 8
mi_numero <8
## [1] FALSE