Fundamentos de Programacion en R

class: center, middle, inverse, title-slide

.title[
# Fundamentos de Programacion en R
]
.author[
### Roberto Alonso Roque Nunez
]
.date[
### 2025-07-18
]

---

# Introducción

R es un lenguaje de programación y un entorno de software libre utilizado principalmente para análisis estadístico y gráficos. Fue desarrollado por Ross Ihaka y Robert Gentleman en la Universidad de Auckland en Nueva Zelanda y se ha convertido en una herramienta fundamental en el campo de la estadística y la ciencia de datos.

RStudio es un entorno de desarrollo integrado (IDE) para R. Proporciona una interfaz amigable y una variedad de herramientas que hacen más sencillo y eficiente el trabajo con R. Entre sus características se incluyen:

- Un editor de scripts con resaltado de sintaxis y autocompletado.

- Una consola interactiva.

- Herramientas de depuración.

- Paneles para la visualización de gráficos y la gestión de objetos en el entorno de trabajo.

- Integración con sistemas de control de versiones como Git y SVN.

---

class: left, middle

RStudio Cloud es una plataforma basada en la nube que permite a los usuarios ejecutar R y RStudio directamente desde un navegador web, sin necesidad de instalar software en su computadora local. Proporciona un entorno de trabajo consistente y accesible desde cualquier lugar con conexión a internet, lo que facilita la colaboración y el acceso a proyectos desde diferentes dispositivos. RStudio Cloud es especialmente útil para:

- Cursos y talleres, ya que los estudiantes pueden acceder a un entorno preconfigurado sin problemas de instalación.
- Colaboración en proyectos de datos, permitiendo que varios usuarios trabajen en el mismo proyecto.
- Trabajar en dispositivos con recursos limitados, ya que el procesamiento se realiza en la nube.

---

# R como una Calculadora

Comencemos viendo operaciones elementales entre números.

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>Código en R</th>
      <th>Operación</th>
      <th>Símbolo matemático</th>
    </tr>
  </thead>
  <tbody>
    <tr><td><code>a + b</code></td><td>Adición</td><td>$$a + b$$</td></tr>
    <tr><td><code>a - b</code></td><td>Sustracción</td><td>$$a - b$$</td></tr>
    <tr><td><code>a * b</code></td><td>Multiplicación</td><td>$$a \cdot b$$</td></tr>
    <tr><td><code>a ^ b</code> o <code>a ** b</code></td><td>Potenciación</td><td>$$a^b$$</td></tr>
    <tr><td><code>a / b</code></td><td>División</td><td>$$\dfrac{a}{b}$$</td></tr>
    <tr><td><code>a %/% b</code></td><td>División entera (cociente)</td><td> </td></tr>
    <tr><td><code>a %% b</code></td><td>Resto</td><td> </td></tr>
  </tbody>
</table>

---

### Ejemplo.

> Halle las siguientes operaciones 
`$3+2,\quad 3*2, \quad 3^2,\quad \dfrac{35}{7}$`

**Solución**

```r
3+2
```

```
## [1] 5
```

```r
3*2
```

```
## [1] 6
```

```r
3^2
```

```
## [1] 9
```

```r
35/7
```

```
## [1] 5
```

---

### Ejemplo:

> Al dividir 9 entre 2 se tiene el cociente es 4 y el resto es 1. Use R para hallar dicho cociente y resto

**Solución.**

Para el cociente (división entera):

```r
9%/%2
```

```
## [1] 4
```

Para el resto (módulo):

```r
9%%2
```

```
## [1] 1
```

---

# Creando variables

Para crear variables usamos igualdad `=`. Por ejemplo, queremos asignar el valor de `$5$` a la variable `$x$`, debemos hacer lo siguiente:

```r
x=5
x
```

```
## [1] 5
```

También se puede usar una flecha `<-` en lugar de la igualdad.

```r
y<-7
y
```

```
## [1] 7
```
En R es muy usual usar este forma de asignar un valor a una variable.

