Vectores

Es la estructura de datos más sencilla. Un vector es una colección de uno o más datos del mismo tipo.

x <- 5
x
## [1] 5
class(x)
## [1] "numeric"
y <- "Hola"
y
## [1] "Hola"
class(y)
## [1] "character"

¿Cómo crear vectores?

  1. Empleando la función \(\texttt{c()}\) que concatena elementos individuales y/o vectores (todos del mismo tipo).
x <- c(2,5,6,9,15)
x
## [1]  2  5  6  9 15
is.vector(x)
## [1] TRUE
y <- c("Hola","Adiós","Buenos días","Buenas noches","Hola")
y
## [1] "Hola"          "Adiós"         "Buenos días"   "Buenas noches"
## [5] "Hola"
is.vector(y)
## [1] TRUE
  1. A partir de secuencias o patrones:
  • \(\texttt{numeric(length)}\): crea vectores de \(0\) de longitud \(\texttt{length}\).
numeric(5)
## [1] 0 0 0 0 0
  • \(\texttt{seq(from,to,by,lenght.out)}\): crea una secuencia de valores desde \(\texttt{from}\) hasta \(\texttt{to}\), bien en saltos de tamaño \(\texttt{by}\) o bien creando un vector de longitud \(\texttt{lenght.out}\).
seq(from=1,to=10,by=2)
## [1] 1 3 5 7 9
seq(from=1,to=10,length.out=7)
## [1]  1.0  2.5  4.0  5.5  7.0  8.5 10.0
  • \(\texttt{rep(x,times,each)}\): crea un vector de valores repetidos \(\texttt{times}\) veces o bien cada valor repetido \(\texttt{each}\) veces.
rep(c(2,5),times=3)
## [1] 2 5 2 5 2 5
rep(c(2,5),each=3)
## [1] 2 2 2 5 5 5
  • \(\texttt{sample(x,size,replace=FALSE)}\): crea un vector aleatorio de elementos de tamaño \(\texttt{size}\), si se quiere que se repitan valores es necesario indicar \(\texttt{replace=TRUE}\).
sample(100,size=10,replace=FALSE)
##  [1]  67   9  25  21  88  99  51  93 100  12
sample(6,size=10,replace=TRUE)
##  [1] 3 6 3 6 6 2 4 5 4 2
  1. Operador \(\texttt{:}\) para generar secuencias de enteros en orden creciente o decreciente.
1:6
## [1] 1 2 3 4 5 6
6:1
## [1] 6 5 4 3 2 1

Para acceder a los elementos de un vector se emplea el operador [índice del elemento]

x <- sample(100,10)
x[3]
## [1] 1

Accediendo a los elementos del vector se pueden modificar, por ejemplo:

x[3] <- 4
x
##  [1] 64 36  4 93 98  4 94 18 82 24

Funciones útiles

  • Aritméticas: \(\texttt{sqrt(), sum(), prod(), round(), max(), min(), cumsum(), cumprod(),...}\)
  • Manipulación: \(\texttt{length(), order(), sort(), rev(), which(), rank(), is.na(),...}\)
  • Estadísticas: \(\texttt{mean(), median(), var(), sd(), quantile(), summary(),...}\)

Una de las funciones más interesantes es \(\texttt{which(condición)}\) ya que genera un vector numérico con las posiciones de los elementos del vector que cumplan la condición indicada. Una de las utilidades se encuentra cuando disponemos de datos ausentes en nuestros conjuntos de datos, denotados en \(\texttt{R}\) como \(\texttt{NA}\).

x[4] <- NA
x
##  [1] 64 36  4 NA 98  4 94 18 82 24
which(is.na(x))
## [1] 4

Además, la mayoría de funciones base de \(\texttt{R}\) disponen de un argumento para que obvien los datos ausentes: \(\texttt{na.rm=TRUE}\).

mean(x)
## [1] NA
mean(x,na.rm=TRUE)
## [1] 47.11111

Matrices y Arrays

Se construyen a partir de la función \[\texttt{matrix(data,nrow,ncol)}\]

x <- sample(100,20,replace = T)
X <- matrix(x,nrow=4,ncol=5)
X
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   38   52   91   83   94
## [2,]   27   35   62   49   77
## [3,]   72   52   91   73   37
## [4,]   46    3   86   22   12

Para acceder a los elementos de una matriz se emplea el operador [índice de la fila, índice de la columna]

X[2,4] #elemento de la fila 2 y columna 4
## [1] 49

Se puede añadir una fila o una columna a la matriz empleando las funciones: \(\texttt{rbind(matrix,row_new)}, \texttt{cbind(matrix,col_new)}\)

