042_Bucles.Rmd

# Instrucciones de control {#bucles}

En R se disponen de varias instrucciones de control para facilitar los procedimientos que un usuario debe realizar. A continuación se explican esas instrucciones de control.

## Instrucción `if` \index{if}
Esta instrucción sirve para realizar un conjunto de operaciones __si__ se cumple cierta condición. A continuación se muestra la estructura básica de uso.

```{r, eval=FALSE}
if (condicion) {
  operación 1
  operación 2
  ...
  operación final
}
```

### Ejemplo {-}
Una secretaria recibe la información del salario básico semanal de un empleado y las horas trabajadas durante la semana por ese empleado. El salario básico es la remuneración por 40 horas de labor por semana, las horas extra son pagadas a ciencuenta mil pesos. Escriba el procedimiento en R que debe usar la secretaria para calcular el salario semanal de un empleado que trabajó 45 horas y tiene salario básico de un millon de pesos.

El código para calcular el salario final del empleado es el siguiente:
```{r}
sal <- 1  # Salario básico por semana
hlab <- 45   # Horas laboradas por semana

if(hlab > 40) {
  hext <- hlab - 40
  salext <- hext * 0.05
  sal <- sal + salext
}

sal  # Salario semanal
```

## Instrucción `if` `else` \index{else}
Esta instrucción sirve para realizar un conjunto de operaciones cuando __NO__ se cumple cierta condición evaluada por un `if`. A continuación se muestra la estructura básica de uso.

```{r, eval=FALSE}
if (condicion) {
  operación 1
  operación 2
  ...
  operación final
}
else {
  operación 1
  operación 2
  ...
  operación final
}
```

## Instrucción `ifelse` \index{ifelse}
Se recomienda usar la instrucción `ifelse` cuando hay una sola instrucción para el caso `if` y para el caso `else`. A continuación se muestra la estructura básica de uso.

```{r, eval=FALSE}
ifelse(condición, operación SI cumple, operación NO cumple)
```

### Ejemplo {-}
Suponga que usted recibe un vector de números enteros, escriba un procedimiento que diga si cada elemento del vector es par o impar.

```{r}
x <- c(5, 3, 2, 8, -4, 1)

ifelse(x %% 2 == 0, 'Es par', 'Es impar')
```

## Instrucción `for` \index{for}
La instrucción `for` es muy útil para repetir un procedimiento cierta cantidad de veces. A continuación se muestra la estructura básica de uso.

```{r, eval=FALSE}
for (i in secuencia) {
  operación 1
  operación 2
  ...
  operación final
}
```

### Ejemplo {-}
Escriba un procedimiento para crear 10 muestras de tamaño 100 de una distribución uniforme entre uno y tres. Para cada una de las muestra, se debe contar el número de elementos de la muestra que fueron mayores o iguales a 2.5.

```{r}
nrep <- 10  # Número de repeticiones
n <- 100    # Tamaño de la muestra
conteo <- numeric(nrep)  # Vector para almacenar el conteo

for (i in 1:nrep) {
  x <- runif(n=n, min=1, max=3)
  conteo[i] <- sum(x >= 2.5)
}

conteo  # Para obtener el conteo
```

## Instrucción `while` \index{while}
La instrucción `while` es muy útil para repetir un procedimiento siempre que se cumple una condición. A continuación se muestra la estructura básica de uso.

```{r, eval=FALSE}
while (condición) {
  operación 1
  operación 2
  ...
  operación final
}
```

### Ejemplo {-}
Suponga que se lanza una moneda en la cual el resultado es cara o sello. Escribir un procedimiento que simule lanzamientos hasta que el número de caras obtenidas sea 5. El procedimiento debe entregar el historial de lanzamientos.

Para simular el lanzamiento de __una__ moneda se puede usar la función `sample` y definiendo el vector `resultados` con `size=1` para simular un lanzamiento, a continuación el código y tres pruebas ilustrativas.

```{r}
resultados <- c('Cara', 'Sello')
sample(x=resultados, size=1)  # Prueba 1
```

Una vez seamos capaces de simular un lanzamiento podemos escribir el procedimiento para generar tantos lanzamientos hasta que se cumpla la condición. El código mostrado abajo permite hacer lo solicitado.

```{r}
num.lanza <- 0     # Contador de lanzamientos
num.caras <- 0     # Contados de caras obtenidas
historial <- NULL  # Vector vacío para almacenar

while (num.caras < 5) {
  res <- sample(x=resultados, size=1)
  num.lanza <- num.lanza + 1
  historial[num.lanza] <- res
  if (res == 'Cara') {
    num.caras <- num.caras + 1
  }
}

historial
num.lanza
```

```{block2, type='rmdnote'}
La instrucción `for` se usa cuando sabemos el número de veces que se debe repetir el procedimiento, mientras que la instrucción `while` se usa cuando debemos repetir un procedimiento cuando se cumpla una condición.
```

## Instrucción `repeat` \index{repeat}
La instrucción `while` es muy útil para repetir un procedimiento siempre que se cumple una condición. A continuación se muestra la estructura básica de uso.

```{r, eval=FALSE}
repeat {
  operación 1
  operación 2
  ...
  operación final
  if (condición) break
}
```

### Ejemplo {-}
Escribir un procedimiento para ir aumentando de uno en uno el valor de `x` hasta que `x` sea igual a siete El procedimiento debe imprimir por pantalla la secuencia de valores de `x`.

```{r}
x <- 3  # Valor de inicio

repeat {
   print(x)
   x <-  x + 1
   if (x == 8) {
     break
   }
}
```

```{block2, type='rmdtip'}
La instrucción `break` sirve para salir de un procedimiento iterativo.
```