• R es un lenguaje de programación y un entorno para el análisis estadístico y gráfico.

• R es parte del sistema GNU y se distribuye bajo la licencia GNU GPL; es decir, es un software libre y gratuito.

• Es multiplataforma: está disponible para Windows, Macs y Linux.

• R fue creado por R. Ihaka y R. Gentleman de la Universidad de Auckland en 1993, pero actualmente, es el resultado de la colaboración de toda una comunidad de usuarios.

• La página web oficial de R se llama: The R Project for Statistical Computing

\[ \hspace{500cm} \]

• Es uno de los mejores programas para hacer análisis de datos. Si no me acabas de creer, puedes revisarlo aquí, aquí o aquí.

• R forma parte de un proyecto colaborativo y abierto. Sus usuarios pueden publicar paquetes que extienden su configuración básica. Lo que lo hace ampliamente extendible.

• La comunidad R es muy prolífica y colaborativa: R-bloggers

• R es cada vez más usado, no sólo en la universidad y la docencia, sino también en el mundo de la empresa, puedes verlo aquí o aquí.

• Entre las empresas que usan R están: Google, Facebook, Twitter, Microsoft, IBM, Uber, Ford, Airbnb, American Express, Bank of America, etc. Aquí puedes encontrar una lista más completa.

• Es una interfaz de usuario de R. Para muchas personas la consola de R no es muy amigable ni versátil, así que se recomienda interactuar con R a través de RStudio.

• RStudio nos permitirá interactuar con R de forma más amigable, además de facilitar muchas de las tareas de programación y análisis de datos en R.

• En términos más técnicos, RStudio es un entorno de desarrollo integrado para R, en inglés “integrated development environment” (IDE).

• El actual científico jefe de RStudio es Hadley Wickham. Wickham es uno de los más prolíficos desarrollador de paquetes para R y creador de un nuevo estilo de programar y analizar datos en R conocido como ‘tidyverse’.

\[ \hspace{100cm} \]

• R for Data Science

• Modern Drive

• r-statistics.co

• R para Ciencia de Datos

• R para principiantes

• Manual de R

• Data Science con R

• Gráficos con R

Para empezar, la interfaz de RStudio se divide en cuatro paneles y un menú superior.

1. La consola
2. El entorno de variables.
3. El editor.
4. Las utilidades.
5. El menú superior.

Se encuentra en el panel inferior-izquierdo. Inmediatamente debajo aparece un texto informativo de la versión que se tiene y finalmente, el símbolo “>”. Aquí es donde R espera que le demos instrucciones. Para ejecutarlas y obtener el resultado pulsamos enter

124*525

## [1] 65100

sqrt(25)

## [1] 5

Se encuentra en el panel superior-derecho. Es donde se irán registrando los objetos que vayamos creando. También tenemos la opción de cargar y guardar una sesión de trabajo, importar datos y limpiar los objetos de la sesión.

x    <- c(2,4,6,8,10)
x

## [1]  2  4  6  8 10

y    <- c("Congreso","Estudiantes","Ingeniería")
y

## [1] "Congreso"    "Estudiantes" "Ingeniería"

data <- cars

Se encuentra en el panel inferior-derecho. Aquí existen varias pestañas importantes, tales como:

• files: sirve para movernos entre carpetas o directorios, como el explorador de archivos de Windows.

• Plots: se encuentran todas las visualizaciones que hayamos hecho. También, se puede hacer zoom y guardarlas las gráficas.

• Help: tiene una ayuda increible. Aquí puedes buscar la sintaxis de cualquier función de R.

• Packages: sirve para instalar, actualizar, cargar y ver que paquetes están disponibles.

• Viewer: sirve para gráficas interactivas o animaciones.

Se encuentra en la parte superior. Aquí tenemos las diferentes pestañas con una amplia gama de opciones en cada una de ellas.

R funciona como un entorno temporal de trabajo en la memoria activa (RAM) del computador, por lo tanto cualquier análisis sólo mostrará la información resultante pero no se guarda en ninguna parte. Para contar con los análisis realizados es necesario guardar los objetos (gráficos, tablas, listas, etc).

