¿Qué es la programación?

La programación es una herramienta en la cual nosotros como usuarios le damos instrucciones a la computadora sobre que queremos que haga y eso podría ser podría ser cualquier cosa que represente una solución al mundo real, desde una página web, un software o incluso una imagen bonita.

Lenguajes de Programación

Existen una gran cantidad de lenguajes de programación en los cuales cambia la sintaxis de cierta manera. Estos son algunos de los lenguajes que se llegan a ver en las carreras de actuaría, natemáticas y física:

  • R
  • Java
  • Python
  • C / C++
  • VBA
  • MATLAB

Declaración de variables en R, Java y Python

R es un lenguaje de programación y entorno computacional dedicado a la estadística. En R, todo es un objeto, de hecho todos los datos y estructuras de datos son objetos y además todos estos objetos tienen un nombre para identificarlos.

OBJETO EN PROGRAMACION: Es decir, que tiene una serie de datos almacenados y tareas que realiza con esos datos en el tiempo de ejecución.

Es importante recalcar que los lenguajes de programación son distintos por ende la declaración de variables en cada uno debe de ser distinta, en R los datos pueden ser de diferentes tipos, cada tipo tiene características particulares que lo distinguen de los demás, acontinuación veremos esto:

Datos más comunes

  • R

Los tipos de datos de uso más común eb R son los siguientes:

En R se asignan variables con una especie de flecha (nombre_de_la_variable <- valor_a_asignar)

Por ejemplo:

radio <- 3 caracter <- “hola”

  • Pythhon

Tipos de datos en Python:

Una variable se define con la sintaxis:

Nombre_de_la_variable = Valor_de_la_variable

Ejemplos:

String: ¡mi_cadena = “Hola Mundo!"
Número entero (Int): edad = 35
Una tupla : mi_tupla = ('cadena de texto', 15, 2.8, 'otro dato', 25)
Una lista: print mi_lista[1:4] # Devuelve: [15, 2.8, 'otro dato']
  • Java

Tipos de datos en Java:

Declaración de variables en Java:

tipo nombrevariable;

Donde tipo es el tipo de datos que almacenará la variable (texto, números enteros,…) y nombrevariable es el nombre con el que se conocerá la variable.

Por ejemplo:

int dias; boolean decision;

La variable puede tomar un valor inicial al declararla, se pueden declarar más de una a la vez y hasta se puede ocupar una expresión al declararla.

Ejemplos:

int dias=365; int dias=365, anio=23, semanas; int a=13, b=18; int c=a+b;

R, RStudio y RStudio Cloud

Para trabajar en R podríamos descargarnos R en nuestras computadoras pero ojo existe R que tal cual va a ser un blog de notas sin chiste y existe R Studio que es una IDE para R, ¿y que es una IDE?, pues básicamente es un entorno de desarrollo integrado o entorno de desarrollo interactivo, dicho en otras palabras es una interfaz donde podremos ver lo que hace nuestro código, pero para esta clase lo que nosotros haremos será utilizar el servicio en la nube que se llama RCloud Studio, que básicamente seria como lo que es Overleaf para Latex, aunque en RCloudStudio solo se pueden crear a lo más 15 proyectos.

Lo que haremos será meternos a la página rstudio.cloud e iniciaremos sesión, yo les recomiendo usar su cuenta de Google para que todo sea más rápido.

En este entorno podrán crear proyectos en R y compartirlos, y a las personas que les compartan sus proyectos no solo podrán hacer una copia de ellos sino que podrán editar también sus proyectos, para entender más sobre esto pueden consultar la sección de about donde se explica cómo realizar esto: https://rstudio.cloud/personal/about

Ahora, ya estando en RStudio Cloud creamos un nuevo proyecto, y ya una vez habiéndolo creado crearemos un nuevo script que es básicamente un espacio de trabajo (\(File \rightarrow NewFile \rightarrow Script\)). Ya habiendo creado el script tendremos ciertos espacios como lo son la consola donde se verán resultados de lo que hagamos en el script y también podemos realizar ejecuciones desde la consolar, también estaban los espacio del enviroment/history/… donde veremos los valores de nuestras variables, y también está el espacio de Files/Plots/… donde veremos los archivos disponibles para trabajar, visualizar gráficas, etc.

