Tutorial R: Operadores

Operadores aritméticos y precedencia

R es un lenguaje especialmente diseñado para el análisis estadístico y la manipulación de datos, por lo que sus operadores aritméticos son fundamentales para realizar cálculos matemáticos. Estos operadores nos permiten ejecutar operaciones básicas como sumas, restas y multiplicaciones, así como operaciones más complejas.

Operadores aritméticos básicos

R incluye los siguientes operadores aritméticos fundamentales:

• Suma: Se representa con el símbolo +
• Resta: Se representa con el símbolo -
• Multiplicación: Se representa con el símbolo *
• División: Se representa con el símbolo /
• Potenciación: Se representa con el símbolo ^ o **

Veamos ejemplos sencillos de cada uno:

# Suma
5 + 3  # Resultado: 8

# Resta
10 - 4  # Resultado: 6

# Multiplicación
6 * 7  # Resultado: 42

# División
20 / 5  # Resultado: 4

# Potenciación (dos formas equivalentes)
2 ^ 3  # Resultado: 8
2 ** 3  # Resultado: 8

División entera y módulo

Además de los operadores básicos, R proporciona operadores para la división entera y el módulo (resto de la división):

• División entera: Se representa con el operador %/%
• Módulo: Se representa con el operador %%

Estos operadores son útiles cuando necesitamos trabajar con números enteros:

# División entera
17 %/% 5  # Resultado: 3 (parte entera de 17/5)

# Módulo (resto)
17 %% 5   # Resultado: 2 (resto de dividir 17 entre 5)

La división entera devuelve el cociente sin la parte decimal, mientras que el módulo devuelve el resto de la división.

Operaciones con vectores

Una característica poderosa de R es que los operadores aritméticos funcionan de manera vectorizada, lo que significa que pueden aplicarse a vectores completos elemento por elemento:

# Creamos dos vectores
x <- c(1, 2, 3, 4)
y <- c(10, 20, 30, 40)

# Operaciones vectorizadas
x + y  # Resultado: 11 22 33 44
x * y  # Resultado: 10 40 90 160
x ^ 2  # Resultado: 1 4 9 16

Cuando operamos con vectores de diferentes longitudes, R aplica la regla de reciclaje, repitiendo el vector más corto:

# Vector corto reciclado para coincidir con el más largo
c(1, 2, 3, 4) + 10  # Resultado: 11 12 13 14
c(1, 2) + c(10, 20, 30, 40)  # Resultado: 11 22 31 42

En el segundo ejemplo, el vector c(1, 2) se recicla para convertirse efectivamente en c(1, 2, 1, 2) durante la operación.

Precedencia de operadores

La precedencia determina el orden en que se evalúan las operaciones cuando aparecen juntas en una expresión. En R, las reglas de precedencia siguen un orden similar al de las matemáticas:

• 1. Paréntesis ()
• 2. Potenciación ^ o **
• 3. Multiplicación * y división /
• 4. Suma + y resta -

Veamos algunos ejemplos para entender mejor la precedencia:

# Sin paréntesis, se aplica la precedencia estándar
2 + 3 * 4  # Resultado: 14 (primero 3*4=12, luego 2+12=14)

# Con paréntesis, se altera el orden de evaluación
(2 + 3) * 4  # Resultado: 20 (primero 2+3=5, luego 5*4=20)

# Expresión compleja
2 ^ 3 * 4 + 5  # Resultado: 37 (primero 2^3=8, luego 8*4=32, finalmente 32+5=37)

Operadores unarios

Los operadores + y - también pueden usarse como operadores unarios (con un solo operando):

x <- 5
-x  # Resultado: -5 (negación)
+x  # Resultado: 5 (mantiene el signo)

# Útil para invertir todos los valores de un vector
valores <- c(1, -2, 3, -4)
-valores  # Resultado: -1 2 -3 4

Funciones matemáticas comunes

Aunque no son operadores en sentido estricto, R incluye numerosas funciones matemáticas que complementan a los operadores aritméticos:

# Valor absoluto
abs(-7)  # Resultado: 7

# Raíz cuadrada
sqrt(16)  # Resultado: 4

# Redondeo
round(3.7)  # Resultado: 4
floor(3.7)  # Resultado: 3 (redondeo hacia abajo)
ceiling(3.2)  # Resultado: 4 (redondeo hacia arriba)

