Las entidades en las que opera R son técnicamente conocidas como objetos. Por ejemplo, vectores de valores numéricos, vectores de valores lógicos y vectores de cadenas de caracteres. Estas se conocen como estructuras “atómicas” ya que sus componentes son todos del mismo tipo o clase, es decir, numéricos, lógicos y de caracter.

Los vectores tienen la característica de que todos sus valores son del mismo tipo. Por lo tanto, cualquier vector dado debe ser inequívocamente lógico, numérico o de caracteres.

Vectores

El tipo más básico de estructura de dato en R es el vector. El vector es una estructura compuesta de un número de elementos finitos, homogéneos y donde dicha estructura tiene un tamaño fijo. Finito porque existe un último elemento; homogéneo porque todos los elementos son del mismo tipo y tamaño fijo porque el tamaño del vector debe ser conocido en tiempo de ejecución o compilación.

v_num <- c(1, 2.5, 4.5)
class(v_num)
## [1] "numeric"
v_int <- c(1L, 6L, 10L)  # Con el sufijo L, conseguimos un integer en lugar de un number
class(v_int)
## [1] "integer"
v_log <- c(TRUE, FALSE, T, F) # Usamos TRUE y FALSE (o T y F) para crear vectores lógicos
class(v_log)
## [1] "logical"
v_char <- c("María", "Pedro", "Oscar")
class(v_char)
## [1] "character"

Además, mediante el operador : podemos generar sucesiones de números:

1:10
##  [1]  1  2  3  4  5  6  7  8  9 10
15:11
## [1] 15 14 13 12 11
1:10 - 1
##  [1] 0 1 2 3 4 5 6 7 8 9
1:(10 - 1)
## [1] 1 2 3 4 5 6 7 8 9

También podemos usar las funciones seq() y rep():

seq(10)  # mismo efecto que 1:10
##  [1]  1  2  3  4  5  6  7  8  9 10
seq(3, 10)  # mismo efecto que 3:10
## [1]  3  4  5  6  7  8  9 10
seq(1, 10, by = 3)  #saltando de 3 en 3
## [1]  1  4  7 10
rep(1:4, 2)  #repetimos 1:4 dos veces
## [1] 1 2 3 4 1 2 3 4
rep(1:4, each = 2)  #repetimos 1:4 dos veces, intercalando resultado
## [1] 1 1 2 2 3 3 4 4

Mediante *[], obtendremos el elementos de las posiciones indicadas:

v <- c(10, 3, NA, 5, 8, 1, NA)
v[2]
## [1] 3
v[c(2,3,7)]
## [1]  3 NA NA

Por medio de un vector lógico obtenemos todos los valores correspondientes al valor TRUE. Este tipo es útil en conjunción con la funciones de comparación:

v <- c(10, 3, NA, 5, 8, 1, NA)

v[!is.na(v)]  # Devuelve todos los valores que no son NA en x
## [1] 10  3  5  8  1

Este es un estatuto de asignación que utiliza la función c () que en este contexto puede tomar un número arbitrario de argumentos y cuyo valor es un vector obtenido al concatenar sus argumentos de punta a punta.

Un número que aparece solo en una expresión se toma como un vector de longitud uno.

Observa que el operador de asignación (<-) consta de los dos caracteres ‘<’ (menor que “) y ‘-’ (menos) que ocurren estrictamente uno al lado del otro y apunta al objeto que recibe el valor de la expresión. En la mayoría de los contextos, el operador ‘=’ se puede utilizar como alternativa.

La asignación también se puede hacer usando la función assign ().

Una forma equivalente de hacer la misma asignación que la anterior es con:

x<-c(10, 5, 3, 6, 20)

x= c(10, 5, 3, 6, 20)

assign("x", c(10, 5, 3, 6, 20))

Nombres de los Elementos

Una gran característica de los vectores en R es que podemos asignar a cada elemento un nombre. Etiquetar los elementos hace nuestro código mas legible. Podemos especificar los nombres cuando creamos un vector con la forma nombre = valor