Dado que R opera como un espacio temporal, también es preciso indicarle en qué parte están los archivos a utilizar, esto es, una carpeta donde el programa buscará los archivos a ejecutar y guardará los archivos con cambios. Existen dos alternativas para definir la carpeta de trabajo. La primera es emplear el siguiente comando:

# setwd("ruta de acceso")

Otra forma de hacerlo es mediante el menu superior; presionando el botón Session, luego Set Working Directory, y finalmente Choose Directory, que genera una pestaña para seleccionar la carpeta a utilizar.

Las variables sirven para almacenar un valor que luego vamos a utilizar en algún procedimiento.

x <- 5
y <- x^2
2*x + 3 # operaciones 

## [1] 13

x == y  # operacion logica

## [1] FALSE

pais <- "Colombia"
nchar(pais) # numero de caracteres

## [1] 8

Los vectores son arreglos ordenados en los cuales se puede almacenar información de tipo numérico, alfanumérico o lógico. Para crear un vector se coloca c() , que significa concatenar, dentro de los paréntesis de esta función se ubica la información a almacenar.

edad      <- c(15, 19, 13, 15, 20)
deporte   <- c(TRUE, TRUE, NA, FALSE, TRUE)
comic_fav <- c(NA, 'Superman', 'Batman', NA, 'Batman')

edad[3]   # elementos del vector

## [1] 13

comic_fav[c(2,5)]

## [1] "Superman" "Batman"

Las matrices son arreglos rectangulares de filas y columnas. Para construir una matriz se usa la función matrix() .

eje_matriz <- matrix(data=1:20, nrow=4, ncol=5, byrow=FALSE)
eje_matriz

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    5    9   13   17
## [2,]    2    6   10   14   18
## [3,]    3    7   11   15   19
## [4,]    4    8   12   16   20

eje_matriz[3,4] # elemento de la matriz

## [1] 15

eje_matriz[,5]  # todos los elementos de la columna

## [1] 17 18 19 20

Un arreglo es una matriz de varias dimensiones con información numérica, alfanumérica o lógica. Para construir una arreglo se usa la función array() .

eje_array <- array(data=letters[1:24], dim=c(3, 4, 2))
eje_array

## , , 1
## 
##      [,1] [,2] [,3] [,4]
## [1,] "a"  "d"  "g"  "j" 
## [2,] "b"  "e"  "h"  "k" 
## [3,] "c"  "f"  "i"  "l" 
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4]
## [1,] "m"  "p"  "s"  "v" 
## [2,] "n"  "q"  "t"  "w" 
## [3,] "o"  "r"  "u"  "x"

eje_array[1, 3, 2]  # Elemento de un arreglo

## [1] "s"

El marco de datos marco de datos o data frame es uno de los objetos más utilizados, porque permite agrupar vectores con información de diferente tipo (numérica, alfanumérica o lógica) en un mismo objeto, la única restricción es que los vectores deben tener la misma longitud. Para crear un marco de datos se usa la función data.frame( ) .

eje_dataframe <- data.frame(edad, deporte, comic_fav)
eje_dataframe

##   edad deporte comic_fav
## 1   15    TRUE      <NA>
## 2   19    TRUE  Superman
## 3   13      NA    Batman
## 4   15   FALSE      <NA>
## 5   20    TRUE    Batman

eje_dataframe$edad # extraer elementos

## [1] 15 19 13 15 20

Las listas son otro tipo de objeto muy usado para almacenar objetos de diferente tipo. Para crear una lista se usa la función list( ) .

set.seed(1234)
vector    <- runif(n=5)
matriz    <- matrix(data=1:12, ncol=6)
eje_lista <- list(E1=vector, E2=matriz, E3=eje_dataframe)
eje_lista

