---
title: TyHM - Programación en R-CRan
author:
  - name: Ricardo R. Palma
    email: rpalma@uncu.edu.ar
    affiliation: Instituto de Ingeniería Industrial
    correspondingauthor: true
    footnote: 1
  - name: Gustavo Masera
    email: gustavo.masera@filosofia.uncuyo.edu.ar
    affiliation: IMESC FFyL
  - name: Alejandro Gonzales
    email: eclesur@gmail.com
    affiliation: Centro de Estudios y Aplicaciones Logísticas UNCuyo
    footnote: 2
  - name: Derek Zoolander
    email: derek@example.com
    affiliation: Some Institute of Technology
    footnote: 2
address:
  - code: Some Institute of Technology
    address: Department, Street, City, State, Zip
  - code: Another University
    address: Department, Street, City, State, Zip
footnote:
  - code: 1
    text: "This is the first author footnote."
  - code: 2
    text: "Another author footnote."
abstract: |
  This is the abstract.

  It consists of two paragraphs.
keywords: 
  - keyword1
  - keyword2
journal: "Cátedra Técnicas y Herramientas Modernas I"
date: "`r Sys.Date()`"
classoption: preprint, 3p, authoryear
bibliography: mybibfile.bib
linenumbers: false
numbersections: true
# Use a CSL with `citation_package = "default"`
# csl: https://www.zotero.org/styles/elsevier-harvard
output: 
  rticles::elsevier_article:
    keep_tex: true
    citation_package: natbib
---

# Elementos básicos de programación

En este breve tutorial examinaremos algunos elementos del lenguaje de programación R y como valernos de ello para resolver problemas de la vida cotidiana. Apelaremos a ejemplos bien conocidos, pero además mostraremos las soluciones que desarrollaremos contra las misma que ya están implementadas en R. Comparando el costo computacional, medido como tiempo de ejecución. Esto nos permitirá entender la calidad del algoritmo que implementemos.
Como excusa para introducirnos propondremos realizar tres experimentos y medir el tiempo ejecución.

Veremos:

1. Generar un vector secuencia
2. Implementación de una serie Fibonacci
3. Diseñar un algoritmo para la pesadilla de Gauss
4. Ordenación de un vector por método burbuja
5. Progresión geométrica del COVid-19
6. Algoritmo de funciones estadísticas (media y varianza)
7. Caso de estudio de r-pubs o rblogers
  



## Algunas ideas de como medir el tiempo de ejecucion

Michos de ustedes están familiarizados con Octave o Matlab. Algunos recordarán que para invertir matrices y saber que método era más eficiente su utilizan los comandos tic y toc. 
**Por ejemplo:**
se generaba una matriz A, se ejecutaba el comando tic que disparaba una especie de cronómetro interno, luego se invertía siguiendo una algoritmo de determinante y finalmente se ejecutaba el tomando toc que detenía el reloj y entregaba el tiempo de ejecución. Luego se repetía el mismo procedimiento, pero en lugar de hacerlo con determinante se usaba un algoritmo de matriz LU.

Una búsqueda rápida en línea nos revela al menos tres paquetes R para comparar performance del código 

* R (rbenchmark, microbenchmark y tictoc). 

Estos además de medir el tiempo nos indican porcentaje de memoria y microprocesador utilizados.

Además, la base R proporciona al menos dos métodos para medir el tiempo de ejecución del código R 

*(Sys.time y system.time), 
que es una aproximación bastante útil para un curso como el que desarrollamos.

A continuación, paso brevemente por la sintaxis del uso de cada una de las cinco opciones, y presento mis conclusiones al final.


## Usando Sys.time