Ahora, enfocándonos ya en R, se tiene que para declarar una variable pondremos el nombre que le daremos y le asignaremos el valor que queramos con el símbolo <- o con el símbolo =

Ejemplo: Le asignaremos el valor de 2 a la variable x:

x <- 2

O también podemos hacer:

x = 2

De igual manera podemos guardar cadenas de caracteres, como serían las palabras

p <- "Hola"

Para imprimir una variable podemos simplemente poner la variable y ejecutar con ctrl+enter o poner print(varible)

x
## [1] 2
print(p)
## [1] "Hola"

Para realizar un comentario en el código, pondremos el simbolo del gato/hashtag (#) y escribiremos lo que no queremos que se ejecute, si no que quede ahí como nota.

# Este es un comentario, en Java podremos comentar poniendo: // o si queremos encerrar varios renglones como comentario pondremos: /* --renglones-- */.
# En Python para comentar pondremos poner de igual manera # o '''

Ahora, cresulta que en R y en prácticamente todos los lenguajes de programación existen las palabras reservadas (por lo general son palabras que ya tienen una función asignada) las cuales no debemos de usar como variables para no generar problemas en nuestro codigo.

Por ejemplo, los operadores logicos TRUE (T) y FALSE (F)

verdad <- TRUE
falso <- FALSE

Podríamos verificar si estas variables son iguales comparandolas:

verdad == falso
## [1] FALSE

El resultado es FALSE pues una variable tiene TRUE y la otra es FALSE, otro ejemplo:

1==2
## [1] FALSE

Otra palabra reservada es NULL, la cual nos sirve para sentenciar que una variable no tiene ningun valor asignado.

nada<-NULL
# Y ahora si le asignamos un valor a la variable
nada<-0

Notemos que en ningun momento le decimos a R que tipo de variable es con la que queremos trabajar, nosotros solo le asignamos valores a la variable y R detecta coon que tipo de varible se quiere trabajar.

Operaciones entre variables

Declaramos dos variables:

x <- 4
y <- 3
  • Suma (+)
x+y
## [1] 7
z = x+y
z
## [1] 7
  • Resta (-)
x-y
## [1] 1
  • Multiplicación (*)
x*y
## [1] 12
  • División (/)
x/y
## [1] 1.333333
  • Potencia (^)
x^2
## [1] 16
  • Raíz cuadrada (Función sqrt())
sqrt(x)
## [1] 2

Nota: srqt() es una función ya preestablecida en R, la cual recibe un argumento entre paréntesis (un número) y le saca la raíz a este.

Si quisiesemos consultar como funciona una función lo que podemos hacer es utilizar la sentencia ?funcion, por ejemplo: ?sqrt y en la parte inferior derecha de RStudio se nos mostrara la información que hay con respecto a esta función en la paqueteria. Las paqueterias son librerias en las cuales vienen nuevas funciónes y opciones que podremos utilizar, nuestras paqueterias las podemos ver en la pestaña de packages de igual manera en la parte inferior derecha, ahí mismo podremos opbservar que se da la opción de instalar nuevas paquerterias, si le damos ahí podremos buscar la paqueteria que necesitamos y darle a instalar, aunque también podemos usar el siguiente comando: install.packages(“nombre_de_la_paqueteria”). Y una vez se haya terminado de instalar para poderla utilizar marcaremos con palomita la paquetria o pondremos al inicio del código la sentencia: require(nombre_de_la_paqueteria).

Ahora, una de las ventajas de R para nosotros los que le damos un enfoque a la programación hacia el rubro de las matemáticas, es que R toma a las variables como vectores/arreglos, esto es un conjunto de valores los cuales los guarda en entradas, ejemplo: vector <- c(entrada1,entrada2,…entradan)

Se tiene el siguiente ejemplo:

v <- c(1,2,3)

Y podemos consultar los valores de cada una de las entradas de la siguiente manera:

v[1]
## [1] 1
v[2]
## [1] 2
v[3]
## [1] 3

También podremos agregar, sustituir y eliminar valores en el arreglo:

# Agregar
v[4]<-5
v
## [1] 1 2 3 5
# Sustituir
v[4]<-4
v
## [1] 1 2 3 4
# Eliminar
v=v[-c(4)]

Tambien podemos realizar operaciones entre estos vectores

w <- c(4,5,6)
# SUma
v+w
## [1] 5 7 9
# Resta
v-w
## [1] -3 -3 -3
# Multiplicación
v*w
## [1]  4 10 18
# División
v/w
## [1] 0.25 0.40 0.50

Notese que las operaciones se realizan entrada por entrada, por lo que es necesaria que ambos vectores, en nuestro caso v y w, tengan la misma cantidad de entradas sino nos saltara un error.

También podremos realizar operaciones entre entradas particulares.

v[1]= v[1]+v[2]

Pedirle valores al usuario

En los ejemplos que hemos visto anteriormente nosotros establecemos el valor que tendra una variable desde que la declaramos en el script, pero también nos podríamos pedirle al usuario que nos proporcione cualquier valor que se le ocurra desde la consola:

Las sentencias de código se pondran como comentarios ya que como este documento es un markdown cuya salida será un PDF entonces no podremos interactuar con la consola

#p <- readline(prompt = "Cual es tu nombre?:")
#p
#
#n <- readline(prompt = "Dame un numero:")

Es importante señalar que la función readline solamente guarda carácteres:

#print(n)

Por lo que no podríamos realizar operaciones con n ya que no es un número, para pasarlo a número no que aremos sera convertirlo con la siguiente función:

#n <- as.integer(n)
#n

Sentencias

Condicional

En programación, una sentencia condicional es una instrucción o grupo de instrucciones que se pueden ejecutar o no en función del valor de una condición. En pocas palabras, el condicional nos sirve para hacer validaciones.

Nosotros trabajaremos con el condicional IF (Si). En R se tiene que la sintaxis del IF se:

if(condicion1){

acciones_a_realizar

}else if(condicion2){

acciones_a_realizar

}else{

acciones_a_realizar

}

Esto lo que nos dice, si se cumple la condición 1 entonces realiza estas acciones, o si se cumple la condición 2,3,…,n realiza estas acciones, o en el ultimo de los casos si ninguna de las condiciones anteriores se cumplio entonces realiza estas acciones.

Ejemplos:

if((2*2)==(2+2)){
  print("Son iguales")
}
## [1] "Son iguales"
carro = "automovil"
if(carro=="automovil"){
  print("La variable si dice automovil")
}
## [1] "La variable si dice automovil"
m <- 9
if(m%%2==0){
  print("El numero es par") 
} else{
  print("El numero es impar")
}
## [1] "El numero es impar"

Observemos que en el último ejemplo se utilizo el operador %%, este operador nos sirve para obtener el residuo de un numero al ser dividido por otro, basicamente lo que dijimos fue y el residuo del numero m al dividirlo entre 2 es cero entonces el número es par.

  • IF en Python

if condición1:

acción_a_realizar

elif condición2:

acción_a_realizar

else:

acción_a_realizar

Nota: observemos que aquí las acciones a realizar no van dentro de llaves, entonces podríamos pensar como sabe el ciclo hasta que acción tomar si es que hibiesen más acciones debajo del ese, pues esto los sabe por la identación y esto es basicamente la estructura que tienen las sentencias en el código, en este caso es que las acciones a realizar estan separadas por un tabulador.7

  • IF en Java

if (condición1) {

acción_a_realizar;

} else if (condición2) {

acción_a_reaalizar;

} else {

acción_a_realizar;

}

Nota: En Java también existe otra forma de condicional llamada SWITCH, se recomienda googlear si se desea saber más.

Regresando a R, se tiene que existen más operadores aparte del de compara/igual (==), distinto (!=), mayort o menor (> o <), mayoro igual o menor o igual (>= o <=), módulo (%%), como lo son la intersección Y (&), la unión O (||).

Por ejemplo: Y en la condicion

m <- 9
if(m%%2==0 & m<10){
  print("El numero es par y menor a 10") 
} else{
  print("El numero es impar o no es menor a 10")
}
## [1] "El numero es impar o no es menor a 10"

También podríamo usar IFs dentro de un mismo IF, a este tipo de sentencia se le llama IF anidado.

Ejercicio

Verificar si una persona tiene la edad suficiente para votar pidiendo la edad al usuario

#n <- readline(prompt = "Cual es tu edad:")
#n <- as.integer(n)
#
#if(n>=18){
#  print("Tiene edad para votar")
#} else{
#  print("No tiene la edad suficiente para votar")
#}

Ciclos

Un ciclo es una secuencia que ejecuta repetidas veces una instrucción/un trozo de código, hasta que la condición asignada a dicho bucle deja de cumplirse. Dicho con otras palabras, el ciclo sirve para realizar una accion en bucle (nosotros podemos definir el número repeticiones).

Por ejemplo, existe el ciclo for, el cual en R tiene la siguiente sintaxis:

for(variable1 in número1:numero:2){

acciones_a_realizar

}

Esto basicamente lo que nos dice es nuestra variable1 tomara el valor inicial número1 y tomara todos los valores (enteros) que esten entre este número1 y número2, aumentando en uno cada iteración. Cada una de estas iteraciones es una repetición donde se estara realizando la acci´n que este dentro de las llaves.

Ejemplos:

for(i in 1:10){
  print(i)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10
v<-NULL

contador<-0
for(j in 1:100){
  contador=contador+j
}
contador
## [1] 5050

Nota: El último ejemplo esta inspirrado en la historia que cuenta que un día el profesor de Gauss, cuando este era niño, tenía flojera de dar clase así que les dejo sumar los números entre el 1 y 100, Gauss que era un niño muy listo se dio cuenta que si sumabamos el primer número y el último número se obtenia 101, y así sucesivamente (segundo+penultimo=101), Gauss se dio cuenta que al sumar estas parejas siempre se tenía 101 por lo cual el dijo de los 100 números al tenerlos en parejas paso a tener \(\frac{100}{2}=50\) y estas parejas son todos 101, se tiene entonces que la suma de todos estos numeros es \(101x50=5050\). Bueno pues nosotros realizamos esto con un ciclo, sumando los 100 números uno por uno, podría pareser algo impractico pero la verdad es que para la computadora esto no representa prácticamente ningún esfuerzo y lo realiza de una manera realmente rápida.

  • FOR en Python

for variable in vector:

acción_a_realizar
  • FOR en Java

for(int variable = valor_inicial; variable <= valor_final; variable = variable + salto){

acción_a_realizar

}

Nota: En Java también existe otra forma de FOR llamada FOREACH, se recomienda googlear si se desea saber más.

Ahora, volviendo a R, también podemos hacer un FOR de manera decreciente:

for(k in 10:1){
  print(k)
}
## [1] 10
## [1] 9
## [1] 8
## [1] 7
## [1] 6
## [1] 5
## [1] 4
## [1] 3
## [1] 2
## [1] 1

Y al igual que con el IF podemos hacer un FOR anidado con cuantos FORs se quieran:

c<-0
for(i in 1:10){
  for(j in 1:10){
    c=c+j
  }
}
c
## [1] 550

Ejercicio

#suma<-0
#for(i in 1:100){
#  if(i%%2==0){
#    suma=suma+i
#  }
#}
#suma
#divisores<-0
#vector<-c()
#indice<-1
#for(i in 1:9887){
#  if(9887%%i==0){
#    divisores=divisores+1
#    vector[indice]=i
#    indice=indice+1
#  }
#}
#divisores
#vector

Ahora, exite una sentencia que es un ciclo pero a su vez tiene en si una condicional, este ciclo se llama WHILE (mientras), el cual lo que hace es que mientras se cumpla una condición se va a realizar una acción.

Se declara de la siguiente manera:

while(condición){

acción_a_realizar

}

Ejemplo:

i <- 1
while(i!=10){
  print(i)
  i=i+1
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9

while condición:

acción_a_realizar

while (condición) {

acción_a_realizar;

}

Nota: En Java también exite otra versión del WHILE llamada DO-WHILE, se recomienda googlear si se desea saber más.

Ejercicio

Preguntar la contraseña hasta que la den correctamente

#contrasenia<-""
#while(contrasenia!="piolin23"){
#  contrasenia <- readline(prompt = "Dame la contrasenia:")
#}

Nota: Así como existen los IFs, FORs nosotros también podemos hacer combinaciones entre distintos tipos de sentencias como se vio en uno de los ejercicios de la sentencia FOR.

Algunas funciones en R

Generar números aleatorios y muestras

Acontinuación veremos algunas funciones para obtener números aleatorios entre un cierto rango. Con la función runif() nosotros podemos obtener n numeros aleatorios entre 0 y 1.

runif(n = 4)
## [1] 0.9484938 0.1906889 0.2450053 0.5649827

Obviamente si los quiero entre 1 y 10 hago lo siguiente:

runif(n = 4,)*10
## [1] 2.914630 4.172821 3.522446 3.419511

Pero si yo quisiese que entos números sean enteros utilizo la función round() (redondear):

round(runif(n = 4)*10)
## [1] 4 9 2 3

Lo hecho anteriormente se pudo haber hecho de otra manera, y esta era dandole más argumentos a la función runif() como lo eran el min (valor mínimo) y el max (valor máximo)

round(runif(n = 4, min = 1, max = 10))
## [1] 6 1 2 2

*Nota: Posiblemente cuando estemos trabajando con números aleatorios nos gustaría quedarnos con una muestra para analizar pero si nosotros corremos varias veces el código obtendremos muestras distintos, para evitarnos de este problema haremos uso de la función set.seed() la cual fija una semilla, es decir, fija una simulación.

set.seed(1)
round(runif(n = 4, min = 1, max = 10))
## [1] 3 4 6 9

Ahora podríamos pensar que la función runif() no es muy buena pues los valores extremos tendrán menos probabilidad de ser seleccionados ya que el redondeo es tomado con el .5, para intentar solucionar esto nosotros podemos usar una función que tiene ciertas carácteristicas especiales como lo es la función sample().

sample(x = 1:10, size = 4, replace = T)
## [1] 2 7 2 3

Lo que hicimos fue decirle, toma 4 valores entre el 1 y 10 y estos valores se pueden repetir.

En este otro ejemplo nosotros podemos definir que valores queremos que sean seleccionados aleatoriamente de un arreglo/vector, se tomaran solo 3 valores de los 5 que hay en el arreglo los cuales ahora son palabras, y no se podrán repetir las selecciones:

sample(x = c("Aixa","Eros","Gabriela","Diego","Stephany"), size = 3, replace = F)
## [1] "Aixa"     "Stephany" "Diego"

Media

La función mean() nos sirve para obtener la media de una muestra, ejemplo:

muestra<-sample(x = 1:10000, size = 1000, replace = T)
mean(muestra)
## [1] 5063.572

Summary

La función summary() nos sirve para obtener datos como la mediana, la media, mínimo valor, máximo valor y los cuantiles.

summary(muestra)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##      27    2435    5162    5064    7674    9995

Funciones y gráficas

Algo que nos podría interesar es el poder definir funciones para así trabajar con ellas, como encontrar cierto valor de f(x), gráficar la función, etc. Para ello utilizaremos la función f(x) de la siguiente manera:

funcion <- function(x){
  3*x+2
}

Aquí ya hemos declarado nuestra función, si quisieramos utilizarla hacemos lo siguiente.

Ejemplo: f(2)

funcion(2)
## [1] 8

También podriamos mandarle a nuestra función un conjunto de valores ‘x’ y esta nos devolvera sus respectivos valores f(x).

valores = c(1,1,2,2,3,4,5)
funcion(valores)
## [1]  5  5  8  8 11 14 17

Ahora bien, nosotros podríamos graficar este conjunto de valores obtenidos utilizando la función plot:

plot(x = valores, y = funcion(valores))

# Notemos que para cada valor de 'x' le debe de corresponder una 'y' por lo que ambos arreglos deben tener la misma longitud.

Otro ejemplo:

eje_y<-sample(x = 1:1000, size = 100, replace = T)
plot(x = 1:100, y = eje_y, main = "Otro ejemplo", xlab = "Eje X", ylab = "Eje Y", type = "l", col = "red", xlim = c(1,100), ylim = c(1,1000))

Aquí le dimos mas argumentos a la función plot, como fueron:

  • main: Ponerle un titulo a la grafica.
  • xlab, ylab: Ponerle un nombre al eje ‘x’ y ‘y’ respectivamente.
  • col: Ponerle un cierto color a la gráfica.
  • xlim, ylim: Sirve para definir los limites de los ejes ‘x’ y ‘y’ respectivamente.
  • type: Definir el tipo de gráfica que quiero, linea (“l”), puntos (“d”), histograma(“h”), puntos y lineas (“b”), entre otros.

También podríamos fucionar dos graficos en una misma gráfica utilizando la función lines().

eje_y1<-sample(x = 1:100, size = 10, replace = T)
eje_y2<-round(runif(n = 10, min = 1, max = 100))
plot(x = 1:10, y = eje_y1, main = "Otro ejemplo", xlab = "Eje X", ylab = "Eje Y", type = "b", col = "red", xlim = c(1,10), ylim = c(1,100))
lines(x = 1:10, y = eje_y2, type = "b", col = "blue")

Lectura de archivos

Nosotros podemos cargar a nuestro proyecto archivos como excels, imagenes, pdfs, words, etc los cuales podramos llegar a utilizar en nuestro código, para cargarlos en la parte inferior derecha del RStudio podremos encontrar la pestaña de Files y ahí tendremos la opción de Upload, ahí podremos elegir el archivo que deseemos importar a nuestro espacio de trabajo.

En este caso nostros importaremos un archivo de tipo CSV, esto es un archivo delimitado por comas. Una vez habiendo cargado el archivo (en nuestro caso se cargo el archivo ejemplo.csv el cual viene de una base de datos de Airbnb sobre Singapore) lo que haremos sera utilizar la función read.csv() para guardar los datos del archivo (“ejemplo.csv”) en una variable

archivo=read.csv("ejemplo.csv")

Con esto hemos guardado los datos en una variable pero el trabajar con estos nos resultaria algo impractico pues tenemos todos los datos amontodatos en un vector/arreglo, pero en R existe el concepto de DataFrames los cuales nos guardan los datos seccionandolos según su columna originaria en el CSV para así trabajar con los datos de una manera más facil. Para pasar nuestros datos a unos del tipo dataframe usaremos la función as.data.frame().

datos=as.data.frame(archivo)

Con esto podremos consultar otrabajar solamente las columnas que nos interesen poniendo el nombre de la variable junto con un signo de pesos y después el nombre de la columna que nos interesa.

#Comentamos estas dos lineas de codigo por que de lo contrario se mostrarian muchas datos en en PDF
#datos$id
#datos$name
mean(datos$price)
## [1] 169.333

Si quisiesemos definir un dataframe de manera manual se utiliza la función data.frame()

df<-data.frame(columna_uno = c(1,2,3), columna_dos = c(4,5,6))
df
##   columna_uno columna_dos
## 1           1           4
## 2           2           5
## 3           3           6

RMarkdown

Con Daniel vieron la herramienta de LATEX la cual nos servia como un editor de textos cientificos, pues resulta que nosotros podemos fucionar de cierta manera a R con Latex utilizando RMarkdown, el cual nos permitira utilizar el lenguaje de latex y generar archivos de tipo PDF, HTML y más.

Para crear un Markdown haremos: \(File \rightarrow NewFile \rightarrow RMarkdown\) y una vez dandole ahí daremos nombre y autor al archivo y podremos decidir si queremos un PDF, HTML o WORD. Cuando se cree el archivo se instalara una paqueteria necesaria para que RMarkdown funcione.

Por default siempre se nos creara un RMarkdown con una plantilla de ejemplo (Donde los titulos vienen con # y los subtitulos con ##), podremos observar que al inicio se nos muestran de una manera apartado las siguientes cosas:

title: Titulo del documento author: Nombre del autor date: Fecha output: Tipo de documento

Veremos que después de estas lineas habra texto dentro y fuera de unos chunks ({r},), lo que esta fuera de los chunks será la parte del archivo la cual podremos utilizar como si fuese latex, y la parte que va dentro de los chunks será en la cual ira el código.

Por ejemplo: Todo este archivo ha sido trabajado en un RMarkdown :p

Ahora, resulta que los chunks tienen ciertas opciones de salida, esto es que nosotros podremos sugerir que queremos que se muestre a la hora de compilar el PDF/HTML/etc, por ejemplo:

Nota: Existen muchos otros tipos de opciones para el chunk pero aquí lo interesante es que podemos fucionar estas atráves de comas: r message=False, warnings=False.

Ejemplo: Utilizando las graficas que usamos anteriormente se utilizara lo siguiente r echo=FALSE, fig.width=8, fig.align=“center”.