2  R es una calculadora demasiado extraña

Introducción a R

NotaResumen

Discutimos cómo usar R como si fuera una calculadora así como la lectura de datos, el directorio y la instalación de paquetes.

Advertencia

Si aún no cuentas con una instalación de R y RStudio ve a la sección de instalación

3 Primeros pasos con R

3.1 Cálculos numéricos

R sirve como calculadora para las operaciones usuales. En él puedes hacer sumas,

# Esto es una suma en R
12 + 31
[1] 43

Ada Lovelace (1815-1852), la primera en diseñar un algoritmo computacional ¡y sin tener computadoras!

restas,

# Esto es una resta en R
3 - 4
[1] -1

multiplicaciones,

# Esto es una multiplicación en R
7 * 8
[1] 56

divisiones,

# Esto es una división en R
4 / 2
[1] 2

sacar logaritmos naturales \(\ln\),

# Para sacar logaritmo usas el comando log
log(100)
[1] 4.60517

o bien logaritmos en cualquier base,1

1 Recuerda que un logaritmo base \(a\) te dice a qué potencia \(b\) tuve que elevar \(a\) para llegar a \(b\). Por ejemplo \(\log_{10}(100) = 2\) te dice que para llegar al \(100\) tuviste que hacer \(10^2\).

# Puedes especificar la base del logaritmo con base
log(100, base = 10)
[1] 2

también puedes elevar a una potencia (por ejemplo hacer \(6^3\)),

# Así se calculan potencias
6^3
[1] 216

calcular la exponencial \(e\),

# Para exponenciales puedes usar exp
exp(1)
[1] 2.718282

o bien exponenciar cualquier variable \(e^{-3}\),

# O bien exponenciales específicas, e^-3
exp(-3)
[1] 0.04978707

también puedes usar el número \(\pi\).

# Cálculo de pi
pi
[1] 3.141593

No olvides que R usa el orden de las operaciones de matemáticas. Siempre es de izquierda a derecha con las siguientes excepciones:

  1. Primero se evalúa lo que está entre paréntesis.

  2. En segundo lugar se calculan potencias.

  3. Lo tercero en evaluarse son multiplicaciones y divisiones.

  4. Finalmente, se realizan sumas y restas.

Por ejemplo, en la siguiente ecuación

\[ 2 - 2 \cdot \frac{(3^4 - 9)}{(5 + 4)} \]

se resuelven primero los paréntesis \((3^4 - 9) = 81 - 9 = 72\) y \((5 + 4) = 9\); luego se resuelve la división: \(\frac{72}{9}=8\), se multiplica por el \(2\): \(2 \cdot 8\) y finalmente se hace la resta: \(2-8 = -6\).

3.1.1 Ejercicio (operaciones sin contexto)

Determina, sin evaluar, los resultados de los siguientes segmentos de código:

# Primer ejercicio
(9 - 3)^2 * (2 - 1) - 6
# Segundo ejercicio
6 * 2 / (7 - 3) * 5
# Tercer ejercicio
2 * 3^2 * 2 / (5 - 4) * 1 / 10

Evalúa para comprobar tus respuestas.

3.1.2 Ejercicio (NNT)

El número (de pacientes) que es necesario tratar (NNT) se define como la cantidad total de pacientes a quienes es necesario darles tratamiento para evitar un resultado negativo (es decir a cuántos pacientes debo darles tratamiento para que al menos uno se beneficie).

TipNNT perfecto

El NNT perfecto es cuando \(NNT = 1\). ¿Por qué es éste el mejor escenario?

Dada la siguiente tabla

Resultado
Si No
Tratamiento Si A B
No C D

para calcular el NNT es necesario calcular la tasa de los eventos en el grupo experimental EER y en el grupo control CER como sigue:

\[ EER = \frac{A}{A+B} \quad \text{y}\quad CER = \frac{C}{C+D} \]

finalmente, el número necesario a tratar NNT se define como

\[ NNT = \frac{1}{|EER - CER|} \]

El ejercicio consiste en calcular en R el NNT para la siguiente tabla:

Resultado
Si No
Tratamiento Si 234 39
No 981 1040

Respuestas

3.1.3 Ejercicio (círculos)

Calcula en R el área y el perímetro de un círculo de radio 5.

Recuerda que la fórmula del área es \(\pi \cdot r^2\) donde \(r\) es el radio; mientras que la del perímetro es: \(\pi \cdot d\) donde \(d\) es el diámetro (= dos veces el radio).

Respuestas

3.1.4 Ejercicio (R0)

El \(R_0\) se interpreta como el promedio de casos nuevos que genera un infectado en una enfermedad infecciosa. En su forma más sencilla se puede modelar como:

\[ R_0 = \text{Transmisibilidad} \times \text{Promedio de tasa de contactos} \times \text{Duración del periodo infeccioso} \]

donde la transmisibilidad es la probabilidad de contagio si hay un contacto entre un individuo infectado y uno susceptible, el promedio de contactos es el promedio de interacciones entre un infectado y un susceptible que ocurran y la duración es la cantidad de tiempo que un individuo infectado dura contagioso.

Calcula en R el \(R_0\) para una enfermedad con \(10\) días de duración de periodo infeccioso, un promedio de \(2\) contactos por día y una transmisibilidad de \(0.07\).

Resultado

3.1.5 Ejercicio a mano (orden de las operaciones)

Importante

Este ejercicio es a lápiz y papel. Cierra RStudio, resuelve las siete operaciones a mano escribiendo paso por paso y hasta el final ábrelo para comprobar. La idea no es que le atines: es que sepas por qué R contesta lo que contesta.

Copia esta tabla en tu cuaderno y llénala. La columna de “Mi respuesta” la escribes antes de tocar la computadora; la de R después:

# Operación Mi respuesta (a mano) Lo que contestó R ¿Coincidieron?
a 10 - 2 * 3
b (10 - 2) * 3
c 100 / 10 / 2
d 1 + 2 * 10^2
e 2^3^2
f -3^2
g (-3)^2
TipPista para los incisos e, f y g

Estos tres son trampa y por eso vienen al final. Las potencias en R se resuelven de derecha a izquierda (no de izquierda a derecha como las sumas), y el signo de menos se aplica después de la potencia. Si tu respuesta a f y a g fue la misma, vuelve a pensarle.

Cuando termines, responde: ¿en cuáles te equivocaste y por qué? Esos son justo los paréntesis que sí vale la pena escribir aunque R no te los exija.

3.1.6 Ejercicio (encuentra el error)

Cada uno de los siguientes bloques está mal escrito y R va a devolver un error (o, peor, un resultado equivocado sin avisarte). Para cada uno:

  1. Escribe qué crees que está mal antes de correrlo.
  2. Córrelo y lee el mensaje de error completo.
  3. Corrígelo y verifica que ahora sí dé el resultado que se pide.