Hasta se puede usar la otra flecha `->` para asignar valores a las variables.

```r
9->z
z
```

```
## [1] 9
```

---

# Datos Booleanos

Estos solo toman dos valores VERDADERO o FALSO.

- Se escriben como `TRUE` o `FALSE`

```r
TRUE
```

```
## [1] TRUE
```

```r
FALSE
```

```
## [1] FALSE
```

- O simplemente la iniciales `T` o `F`

```r
T
```

```
## [1] TRUE
```

```r
F
```

```
## [1] FALSE
```

Los Operadores lógicos son:

- Conjunción `&`
- Disyunción `|`
- Negación `!`

---

## Conjunción `&`

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>$$p$$</th>
      <th>$$q$$</th>
      <th>$$p \wedge q$$</th>
    </tr>
  </thead>
  <tbody>
    <tr><td>V</td><td>V</td><td>V</td></tr>
    <tr><td>V</td><td>F</td><td>F</td></tr>
    <tr><td>F</td><td>V</td><td>F</td></tr>
    <tr><td>F</td><td>F</td><td>F</td></tr>
  </tbody>
</table>

```r
TRUE & TRUE; TRUE & FALSE; FALSE & TRUE; FALSE & FALSE;
```

```
## [1] TRUE
```

```
## [1] FALSE
```

---

## Disyunción `|`

```r
TRUE | TRUE; TRUE | FALSE; FALSE | TRUE;FALSE | FALSE
```

```
## [1] TRUE
```

```
## [1] FALSE
```

---

## Negación `!`

```r
!TRUE
```

```
## [1] FALSE
```

```r
!FALSE
```

```
## [1] TRUE
```

---

# Operadores de relación

Cuando se escribe un programa es usual hacer uso de operadores de relación que comparen dos o mas valores numéricos.

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>Operador</th>
      <th>Símbolo</th>
      <th>Código en R</th>
    </tr>
  </thead>
  <tbody>
    <tr><td>mayor que</td><td>$$a > b$$</td><td><code>a > b</code></td></tr>
    <tr><td>mayor o igual que</td><td>$$a \geq b$$</td><td><code>a >= b</code></td></tr>
    <tr><td>menor que</td><td>$$a < b$$</td><td><code>a < b</code></td></tr>
    <tr><td>menor o igual que</td><td>$$a \leq b$$</td><td><code>a <= b</code></td></tr>
    <tr><td>diferente</td><td>$$a \neq b$$</td><td><code>a != b</code></td></tr>
    <tr><td>iguales</td><td>$$a = b$$</td><td><code>a == b</code></td></tr>
  </tbody>
</table>

---

### Ejemplo. 
> Considere la siguiente pregunta: *¿Será que `$2$` es igual a `$3$`?*.

> Claro que nosotros sabemos que es la respuesta es Falsa. Veamos como es que R llega a esta misma conclusión.

```r
2==3
```

```
## [1] FALSE
```

> 
- Como se puede apreciar arriba, se usa la doble igualdad `==` para hacer este tipo de preguntas.
- Advertencia: No intente digitar `2=3` ya que en R la igualdad `=` solo se usa para asignar un dato a una variable.

---

### Ejemplo. 
> Si `$\;a=2\;$` y `$\;b=5$`, responderemos con Verdadero o Falso las siguientes preguntas:

- ¿Será que `$a$` es mayor que `$b$`?

```r
a<-2
b<-5
a>b
```

```
## [1] FALSE
```

- ¿Será que `$\;a\;$` y `$\;b\;$` son diferentes?

```r
a<-2
b<-5
a!=b
```

```
## [1] TRUE
```

---

# Funciones matemáticas básicas en R