X <- rbind(X,sample(100,4))
## Warning in rbind(X, sample(100, 4)): number of columns of result is not a
## multiple of vector length (arg 2)
X
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   38   52   91   83   94
## [2,]   27   35   62   49   77
## [3,]   72   52   91   73   37
## [4,]   46    3   86   22   12
## [5,]   95   20   42   62   95
X <- cbind(X,sample(100,5))
X
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   38   52   91   83   94   65
## [2,]   27   35   62   49   77   26
## [3,]   72   52   91   73   37  100
## [4,]   46    3   86   22   12   77
## [5,]   95   20   42   62   95   91

Funciones útiles

  • \(\texttt{apply(matrix,MARGIN=c(1,2),FUN)}\): permite aplicar a los elementos de una matriz la función \(\texttt{FUN}\). Si \(\texttt{MARGIN}=1\), entonces aplica la función por filas, en cambio si \(\texttt{MARGIN}=2\) lo hace por columnas.
apply(X,1,sum)
## [1] 423 276 425 246 405
apply(X,2,sum)
## [1] 278 162 372 289 315 359
  • \(\texttt{dim(x)}\): devuelve las dimensiones de la matriz. Equivalentemente, existen las funciones \(\texttt{nrow(x)}\) y \(\texttt{ncol(x)}\) para conocer el número de filas y columnas, respectivamente.
dim(X)
## [1] 5 6
c(nrow(X),ncol(X))
## [1] 5 6

Arrays

Es un caso general de matrices cuando se dispone de una estructura con más de 2 dimensiones. Para su creación se emplea la función \(\texttt{array(data,dim)}\).

X <- array(sample(100,36,replace=T),dim=c(2,4,3))
X
## , , 1
## 
##      [,1] [,2] [,3] [,4]
## [1,]   59   95   26   18
## [2,]   64   63   80   26
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4]
## [1,]   28   70   91   57
## [2,]   59   36   84   40
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4]
## [1,]   87   34   23   96
## [2,]    2   61   70   20
X[1,2,3] #elemento de la fila 1 y columna 2 en la dimensión 3
## [1] 34

Factores y Cadenas de Caracteres

Una de las estructuras más frecuentes para variables cualitativas es la cadena de caracteres. Éstas se emplean para nombrar valores de variables que no tienen valores numéricos. Para facilitar el trabajo de este tipo de datos se emplea la clase \(\texttt{factor(x,levels)}\).

Esta estructura presenta un atributo denominado \(\texttt{levels}\) que identifica los elementos del vector sin repetición.

x <- c("azul","amarillo","rojo",
       "negro","blanco","verde")
color <- sample(x,20,replace=T)
f.color <- factor(color,x)
f.color
##  [1] azul     verde    verde    azul     verde    amarillo azul     verde   
##  [9] rojo     negro    amarillo blanco   azul     azul     amarillo blanco  
## [17] negro    rojo     blanco   negro   
## Levels: azul amarillo rojo negro blanco verde
levels(f.color)
## [1] "azul"     "amarillo" "rojo"     "negro"    "blanco"   "verde"

Listas

Es una clase de datos con 0 o más elementos, cada uno de los cuales puede ser nombrado y tener clases distintas. Se crea con la función \(\texttt{list}\).

mineral <- list(dureza=1:10,
                brillo=c("Metálico","No Metálico","Submetálico"),
                radioactividad=c(TRUE,FALSE))
mineral
## $dureza
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $brillo
## [1] "Metálico"    "No Metálico" "Submetálico"
## 
## $radioactividad
## [1]  TRUE FALSE

Para acceder a sus elementos individuales es recomendable hacerlo empleando el operador $. Además, permite combinar este operador [] para acceder a un elemento concreto.

mineral$dureza
##  [1]  1  2  3  4  5  6  7  8  9 10
mineral$brillo[2]
## [1] "No Metálico"

En el caso de listas, se puede emplear la función \[\texttt{lapply(x,FUN)}\] que permite aplicar a los elementos de la lista la función \(\texttt{FUN}\).

lapply(mineral,rep,times=2)
## $dureza
##  [1]  1  2  3  4  5  6  7  8  9 10  1  2  3  4  5  6  7  8  9 10
## 
## $brillo
## [1] "Metálico"    "No Metálico" "Submetálico" "Metálico"    "No Metálico"
## [6] "Submetálico"
## 
## $radioactividad
## [1]  TRUE FALSE  TRUE FALSE

Como se observa si las funciones necesitan más argumentos, éstos se añaden tras la función (esto también es válido en la función \(\texttt{apply}\)).

Data Frame