# Logaritmos
log(10)  # Resultado: 2.302585 (logaritmo natural)
log10(100)  # Resultado: 2 (logaritmo en base 10)

Operaciones con valores especiales

R maneja algunos valores especiales en operaciones aritméticas:

# Infinito
1/0  # Resultado: Inf

# Operaciones con infinito
Inf + 100  # Resultado: Inf
Inf - Inf  # Resultado: NaN (Not a Number)

# Valores no numéricos
0/0  # Resultado: NaN
sqrt(-1)  # Resultado: NaN (en R base, sin números complejos)

El valor NaN (Not a Number) aparece cuando el resultado de una operación no está definido matemáticamente, mientras que Inf representa el infinito.

Ejemplo práctico

Veamos un ejemplo que combina varios operadores para calcular la media y la varianza de un conjunto de datos:

# Datos de ejemplo: temperaturas diarias
temperaturas <- c(22, 24, 19, 21, 25, 23, 20)

# Cálculo de la media aritmética
n <- length(temperaturas)
suma <- sum(temperaturas)
media <- suma / n  # Resultado: 22

# Cálculo de la varianza (usando operadores aritméticos)
diferencias_cuadradas <- (temperaturas - media) ^ 2
varianza <- sum(diferencias_cuadradas) / n  # Resultado: 3.714286

Este ejemplo muestra cómo los operadores aritméticos son fundamentales para realizar cálculos estadísticos básicos, una de las aplicaciones principales de R.

Operadores relacionales y lógicos

Los operadores relacionales y lógicos en R son fundamentales para realizar comparaciones y construir expresiones condicionales. Estos operadores nos permiten evaluar condiciones y obtener resultados booleanos (verdadero o falso), que son esenciales para el análisis de datos y la toma de decisiones en nuestros programas.

Operadores relacionales

Los operadores relacionales comparan dos valores y devuelven un resultado lógico. En R, estos valores lógicos se representan como TRUE (verdadero) o FALSE (falso). Los principales operadores relacionales son:

• Igual a: ==
• Distinto de: !=
• Mayor que: >
• Menor que: <
• Mayor o igual que: >=
• Menor o igual que: <=

Veamos ejemplos básicos de cada uno:

# Comparaciones de igualdad
5 == 5    # TRUE
5 == 7    # FALSE

# Comparaciones de desigualdad
5 != 7    # TRUE
5 != 5    # FALSE

# Comparaciones de orden
5 > 3     # TRUE
5 < 3     # FALSE
5 >= 5    # TRUE
5 <= 3    # FALSE

Al igual que con los operadores aritméticos, los operadores relacionales en R funcionan de manera vectorizada, permitiendo comparar vectores elemento a elemento:

# Comparación de vectores
x <- c(1, 2, 3, 4)
y <- c(1, 3, 3, 0)

x == y    # Resultado: TRUE FALSE TRUE FALSE
x > y     # Resultado: FALSE FALSE FALSE TRUE

Operadores lógicos

Los operadores lógicos nos permiten combinar expresiones lógicas. Los principales operadores lógicos en R son:

• AND lógico: & (vectorizado) y && (evalúa solo el primer elemento)
• OR lógico: | (vectorizado) y || (evalúa solo el primer elemento)
• NOT lógico: ! (negación)

Veamos ejemplos de cada uno:

# AND lógico
TRUE & TRUE      # TRUE
TRUE & FALSE     # FALSE
FALSE & FALSE    # FALSE

# OR lógico
TRUE | TRUE      # TRUE
TRUE | FALSE     # TRUE
FALSE | FALSE    # FALSE

# NOT lógico
!TRUE            # FALSE
!FALSE           # TRUE

La diferencia entre los operadores & y && (o entre | y ||) es importante:

# Operadores vectorizados (& y |)
c(TRUE, FALSE, TRUE) & c(TRUE, TRUE, FALSE)  # Resultado: TRUE FALSE FALSE

# Operadores no vectorizados (&& y ||)
c(TRUE, FALSE, TRUE) && c(TRUE, TRUE, FALSE)  # Evalúa solo TRUE && TRUE = TRUE