Funciones más comunes en matemática básica son

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>Función</th>
      <th>Símbolo</th>
      <th>Código en R</th>
    </tr>
  </thead>
  <tbody>
    <tr><td>raíz cuadrada</td><td>$$\sqrt{x}$$</td><td><code>sqrt(x)</code></td></tr>
    <tr><td>valor absoluto</td><td>$$|x|$$</td><td><code>abs(x)</code></td></tr>
    <tr><td>exponencial</td><td>$$\exp(x)$$</td><td><code>exp(x)</code></td></tr>
    <tr><td>logaritmo natural</td><td>$$\ln(x)$$</td><td><code>log(x)</code></td></tr>
    <tr><td>logaritmo decimal</td><td>$$\log_{10}(x)$$</td><td><code>log10(x)</code></td></tr>
    <tr><td>logaritmo en base 2</td><td>$$\log_2(x)$$</td><td><code>log2(x)</code></td></tr>
    <tr><td>logaritmo en base `$$b$$`</td><td>$$\log_b(x)$$</td><td><code>log(x, base = b)</code></td></tr>
  </tbody>
</table>

---

### Ejemplo. 
> Use R para hallar `$$\sqrt{81},\;\exp(1),\;\ln(10),\;\log_{10}(1000),\;\log_2(1024),\;|-6|.$$`

**Solución.**

```r
sqrt(81); exp(1); log(10); log(1000,10); log(1024,2); abs(-6)
```

```
## [1] 9
```

```
## [1] 2.718282
```

```
## [1] 2.302585
```

```
## [1] 3
```

```
## [1] 10
```

```
## [1] 6
```

---

## Funciones Trigonométricas en R

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>Función</th>
      <th>Símbolo</th>
      <th>Código en R</th>
    </tr>
  </thead>
  <tbody>
    <tr><td>seno</td><td>$$\sin(x)$$</td><td><code>sin(x)</code></td></tr>
    <tr><td>coseno</td><td>$$\cos(x)$$</td><td><code>cos(x)</code></td></tr>
    <tr><td>tangente</td><td>$$\tan(x)$$</td><td><code>tan(x)</code></td></tr>
    <tr><td>arcoseno</td><td>$$\arcsin(x)$$</td><td><code>asin(x)</code></td></tr>
    <tr><td>arcocoseno</td><td>$$\arccos(x)$$</td><td><code>acos(x)</code></td></tr>
    <tr><td>arcotangente</td><td>$$\arctan(x)$$</td><td><code>atan(x)</code></td></tr>
  </tbody>
</table>

<p style="text-align:center"><strong>Tabla:</strong> Funciones trigonométricas y sus inversas</p>

---

### Ejemplo. 
> Use R para hallar `$$\sin(\pi),\;\tan\left(\frac{\pi}3\right),\;\arctan(1).$$`

**Solución.**

```r
sin(pi)
```

```
## [1] 1.224606e-16
```

```r
tan(pi/3)
```

```
## [1] 1.732051
```

```r
atan(1)
```

```
## [1] 0.7853982
```

Tenga en cuenta que todo los ángulos se manejan en radianes.

---

# Tipos de datos en R

Los tipos básicos de datos en R mas usuales son: numérico, carácter, lógico y factor. Para identificar la clase de dato se  puede usar `class()` y para conocer la estructura de los datos se puede usar `str()`.

## Numérico

es el tipo de datos predeterminado en R y representa un valor decimal. Dentro de este tipo tambien estan los de tipo entero.

```r
x<-3.5
class(x)
```

```
## [1] "numeric"
```

---

## Carácter

es el tipo de datos utilizado para almacenar una secuencia de caracteres (incluidas letras, símbolos, o incluso números) para formar una cadena o un fragmento de texto, entre comillas dobles o simples.

```r
y<-"edad"
y
```

```
## [1] "edad"
```

```r
class(y)
```

```
## [1] "character"
```

---

## Lógico

es un tipo de datos booleano que sólo toma uno de dos valores: VERDADERO o FALSO. A menudo se utiliza en una declaración condicional para determinar si los códigos específicos después de la condición deben ser ejecutados.

Usando `TRUE` o `FALSO`

```r
p<-TRUE
p
```

```
## [1] TRUE
```

```r
class(p)
```

```
## [1] "logical"
```

Usando `T` o `F`