#a) Queremos sumar doce punto cinco más tres
12,5 + 3
#b) Queremos el logaritmo natural de 100
log 100
#c) Queremos calcular (3 + 4) por (2 - 1)
(3 + 4 * (2 - 1)
# d) Queremos el logaritmo base 10 de 1000
Log(1000, base = 10)
#e) Queremos multiplicar 6 por 3
6 x 3
# f) Queremos elevar e a la potencia 2
exp[2]
  1. R usa punto decimal, no coma. La coma sirve para separar argumentos, así que R cree que le diste dos cosas. Correcto: 12.5 + 3.
  2. A las funciones siempre se les ponen paréntesis. Correcto: log(100).
  3. Falta cerrar un paréntesis (abriste dos y cerraste uno). Además el paréntesis está en el lugar equivocado para lo que se pide. Correcto: (3 + 4) * (2 - 1). Cuando R se queda esperando un paréntesis, la consola te muestra un + en lugar del >; si te pasa, presiona Esc.
  4. R distingue mayúsculas de minúsculas: Log no existe, log sí. Correcto: log(1000, base = 10).
  5. La multiplicación se escribe con asterisco. Correcto: 6 * 3.
  6. Los corchetes [ ] no sirven para llamar funciones, sólo los paréntesis ( ). Correcto: exp(2).

3.1.7 Ejercicio (indicadores de salud pública)

Éstos ya son cálculos como los que haces en el trabajo. Resuélvelos en R guardando cada paso en una variable (no lo escribas todo en un solo renglón) y comenta cada línea con un #.

Advertencia

Todas las cifras de este ejercicio son hipotéticas, inventadas para practicar. No las cites como si fueran datos reales.

  1. Tasa de incidencia. En un estado con 3,540,000 habitantes se notificaron 1,284 casos nuevos de dengue durante un año. Calcula la tasa de incidencia por cada 100,000 habitantes:

    \[ \text{Tasa} = \frac{\text{casos nuevos}}{\text{población}} \times 100{,}000 \]

  2. Prevalencia. En una encuesta a 1,730 personas adultas, 219 resultaron con hipertensión. Calcula la prevalencia en porcentaje.

  3. Letalidad. De 1,284 casos de dengue, 17 fallecieron. Calcula la tasa de letalidad en porcentaje. ¿Por qué esta tasa no se divide entre la población del estado?

  4. Razón de momios (OR). Para la siguiente tabla de un estudio de casos y controles sobre tabaquismo e infarto:

    Infarto (casos) Sin infarto (controles)
    Fumador 182 104
    No fumador 118 296

    calcula la razón de momios con la fórmula

    \[ OR = \frac{a \cdot d}{b \cdot c} \]

    donde a = fumadores con infarto, b = fumadores sin infarto, c = no fumadores con infarto y d = no fumadores sin infarto. Interpreta en una frase el número que obtuviste.

  5. Dosis por peso. Un medicamento se administra a razón de 15 mg por kilogramo de peso, repartidos en 3 tomas al día. ¿Cuántos miligramos lleva cada toma para una persona de 68 kg?

En el 3, la letalidad mide qué tan grave es la enfermedad una vez que la tienes, por eso el denominador son los enfermos y no la población. En el 4, un OR de 4.39 quiere decir que los momios de haber fumado son alrededor de 4.4 veces mayores entre quienes tuvieron infarto que entre quienes no.

3.1.8 Ejercicio con apoyo de una IA

Hoy es normal resolver dudas de R preguntándole a una inteligencia artificial (ChatGPT, Claude, Gemini, Copilot o la que uses). Es una herramienta buenísima si sabes revisarle la tarea, porque estos programas inventan cosas con toda seguridad y aplomo. Este ejercicio es para que practiques justamente eso.

ImportanteAntes de empezar: datos de pacientes, nunca

No pegues en una IA datos personales identificables (nombres, CURP, expedientes, domicilios) ni bases de datos confidenciales de tu institución. Lo que escribes ahí sale de tu computadora y puede quedar almacenado en un servidor de otro país. Pega el código y el mensaje de error, no los datos.

  1. Pregunta y verifica. Pídele a la IA: “¿Cómo calculo la raíz cuadrada de 5566 en R?”. Corre lo que te dé. Después comprueba tú misma o tú mismo el resultado de otra forma (por ejemplo elevando a la potencia 0.5, que es lo mismo que sacar raíz). ¿Coinciden?

  2. Que te explique un error. Corre a propósito el inciso b del ejercicio de “encuentra el error” (log 100). Copia el mensaje de error completo y pégaselo a la IA pidiéndole: “Explícame este error de R como si nunca hubiera programado y dime cómo lo arreglo”. Compara su explicación con la respuesta que ya leíste arriba.

  3. Cázala inventando. Pídele: “Dame la función de R de paquetería base que calcula la tasa de mortalidad estandarizada por edad”. Es muy probable que se invente una función que no existe. Verifica toda función que te den escribiendo ?nombre_de_la_funcion en la consola: si R te contesta No documentation for ..., esa función no existe en tu instalación (o vive en un paquete que no tienes). Escribe en tu cuaderno qué te inventó.

  4. Que comente tu código. Toma tu solución del ejercicio de indicadores de salud pública y pídele: “Agrégale comentarios en español a este código de R explicando cada línea, sin cambiar los cálculos”. Revisa línea por línea que no te haya modificado ningún número ni ninguna fórmula. Si te cambió algo, ése es exactamente el motivo por el cual hay que revisar.

  5. Reflexiona. Contesta en dos o tres renglones: ¿en cuál de los cuatro puntos anteriores te habría metido en problemas confiar sin verificar? Si tú fueras quien firma un informe de vigilancia epidemiológica, ¿de quién es la responsabilidad del número final?

3.1.9 Variables

R es un programa orientado a objetos; esto quiere decir que R almacena la información en un conjunto de variables que pueden tener diferentes clases y opera con ellos según su clase. Por ejemplo, un conjunto de caracteres, entre comillas, es un Character (R lo piensa como texto)

# Un conjunto de caracteres es un char
"Hola"
[1] "Hola"

Un número (por ejemplo 2 tiene clase numeric)2. Hay que tener mucho cuidado con combinar floats con Strings:

2 Puede ser float, int, double pero no nos preocuparemos por eso.

# Código que sí funciona porque ambos son números
2 + 4
[1] 6

El algoritmo diseñado por Ada Lovelace.
# Código que no funciona porque uno es caracter
2 + "4"
Error in `2 + "4"`:
! argumento no-numérico para operador binario

Si lo piensas, este último error ¡tiene todo el sentido! no puedes sumar un número a un texto. ¿O qué significaría 'Felices' * 4 ?

La magia de R comienza con que puedes almacenar valores en variables. Por ejemplo, podemos asignar un valor a una variable:

# Asignamos x = 10
x <- 10

Hay dos formas de asignar valores, una es con la flecha de asignación \(\leftarrow\) y otra con el signo de igual:

#Podemos asignar valores con el signo de =
y = 6

Nota que, cuando realizamos operaciones, la asignación es la última que se realiza:

# Aquí z = 106
z <- y + x^2

Los valores que fueron asignados en las variables, R los recuerda y es posible calcular con ellos:

# Podemos realizar una suma
x + y
[1] 16
# O bien podemos realizar una multiplicación
3 * y - x
[1] 8

Podemos preguntarnos por el valor de las variables numéricas mediante los operadores == (sí, son dos iguales), != (que es un \(\neq\)) >, >=, <= y <:

# Podemos preguntarnos si x vale 4
x == 4
[1] FALSE
Advertencia

El operador de asignación también se puede utilizar al revés \(2 \rightarrow x\) pero no lo hagas, por favor.

Nota que no estamos asignando el valor de x:

x
[1] 10

Podemos preguntarnos por diferencia:

x != 4
[1] TRUE

Así como por mayores, menores incluyendo posibles igualdades (i.e. los casos \(\geq\) y \(\leq\))

# Nos preguntamos si x > y
x > y
[1] TRUE
# Nos preguntamos si x >= 10
x >= 10
[1] TRUE
# Nos preguntamos si y < 6
y < 6
[1] FALSE
# O bien si y <= 6
y <= 6
[1] TRUE

En todos los casos los resultados han sido TRUE ó FALSE. La clase de variables que toma valores TRUE ó FALSE se conoce como booleana. Hay que tener mucho cuidado con ellas porque, puedes acabar con resultados muy extraños:

# MALAS PRÁCTICAS, NO HAGAS ESTO
# Cuando lo usas como número TRUE vale 1
100 + TRUE
[1] 101
# MALAS PRÁCTICAS, NO HAGAS ESTO
# Cuando lo usas como número FALSE vale 0
6 * FALSE
[1] 0
Advertencia

Aquí puedes encontrar una lista de malas prácticas en computación a evitar.

Finalmente, nota que es posible reescribir una variable y cambiar su valor:

# Aquí x vale 10, como antes
x
[1] 10
# Aquí cambianos el valor de x y valdrá 0.5
x <- 0.5
x
[1] 0.5

3.1.10 Ejercicios de variables (para confundir)

Determina el valor que imprime R en cada caso, sin que corras los siguientes pedazos de código. Después, verifica tu respuesta con R:

Ejercicios R BÁSICO

# Primer ejercicio
x <- 100
y <- 3
x > y
# Segundo ejercicio
z <- (4 - 2)^3
z <- z + z + z
z
# Tercer ejercicio
x <- 3
y <- 2
z <- x * y
x <- 5
y <- 10
z
# Cuarto ejercicio
variable1 <- 1000
variable2 <- 100
variable3 <- variable1 / variable2 <= 10
variable3
# Quinto ejercicio
"2" - 2
# Sexto ejercicio
(0.1 + 0.1 + 0.1) == 0.3

Ejercicios R intermedio

Determina, sin correr el programa, qué regresa la consola en este caso

x <- 2
x <- 5 + x -> y -> x
x <- x^2
x
x <- TRUE
if (x > FALSE) {
  x <- x^(FALSE)^(TRUE)
} else {
  x <- x^(FALSE)^(TRUE)
}
x

Comprueba con la consola tus resultados; puede que encuentres respuestas poco intuitivas.

Ejercicio a mano: sigue el rastro de las variables

Importante

Otra vez a lápiz y papel. La computadora se queda cerrada hasta el final.

La computadora ejecuta tu programa de arriba hacia abajo, un renglón a la vez, y una variable siempre guarda lo último que le asignaste. Para convencerte, copia esta tabla en tu cuaderno y ve anotando cuánto vale cada variable después de ejecutar cada renglón. Si en ese renglón la variable todavía no existe, escribe una raya.

peso <- 70 # renglón 1
altura <- 1.75 # renglón 2
imc <- peso / altura^2 # renglón 3
peso <- 80 # renglón 4
imc # renglón 5
Después del renglón peso altura imc
1
2
3
4

La pregunta importante es la del renglón 5: ¿qué imprime imc, el índice de masa corporal de una persona de 70 kg o el de una de 80 kg? ¿Por qué?

Ahora haz lo mismo con este otro, que es el mismo error pero disfrazado:

casos_2025 <- 400
casos_2026 <- 500
incremento <- casos_2026 - casos_2025
casos_2026 <- 600
porcentaje <- incremento / casos_2025 * 100
porcentaje

¿Cuánto vale porcentaje? ¿Es el incremento correcto respecto a los 600 casos? Escribe en una frase cuál es la moraleja.

Tip

Ésta es una de las fuentes de error más comunes (y más difíciles de detectar) en el análisis de datos real: corregiste un dato, pero no volviste a correr los cálculos que dependían de él. Por eso conviene correr siempre el script completo de arriba a abajo antes de reportar un número.

Ejercicio a mano: sigue un if paso a paso

TipCómo se lee un if

Un if es una bifurcación: R revisa la condición que va entre paréntesis y, si es TRUE, ejecuta lo que está entre las llaves { } que le siguen; si es FALSE, se brinca ese bloque y pasa al siguiente else if (que significa “si no, entonces prueba con esto otro”) o al else (que significa “si nada de lo anterior se cumplió, haz esto”). En cuanto una condición se cumple, R ya no revisa las demás: se sale del if. Ese detalle es el que hace que el orden de las condiciones importe muchísimo.

Considera el siguiente código, que clasifica un resultado de glucosa en ayuno (en mg/dL):

glucosa <- 108

if (glucosa >= 126) {
  diagnostico <- "diabetes"
} else if (glucosa >= 100) {
  diagnostico <- "prediabetes"
} else {
  diagnostico <- "normal"
}

diagnostico

Sin correr nada, llena esta tabla escribiendo qué contesta TRUE o FALSE cada condición y con qué diagnóstico se queda la persona:

glucosa ¿glucosa >= 126? ¿glucosa >= 100? diagnostico
108
99
100
126
300
Advertencia

Ojo con los renglones de 100 y 126: están exactamente en la frontera. Ahí es donde se decide si el >= debía ser > y donde se cuelan los errores de clasificación en la vida real.

Ahora la pregunta que de verdad importa. Alguien escribió esta otra versión, que se ve casi igual:

glucosa <- 150

if (glucosa >= 100) {
  diagnostico <- "prediabetes"
} else if (glucosa >= 126) {
  diagnostico <- "diabetes"
} else {
  diagnostico <- "normal"
}

diagnostico

¿Qué diagnóstico le da a una persona con glucosa de 150? ¿Está bien? ¿Cuántas personas con diabetes clasificaría mal este código y por qué nunca puede entrar al bloque de "diabetes"?

Ejercicio a mano: sigue un for paso a paso

TipCómo se lee un for

Un for es una repetición. Cuando escribes for (i in 1:4) { ... }, R ejecuta lo que está entre llaves cuatro veces: la primera con i valiendo 1, la segunda con i valiendo 2, y así hasta el 4. Si en vez de 1:4 pones c(3, 7, 2, 8) (la c de “combinar” arma una lista de valores), entonces la variable va tomando esos valores en ese orden. Al terminar todas las vueltas, R sigue con el renglón que está debajo del for.

Éste también es a mano. Para cada código, llena una tabla con una fila por vuelta.

  1. ¿Cuánto vale total al final?
total <- 0
for (casos in c(3, 7, 2, 8)) {
  total <- total + casos
}
total
Vuelta casos total antes total después
1 3 0
2 7
3 2
4 8
  1. ¿Cuánto vale poblacion al final? (Es una población que crece 10% al año durante 3 años.)
poblacion <- 1000
for (anio in 1:3) {
  poblacion <- poblacion * 1.1
}
poblacion
  1. Éste es trampa. ¿Cuánto vale contagios al final y cuántas vueltas dio el for?
contagios <- 1
for (dia in 1:5) {
  contagios <- contagios * 2
}
contagios
  1. Y éste es más trampa todavía. ¿Cuánto vale suma? Fíjate bien en dónde está el suma <- 0.
for (i in 1:4) {
  suma <- 0
  suma <- suma + i
}
suma
  1. total vale 20 (0+3=3, 3+7=10, 10+2=12, 12+8=20).
  2. poblacion vale 1331 (\(1000 \times 1.1^3\)). Nota que no son 1300: el crecimiento se aplica sobre el resultado de la vuelta anterior, no sobre los 1000 originales.
  3. contagios vale 32 (\(2^5\)) y el for dio 5 vueltas (1:5 son cinco números: 1, 2, 3, 4 y 5). Es el clásico error de contar 4 porque “del 1 al 5 hay 4 de diferencia”.
  4. suma vale 4, no 10. Como el suma <- 0 está adentro de las llaves, se vuelve a poner en cero en cada vuelta y se borra lo acumulado. Sólo sobrevive la última vuelta (i = 4). Para que diera 10 el suma <- 0 tendría que estar antes del for.

Ejercicio: encuentra el error (variables)

Los siguientes renglones fallan al crear variables. Di qué está mal en cada uno, corrígelo y verifica:

#a) Queremos una variable llamada 2edad con valor 30
2edad <- 30
#b) Queremos guardar la edad de la persona
mi variable <- 5
#c) Queremos guardar un peso de 70 kilos
peso <- 70 kg
# d) Queremos asignarle a altura el valor 1.70
altura < -1.70
# e) Queremos calcular el índice de masa corporal
peso <- 70
altura <- 1.70
IMC <- peso / Altura^2
#f) Queremos saber si la persona tiene 18 años
edad <- 25
edad = 18
  1. Los nombres de variables no pueden empezar con número. Usa edad2 o edad_2.
  2. Los nombres no pueden llevar espacios. Usa mi_variable o mi.variable.
  3. R no entiende unidades. Escribe peso <- 70 y anota los kilos en un comentario: peso <- 70 #kg.
  4. El operador de asignación es <- pegado, sin espacio en medio. Tal como está, R entiende “¿altura es menor que negativo 1.70?”.
  5. Altura con mayúscula no existe; la variable se llama altura. R distingue mayúsculas de minúsculas.
  6. Un solo = asigna (le cambia el valor a edad y lo deja en 18); para preguntar se usan dos: edad == 18. Éste es el error más peligroso de la lista porque no da error: modifica tus datos en silencio.

Ejercicio con apoyo de una IA (variables)

  1. Toma el código del ejercicio del if mal ordenado (el de la glucosa de 150) y pégaselo a una IA con esta instrucción: “Este código de R clasifica mal a algunas personas. Explícame en español sencillo cuál es el error, sin darme el código corregido todavía.” Compara su explicación con la que tú escribiste a mano. ¿Encontró lo mismo que tú?

  2. Ahora pídele el código corregido. Antes de correrlo, vuelve a llenar tu tabla a mano con la versión que te dio, usando los valores 99, 100, 126 y 150. ¿Su corrección funciona en las fronteras?

  3. Pégale el ejercicio 4 del for (el del suma <- 0 adentro de las llaves) y pregúntale “¿cuánto vale suma al final?”. Verifica tú en R. Si la IA se equivocó, escribe cuál fue su error de razonamiento; si le atinó, pídele que te explique por qué y verifica que la explicación sea la misma que aparece en las respuestas de arriba.

  4. Pídele que te genere tres ejercicios nuevos de seguimiento de variables a mano, con sus respuestas en una sección aparte. Resuélvelos a mano, luego revisa en R si las respuestas que la IA dio eran correctas. Es muy común que se equivoque en éstos: encontrar su error es la mitad del ejercicio.

3.2 Observaciones sobre la aritmética de punto flotante

Si hiciste el penúltimo ejercicio (el cual, obviamente hiciste y comprobaste con la consola) podrás haber notado una trampa. Analicemos qué ocurre; quizá hicimos mal la suma

# Veamos si este lado está mal
(0.1 + 0.1 + 0.1)
[1] 0.3
# O si éste es el que tiene la trampa
0.3
[1] 0.3

Aparentemente no hay nada malo ¿qué rayos le pasa a R? La respuesta está en la aritmética de punto flotante. Podemos pedirle a R que nos muestre los primeros 100 dígitos de la suma 0.1 + 0.1 + 0.1:

Réplica de la Z3, la primer computadora con punto flotante (1941).
# Veamos qué pasa con la suma
options(digits = 22) # Cambiamos dígitos
(0.1 + 0.1 + 0.1) # Sumamos
[1] 0.3000000000000000444089
Advertencia

El comando options(digits = 22) especifica que R debe imprimir en la consola 22 dígitos. No más. Si quieres devolverlo a como lo tenías haz options(digits = 7).

¡Ahí está el detalle! R no sabe sumar. En general, ningún programa de computadora sabe hacerlo. Veamos otros ejemplos:

4.1 - 0.1 # Debería dar 4
[1] 3.999999999999999555911
3 / 10 # Debería ser 0.3
[1] 0.2999999999999999888978
log(10^(12345), base = 10) # Debería dar 12345
[1] Inf

El problema está en cómo las computadoras representan los números. Ellas escriben los números en binario. Por ejemplo, 230 lo representan como 11100110 mientras que el 7 es: 111. El problema de las computadoras radica en que éstas tienen una memoria finita por lo que números muy grandes como: \(124765731467098372654176\) la computadora hace lo mejor por representarlos eligiendo el más cercano:

# Nota la diferencia entre lo que le decimos a R
# y lo que resulta
x <- 124765731467098372654176
x
[1] 124765731467098377420800
Advertencia

Un error de punto flotante en la vida real ocasionó en los años noventa, la explosión del cohete Ariane 5. Moraleja: hay que tener cuidado y respeto al punto flotante.

No olvides cambiar la cantidad de dígitos que deseas que imprima R en su consola de vuelta:

options(digits = 7) # Cambiamos dígitos

El mismo problema ocurre con números decimales cuya representación binaria es periódica; por ejemplo el \(\frac{1}{10}\) en binario se representa como \(0.0001100110011\overline{0011}\dots\). Como es el cuento de nunca acabar con dicho número, R lo trunca y almacena sólo los primeros dígitos de ahí que, cada vez que escribes 0.1, R en realidad almacene el 0.1000000000000000055511 que es casi lo mismo pero no es estrictamente igual. Hay que tener mucho cuidado con esta inexactitud de las computadoras (inexactitud estudiada por la rama de Análisis Numérico) pues puede generar varios resultados imprevistos.

3.2.1 ¿Cómo checar un if?

En general lo que hacen las computadoras para comparar valores es que verifican que, en valor absoluto, el error sea pequeño. Recuerda que el valor absoluto de \(x\), \(|x|\), regresa siempre el positivo:

\[ |4| = 4 \qquad \textrm{y} \qquad |-8| = 8 \]

Para verificar que algo es más o menos \(0.3\) suele usarse el valor absoluto3 de la siguiente manera:

3 En R el comando abs toma el valor absoluto.

abs((0.1 + 0.1 + 0.1) - 0.3) < 1.e-6
[1] TRUE

donde 1.e-6 es notación corta para 0.000001 (también escrito como \(1\times 10^{-6}\)). La pregunta que nos estamos haciendo es que si el error entre sumar \(0.1+0.1+0.1\) y \(0.3\) es muy pequeño \(< 0.000001\):

\[ | (0.1 + 0.1 + 0.1) - 0.3 | < 0.000001 \]

3.3 Leer y almacenar variables en R

Para terminar esta sección, aprenderemos cómo guardar variables en R. Para eso, el concepto de directorio es uno de los más relevantes. En general, en computación, el directorio se refiere a la dirección en tu computadora donde estás trabajando. Por ejemplo, si estás en una carpeta en tu escritorio de nombre Ejercicios_R probablemente tu directorio sea \~/Desktop/Ejercicios_R/ (en Mac) o bien \~\\Desktop\\Ejercicios_R\\ en Windows4. La forma de saber tu directorio (en general) es ir a la carpeta que te interesa y con clic derecho ver propiedades (o escribir ls en la terminal Unix).

4 Windows usa backslash. Y hay toda una historia detrás de ello

R tiene un directorio default que quién sabe dónde está (depende de tu instalación, generalmente está donde tu Usuario). Usualmente lo mejor es elegir un directorio para cada uno de los proyectos que hagas. Para ello si estás en RStudio puedes utilizar Shift+Ctrl+H (Shift+Cmd+H en Mac) o bien ir a Session > Set Working Directory > Choose Directory y elegir el directorio donde deseas trabajar tu proyecto. Pensando que elegiste el escritorio (Desktop en mi computadora) notarás que en la consola aparece el comando setwd("~/Desktop") (o bien con ‘\’ si eres Windows). Mi sugerencia es que copies ese comando en tu Script para que, la próxima vez que lo corras ya tengas preestablecido el directorio.

#Si eres Mac/Linux
setwd("~/Desktop") 

#Si eres Windows
setwd("C:\Users\Rodrigo\Desktop") #Rodrigo = Mi usuario

Podemos verificar el directorio elegido con getwd():

getwd()
Advertencia

En general es buena práctica en R establecer, hasta arriba del Script, el comando de directorio. Esto con el propósito de que, cuando compartas un archivo, la persona a quien le fue compartido el archivo pueda rápidamente elegir su propio directorio en su computadora.

Probemos guardar unas variables en un archivo dentro de nuestro directorio. Para ello utilizaremos el comando save.

# Crear las variables
x <- 200
y <- 100

# Los archivos de variables de R son rda
save(x, y, file = "MisVariables.rda")

Si vas a tu directorio, notarás que el archivo MisVariables.rda acaba de ser creado. De esta forma R puede almacenar objetos creados en R que sólo R puede leer (más adelante veremos cómo exportar bases de datos y gráficas). Observa que en tu ambiente (si estás en RStudio puedes verlas en el panel 3) deben aparecer las variables que hemos usado hasta ahora:

[1] "x"                   "y"                   "z"                  
[4] ".QuartoInlineRender"

Podemos probar sumar nuestras variables y todo funciona súper:

x + y # Funciona magnífico
[1] 300

Limpiemos el ambiente. El comando equivalente al clear all en R es un poco más complicado de memorizar:

# EL clear all de R
rm(list = ls())

Ahora, si vuelves a ver el ambiente, éste estará vacío: ¡hemos limpiado el historial! Nota que si intentamos operar con las variables, R ya no las recuerda:

x + y # Error
Error:
! objeto 'x' no encontrado
Advertencia

Así como hay que lavarse las manos antes de comer, es buen hábito limpiar todas las variables del ambiente de R antes de usarlo.

Podemos leer la base de datos usando load:

# Leemos las variables
load("MisVariables.rda")

# Una vez leídas podemos empezar a jugar con ellas
x + y # Ya funciona
[1] 300

Por último, es necesario resaltar la importancia del directorio. Para ello crea una nueva carpeta en tu escritorio de nombre "Mi_curso_de_R". Mueve el archivo "MisVariables.rda" dentro de la carpeta. Borra todo e intenta leer de nuevo el archivo:

# Borramos todo
rm(list = ls())

# Intentamos leer el archivo de nuevo
load("MisVariables.rda")
Error in `readChar()`:
! no se puede abrir la conexión

Este error es porque R sigue pensando que nuestro directorio es el escritorio y está buscando el archivo ahí sin hallarlo. Para encontrarlo hay que cambiar el directorio a través de RStudio (ya sea Ctrl+Shift+H o Session >Set Working Directory > Choose Directory) o bien a través de comandos en R:

#Si eres Mac/Linux
setwd("~/Desktop/Mi_curso_de_R") 

#Si eres Windows
setwd("C:\Users\Rodrigo\Desktop\Mi_curso_de_R") #Rodrigo = Mi usuario
# Aquí sí se puede leer
load("MisVariables.rda")

3.3.1 Ejercicio

Responde a las siguientes preguntas:

  1. ¿Qué es el directorio y por qué es necesario establecerlo?

  2. Si R me da el error 'No such file or directory' ¿qué hice mal?

  3. En RStudio, ¿qué hace Session > Restart R? ¿cuál es la diferencia con rm(list = ls())?

  4. ¿Qué hace el comando cat("\014")? (Ojo puede que no haga nada). Si funciona, ¿cuál es la diferencia con rm(list = ls()) y con Restart R?

3.4 Instalación de paquetes

Un paquete de R es un conjunto de funciones adicionales elaboradas por los usuarios, las cuales permiten hacer cosas adicionales en R. Para instalarlos requieres de una conexión a Internet (o bien puedes instalarlos a partir de un archivo, por ejemplo, mediante una USB). El comando de instalación es install.packages seguido del nombre del paquete. Por ejemplo (y por ocio) descarguemos el paquete beepr para hacer reproducir sonidos en la computadora5. Para ello:

5 En los siguientes capítulos descargaremos paquetes más interesantes; pero no desprecies la utilidad de beepr yo lo he usado en múltiples ocasiones para que la computadora me avise que ya terminó de correr un código.

install.packages("beepr")
[...]
* DONE (beepr)

The downloaded source packages are in
    ‘/algun/lugar/downloaded_packages’

Esto significa que el paquete ha sido instalado. Nos interesa usar la función beep que emite un sonido (??beep para ver la ayuda). Si la llamamos así tal cual, nos da error:

beep(3)
Error in `beep()`:
! no se pudo encontrar la función "beep"

R es incapaz de hallar la función porque aún no le hemos dicho dónde se encuentra. Para ello podemos llamar al paquete mediante la función library y decirle a R que incluya las funciones que se encuentran dentro de beepr:

library(beepr)
beep(3) # Esto produce un sonido

El comando library le dice a R ¡hey, voy a usar unas funciones que creó alguien más y que están dentro del paquete beepr! De esta manera, al correr beep(3), R ya sabe dónde hallar la función y por eso no arroja error.

3.4.1 Ejercicios

R BÁSICO

  1. Instala el paquete ggplot2 en R así como ggformula, readr y readxl (son 4 paquetes distintos).
  2. Con ggplot2 haz lo necesario para que el siguiente bloque de código te arroje una gráfica:
# Aquí tienes que hacer algo
#
# RELLENA AQUÍ
#

# Esto genera un histograma
set.seed(1364752)
mis.datos <- data.frame(x = rnorm(1000))

# Las siguientes funciones viven en el paquete ggplot2
ggplot(mis.datos, aes(x = x)) +
  geom_histogram(bins = 50, fill = "deepskyblue3") +
  ggtitle("Histograma generado por el código")
Error in `ggplot()`:
! no se pudo encontrar la función "ggplot"
  1. ¿Qué es un paquete para R?

R INTERMEDIO

  1. Instala el paquete devtools (para hacerlo probablemente necesites instalar más cosas en tu computadora; averigua cuáles)
  2. Usa devtools para instalar el paquete emoGG desde Github.
  3. Verifica que tu instalación fue correcta haciendo la siguiente gráfica:
library(emoGG)
ggplot(mtcars, aes(wt, mpg)) +
  geom_emoji(emoji = "1f697")

3.5 Comentarios adicionales sobre el formato

Así como en el español existen reglas de gramática para ponernos todos de acuerdo y entendernos entre todos, en R también existen sugerencias a seguir para escribir tu código. Las sugerencias que aquí aparecen fueron adaptadas de las que utiliza el equipo de Google.

  1. No escribas líneas de más de 80 caracteres (si se salió de tu pantalla, mejor continúa en el siguiente renglón).

  2. Coloca espacios entre operadores +,*,/,-,<-,=, <, <=, >, >=, == y usa paréntesis para agrupar:

#Esto no se ve muy bien
abs(3*5/(4-9)^2-60/100-888+0.1*8888-4/10*2) < 1.e-6

#Los espacios permiten distinguir el orden de las operaciones
abs( (3 * 5) / (4 - 9)^2 - 60 / 100 - 888 
      + (0.1 * 8888) - (4 / 10) * 2 ) < 1.e-6
  1. Intenta alinear la asignación de variables para legibilidad:
#Esto no tanto
altura <- 1.80
peso <- 80
edad <- 32

#Esto se ve bien
altura <- 1.80
peso   <- 80
edad   <- 32
  1. Utiliza nombres que evoquen la variable que representas
#Cuando regreses a esto no sabrás ni qué
x <- 10
y <- 2
z <- 3.14
W <- z * x^y #¿Qué calculé?

#Es mejor especificar la variable
radio        <- 10
potencia     <- 2
pi_aprox     <- 3.14
area_circulo <- pi_aprox * radio^potencia
  1. No utilices un nombre demasiado similar para cosas diferentes.
#Aquí, seguro eventualmente te vas a equivocar
altura <- 10   #Altura del edificio
Altura <- 1.8  #Mi altura
ALTURA <- 2000 #La altitud de la CDMX

#Siempre elegir nombres claros, aunque largos
altura.edificio <- 10   #Altura del edificio
altura.Rodrigo  <- 1.8  #Mi altura
altura.CDMX     <- 2000 #La altitud de la CDMX
  1. Comenta:
#¿Qué hace esto?
x <- 168
x <- x/100
y <- 71.2
print(y/x^2) 
  
#Es mejor así
altura <- 168        #en centímetros
altura <- altura/100 #en metros
peso   <- 71.2       #peso en kg
print(peso/altura^2) #índice masa corporal

Trad: Un periodista se acerca a un programador a preguntarle ¿qué hace que un código sea malo? -Sin comentarios.
  1. Siempre pon las llamadas a los paquetes y el directorio al inicio de tu archivo para que otro usuario sepa qué necesita.

Código limpio y legible:

# Asumiendo aquí inicia el archivo:
setwd("Mi directorio")

# Llamamos la librería
library(beepr)
library(tidyverse)

# Analizamos una base de datos de R
data(iris) # Base de datos de flores

# Agrupamos la base por especie
iris.agrupada <- group_by(iris, Species)

# Obtenemos la media por longitud de sépalo
iris.media <- summarise(iris.agrupada, SL.mean = mean(Sepal.Length))

# Avisa que ya terminó
beep(5)

es siempre preferible a código escrito con prisas :

Yo, leyendo mi código no comentado y con mala edición 6 meses después de haberlo hecho.
data(iris);setwd("Mi directorio")
library(tidyverse);x<-group_by(iris,Species  )
#Aquí hacemos esto
iris.means=summarise( x,SL.mean=mean(Sepal.Length));library(beepr);beep(5)#FIN

Siempre escribe tu código pensando que alguien más (y ese alguien más puedes ser tú) va a leerlo. ¡No olvides comentar!

3.6 Continuación

¡Felicidades! Ya terminaste esta sección. Puedes ir a:

3.7 Ejercicios de cierre de la sección

  1. El siguiente código crea una variable que se llama enfermedad a la cual se le asigna el valor (caracter) "Polio". Sin embargo el código no corre. Arréglalo para que funcione
enfermedad == POLIO

  1. ¿Cuál es la diferencia entre R y RStudio?

  2. Corre el siguiente código el cuál se encarga de generar una variable de nombre viento, crear un archivo MIVIENTO.rda, guardarlo en otro directorio y decirte en qué directorio lo guardó. Cambia el directorio con setwd y lee el archivo usando load

# Genera una variable viento y la guarda en un archivo rda. Córreme completo
set.seed(2734)
directorio <- tempdir()
viento <- rexp(1)
save(viento, file = file.path(directorio, "MIVIENTO.rda"))
rm(viento)
message(paste("Guardé MIVIENTO.rda en el directorio;", directorio))
# Ahora usa setwd para ir al directorio y leer "MIVIENTO.rda"
  1. El siguiente código se encarga de clasificar los resultados de un test de A1C (porcentaje) de una persona en tres: diabetes (si AIC es mayor o igual a 6.5%), prediabetes (5.7 a 6.4%) y normal (menor a 5.7%). Sin embargo el código tiene varios errores y sin importar la persona a todos les dice que tienen diabetes. Corrige el código para que funcione
# Aquí cambia el usuario cambia el nivel de AIC según el resultado de cada persona:
nivel_AIC <- 5.4

# Hacemos la clasificación:
clasif <- "diabetes"
if (nivel_AIC > 6.5) {
  clasif <- "diabetes"
} else if (nivel_AIC < 6.5 & nivel_AIC > 5.7) {
  clasif1 <- "prediabetes"
} else {
  clasif2 <- "normal"
}

message(paste0("Sus niveles corresponden a ", clasif))
  1. ¿Qué significan los signos de + en el siguiente input de la consola?
x <-
  +"Ho
+  la"
  1. El primer signo de + indica que a lo que estuviera en x se le agregan los caracteres "Ho".
  2. El segundo signo de + indica concatenación de caracteres y está juntando el Ho con el la para formar un Hola.
  3. El segundo signo de + está dentro del caracter por lo que estamos escribirndo Ho+la.
  4. El signo de + le indica al usuario que hay un error en la línea previa.
  5. El signo de + le indica al usuario que la línea previa está incompleta.
  1. ¿Qué es el directorio que ponemos con setwd?
  1. Es la carpeta donde vive R.
  2. Es la carpeta donde viven los paquetes de R.
  3. Es la carpeta donde viven los archivos que estoy usando para mi proyecto actual en R.
  1. Genera un RScript de nombre IMC.R en el cual las personas almacenen en una variable su peso (kilos), en otra su altura (metros) y les calcule su índice de masa corporal IMC con la siguiente fórmula:

\[ \text{IMC} = \frac{\text{Peso}}{\text{Altura}^2} \]

  1. Encuentra el error (script completo). El siguiente script pretende calcular la cobertura de vacunación de una jurisdicción y avisar si está por debajo de la meta del 95%. Tiene cuatro errores distintos. Encuéntralos todos, corrígelo y verifica que para estos datos la cobertura sea 88.4% y que el mensaje diga que no se alcanzó la meta.
#Cobertura de vacunación de la jurisdicción
dosis aplicadas <- 8840
poblacion.meta  <- 10000
cobertura       <- dosis aplicadas / poblacion.meta

if (cobertura > 95) {
  mensaje <- "Se alcanzó la meta"
} else {
  mensaje <- "NO se alcanzó la meta"
}

message(paste0("Cobertura: ", cobertura, "%. ", Mensaje))

Los cuatro errores son de cuatro tipos distintos: uno es de nombre de variable, uno es de mayúsculas, uno es de unidades (la cobertura queda en proporción y se compara contra 95) y uno es de frontera: la meta es “95% o más”, así que una jurisdicción con exactamente 95% de cobertura sí la alcanzó. Los primeros tres tronarán o darán un resultado obviamente raro; el cuarto es silencioso y sólo se nota con los datos correctos.

  1. A mano: sigue el rastro. Sin correr nada, di qué imprime este código y por qué. Después verifica.
casos <- 100
defunciones <- 4
letalidad <- defunciones / casos * 100
defunciones <- 8
letalidad

  1. Indicador propio. Elige un indicador que uses en tu trabajo (razón de mortalidad materna, años de vida potencialmente perdidos, tasa de hospitalización, porcentaje de detecciones oportunas, el que sea). Escribe un RScript de nombre mi_indicador.R que:

    1. Tenga hasta arriba un comentario con tu nombre, la fecha y qué calcula.
    2. Guarde cada dato de entrada en su propia variable con nombre claro y con las unidades anotadas en un comentario.
    3. Calcule el indicador en pasos separados (no todo en un renglón).
    4. Imprima el resultado con message en una frase que se entienda sola, del estilo "La razón de mortalidad materna es de X por cada 100,000 nacidos vivos".

    Guarda las variables con save en un archivo mi_indicador.rda, limpia el ambiente con rm(list = ls()) y vuelve a leerlas con load para comprobar que quedaron bien guardadas.

  2. Con apoyo de una IA (cierre). Toma el script que acabas de escribir en el ejercicio 10 y haz lo siguiente, en este orden:

    1. Pídele a una IA: “Revisa este código de R, dime si hay errores y si los nombres de las variables son claros. No me lo reescribas todavía.”
    2. Anota cuáles de sus observaciones te parecen correctas y cuáles no.
    3. Ahora pídele que te lo reescriba aplicando sólo las observaciones con las que estuviste de acuerdo.
    4. Corre las dos versiones (la tuya y la suya) y verifica que den exactamente el mismo número. Si no coinciden, la que está mal no es necesariamente la tuya: averigua cuál.
    Importante

    El punto d no es opcional. Una IA puede “mejorar” tu código y de pasada cambiarte una fórmula, un denominador o un factor de 100. En un indicador de salud pública eso es la diferencia entre un reporte correcto y uno que te van a rebotar.

  3. Pregunta de reflexión. Escribe tres renglones sobre esto: si le pides a una IA que te escriba un análisis completo y tú no entiendes el código que te dio, ¿puedes firmar los resultados? ¿Qué necesitarías saber para poder hacerlo?

3.8 Sistema

sessioninfo::session_info()
─ Session info ───────────────────────────────────────────────────────────────
 setting  value
 version  R version 4.5.3 (2026-03-11)
 os       macOS Sequoia 15.7.3
 system   x86_64, darwin20
 ui       X11
 language (EN)
 collate  es_ES.UTF-8
 ctype    es_ES.UTF-8
 tz       America/Mexico_City
 date     2026-08-05
 pandoc   3.10.1 @ /usr/local/bin/ (via rmarkdown)
 quarto   1.10.18 @ /usr/local/bin/quarto

─ Packages ───────────────────────────────────────────────────────────────────
 package      * version   date (UTC) lib source
 audio          0.1-12    2025-12-15 [1] CRAN (R 4.5.1)
 beepr        * 2.0       2024-07-06 [1] CRAN (R 4.5.0)
 bitops         1.0-9     2024-10-03 [1] CRAN (R 4.5.0)
 boot           1.3-32    2025-08-29 [1] CRAN (R 4.5.3)
 cellranger     1.1.0     2016-07-27 [1] CRAN (R 4.5.0)
 class          7.3-23    2025-01-01 [1] CRAN (R 4.5.3)
 cli            3.6.6     2026-04-09 [1] CRAN (R 4.5.2)
 data.table     1.18.4    2026-05-06 [1] CRAN (R 4.5.2)
 DescTools      0.99.60   2025-03-28 [1] CRAN (R 4.5.0)
 digest         0.6.39    2025-11-19 [1] CRAN (R 4.5.1)
 dplyr          1.2.1     2026-04-03 [1] CRAN (R 4.5.2)
 e1071          1.7-17    2025-12-18 [1] CRAN (R 4.5.1)
 emoGG        * 0.0.4     2026-07-27 [1] Github (dill/emoGG@4210b29)
 evaluate       1.0.5     2025-08-27 [1] CRAN (R 4.5.1)
 Exact          3.3       2024-07-21 [1] CRAN (R 4.5.0)
 expm           1.0-0     2024-08-19 [1] CRAN (R 4.5.0)
 farver         2.1.2     2024-05-13 [1] CRAN (R 4.5.0)
 fastmap        1.2.0     2024-05-15 [1] CRAN (R 4.5.0)
 forcats        1.0.1     2025-09-25 [1] CRAN (R 4.5.1)
 fs             2.1.0     2026-04-18 [1] CRAN (R 4.5.2)
 generics       0.1.4     2025-05-09 [1] CRAN (R 4.5.0)
 ggplot2      * 4.0.3     2026-04-22 [1] CRAN (R 4.5.2)
 gld            2.6.8     2025-09-14 [1] CRAN (R 4.5.1)
 glue           1.8.1     2026-04-17 [1] CRAN (R 4.5.2)
 gtable         0.3.6     2024-10-25 [1] CRAN (R 4.5.0)
 haven          2.5.5     2025-05-30 [1] CRAN (R 4.5.0)
 hms            1.1.4     2025-10-17 [1] CRAN (R 4.5.1)
 htmltools      0.5.9     2025-12-04 [1] CRAN (R 4.5.1)
 htmlwidgets    1.6.4     2023-12-06 [1] CRAN (R 4.5.0)
 httr           1.4.8     2026-02-13 [1] CRAN (R 4.5.2)
 jsonlite       2.0.0     2025-03-27 [1] CRAN (R 4.5.0)
 knitr          1.51      2025-12-20 [1] CRAN (R 4.5.1)
 labeling       0.4.3     2023-08-29 [1] CRAN (R 4.5.0)
 lattice        0.22-9    2026-02-09 [1] CRAN (R 4.5.3)
 lifecycle      1.0.5     2026-01-08 [1] CRAN (R 4.5.1)
 lmom           3.3       2026-03-24 [1] CRAN (R 4.5.2)
 magrittr       2.0.5     2026-04-04 [1] CRAN (R 4.5.2)
 MASS           7.3-65    2025-02-28 [1] CRAN (R 4.5.3)
 Matrix         1.7-5     2026-03-21 [1] CRAN (R 4.5.2)
 mvtnorm        1.3-7     2026-04-15 [1] CRAN (R 4.5.2)
 otel           0.2.0     2025-08-29 [1] CRAN (R 4.5.1)
 pillar         1.11.1    2025-09-17 [1] CRAN (R 4.5.1)
 pkgconfig      2.0.3     2019-09-22 [1] CRAN (R 4.5.0)
 png            0.1-9     2026-03-15 [1] CRAN (R 4.5.2)
 proto          1.0.0     2016-10-29 [1] CRAN (R 4.5.0)
 proxy          0.4-29    2025-12-29 [1] CRAN (R 4.5.1)
 R6             2.6.1     2025-02-15 [1] CRAN (R 4.5.0)
 RColorBrewer   1.1-3     2022-04-03 [1] CRAN (R 4.5.0)
 Rcpp           1.1.2     2026-07-05 [1] CRAN (R 4.5.2)
 RCurl          1.98-1.19 2026-06-03 [1] CRAN (R 4.5.2)
 readr          2.2.0     2026-02-19 [1] CRAN (R 4.5.2)
 readxl         1.4.5     2025-03-07 [1] CRAN (R 4.5.0)
 rlang          1.3.0     2026-07-05 [1] CRAN (R 4.5.2)
 rmarkdown      2.31      2026-03-26 [1] CRAN (R 4.5.2)
 rootSolve      1.8.2.4   2023-09-21 [1] CRAN (R 4.5.0)
 rstudioapi     0.19.0    2026-06-11 [1] CRAN (R 4.5.2)
 S7             0.2.2     2026-04-22 [1] CRAN (R 4.5.2)
 scales         1.4.0     2025-04-24 [1] CRAN (R 4.5.0)
 sessioninfo    1.2.3     2025-02-05 [1] CRAN (R 4.5.0)
 tibble         3.3.1     2026-01-11 [1] CRAN (R 4.5.1)
 tidyselect     1.2.1     2024-03-11 [1] CRAN (R 4.5.0)
 tzdb           0.5.0     2025-03-15 [1] CRAN (R 4.5.0)
 vctrs          0.7.3     2026-04-11 [1] CRAN (R 4.5.2)
 withr          3.0.3     2026-06-19 [1] CRAN (R 4.5.2)
 xfun           0.60      2026-07-09 [1] CRAN (R 4.5.2)
 yaml           2.3.12    2025-12-10 [1] CRAN (R 4.5.1)

 [1] /Library/Frameworks/R.framework/Versions/4.5-x86_64/Resources/library
 * ── Packages attached to the search path.

──────────────────────────────────────────────────────────────────────────────