Los operadores && y || evalúan únicamente el primer elemento de cada vector y son útiles en expresiones condicionales donde solo nos interesa el primer resultado.

Operaciones con valores lógicos

Los valores lógicos TRUE y FALSE se pueden tratar como valores numéricos en operaciones aritméticas, donde TRUE equivale a 1 y FALSE a 0:

# Valores lógicos en operaciones aritméticas
TRUE + TRUE      # Resultado: 2
sum(c(TRUE, FALSE, TRUE))  # Resultado: 2
mean(c(TRUE, FALSE, TRUE, FALSE))  # Resultado: 0.5 (promedio: 2/4)

Esta característica es muy útil para contar cuántos elementos cumplen una condición:

# Vector de edades
edades <- c(25, 18, 30, 16, 22, 40)

# Contar cuántas personas son mayores de edad
sum(edades >= 18)  # Resultado: 5

Operaciones con NA (valores ausentes)

R utiliza NA para representar valores ausentes. Las operaciones relacionales con NA generalmente producen NA:

# Operaciones con NA
5 > NA    # Resultado: NA
NA == NA  # Resultado: NA (no podemos saber si dos valores desconocidos son iguales)

Para verificar si un valor es NA, debemos usar la función is.na():

# Verificar valores ausentes
x <- c(1, NA, 3, NA, 5)
is.na(x)  # Resultado: FALSE TRUE FALSE TRUE FALSE

Combinando operadores relacionales y lógicos

Podemos combinar estos operadores para crear condiciones más complejas:

# Vector de temperaturas
temp <- c(22, 19, 25, 30, 15, 24)

# Temperaturas entre 20 y 25 grados
temp >= 20 & temp <= 25  # Resultado: TRUE FALSE TRUE FALSE FALSE TRUE

# Temperaturas menores a 18 o mayores a 28
temp < 18 | temp > 28    # Resultado: FALSE FALSE FALSE TRUE TRUE FALSE

# Contar temperaturas en el rango confortable (20-25)
sum(temp >= 20 & temp <= 25)  # Resultado: 3

Operador %in%

Aunque se verá con más detalle en otra sección, vale la pena mencionar que el operador %in% es muy útil para verificar si elementos están presentes en un conjunto:

# Verificar pertenencia
5 %in% c(1, 3, 5, 7)  # TRUE
2 %in% c(1, 3, 5, 7)  # FALSE

Aplicaciones prácticas

Los operadores relacionales y lógicos son fundamentales para filtrar datos:

# Datos de estudiantes
nombres <- c("Ana", "Carlos", "Elena", "David", "Beatriz")
edades <- c(22, 19, 25, 20, 18)
calificaciones <- c(85, 70, 92, 78, 65)

# Estudiantes aprobados (calificación >= 70)
aprobados <- calificaciones >= 70
nombres[aprobados]  # Resultado: "Ana" "Carlos" "Elena" "David"

# Estudiantes jóvenes con buenas calificaciones
jovenes_destacados <- edades < 20 & calificaciones >= 70
nombres[jovenes_destacados]  # Resultado: "Carlos"

Evaluación de condiciones en vectores

Cuando evaluamos condiciones en vectores, a veces necesitamos saber si todos los elementos cumplen una condición o si al menos uno la cumple:

# Verificar si todos los elementos cumplen una condición
all(calificaciones >= 60)  # TRUE (todas las calificaciones son >= 60)
all(calificaciones >= 70)  # FALSE (no todas son >= 70)

# Verificar si al menos un elemento cumple una condición
any(calificaciones >= 90)  # TRUE (al menos una calificación es >= 90)
any(calificaciones < 60)   # FALSE (ninguna calificación es < 60)

Las funciones all() y any() son muy útiles para verificar condiciones en conjuntos de datos completos.

Precedencia de operadores lógicos

La precedencia de los operadores lógicos en R sigue este orden:

1. Paréntesis ()
2. Operadores relacionales (>, <, >=, <=, ==, !=)
3. Negación lógica !
4. AND lógico &
5. OR lógico |

# La precedencia afecta el resultado
!TRUE | FALSE      # Equivale a (!TRUE) | FALSE = FALSE
!(TRUE | FALSE)    # Equivale a !(TRUE) = FALSE

