In eyeguas/fundamentosr: Fundamentos de R (Tutoriales basicos en castellano)

library(learnr)
knitr::opts_chunk$set(echo = FALSE)

Introducción

knitr::include_graphics("images/operadores_aritmeticos.jpg")

El presente tutorial pretende ser un vehículo de aprendizaje interactivo para los novatos en el lenguaje R.

Ha sido desarrollado a través del paquete learnr que permite utilizar documentos RMarkdown para generar tutoriales interactivos.

Como se explica en la página de learnr, los tutoriales consisten en contenido (texto, figuras, ilustraciones, ecuaciones, vídeos, etc.) junto con componentes interactivos, como preguntas con múltiples opciones y fragmentos de código de R que los usuarios pueden editar y ejecutar directamente, para verificar y reforzar la comprensión.

Estos tutoriales conservan automáticamente el avance que un usuario realizó, por lo que si un estudiante trabaja en algunos ejercicios o preguntas y vuelve al tutorial más tarde, puede retomarlo exactamente donde lo dejó.

Este tutorial ha sido publicado como el paquete fundamentosr.

Objetivo de aprendizaje

El objetivo de aprendizaje del presente tutorial es el siguiente:

• Aplicar los operadores aritméticos entre los tipos de datos simples en R.

Operadores aritméticos

Los operadores aritméticos son aquellos que permiten operar con datos numéricos. Los operadores unarios (+ y -) preceden a una expresión y los binarios se sitúan entre dos expresiones aritméticas. Las operaciones aritméticas son las siguientes:

• Suma (+),
• Resta (-),
• Multiplicación (*),
• División (/),
• División entera (%/%),
• Módulo (%%),
• Potenciación (^).

En la siguiente tabla se muestran ejemplos de uso de las operaciones aritméticas con los valores literales $7$ y $3$:

Operación | Operador | Ejemplo | Resultado |:--:|:--:|:--:|:--:| Suma | + | 7 + 3 | 10
Resta | - | 7 - 3 | 4 Multiplicación | * | 7 * 3 | 21 División | / | 7 / 3 | 2.333333 División entera| %/%| 7%/%3 | 2 Módulo | %%| 7 %% 3 | 1 Potenciación | ^ | 7 ^ 3 | 343

División entera y módulo

Entre los operadores aritméticos, el de división entera y el módulo requieren una explicación adicional sobre su uso. El módulo proporciona el residuo o resto de la división entera de un número entre otro.

Por ejemplo, si hacemos una división entera de 4 entre 2, el resultado proporcionado por la división entera (%/%) será 2 y el resultado proporcionado por el módulo será 0. Esta es una división exacta y no tiene residuo o resto. El resultado sería el mismo si en vez de 4 usasemos cualquier número decimal con parte entera 4. Sin embargo, el resultado del módulo cambiaría en este último caso, dado que incorporaría como residuo o resto la parte decimal.

4.5 %/% 2
4 %/% 2
4.5 %% 2
4 %% 2

Veamos otro ejemplo. Si deseamos conocer cuántas horas son 525 minutos, podríamos aplicar la división entera entre 60 para calcular las horas. Los minutos restantes se obtendrían mediante el módulo.

minutos=525
horas=525%/%60
minutos_restantes=525%%60
print("Horas")
horas
print("Minutos")
minutos_restantes

Podemos comprobar con el código anterior que 525 minutos son equivalentes a 8 horas y 45 minutos.

Precedencia

Cuando se utilizan múltiples operadores en una expresión, necesitamos conocer la precedencia de operadores para determinar la secuencia de evaluación de las operaciones. La precedencia define el orden de ejecución. Veamos un sencillo ejemplo.

3 + 8 * 6

En este caso el operador de multiplicación * tiene mayor precedencia que el operador +. De ahí que se lleve a cabo en primer lugar la multiplicación y tras ello la suma. Compruébalo en la ejecución del código.

El orden se puede cambiar mediante el uso de paréntesis. Vamos a hacer que la suma tenga lugar en primer lugar: (3 + 8). Verifica que se cumple modificando el código anterior y volviendo a ejecutar.

En la siguiente tabla se muestra el orden de precedencia de los operadores aritméticos (de mayor a menor precedencia).

# | Operaciones | Operadores :--:|:--:|:--:| 1º | Potenciación | ^ 2º | Unarias | +,- 3º | Módulo | %% 4º | Multiplicación| * - | División | / 5º | Suma | + - | Resta | -

En la tabla se puede comprobar que la multiplicación tiene la misma precedencia que la división, y ocurre lo mismo con la suma y la resta. En tal caso, se tendrá en cuenta la asociatividad que explicamos a continuación. No obstante, es recomendable en todo caso utilizar paréntesis para tener presente el orden de evaluación.