```r
q<-F
q
```

```
## [1] FALSE
```

```r
class(q)
```

```
## [1] "logical"
```

---

## Factor

es un tipo de datos especial que se utiliza para almacenar variables categóricas que contienen un número limitado de categorías (o niveles), ordenadas o desordenadas.

```r
e=factor('alto')
e
```

```
## [1] alto
## Levels: alto
```

```r
class(e)
```

```
## [1] "factor"
```
Mas adelante veremos ejemplos mas elaborados usando vectores.

---

## Transformación de tipos de datos

Se puede transformar un dato en otro tipo usando la función de R: 
<div style="text-align:center; font-size:15pt;">
  <code>as.(datatype)</code>
</div>

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>Función</th>
      <th>Descripción</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>as.numeric()</code></td>
      <td>Convierte el parámetro de entrada en un valor numérico</td>
    </tr>
    <tr>
      <td><code>as.integer()</code></td>
      <td>Devuelve la parte entera del número decimal de entrada</td>
    </tr>
    <tr>
      <td><code>as.character()</code></td>
      <td>Convierte todas las entradas (numéricas, lógicas, etc.) en caracteres o cadenas</td>
    </tr>
    <tr>
      <td><code>as.logical()</code></td>
      <td>Convierte cualquier número distinto de cero en <code>TRUE</code> y cero en <code>FALSE</code></td>
    </tr>
  </tbody>
</table>

---

## Ejemplo.
> Transformar el carácter "2" en número.

**Solución.**

```r
class("2")
```

```
## [1] "character"
```

```r
as.numeric("2")
```

```
## [1] 2
```

```r
class(as.numeric("2"))
```

```
## [1] "numeric"
```

---

## Ejemplo.
> Transformar el número 3 en un carácter

**Solución.**

```r
class(3)
```

```
## [1] "numeric"
```

```r
as.character(3)
```

```
## [1] "3"
```

```r
class(as.character(3))
```

```
## [1] "character"
```

---

## Ejemplo.
> Transformar el número 7.0 en entero

**Solución.**

```r
class(7.0)
```

```
## [1] "numeric"
```

```r
class(as.integer(7.0))
```

```
## [1] "integer"
```

## Ejemplo.
> Aplicar la función `as.integer()` al número 9.8

**Solución.**

```r
as.integer(9.8)
```

```
## [1] 9
```

Dado que `as.integer()` solo devuelve la parte entera de la entrada, el resultado siempre es "fijo"
al entero del límite inferior.

---

Podríamos usar la función `round()` para redondearlo hacia arriba o hacia abajo,
dependiendo del valor del primer dígito después del punto decimal:

## Ejemplo.

> Redondear el número 9.8

**Solución.**

```r
round(9.8)
```

```
## [1] 10
```

---

## Ejemplo.
> Transformar el valor booleano TRUE en un carácter

**Solución.**

```r
class(TRUE)
```

```
## [1] "logical"
```

```r
as.character(TRUE)
```

```
## [1] "TRUE"
```

```r
class(as.character(TRUE))
```

```
## [1] "character"
```

---

## Ejemplo.
> Transformar el número 1 en un factor

**Solución.**

```r
as.factor(1)
```

```
## [1] 1
## Levels: 1
```

```r
class(as.factor(1))
```

```
## [1] "factor"
```

---

## Ejemplo.
> Transformar el carácter "altura" en un factor

**Solución.**

```r
as.factor("altura")
```

```
## [1] altura
## Levels: altura
```

```r
class(as.factor("altura"))
```

```
## [1] "factor"
```

---

# Vectores

En R, la unidad básica es un vector y, por tanto, todas estas funciones operan directamente
sobre vectores. Esta unidad consiste en una serie de elementos consistentes a datos de tipo numérico, carácter, lógico o factor. Un vector se genera usando la función `c()`, donde c significa
“combinar” o “concatenar”.

### Ejemplo. 
> Definamos algunos vectores:

- Con datos numéricos:

```r
x=c(2,3,4,6,7,9)
x
```

```
## [1] 2 3 4 6 7 9
```

---

- Con datos de tipo carácter:

```r
paises<-c('Peru','Colombia','Brasil')
paises
```

```
## [1] "Peru"     "Colombia" "Brasil"
```

- Con datos de tipo lógico:

```r
booleanos<-c(T,T,F,F,F,T,F)
booleanos
```

```
## [1]  TRUE  TRUE FALSE FALSE FALSE  TRUE FALSE
```

- Con datos de varios tipos:

```r
y<-c(1,2,3,'Hola mundo','Adios',FALSE,TRUE)
y
```

```
## [1] "1"          "2"          "3"          "Hola mundo" "Adios"     
## [6] "FALSE"      "TRUE"
```

---

# Indexación de los vectores

Si queremos extraer el i-esimo elemento `$x_i$` del vector `$$x=[x_1,x_2,...,x_n]$$` 
debemos escribir `x[i]`.

### Ejemplo. 
> Extraiga el tercer elemento del vector `$$z=[3,5,7,8,10,15]$$`

**Solución.**

```r
z<-c(3,5,7,8,10,15)
z
```

```
## [1]  3  5  7  8 10 15
```

```r
z[3]
```

```
## [1] 7
```

---

Si queremos extraer los elementos `$x_i,x_{i+1},...,x_{k}$` del vector `$$x=[x_1,x_2,...,x_i,x_{i+1},...,x_{k},...,x_n]$$` 
debemos escribir `x[i:k]`.

### Ejemplo. 
>Extraiga los elementos `$x_5,x_6,x_7$` del vector `$$x=[1,2,4,6,8,10,11,1,16,20]$$`

**Solución.**

```r
x<-c(1,2,4,6,8,10,11,1,16,20)
x
```

```
##  [1]  1  2  4  6  8 10 11  1 16 20
```

```r
x[5:7]
```

```
## [1]  8 10 11
```

---

Si queremos extraer algunos elementos específicos.

Por ejemplo, `$x_i$`, `$x_j$`, `$x_{k}$` del vector `$$x=[x_1,x_2,...,x_i,...,x_{j},...,x_{k},...,x_n]$$` 
debemos escribir `c(i,j,k)` dentro del corchete. Es decir, `x[c(i,j,k)]`.

### Ejemplo. 
>Extraiga los elementos `$x_3,x_6,x_8$` del vector `$$x=[1,2,4,6,8,10,11,1,16,20]$$`

**Solución.**

```r
x<-c(1,2,4,6,8,10,11,1,16,20)
x
```

```
##  [1]  1  2  4  6  8 10 11  1 16 20
```

```r
x[c(3,6,8)]
```

```
## [1]  4 10  1
```

---

Si queremos extraer algunos elementos especificos del vector `$$x=[x_1,x_2,...,x_i,...,x_{j},...,x_{k},...,x_n]$$` 
que cumplen cierta condición, digamos una `inecuacion`,
debemos escribir dicha inecuación dentro del corchete. Es decir, `x[inecuacion]`.

### Ejemplo. 
> Las notas de unos estudiantes son `$$5,2,19,9,16,10,12,6,16,10,20$$`
Se considera aprobado a los estudiantes que obtuvieron como minimo 12. Extraiga los datos de los estudiantes aprobados.

**Solución.**

```r
notas<-c(5,2,19,9,16,10,12,6,16,10,20)
notas
```

```
##  [1]  5  2 19  9 16 10 12  6 16 10 20
```

```r
notas[notas>=12]
```

```
## [1] 19 16 12 16 20
```

---

# Operaciones entre vectores

### Adición

Si `$x=[x_1,x_2,...,x_n]\;$` y `$\;y=[y_1,y_2,...,y_n]$`, entonces
`$$x+y=[x_1+y_1,x_2+y_2,...,x_n+y_n]$$`

### Ejemplo.

```r
x<-c(1,2,3)
y<-c(3,5,7)
x+y
```

```
## [1]  4  7 10
```

