Una parte crucial de la informática consiste en hacer preguntas sobre las cosas. ¿Es una cosa más grande que otra? Son dos cosas del mismo tamaño? Las preguntas se pueden unir usando palabras como “y”, “o”, “no”. Preguntas en R normalmente se evalúa como VERDADERO o FALSO, pero existe la opción de “tal vez” (cuando la respuesta no está disponible, N / A). En R, < significa ‘menor que’, > significa ‘mayor que’ y ! significa ‘no’. Y con lo siguiente demostraremos como es posible hacer operaciones logicas y secuencias con R-Marckdown.
num1 <- 3
num2 <- 5
num3 <- 2
logical_result1 <- num1 > num2
logical_result2 <- num1 < num2
logical_result3 <- num1 == num2
logical_result4 <- num1 <= num2
logical_result5 <- num1 >= num2
logical_result1## [1] FALSElogical_result2## [1] TRUElogical_result3## [1] FALSElogical_result4## [1] TRUElogical_result5## [1] FALSEEn esta sección, se definen tres variables num1, num2 y num3 con los valores 3, 5 y 2 respectivamente. Luego, se realizan las siguientes operaciones lógicas:
1.logical_result1 almacena el resultado de la comparación num1 > num2, es decir, verifica si num1 es mayor que num2.
2.logical_result2 almacena el resultado de la comparación num1 < num2, es decir, verifica si num1 es menor que num2.
3.logical_result3 almacena el resultado de la comparación num1 == num2, es decir, verifica si num1 es igual a num2.
4.logical_result4 almacena el resultado de la comparación num1 <= num2, es decir, verifica si num1 es menor o igual que num2.
5.logical_result5 almacena el resultado de la comparación num1 >= num2, es decir, verifica si num1 es mayor o igual que num2.
Estas operaciones lógicas devuelven valores de TRUE o FALSE dependiendo del resultado de las comparaciones.
resultado1 <- TRUE == FALSE
resultado2 <- T == F
T <- 0
resultado3 <- T == FALSE
F <- 1
resultado4 <- TRUE == F
resultado5 <- T != F
data.frame(Comparación = c("TRUE == FALSE", "T == F", "T == FALSE", "TRUE == F", "T != F"),
Resultado = c(resultado1, resultado2, resultado3, resultado4, resultado5))En este ejemplo, se realiza una serie de comparaciones utilizando
== y != para verificar la igualdad o
desigualdad entre valores lógicos.
Cada comparación se almacena en una variable
(resultado1, resultado2, etc.) y se muestra en
una tabla al final del bloque de código utilizando
data.frame().
Como se mencionó anteriormente, se recomienda siempre escribir
TRUE y FALSE en lugar de utilizar
T y F como variables para evitar posibles
confusiones.
Al compilar el documento en RMarkdown, se generará un HTML que muestra los resultados de las comparaciones en forma de tabla.
num4 <- 6
num5 <- 0
logical_arithmetic_result1 <- num1 + num2
logical_arithmetic_result2 <- num1 * num2
logical_arithmetic_result3 <- num1 / num2
logical_arithmetic_result4 <- num4 / num5
logical_arithmetic_result1## [1] 8logical_arithmetic_result2## [1] 15logical_arithmetic_result3## [1] 0.6logical_arithmetic_result4## [1] InfEn este bloque, se definen dos variables: num4 y num5, que contienen valores numéricos.
logical_arithmetic_result1 realiza una operación de suma entre num1 y num2. Aquí, los valores numéricos se interpretan como lógicos, donde cualquier valor distinto de cero se considera verdadero (TRUE) y cero se considera falso (FALSE). En este caso, la suma de num1 (3) y num2 (5) da como resultado 8, que se interpreta como TRUE.
logical_arithmetic_result2 realiza una operación de multiplicación entre num1 y num2. Al igual que en el ejemplo anterior, los valores numéricos se interpretan como lógicos. La multiplicación de num1 (3) y num2 (5) da como resultado 15, que se interpreta como TRUE.
logical_arithmetic_result3 realiza una operación de división entre num1 y num2. Nuevamente, los valores numéricos se interpretan como lógicos. La división de num1 (3) por num2 (5) da como resultado 0.6, que se interpreta como TRUE.
logical_arithmetic_result4 realiza una operación de división entre num4 y num5. En este caso, num5 tiene un valor de cero, lo que resulta en una división por cero. En R, la división por cero devuelve un valor especial llamado “Inf” que se interpreta como infinito. Por lo tanto, el resultado de la división de num4 (6) por num5 (0) es “Inf”, que se interpreta como TRUE.
num1 <- 3.14
num2 <- 3.14
equality_test <- num1 == num2
num3 <- 0.1 + 0.2
num4 <- 0.3
equality_test2 <- all.equal(num3, num4)
equality_test## [1] TRUEequality_test2## [1] TRUEEn este bloque, se realizan pruebas de igualdad utilizando números reales y de punto flotante. Se definen dos variables: num1 y num2.
La variable num1 es 3.14, mientras que num2 tambien es 3.14.
Luego se realizan las siguientes pruebas de igualdad:
equality_test compara si num1 es igual a num2 utilizando el operador ==. Sin embargo, debido a las limitaciones de precisión en la representación de números de punto flotante.
equality_test2 utiliza la función all.equal() para realizar una comparación más precisa de igualdad entre num3 y num4. La función all.equal() compara dos valores numéricos teniendo en cuenta la tolerancia establecida por defecto. Esta función es útil para comparar números de punto flotante, ya que tiene en cuenta las pequeñas diferencias esperadas debido a la representación en punto flotante. En este caso, equality_test2 devolverá TRUE, indicando que num3 y num4 son iguales dentro de la tolerancia establecida.
x <- c(1.1, 2.2, 3.3)
y <- c(1.11, 2.22, 3.33)
diferencias <- all.equal(x, y)
if (is.logical(diferencias)) {
if (diferencias) {
mensaje <- "Los vectores son iguales."
} else {
mensaje <- "Los vectores son diferentes. Las diferencias encontradas son las siguientes:"
mensaje <- paste0(mensaje, "\n", unlist(attr(diferencias, "message")))
}
} else {
mensaje <- "Los objetos no son comparables."
}
mensaje## [1] "Los objetos no son comparables."En este ejemplo, se comparan los vectores x e y utilizando all.equal() y se almacena el resultado en la variable diferencias. Luego, se verifica si diferencias es un valor lógico o si hay un mensaje de error. Si diferencias es un valor lógico, se construye un mensaje indicando si los vectores son iguales o diferentes. Si diferencias contiene un mensaje de error, se extrae y se muestra como parte del mensaje de diferencias.
Es importante destacar que all.equal() devuelve TRUE si los objetos son iguales y un mensaje de texto en caso de que haya diferencias. Por lo tanto, es necesario comprobar el tipo de objeto devuelto por all.equal() para generar un mensaje adecuado y mostrar las diferencias cuando sea necesario.
result6 <- TRUE & TRUE | FALSE
result7 <- TRUE && TRUE || FALSE
result6## [1] TRUEresult7## [1] TRUEEn este bloque, se definen dos variables: result6 y result7.
result6 combina los operadores lógicos AND (&) y OR (|) para evaluar la expresión TRUE & TRUE | FALSE. En esta expresión, el operador AND (&) se evalúa primero, y luego el operador OR (|) se aplica a los resultados de la evaluación anterior. Al combinar TRUE con TRUE mediante el operador AND, se obtiene TRUE. Luego, el operador OR se aplica entre el resultado anterior (TRUE) y FALSE, lo que resulta en TRUE como resultado final.
result7 utiliza los operadores lógicos AND (&&) y OR (||) para evaluar la expresión TRUE && TRUE || FALSE. En esta expresión, el operador AND de cortocircuito (&&) se evalúa primero, y luego el operador OR de cortocircuito (||) se aplica a los resultados de la evaluación anterior. El operador AND de cortocircuito evalúa el segundo operando solo si el primer operando es TRUE. En este caso, como ambos operandos son TRUE, el resultado de la evaluación de TRUE && TRUE es TRUE. Luego, el operador OR de cortocircuito se aplica entre el resultado anterior (TRUE) y FALSE, lo que resulta en TRUE como resultado final.
Una forma importante de crear vectores es generar una secuencia de números. Las secuencias más simples están en pasos de 1, y el operador de dos puntos es la forma más sencilla de generar este tipo de secuencias. Todo lo que haces es especificar el primero y último valor separados por dos puntos. Aquí hay una secuencia de 0 a 10.
seq1 <- seq(1, 10, by = 2)
seq2 <- seq(10, 1, by = -1)
seq1## [1] 1 3 5 7 9seq2## [1] 10 9 8 7 6 5 4 3 2 1En este bloque, se definen dos variables: seq1 y seq2.
seq1 utiliza la función seq() para generar una secuencia de números del 1 al 10, incrementando de 2 en 2. La sintaxis utilizada es seq(1, 10, by = 2). Esto significa que la secuencia comienza en 1, termina en 10 y avanza de 2 en 2. El resultado es una secuencia que contiene los números 1, 3, 5, 7, 9.
seq2 también utiliza la función seq() para generar una secuencia de números del 10 al 1, decrementando de 1 en 1. La sintaxis utilizada es seq(10, 1, by = -1). Esto significa que la secuencia comienza en 10, termina en 1 y retrocede de 1 en 1. El resultado es una secuencia que contiene los números 10, 9, 8, 7, 6, 5, 4, 3, 2, 1.
rep1 <- rep(c("A", "B", "C"), times = 3)
rep2 <- rep(1:3, each = 2)
rep1## [1] "A" "B" "C" "A" "B" "C" "A" "B" "C"rep2## [1] 1 1 2 2 3 3En este bloque, se definen dos variables: rep1 y rep2.
rep1 utiliza la función rep() para generar repeticiones de los elementos “A”, “B” y “C”. La sintaxis utilizada es rep(c(“A”, “B”, “C”), times = 3). Esto significa que los elementos “A”, “B” y “C” se repiten 3 veces. El resultado es un vector que contiene las repeticiones de “A”, “B” y “C”: “A”, “B”, “C”, “A”, “B”, “C”, “A”, “B”, “C”.
rep2 utiliza la función rep() para generar repeticiones de los números del 1 al 3. La sintaxis utilizada es rep(1:3, each = 2). Esto significa que cada número del 1 al 3 se repite 2 veces. El resultado es un vector que contiene las repeticiones de los números del 1 al 3: 1, 1, 2, 2, 3, 3.
levels1 <- factor(c("apple", "banana", "apple", "orange"), levels = c("apple", "banana", "orange"))
levels2 <- factor(c("low", "high", "medium"), levels = c("low", "medium", "high"))
levels1## [1] apple banana apple orange
## Levels: apple banana orangelevels2## [1] low high medium
## Levels: low medium highEn este bloque, se definen dos variables: levels1 y levels2.
levels1 utiliza la función factor() para crear un factor a partir de un vector de caracteres: “apple”, “banana”, “apple”, “orange”. Se especifican los niveles del factor utilizando el argumento levels, que es un vector que contiene los niveles en el orden deseado: “apple”, “banana”, “orange”. El resultado es un factor que contiene los elementos del vector original, pero ahora están categorizados en los niveles especificados. En este caso, los niveles del factor son: “apple”, “banana”, “orange”, y los elementos del factor son: “apple”, “banana”, “apple”, “orange”.
levels2 utiliza la función factor() para crear otro factor a partir de un vector de caracteres: “low”, “high”, “medium”. También se especifican los niveles del factor utilizando el argumento levels, que es un vector que contiene los niveles en el orden deseado: “low”, “medium”, “high”. El resultado es otro factor con los elementos del vector original categorizados en los niveles especificados. Los niveles del factor son: “low”, “medium”, “high”, y los elementos del factor son: “low”, “high”, “medium”.