# Comparación y operadores lógicos
x <- 5
x > 3 & x < 10     # TRUE (5 > 3 y 5 < 10)
x < 3 | x > 8      # FALSE (5 no es < 3 ni > 8)

Cuando tenemos dudas sobre la precedencia, es recomendable usar paréntesis para hacer el código más claro y evitar errores:

# Uso de paréntesis para claridad
(x > 3) & (x < 10)  # Más claro que x > 3 & x < 10
!(x < 3 | x > 8)    # Negación de toda la expresión

Los operadores relacionales y lógicos son herramientas esenciales en R que nos permiten realizar análisis condicionales de datos, filtrar información y tomar decisiones basadas en criterios específicos.

Operadores especiales de R: %in%, ::

R se distingue de otros lenguajes de programación por incluir una serie de operadores especiales que facilitan tareas específicas de análisis de datos y manipulación de objetos. Estos operadores tienen una sintaxis característica que suele incluir símbolos como % o :. Vamos a explorar dos de los más útiles: el operador de pertenencia %in% y el operador de acceso a espacios de nombres ::.

El operador %in%

El operador %in% es uno de los más prácticos en R, ya que permite verificar si un valor o conjunto de valores está presente dentro de otro conjunto. Su funcionamiento es sencillo pero extremadamente útil en el análisis de datos.

La sintaxis básica es:

x %in% y

Donde x representa el valor o valores que queremos buscar, y y es el conjunto donde queremos buscarlos.

Veamos algunos ejemplos simples:

# Verificar si un valor está en un vector
"manzana" %in% c("pera", "manzana", "naranja")  # TRUE
"uva" %in% c("pera", "manzana", "naranja")      # FALSE

# Verificar múltiples valores a la vez
c(1, 3, 5) %in% c(1, 2, 3, 4)  # Resultado: TRUE TRUE FALSE

En el último ejemplo, el resultado es un vector lógico que indica, para cada elemento de c(1, 3, 5), si está presente o no en c(1, 2, 3, 4).

Aplicaciones prácticas de %in%

El operador %in% es especialmente útil para filtrar datos basados en criterios de pertenencia:

# Datos de ejemplo
frutas <- c("manzana", "pera", "naranja", "plátano", "kiwi")
precios <- c(2.5, 1.8, 3.0, 2.2, 4.0)

# Filtrar frutas específicas
frutas_seleccionadas <- c("manzana", "kiwi", "uva")
indice <- frutas %in% frutas_seleccionadas
frutas[indice]  # Resultado: "manzana" "kiwi"
precios[indice] # Resultado: 2.5 4.0

También es muy útil para verificar categorías en conjuntos de datos:

# Verificar si los valores están dentro de categorías válidas
categorias_validas <- c("A", "B", "C")
datos_categoria <- c("A", "D", "B", "E", "C", "A")

# Identificar valores inválidos
datos_invalidos <- !datos_categoria %in% categorias_validas
datos_categoria[datos_invalidos]  # Resultado: "D" "E"

Diferencia con ==

Es importante entender la diferencia entre %in% y el operador de igualdad ==:

# Usando ==
c(1, 2, 3) == 2  # Resultado: FALSE TRUE FALSE

# Usando %in%
c(1, 2, 3) %in% 2  # Resultado: FALSE TRUE FALSE

En este caso simple, ambos producen el mismo resultado. Sin embargo, la diferencia es crucial cuando comparamos vectores de diferentes longitudes:

# Comparación con vectores de diferentes longitudes
c(1, 2, 3) == c(1, 2)  # Resultado: TRUE TRUE FALSE (con advertencia de reciclaje)

# Con %in% buscamos cada elemento del primer vector en el segundo
c(1, 2, 3) %in% c(1, 2)  # Resultado: TRUE TRUE FALSE (sin advertencia)

La verdadera ventaja de %in% se aprecia cuando buscamos coincidencias en conjuntos más grandes:

# Buscar coincidencias en un conjunto
buscar <- c(5, 10, 15)
conjunto <- c(1, 5, 10, 15, 20, 25)

# Con %in% es simple y directo
buscar %in% conjunto  # Resultado: TRUE TRUE TRUE

# Con == sería más complicado y menos eficiente

El operador ::