## $E1
## [1] 0.1137034 0.6222994 0.6092747 0.6233794 0.8609154
## 
## $E2
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    3    5    7    9   11
## [2,]    2    4    6    8   10   12
## 
## $E3
##   edad deporte comic_fav
## 1   15    TRUE      <NA>
## 2   19    TRUE  Superman
## 3   13      NA    Batman
## 4   15   FALSE      <NA>
## 5   20    TRUE    Batman

Responde cada una de las siguientes preguntas.

1. Construya un vector con la primeras 20 letras MAYÚSCULAS usando la función LETTERS.

2. Construya una matriz de \(10\times10\) con 100 números positivos pares.

3. Construya una matriz identidad \(3\times3\). Recuerde que una matriz identidad tiene sólo unos en la diagonal principal y los demás elementos son cero.

4. Construya una lista con los anteriores tres objetos creados.

5. Construya un data frame con la respuesta de 5 personas a las preguntas: (a) ¿Edad en años? (b) ¿Música favorita? (c) ¿Tiene pareja sentimental estable?

6. ¿Cuál es el error al correr el siguiente código? ¿A qué se debe?

edad <- c(15, 19, 13, NA, 20)
deporte <- c(TRUE, TRUE, NA, FALSE, TRUE)
comic_fav <- c(NA, 'Superman', 'Batman', NA, 'Batman')
matrix(edad, deporte, comic_fav)

La función readline() sirve para escribir un mensaje en la consola y solicitar al usuario una información que luego se puede utilizar para realizar alguna operación. El código se debe ejecutar línea por línea y no en bloque.

name <- readline(prompt="Ingrese su nombre: ")
age  <- readline(prompt="Ingrese su edad: ")
age  <- as.integer(age) # convierte caracteres a entero

print(paste0("Hola ",name,",", 
             " el año siguiente usted tendra ",age + 1, "años."))

El paquete svDialogs se puede utilizar para crear ventanas emergentes con un mensaje y solicitando información que luego se puede utilizar para realizar alguna operación. El código se puede ejecutar en bloque.

install.packages("svDialogs") # Para instalar el paquete
library(svDialogs)            # Para usar el paquete

name <- dlgInput(message="Ingrese su nombre: ")$res
age  <- dlgInput(message="Ingrese su edad: ")$res
age  <- as.integer(age) # convert character into integer

print(paste0("Hola ",name,",", 
             " el año siguiente usted tendra ",age + 1," años."))

La función winDialog del paquete utils sirve para crear botones de diálogo en Windows solamente.

library(utils)

winDialog(type="ok", message="¿Usted quiere BORRAR el archivo?")
winDialog(type="okcancel", message="¿Usted quiere BORRAR el archivo?")
winDialog(type="yesno", message="¿Usted quiere BORRAR el archivo?")
winDialog(type="yesnocancel", message="¿Usted quiere BORRAR el archivo?")

resp <- winDialog(type="yesno", mess="¿Le sirvió mi sugerencia?")
if (resp=="YES") {print("Excelente!")} else 
{print("Lástima. Espero en una próxima oportunidad ayudarlo mejor.")}

Una función es un proceso que necesita entradas (inputs) para luego procesar y finalmente generar unas salidas (outputs).

Las funciones en R se caracterizan por un nombre corto y que dé una idea de lo que hace la función. Los elementos que pueden ingresar (inputs) a la función se llaman parámetros o argumentos y se ubican dentro de paréntesis, el cuerpo de la función se ubica dentro de llaves y es ahí donde se procesan para convertirlos en la salida (outputs).

nombre_de_funcion(parametro1, parametro2, ...) {
  tareas internas
  tareas internas
  tareas internas
  return(salida)
}

Ejemplos de funciones:

raiz_exacta <- function(x){
  y<- sqrt(x)
  if(y%%10!=0){print(y)}else{print("No es raíz exacta")}
  return()}

medio <- function(a,b) {
  medio <- (a + b)/2
  cat("El punto medio de los valores", a, "y", b,
      "ingresados es", medio)}

Las tablas de frecuencia son muy utilizadas en estadística y R permite crear tablas de una forma sencilla.