---

### Sumando un número a cada elemento

Si `$x=[x_1,x_2,...,x_n]$`, entonces se le puede sumar un número `$k$` a cada elemento
`$$\left[x_1+k,x_2+k,...,x_n+k\right]$$`

### Ejemplo.
> Sumele 3 a cada elemento del vector `$x=[1,2,3]$`.

**Solución.**

```r
x<-c(1,2,3)
x+3
```

```
## [1] 4 5 6
```

---

### Sustracción

Si `$x=[x_1,x_2,...,x_n]\;$` y `$\;y=[y_1,y_2,...,y_n]$`, entonces
`$$x-y=[x_1-y_1,x_2-y_2,...,x_n-y_n]$$`

### Ejemplo.

```r
x<-c(4,2,3)
y<-c(3,5,7)
x-y
```

```
## [1]  1 -3 -4
```

---

### Multiplicación elemento a elemento

Si `$x=[x_1,x_2,...,x_n]\;$` y `$\;y=[y_1,y_2,...,y_n]$`, entonces la multiplicación elemento a elemento es
`$$[x_1y_1,x_2y_2,...,x_ny_n]$$`

### Ejemplo.
> Considere los vectores `$$x=[4,2,3]\quad y=[3,5,7].$$`
Halle los productos `$x_iy_i$` para cada `$i=1,2,3$`.

**Solución.**

```r
x<-c(4,2,3)
y<-c(3,5,7)
x*y
```

```
## [1] 12 10 21
```

---

### Potenciación a cada elemento de un vector

Si `$x=[x_1,x_2,...,x_n]$`, entonces la `$k$`-ésima potenciación de cada elemento de `$x$` es
`$$[x_1^k,x_2^k,...,x_n^k]$$`

### Ejemplo.
> Halle el cuadrado de cada elemento del vector `$$x=[-2,3,4,6,9]$$`

**Solución.**

```r
x<-c(-2,3,4,6,9)
x^2
```

```
## [1]  4  9 16 36 81
```

---

### Comparaciones entre elementos de dos vectores

```r
x<-c(1,3,4,-6,7)
y<-c(3,-5,2,4,8)
x<y
```

```
## [1]  TRUE FALSE FALSE  TRUE  TRUE
```

---

# Construcción de vectores

## Secuencias
Podemos construir un vector de elementos que incrementan de uno en uno
`$$a,a+1,a+3,...,b$$`
usando `seq(a,b)`.

### Ejemplo. 
> Construya los números enteros consecutivos del 4 al 15

```r
n<-seq(4,15)
n
```

```
##  [1]  4  5  6  7  8  9 10 11 12 13 14 15
```

Los cuales podemos verificar que son enteros

```r
class(n)
```

```
## [1] "integer"
```

**Otra forma:** De manera opcional también se pudo escribir como

```r
4:15
```

```
##  [1]  4  5  6  7  8  9 10 11 12 13 14 15
```

---

Si se desea modificar el incremento a un número `$r$`, solo hacemos `seq(a,b,by=r)`

### Ejemplo. 
> Construya los números del 2 al 5 con un incremento de `$0.5$`

```r
seq(2,5,by=0.5)
```

```
## [1] 2.0 2.5 3.0 3.5 4.0 4.5 5.0
```

---

# Repeticiones

Podemos construir un vector en el que un elemento `$a$` se repiten `$n$`-veces `$$\underbrace{[a,a,...,a]}_{n\;veces}$$` para ello usamos `rep(a,n)`.

### Ejemplo. 
> Construya un vector en el que 3 se repite 7 veces.

```r
rep(3,times=7)
```

```
## [1] 3 3 3 3 3 3 3
```

---

# Muestras

Si se tiene un conjunto de datos en un vector `$$x=[x_1,x_2,...,x_n],$$`
se puede extraer un subcojunto

- Con `$k$` datos aleatorios todos diferentes usando `sample(x,k)`. En este caso siempre se tiene que `$k\leq n$`. No hay reemplazamiento de datos (no hay reposición).