nombre.valor<-c(manzana = 1, platano = 2, kiwi = 3)
nombre.valor
## manzana platano    kiwi 
##       1       2       3

Podemos añadir nombres a los elementos de un vector después de su creación con la ayuda de la función names():

frutas <- 1:4
frutas
## [1] 1 2 3 4
names(frutas)<-c("manzana", "platano", "kiwi")
frutas
## manzana platano    kiwi    <NA> 
##       1       2       3       4
names(frutas) #Gracias a la función names() podemos conocer los nombres de un vector:
## [1] "manzana" "platano" "kiwi"    NA

si un vector no tiene nombres, la función names() devuelve NULL:

names(v)
## NULL

Aritmética para vectores

Los operadores aritméticos elementales son los habituales

simbolo nombre
+ suma
- resta
* multiplicación
/ división
^ potencia 
a<-2
b<-3

a+b  #Suma
## [1] 5
a-b  #resta
## [1] -1
a*b  #Producto (multiplicación)
## [1] 6
a/b  #División
## [1] 0.6666667
a^b  #Potencia 
## [1] 8

Además, todas las funciones aritméticas comunes están disponibles.
log, exp, sin, cos, tan, sqrt, etc., todos tienen su significado habitual.

Operaciones Vectorizadas

La mayoría de las operaciones en R son vectorizadas, esto es que un operador o una función actúa en cada elemento de un vector sin la necesidad de que tengamos que escribir una construcción iterativa. Esta característica nos permite escribir un código más eficiente, conciso y mas legible que en otros lenguajes de programación.

El ejemplo mas simple es cuando sumamos dos vectores:

v1 <- 1:4
v1
## [1] 1 2 3 4
v2 <- 5:8
v2 
## [1] 5 6 7 8
v3 <- v1 + v2
v3
## [1]  6  8 10 12

Otro tipo de operaciones que podemos realizar de forma vectorizada son las comparaciones lógicas. Supongamos que queremos saber que elementos en un vector son mas grandes que 2. Podríamos hacer lo siguiente:

v1 <- 1:4
v1
## [1] 1 2 3 4
v1 > 2
## [1] FALSE FALSE  TRUE  TRUE
v1<3
## [1]  TRUE  TRUE FALSE FALSE
v1==3
## [1] FALSE FALSE  TRUE FALSE

La suma, resta, multiplicación y división son también operaciones vectorizadas:

v1 + v2
## [1]  6  8 10 12
v1 - v2
## [1] -4 -4 -4 -4
v1 * v2
## [1]  5 12 21 32
v1/v2
## [1] 0.2000000 0.3333333 0.4285714 0.5000000
v1^2
## [1]  1  4  9 16
v1^v2
## [1]     1    64  2187 65536

Cuando sumamos dos vectores de diferente longitud, R reciclará los elementos del vector más pequeño para que coincida con el más grande

1:2 + 1:4
## [1] 2 4 4 6

Si la longitud del vector más grande no es múltiple con la longitud del vector más pequeño, R nos lo hará saber mediante un mensaje:

1:5 + 1:7
## Warning in 1:5 + 1:7: longer object length is not a multiple of shorter object
## length
## [1]  2  4  6  8 10  7  9

Aunque R nos permita realizar operaciones con vectores de diferente longitud, esto no significa que nosotros deberíamos hacerlo. Realizar una suma de un valor escalar a un vector es coherente, pero realizar operaciones con vectores de diferente longitud puede llevarnos a errores. Es por eso, que recomendamos crear explícitamente vectores de la misma longitud antes de operar con ellos.

La función rep() es muy útil para esta tarea, permitiéndonos crear un vector con elementos repetidos:

rep(1:5, 3)
##  [1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
rep(1:5, each = 3)
##  [1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5
rep(1:5, times = 1:5)
##  [1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
rep(1:5, length.out = 7)
## [1] 1 2 3 4 5 1 2
rep_len(1:5, 7)  # Alternativamente podemos hacerlo mediante rep_len ()
## [1] 1 2 3 4 5 1 2