Es un caso particular de lista, cuyos elementos deben tener todos la misma longitud. Es un objeto pensado para contener datos estructurados en forma de variables (columnas) para los distintos individuos (filas).

Además, sus variables pueden ser de distinto tipo, y se crean con la función \(\texttt{data.frame(variables)}\)

mineral <- data.frame(dureza=1:15,
                      brillo=rep(c("Metálico","No Metálico","Submetálico"),each=5),
                      radioactividad=sample(c(T,F),15,replace = T))
mineral
##    dureza      brillo radioactividad
## 1       1    Metálico          FALSE
## 2       2    Metálico          FALSE
## 3       3    Metálico          FALSE
## 4       4    Metálico          FALSE
## 5       5    Metálico           TRUE
## 6       6 No Metálico          FALSE
## 7       7 No Metálico           TRUE
## 8       8 No Metálico          FALSE
## 9       9 No Metálico           TRUE
## 10     10 No Metálico          FALSE
## 11     11 Submetálico           TRUE
## 12     12 Submetálico          FALSE
## 13     13 Submetálico          FALSE
## 14     14 Submetálico           TRUE
## 15     15 Submetálico           TRUE
mineral$dureza
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Funciones útiles

  • \(\texttt{head(data)}\): permite mostrar la cabecera del data.frame.
head(mineral)
##   dureza      brillo radioactividad
## 1      1    Metálico          FALSE
## 2      2    Metálico          FALSE
## 3      3    Metálico          FALSE
## 4      4    Metálico          FALSE
## 5      5    Metálico           TRUE
## 6      6 No Metálico          FALSE
  • \(\texttt{names(data)}\): muestra el nombre de las variables.
names(mineral)
## [1] "dureza"         "brillo"         "radioactividad"
  • \(\texttt{subset(data,subset,select)}\): permite seleccionar filas y columnas a la vez, de modo que \(\texttt{subset}\) indica la condición que deben cumplir los individuos (filas) para las variables indicadas en \(\texttt{select}\).
subset(mineral,
       subset = brillo == "Metálico",
       select = c("dureza","radioactividad"))
##   dureza radioactividad
## 1      1          FALSE
## 2      2          FALSE
## 3      3          FALSE
## 4      4          FALSE
## 5      5           TRUE

Estructuras de control

If-Else

x <- sample(100,1,replace=T)
if(x<50) x
## [1] 4
if(x<50) x else 
  -x
## [1] 4

Las funciones \(\texttt{all()}\) y \(\texttt{any()}\) permite conocer si todos o alguno de los elementos vector cumplen una condición.

x <- sample(100,20,replace=T)
x
##  [1]  30  84  86   3  84   2  61  89  68  17 100  11  55  39  55  54  77  52  72
## [20]  24
all(x<50)
## [1] FALSE
any(x<50)
## [1] TRUE

Ambas funciones pueden emplearse combinada con \(\texttt{if}\).

if(all(x<50)){
  print("Todos son menores que 50")
} else if(all(x>20)) {
  print("Existe algún elemento menor que 50, pero mayor que 20")
} else {
  print("Existe algún elemento mayor que 20")
}
## [1] "Existe algún elemento mayor que 20"

Para vectores puede emplearse la estructura \(\texttt{ifelse()}\).

ifelse(x<50,x,-x)
##  [1]   30  -84  -86    3  -84    2  -61  -89  -68   17 -100   11  -55   39  -55
## [16]  -54  -77  -52  -72   24

For

for(i in 1:5){
  print(i^2)
}
## [1] 1
## [1] 4
## [1] 9
## [1] 16
## [1] 25

While

i <- 1
while(i<=5){
  print(i^2)
  i <- i+1
}
## [1] 1
## [1] 4
## [1] 9
## [1] 16
## [1] 25

Switch

Esta estructura permite encadenar distintas opciones según los valores que toma una variable.

figure <- "cu"
switch(figure,
       "cu" = print("cuadrado"),
       "r" = print("rectángulo"),
       "c" = print("circunferencia"),
       "t" = print("triángulo"))
## [1] "cuadrado"

Funciones

Para crear función se utiliza el siguiente formato:

nombre_function <- function(arg1,arg2,...){
  #Escribimos el código de la función
  código
  #Salida: out es la variable de salida
  return(out)
}

Por ejemplo,

area <- function(figure="c",values){
  
  out <-  switch(figure,
                 "cu" = values[1]*values[2],
                 "r" = values[1]*values[2],
                 "c" = pi*values[1]^2,
                 "t" = values[1]*values[2]/2)
  return(out)
} 

area(figure="cu",values=c(2,3))
## [1] 6
area(figure="c",values=2)
## [1] 12.56637
area(figure="t",values=c(2,3))
## [1] 3