Asociatividad

Existe la posibilidad de tener operadores de una misma precedencia en la misma expresión. En tal caso, el orden de ejecución es determinado por asociatividad. Veamos a continuación un ejemplo simple.

12 / 3 / 2

Si ejecutamos el código anterior comprobaremos como la evaluación se realiza de izquierda a derecha. Ello es debido a que el operador / presente ese tipo concreto de asociatividad. Compruébalo mediante la ejecución del código anterior.

El orden de evaluación se puede cambiar mediante el uso de paréntesis. Vamos a hacer que la división de la derecha se realice en primer lugar: (3 / 2). Modifica el código anterior para que ocurra y comprueba el resultado.

La siguiente tabla muestra el orden de evaluación de las operaciones de acuerdo a la asociatividad.

Operaciones | Operadores | Asociatividad :--:|:--:|:--:| Potenciación | ^ | Derecha a izquierda Unarias | +,- | Izquierda a derecha Módulo | %% | Izquierda a derecha Multiplicación| * | Izquierda a derecha División | / | Izquierda a derecha Suma | + | Izquierda a derecha Resta | - | Izquierda a derecha

Podemos comprobar como los operadores con la misma precedencia tienen la misma asociatividad. Veámoslo con un ejemplo sencillo.

12 * 3 / 2 ^ 2

En este ejemplo, tanto la multiplicación (*) como la división (/) tienen la misma precedencia y asociatividad. Por tanto, para la evaluación se realizará tal y como dicta la asociatividad (de izquierda a derecha). No obstante, la operación que primero se llevará a cabo será la potenciación (mayor precedencia).

Puedes comprobar cómo mediante el uso de paréntesis se podría llevar a cabo una alteración del orden de evaluación. Por ejemplo, si quiero realizar como última operación la potenciación debería incluir paréntesis rodeando la multiplicación y división: (12 * 3 / 2). Compruébalo y ejecuta el código resultante.

Ejercicio oficina

Vamos a realizar un ejercicio acerca del uso de operadores aritméticos:

"Se han adquirido 10 sillas de oficina con un costo de 200 € cada una. También se han adquirido 5 mesas de oficina con un costo de 250 € cada una. El descuento de las sillas es del 10%. El descuento de las mesas es del 15%. Las tasas a agregar al precio final a pagar son del 20%. Desarrolla un segmento de código en R que realice el cálculo."

Inicialización de variables

Para obtener la solución al problema comenzaremos definiendo las variables del mismo que tienen un valor inicial.

#Inicializamos variables
precio_silla<-200
numero_sillas<-10
porcentaje_dto_sillas<-10
precio_mesa<-250
numero_mesas<-5
porcentaje_dto_mesas<-15
tasas<-20

Hemos proporcionado a cada variable un nombre ilustrativo del valor que contiene.

Costo de las sillas

Vamos a agregar el código necesario para calcular en primer lugar el costo de las sillas multiplicando la cantidad de sillas adquiridas por su valor unitario. Una vez obtenido, le aplicaremos el descuento. Incluiremos comentarios en el código para hacer más sencilla su comprensión. Ejecuta el código y comprueba los resultados.

#Inicializamos variables
precio_silla<-200
numero_sillas<-10
porcentaje_dto_sillas<-10
precio_mesa<-250
numero_mesas<-5
porcentaje_dto_mesas<-15
tasas<-20
#Multiplicamos precio unitario por número de sillas
costo_sillas<-precio_silla*numero_sillas
print("Costo sillas según precio unitario:")
costo_sillas
#Calculamos el descuento 
descuento_sillas<-costo_sillas*(porcentaje_dto_sillas/100)
print("Descuento sillas:")
descuento_sillas
#Aplicamos el descuento al costo de las sillas
costo_final_sillas<-costo_sillas-descuento_sillas
print("Costo final sillas:")
costo_final_sillas

Has podido comprobar cómo hemos utilizado también paréntesis para que la precedencia sea la deseada. Así mismo, el uso del print permite seguir con mayor detalle el resultado de las diferentes operaciones. Recuerda que los comentarios son solo para permitir una mejor legibilidad del código y no se muestran como resultado de su ejecución.

Costo de las mesas

Vamos a agregar ahora el código necesario para calcular el costo de las mesas multiplicando la cantidad de mesas adquiridas por su valor unitario. Una vez obtenido, le aplicaremos el descuento. Los comentarios en el código permiten también no perdernos dentro del mismo y los print depurar la ejecución. Siempre mantenemos el código anterior para que se pueda ejecutar por completo dentro del tutorial. Ejecuta el código que se muestra a continuación y comprueba los resultados.