### Ejemplo.

> Considere los datos enteros del 10 al 20. Obtenga una muestra aleatoria de 8 datos diferentes.

**Solución.** Primero definamos la secuencia de datos del 10 al 20.

```r
x<-10:20
x
```

```
##  [1] 10 11 12 13 14 15 16 17 18 19 20
```
Una muestra aleatoria de 8 datos diferentes seria:

```r
sample(x,8)
```

```
## [1] 17 13 20 14 16 12 18 11
```

---

- Con `$k$` datos aleatorios en los cuales se pueden repetir usando `sample(x,k,replace=T)`. En este caso no importa si `$k$` es superior o inferior a `$n$`, ya que se acepta reemplazamiento de datos (hay reposición).

### Ejemplo.

> Considere los datos enteros del 10 al 20. Obtenga una muestra aleatoria de 16 datos en los cuales se pueden admitir repetición de datos.

**Solución.** Primero definamos la secuencia de datos del 10 al 20.

```r
x<-10:20
x
```

```
##  [1] 10 11 12 13 14 15 16 17 18 19 20
```
Una muestra aleatoria de 16 datos en los cuales se pueden admitir repetición seria:

```r
sample(x,16,replace = T)
```

```
##  [1] 12 14 15 10 19 18 11 20 15 19 16 15 14 19 12 12
```

---

### Ejemplo.

> Considere los datos enteros del `$1$` al `$3$` con incremento de `$0.25$`. Obtenga una muestra aleatoria de 14 datos en los cuales se pueden admitir repetición de datos.

**Solución.**

```r
x<-seq(1,3,by=0.25)
x
```

```
## [1] 1.00 1.25 1.50 1.75 2.00 2.25 2.50 2.75 3.00
```

```r
sample(x,24,replace = T)
```

```
##  [1] 2.75 1.75 1.25 2.75 2.50 1.25 2.00 1.25 1.75 1.75 1.50 1.00 1.25 2.25 1.75
## [16] 2.75 1.00 3.00 2.25 2.25 2.25 1.50 1.25 1.50
```

---

# Funciones en vectores

Tenemos a seguir algunas funciones que se pueden aplicar a cualquier vector `$$x=[x_1,x_2,...,x_n]$$`

<table class="table-conjuncion">
  <thead>
    <tr>
      <th>Función</th>
      <th>Descripción</th>
      <th>Fórmula matemática</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>length()</code></td>
      <td>Halla la longitud del vector</td>
      <td>$$n$$</td>
    </tr>
    <tr>
      <td><code>sort()</code></td>
      <td>Ordena los elementos de un vector numérico en orden creciente</td>
      <td>$$x_{k_1} &lt; x_{k_2} &lt; \cdots &lt; x_{k_n}$$</td>
    </tr>
    <tr>
      <td><code>max()</code></td>
      <td>Halla el elemento de valor máximo del vector numérico</td>
      <td>$$\max(x)$$</td>
    </tr>
    <tr>
      <td><code>min()</code></td>
      <td>Halla el elemento de valor mínimo del vector numérico</td>
      <td>$$\min(x)$$</td>
    </tr>
    <tr>
      <td><code>sum()</code></td>
      <td>Halla la suma de los elementos del vector numérico</td>
      <td>$$\sum_{i=1}^n x_i = x_1 + x_2 + \cdots + x_n$$</td>
    </tr>
    <tr>
      <td><code>prod()</code></td>
      <td>Halla el producto de los elementos del vector numérico</td>
      <td>$$\prod_{i=1}^n x_i = x_1 x_2 \cdots x_n$$</td>
    </tr>
    <tr>
      <td><code>mean()</code></td>
      <td>Halla la media aritmética</td>
      <td>$$\overline{x} = \frac{\sum_{i=1}^n x_i}{n}$$</td>
    </tr>
    <tr>
      <td><code>var()</code></td>
      <td>Halla la varianza muestral</td>
      <td>$$s^2 = \frac{\sum_{i=1}^n (x_i - \overline{x})^2}{n - 1}$$</td>
    </tr>
    <tr>
      <td><code>sd()</code></td>
      <td>Halla la desviación estándar muestral</td>
      <td>$$s = \sqrt{ \frac{\sum_{i=1}^n (x_i - \overline{x})^2}{n - 1} }$$</td>
    </tr>
  </tbody>