El operador :: es fundamental para el acceso a funciones y objetos dentro de paquetes específicos. Su sintaxis es:

paquete::objeto

Donde paquete es el nombre del paquete y objeto es la función, dataset o cualquier otro objeto que queremos acceder dentro de ese paquete.

¿Por qué usar ::?

Existen varias razones para utilizar el operador :::

• Evitar conflictos de nombres: Cuando dos paquetes tienen funciones con el mismo nombre
• Claridad en el código: Indica explícitamente de qué paquete proviene cada función
• Acceso sin cargar el paquete completo: Permite usar funciones específicas sin necesidad de cargar todo el paquete

Veamos algunos ejemplos:

# Usar una función de un paquete sin cargarlo
stats::median(c(1, 3, 5, 7, 9))  # Calcula la mediana usando la función del paquete stats

# Acceder a un dataset incluido en un paquete
datasets::mtcars[1:5, ]  # Muestra las primeras 5 filas del dataset mtcars

Resolución de conflictos

Uno de los usos más comunes de :: es resolver conflictos de nombres entre paquetes:

# Supongamos que tenemos cargados los paquetes dplyr y plyr
# Ambos tienen una función llamada "filter"

# Para especificar exactamente qué versión queremos usar:
dplyr::filter(mtcars, mpg > 20)  # Usa filter de dplyr
plyr::filter(mtcars, mpg > 20)   # Usa filter de plyr

Acceso a funciones internas

El operador :: también permite acceder a funciones internas de paquetes que normalmente no están expuestas al usuario:

# Acceder a una función interna
utils:::getS3method("print", "factor")

Nota que para funciones internas se usa ::: (tres dos puntos) en lugar de :: (dos dos puntos).

Comparación con library() y require()

A diferencia de library() o require(), que cargan todo un paquete en la sesión, :: permite acceder a elementos específicos sin cargar el paquete completo:

# En lugar de:
library(ggplot2)
ggplot(mtcars, aes(x = mpg, y = wt)) + geom_point()

# Podemos usar:
ggplot2::ggplot(mtcars, ggplot2::aes(x = mpg, y = wt)) + ggplot2::geom_point()

Aunque la segunda opción es más verbosa, tiene la ventaja de no cargar todo el paquete y hacer explícito el origen de cada función.

Otros operadores especiales en R

Aunque nos hemos centrado en %in% y ::, R tiene otros operadores especiales que vale la pena mencionar brevemente:

• %*%: Multiplicación de matrices
• %o%: Producto exterior
• %/%: División entera
• %%: Módulo (resto de división)
• %>%: Operador pipe del paquete magrittr (muy usado en tidyverse)

Incluso es posible crear operadores personalizados en R:

# Definir un operador personalizado para calcular el promedio
`%avg%` <- function(x, y) (x + y) / 2

# Usar nuestro operador
5 %avg% 10  # Resultado: 7.5

Ejemplo integrado

Veamos un ejemplo que combina ambos operadores para resolver un problema práctico:

# Supongamos que tenemos datos de ventas por región
regiones <- c("Norte", "Sur", "Este", "Oeste", "Centro")
ventas <- c(120, 85, 140, 110, 95)

# Regiones de interés para un análisis específico
regiones_interes <- c("Norte", "Este", "Centro")

# Filtrar solo las regiones de interés
indice_regiones <- regiones %in% regiones_interes
regiones_filtradas <- regiones[indice_regiones]
ventas_filtradas <- ventas[indice_regiones]

# Calcular estadísticas usando funciones específicas de paquetes
media_ventas <- stats::mean(ventas_filtradas)
mediana_ventas <- stats::median(ventas_filtradas)

# Mostrar resultados
data.frame(
  Region = regiones_filtradas,
  Ventas = ventas_filtradas,
  Media = media_ventas,
  Mediana = mediana_ventas
)

Este ejemplo muestra cómo %in% nos permite filtrar datos basados en criterios de pertenencia, mientras que :: nos asegura que estamos utilizando las funciones específicas del paquete stats, evitando posibles conflictos con otras implementaciones de mean o median.

Los operadores especiales de R como %in% y :: son herramientas que, aunque simples, aumentan significativamente la expresividad y claridad del código, permitiendo realizar operaciones comunes de manera más intuitiva y directa.