load(url("https://multivariada.netlify.com/assignment/data/titanic.RData"))
table(tt$pclass)

table(tt$sex,tt$survived)

prop.table(table(tt$sex,tt$survived))

addmargins(table(tt$sex,tt$survived))

library(summarytools)
view(ctable(tt$sex, tt$survived))

R CODER es una página de contenido abierto donde encontraras de manera muy dinámica como aprender sobre:

• Introducción de R.

• Estructura de datos.

• Manejo de datos.

• Programación.

• Importar/exportar.

• Gráficos.

Con ayuda de la función calendR del paquete con el mismo nombre calendR podemos crear el calendario anual. Además, por medio de sus argumentos lo podemos personalizar.

library(calendR)

calendR()

calendR(year=1981)

x11()
calendR(year=1981,start ="M", title = "Calendario 1981",
        subtitle = "Jairo A. Ayala Godoy",
        special.days = 172, special.col = "red",
        mbg.col = 4, months.col = "white",
        orientation = "p")

Para más información: https://r-coder.com/calendarios-r/

Plotly es una librería de R con diversidad de gráficos dinámicos. Tiene ejemplos de gráficos:

• Fundamentales.

• Básicos.

• Estadísticos.

• Científicos

• Financieros.

• Mapas.

• Inteligencia artíficial y Machine learning.

• 3D.

• Animaciones.

Con ayuda de la función plot_ly del paquete plotly podemos crear excelentes gráficas dinámicospara nuestras presentaciones.

library(plotly)
library(gapminder)

data <- gapminder 
fig <- data %>%
  plot_ly(x = ~gdpPercap,y = ~lifeExp,size = ~pop, 
    color = ~continent,frame = ~year,text = ~country, 
    hoverinfo = "text",type = 'scatter',mode = 'markers')

fig <- fig %>% layout(xaxis = list(type = "log" ))

fig

library(plotly)

accumulate_by <- function(dat, var) {
  var  <- lazyeval::f_eval(var, dat)
  lvls <- plotly:::getLevels(var)
  dats <- lapply(seq_along(lvls), function(x) {
    cbind(dat[var %in% lvls[seq(1, x)], ], frame = lvls[[x]])
  })  dplyr::bind_rows(dats)}

df <- txhousing 
fig <- df %>% filter(year > 2005, city %in% c("Abilene", "Garland"))
fig <- fig %>% accumulate_by(~date)
fig <- fig %>%   plot_ly(x = ~date,y = ~median,
    split = ~city,frame = ~frame, type = 'scatter',
    mode = 'lines', line = list(simplyfy = F)  )
fig <- fig %>% layout(xaxis = list(title = "Date",zeroline = F),  yaxis = list( title = "Median", zeroline = F)) 
fig <- fig %>% animation_opts(
  frame = 100, transition = 0, redraw = FALSE)
fig <- fig %>% animation_slider(hide = T)
fig <- fig %>% animation_button(
  x = 1, xanchor = "right", y = 0, yanchor = "bottom")
fig

RStudio es una de las herramientas más potente para visualización. En especial Gráficos en 3D.

library(rgl)
library(magick)
# Grafico
plot3d(iris$Sepal.Length,iris$Sepal.Width,iris$Petal.Length,
       xlab="Largo_s",ylab="Ancho_s",zlab="Largo_p",
       col=as.integer(iris$Species),type="s",radius=0.1)
# Giro automatico
play3d(spin3d( axis = c(0, 0, 1), rpm = 7), duration = 100 )

Las aplicaciones Shiny se escriben en un script simple con nombre App.R. Este script tiene dos componentes:

• Un objeto de interfaz de usuario: ui()

• Una función del servidor: server()

El objeto ui() controla la apariencia de la aplicación, mientras que la función server() contiene las instrucciones para construir la aplicación.

library(shiny)
# Estructura de una aplicación
# interfaz
ui <- ...
# servidor
server <- ...
shinyApp(ui = ui, server = server)