#Inicializamos variables
precio_silla<-200
numero_sillas<-10
porcentaje_dto_sillas<-10
precio_mesa<-250
numero_mesas<-5
porcentaje_dto_mesas<-15
tasas<-20
#Multiplicamos precio unitario por número de sillas
costo_sillas<-precio_silla*numero_sillas
#Calculamos el descuento de las sillas
descuento_sillas<-costo_sillas*(porcentaje_dto_sillas/100)
#Aplicamos el descuento al costo de las sillas
costo_final_sillas<-costo_sillas-descuento_sillas
print("Costo final sillas:")
costo_final_sillas
#Multiplicamos precio unitario por número de mesas
costo_mesas<-precio_mesa*numero_mesas
print("Costo mesas según precio unitario:")
costo_mesas
#Calculamos el descuento de las mesas
descuento_mesas<-costo_mesas*(porcentaje_dto_mesas/100)
print("Descuento mesas:")
descuento_mesas
#Aplicamos el descuento al costo de las mesas
costo_final_mesas<-costo_mesas-descuento_mesas
print("Costo final mesas:")
costo_final_mesas

Con respecto al código anterior del cálculo del costo de las sillas se han eliminado algunas visualizaciones de variables, manteniendo el resto igual. Se siguen incluyendo paréntesis para seleccionar la precedencia adecuada de operadores.

Coste del material de oficina: tasas incluidas

A continuación, vamos a calcular el coste final del material de oficina (mesas y sillas) incluyendo tasas.

#Inicializamos variables
precio_silla<-200
numero_sillas<-10
porcentaje_dto_sillas<-10
precio_mesa<-250
numero_mesas<-5
porcentaje_dto_mesas<-15
tasas<-20
#Multiplicamos precio unitario por número de sillas
costo_sillas<-precio_silla*numero_sillas
#Calculamos el descuento de las sillas
descuento_sillas<-costo_sillas*(porcentaje_dto_sillas/100)
#Aplicamos el descuento al costo de las sillas
costo_final_sillas<-costo_sillas-descuento_sillas
print("Costo final sillas:")
costo_final_sillas
#Multiplicamos precio unitario por número de mesas
costo_mesas<-precio_mesa*numero_mesas
#Calculamos el descuento de las mesas
descuento_mesas<-costo_mesas*(porcentaje_dto_mesas/100)
#Aplicamos el descuento al costo de las mesas
costo_final_mesas<-costo_mesas-descuento_mesas
print("Costo final mesas:")
costo_final_mesas
#Agregamos el coste de las sillas y las mesas
costo_final<-costo_final_sillas+costo_final_mesas
print("Costo final mesas y sillas (sin tasas)")
costo_final
#Aplicamos las tasas
costo_final<-costo_final+(costo_final*(tasas/100))
print("Costo final mesas y sillas (tasas inc.)")
costo_final

Tras ejecutar el código puedes comprobar los resultados de todo el proceso. Podemos hacer mención especial al empleo de una misma variable costo_final para realizar el cálculo y asignar el resultado. En la parte derecha de la asignación tiene el valor previo (coste de mesas y sillas sin tasas) y en la parte izquierda de la asignación recibe el nuevo valor de la operación (coste de mesas y sillas con tasas incluidas). No existe por tanto la posibilidad de conflicto ni error.

Creación de script en RStudio

Prueba el ejemplo de la oficina insertándolo en un script de RStudio y ejecutando dicho script.

Primero es necesario crear un script vacío en RStudio (File > New File > R Script).

knitr::include_graphics("images/nuevo_script.jpg")

Copia el código del tutorial y pégalo en el editor de RStudio.

knitr::include_graphics("images/copiar_codigo.jpg")

knitr::include_graphics("images/nuevo_script2.jpg")

Guarda el fichero correspondiente al script creado (File > Save As...).

knitr::include_graphics("images/save_as.jpg")

Se creará el archivo .R cuyo nombre proporcionemos: en este caso ejemplo_oficina.R.

A continuación ejecutamos el código. Lo seleccionamos y pulsamos el botón Run. El resultado aparecerá en la consola (Console).

knitr::include_graphics("images/ejecutar_script.jpg")

knitr::include_graphics("images/resultado_consola.jpg")

Conclusión

En este tutorial has conseguido aplicar los operadores aritméticos entre los tipos de datos integer y numeric en R para la resolución de problemas. Así mismo, has podido elaborar un script en RStudio para la ejecución del código del ejercicio.

Felicidades, has completado el tutorial de Operadores Aritméticos. Puedes continuar con el siguiente tutorial: Operadores Relacionales y Lógicos.

eyeguas/fundamentosr documentation built on March 31, 2021, 5:20 p.m.