</table>

---

# Tamaño de muestra

### Ejemplo.
> Use R para hallar la longitud del vector
`$$x=[1,2,4,6,8,10,11,1,16,20]$$`

**Solución.**

```r
x<-c(1,2,4,6,8,10,11,1,16,20)
length(x)
```

```
## [1] 10
```

---

# Ordenamiento (creciente)

Si se trata de un vector de elementos numéricos, podemos ordenar sus elementos en orden creciente con `sort()`.

### Ejemplo. 
> Ordene de manera creciente los elementos del vector `$$x=[5,2,19,9,8,10,11,1,16,10,20]$$`

**Solución.**

```r
x<-c(5,2,19,9,8,10,11,1,16,10,20)
x
```

```
##  [1]  5  2 19  9  8 10 11  1 16 10 20
```

```r
sort(x)
```

```
##  [1]  1  2  5  8  9 10 10 11 16 19 20
```

---

# Ordenamiento (decreciente)

### Ejemplo. 
> Ordene de manera decreciente los elementos del vector `$$x=[5,2,19,9,8,10,11,1,16,10,20]$$`

**Solución.**

```r
x<-c(5,2,19,9,8,10,11,1,16,10,20)
x
```

```
##  [1]  5  2 19  9  8 10 11  1 16 10 20
```

```r
sort(x,decreasing = T)
```

```
##  [1] 20 19 16 11 10 10  9  8  5  2  1
```

---

### Ejemplo. 
> Considere los siguientes datos `$$5,2,19,9,8,10,12,13,18,11,1,16,10,20$$`
> Use los comandos de R para hallar
1. Halle el maximo dato.
2. Halle el minimo dato.
3. Halle el promedio.
4. Halle la varianza.
5. Halle la desviación estándar.

**Solución.**

```r
x<-c(5,2,19,9,8,10,12,13,18,11,1,16,10,20)
max(x);min(x);mean(x);var(x);sd(x)
```

```
## [1] 20
```

```
## [1] 1
```

```
## [1] 11
```

```
## [1] 35.07692
```

```
## [1] 5.922577
```

---

### Ejemplo. 
> Como en el ejemplo anterior, considere los siguientes datos `$$5,2,19,9,8,10,12,13,18,11,1,16,10,20$$`
Halle la media, varianza y desviación estándar usando las formulas matematicas y los comandos `length(),sum(),sqrt()`.

**Solución.**

Definamos el vector con estos datos

```r
x<-c(5,2,19,9,8,10,12,13,18,11,1,16,10,20)
x
```

```
##  [1]  5  2 19  9  8 10 12 13 18 11  1 16 10 20
```

---

> Hallemos la media con la fórmula matemática.

```r
#Tamaño de muestra
n<-length(x)
n
```

```
## [1] 14
```

```r
#Sumatoria
sum(x)
```

```
## [1] 154
```

```r
#Media
xbar<-sum(x)/n
```

---

> Hallemos la varianza con la fórmula matemática.

```r
#Hallando xi-xbar
x-xbar
```

```
##  [1]  -6  -9   8  -2  -3  -1   1   2   7   0 -10   5  -1   9
```

```r
#Hallando los cuadrados de xi-xbar
(x-xbar)^2
```

```
##  [1]  36  81  64   4   9   1   1   4  49   0 100  25   1  81
```

```r
#Varianza
varianza<-sum((x-xbar)^2)/(n-1)
varianza
```

```
## [1] 35.07692
```

---

> Hallemos la desviación estándar con la fórmula matemática.

```r
s<-sqrt(varianza)
s
```

```
## [1] 5.922577
```