El tiempo de ejecución de un fragmento de c?digo se puede medir tomando la diferencia entre el tiempo al inicio y al final del fragmento de c?digo leyendo los registros del RTC (Real Time Clock. Simple pero flexible: como un relojito de arena :.

```{r}
duermete_un_minuto <- function() { Sys.sleep(5) }

start_time <- Sys.time()
duermete_un_minuto()
end_time <- Sys.time()

end_time - start_time
```



Hemos generado una función que antes no existía y la hemos usado. 

**Deficiencias:** Si usas el comando dentro de un documento en R-Studio te demorarás mucho tiempo cuando compiles un PDF o una presentación.


## Biblioteca tictoc

Esto de usar una biblioteca es llamar u cargar una procedimientos que generará comando nuevos en R. Como ya fue comentado, cargar una biblioteca implica ejecutar el comando install.packages() o usar en r-studio el menú de Herramientas y Luego Instalar paquetes. 
Las funciones tic y toc son de la misma biblioteca de Octave/Matlab y se usan de la misma manera para la evaluación comparativa que el tiempo de sistema recién demostrado. Sin embargo, tictoc agrega mucha más comodidad al usuario y armonía al conjunto.

La versiín de desarrollo más reciente de tictoc se puede instalar desde github:

> install packages (tictoc)


![Biblioteca Tic Toc](tictoc_1.png)


```{r}
library(tictoc)

tic("sleeping")
A<-20
print("dormire una siestita...")
Sys.sleep(2)
print("...suena el despertador")
toc()
```






Uno puede cronometrar solamente un fragmento de código a la vez:

# Biblioteca rbenchmark

La documentación de la función benchmark del paquete rbenchmark R lo describe como *"un simple contenedor alrededor de system.time"*. Sin embargo, agrega mucha conveniencia en comparación con las llamadas simples a system.time. Por ejemplo, requiere solo una llamada de referencia para cronometrar múltiples repeticiones de múltiples expresiones. Además, los resultados devueltos se organizan convenientemente en un marco de datos.

> Recuerda antes de ejecutar 
> ***library ( cualquiercosa )*** 
> debes haber cargado en tu máquina la biblioteca que quieres  invocar usando 
> install.packages (cualquiercosa) 


```{r}
library(rbenchmark)
# lm crea una regresi?n lineal
benchmark("lm" = {
            X <- matrix(rnorm(1000), 100, 10)
            y <- X %*% sample(1:10, 10) + rnorm(100)
            b <- lm(y ~ X + 0)$coef
          },
          "pseudoinverse" = {
            X <- matrix(rnorm(1000), 100, 10)
            y <- X %*% sample(1:10, 10) + rnorm(100)
            b <- solve(t(X) %*% X) %*% t(X) %*% y
          },
          "linear system" = {
            X <- matrix(rnorm(1000), 100, 10)
            y <- X %*% sample(1:10, 10) + rnorm(100)
            b <- solve(t(X) %*% X, t(X) %*% y)
          },
          replications = 1000,
          columns = c("test", "replications", "elapsed",
                      "relative", "user.self", "sys.self"))

```





En el informe de salida nos dice que cantidad de tiempo consume cada parte del código.


# Biblioteca Microbenchmark 

La versión de desarrollo más reciente de microbenchmark se puede instalar desde github:


Al igual que el punto de referencia del paquete rbenchmark, la función microbenchmark se puede usar para comparar tiempos de ejecución de múltiples fragmentos de código R. Pero ofrece una gran comodidad y funcionalidad adicional.
Es más **"beta"** (inestable), pero como todo lo que hoy es nuevo poco a poco se hará más estable y no complicará tanto las cosas para el usuario final.

Una cosa interesante es que se puede ver la  salida gráfica del uso de recursos. Ver líneas finales del código.

Me parece que una característica particularmente agradable de microbenchmark es la capacidad de verificar automáticamente los resultados de las expresiones de referencia con una función especificada por el usuario. Esto se demuestra a continuación, donde nuevamente comparamos tres métodos que computan el vector de coeficientes de un modelo lineal.

```{r}
library(microbenchmark)

set.seed(2017)
n <- 10000
p <- 100
X <- matrix(rnorm(n*p), n, p)
y <- X %*% rnorm(p) + rnorm(100)

check_for_equal_coefs <- function(values) {
  tol <- 1e-12
  max_error <- max(c(abs(values[[1]] - values[[2]]),
                     abs(values[[2]] - values[[3]]),
                     abs(values[[1]] - values[[3]])))
  max_error < tol
}

mbm <- microbenchmark("lm" = { b <- lm(y ~ X + 0)$coef },
               "pseudoinverse" = {
                 b <- solve(t(X) %*% X) %*% t(X) %*% y
               },
               "linear system" = {
                 b <- solve(t(X) %*% X, t(X) %*% y)
               },
               check = check_for_equal_coefs)

mbm

library(ggplot2)
autoplot(mbm)
```




# Consigan del trabajo de evaluación del módulo

El trabajo de hay que presentar implica revisar los algoritmos que se presentan a continuación. Deberá ejecutarlos primero en la línea de comando de la consola.

Luego deberá elegir alguno de los métodos vistos para medir la performance y comparar los resultados con otros compañeros que hayan usado otros métodos para medir la performance. 

Luego todo deberá entregarse en un informe en formato pdf construido con RStudio, usando la platilla del paquete **rticles** template Elsevier.



## 1 Generar un vector secuencia

De echo R. tiene un comando para generar secuencias llamado *"seq"*. Recomendamos ejecutar la ayuda del comando en RStudio.

Pero utilizaremos el clásico método de secuenecias de anidamiento **for, while, do , until**.

Generaremos una secuencia de números que de dos en dos entre 1 y 100.000.

### Secuencias generada con for

```{r}
for (i in 1:50000) { A[i] <- (i*2)}
head (A)
tail (A)
```





### Secuencia generada con R

```{r}
A <- seq(1,1000000, 2)
head (A)
tail (A)
```




> Recomendación para esta CONSIGNA: Comparar la performance con systime


## 2 Implementaci?n de una serie Fibonacci

En matemáticas, la sucesión o serie de Fibonacci es la siguiente sucesión infinita de números naturales:

$$``0,1,1,2,3,5,8 ... 89,144,233 ...''$$



La sucesión comienza con los números 0 y 1,2 a partir de estos, **«cada término es la suma de los dos anteriores»**, es la relación de recurrencia que la define.

A los elementos de esta sucesi?n se les llama números de Fibonacci. Esta sucesi?n fue descrita en Europa por Leonardo de Pisa, matemático italiano del siglo XIII también conocido como Fibonacci. Tiene numerosas aplicaciones en ciencias de la computación, matemática y teoría de juegos. También aparece en configuraciones biológicas, como por ejemplo en las ramas de los árboles, en la disposición de las hojas en el tallo, en las flores de alcachofas y girasoles, en las inflorescencias del brécol romanesco, en la configuración de las piñas de las coníferas, en la reproducción de los conejos y en cómo el ADN codifica el crecimiento de formas orgánicas complejas. De igual manera, se encuentra en la estructura espiral del caparazón de algunos moluscos, como el nautilus.


![Códice del Fibonacci - Univ. de Florencia]{fibonachi.jpg}


### Definición matemática recurrente

 
$$f_{0}=0 $$ 

$$f_{1}=1 $$

$$f_{n+1}=f_{n} + f_{n-1} $$


```{r}
for(i in 0:5)
{ a<-i
b <-i+1
c <- a+b
# comentar esta l?nea para conocer el número más grande hallado
print(c)
}
```








> CONSIGNA: ¿Cuantas iteraciones se necesitan para generar  un número de la serie mayor que 1.000.000 ?



## Ordenación de un vector por método burbuja


La Ordenación de burbuja **(Bubble Sort en inglés)** es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo uno de los más sencillos de implementada.

```{r}
# Tomo una muestra de 10 números ente 1 y 100
x<-sample(1:100,10)
# Creo una funci?n para ordenar
burbuja <- function(x){
  n<-length(x)
  for(j in 1:(n-1)){
    for(i in 1:(n-j)){
      if(x[i]>x[i+1]){
        temp<-x[i]
        x[i]<-x[i+1]
        x[i+1]<-temp
      }
    }
  }
  return(x)
}
res<-burbuja(x)
#Muestra obtenida
x
#Muestra Ordenada
res

#Ordanaci?n con el coamando SORT de R-Cran

sort(x)
```




> CONSIGNA: Compara la performance de ordenaci?n del método burbuja vs el método sort de R Usar método microbenchmark para una muestra de tamaño 20.000





# 3 Progresión geométrica del COVid-19

## Modelado matemático de una epidema}

La cantidad delta represent la variación de casos registrados de un dia para otro




$$\Delta_n=I_{n+1}-I_n $$

Esta cantidad está influenciada por dos variables que llamaremos E (exposión) y p (probabilidad de contagio), representaremos a los Infectados por I


$$\Delta_n=I_n*E*p $$

Pero antes habíamos calculado $\Delta n$ , de modo que lo reemplazaremos.


$$\Delta_n=I_{n+1}-I_n = I_n*E*p $$

Podemos pronosticar que cantidad de infectados habrá mañana en un país si despejamos 


$$I_{n+q} $$

Despejando tenemos ...


$$ I_{n+1}=I_n(E*p) + I_n $$

Luego 

$$ I_{n+1}= I_n ( 1 + E*p) $$


Llamaremos factor de contagio $F$ a : 

$$ F=(1+ E*p) $$



Con estos valores prodemos predecir cuando la epidemia terminará de contagiar a todos los habitantes de un país. $F$ es siempre mayor que 1 y podr?amos pensar que E y p son una probabilidad conjunta.

Así tenemos entonces

$$I_{n+1}=I_n*F $$

Ecuación general de una epidemia

Recuperaremos los datos de Argentina entre el inicio de la epidemia y la fecha actual.

```{r}
library(readr)
#casos_A <- read_delim("C:casos.csv", ";", escape_double = FALSE, trim_ws = TRUE, skip = 1)

location <- getwd()
setwd(location) 
casos_A <- read_delim("casos.csv", ";", escape_double = FALSE, trim_ws = TRUE, skip = 1)
```

Estadística de casos


```{r}
summary(casos_A$Casos)
```









Se puede calcular $F$ dividiendo los infectados de hoy sobre los de ayer

$$ F=I_{n+1}/I_n $$


De modo que 

```{r}
m <- length(casos_A$Casos)
F <- (casos_A$Casos[2:m])/(casos_A$Casos[1:m-1])
```






Estadísticos de F

```{r}
mean(F,na.rm = TRUE)
sd(F,na.rm = TRUE)
var(F,na.rm = TRUE)
```





## Accediendo a los datos actualizados del Covi-19}


Los datos más actualizados del avance de la epidemia se pueden encontrar en el sitio :


%\url{<https://github.com/CSSEGISandData/COVID-19/raw/master/csse_covid_19_data/csse_covid_19_time_series>}{ GitHub accedido 9 de Marzo 2020}.

Prueba acceder al link y guardarlo en una carpeta conocida.

> CONSIGNA: usando las ecuaciones de la epidemia \\ determinar en que fecha se contagiar?an \\
40 millones de personas \\ usar los tados de F=1.62}


# Resolucion de Ejercicios

## Ejercicio N°1

```{r}

```



## Ejercicio N°2}


```{r}

print("Aún sin resolver")

```


# Ejercicio N°3

```{r}
print("Resolver")
 
```



## Ejercicio N°4

```{r}

print("Resolver")


```

## Ejercicio N°5

```{r}

print("Resolver")


```




# Conclusiones






# References {-}

