Flotantes, booleanos y caracteres en Rust

Los números de punto flotante (flotantes) se utilizan para representar números con decimales. En Rust, existen dos tipos principales: f32 (precisión simple) y f64 (precisión doble). El tipo f64 es el estándar por defecto en Rust y el más recomendado para cálculos generales debido a su mayor precisión. Estos tipos siguen el estándar IEEE 754. Un detalle crítico es el valor NaN (Not a Number), que representa un resultado indefinido; un comportamiento único de NaN es que nunca es igual a sí mismo (NaN != NaN). Para trabajar con ellos, puedes usar literales como 3.14, 2.0f32 (especificando el tipo) o notación científica como 1e10.

Los valores booleanos (bool) representan la lógica binaria con solo dos estados: true o false. A diferencia de otros lenguajes donde los enteros pueden actuar como booleanos, en Rust son tipos estrictos de un solo byte. Se operan con && (AND), || (OR) y ! (NOT). Estos operadores utilizan “evaluación de cortocircuito” (short-circuiting): en una operación &&, si la primera condición es false, la segunda ni siquiera se evalúa porque el resultado ya está determinado.

El tipo char representa un carácter Unicode de 4 bytes, lo que permite almacenar cualquier símbolo de cualquier idioma y emojis, no solo caracteres ASCII. Es importante no confundirlos con el tipo u8 (un byte), que se usa para datos ASCII o bytes puros.

fn main() {
    // --- TIPOS FLOTANTES ---
    let pi: f64 = 3.14159;               // f64 es el estándar por defecto
    let notacion: f64 = 1e10;            // Notación científica
    let precision_baja: f32 = 2.0f32;    // Litera f32 explícito
    let nan_val = f64::NAN;              // Representación de "Not a Number"
    let infinito = f64::INFINITY;        // Representación de infinito

    println!("Pi: {}, Notación: {}, f32: {}", pi, notacion, precision_baja);
    println!("¿NaN es igual a sí mismo? {}", nan_val == nan_val); // Siempre será false
    println!("¿Es infinito?: {}", infinito.is_infinite());

    // Métodos de f64
    let numero = -5.7;
    println!("Absoluto: {}, Floor: {}, Sqrt: {}", numero.abs(), numero.floor(), numero.sqrt());

    // --- TIPOS BOOLEANOS ---
    let es_rust_genial = true;
    let es_difcil = false;
    let logic_and = es_rust_genial && es_difcil; // Operador AND
    let logic_or = es_rust_genial || es_difcil;  // Operador OR
    let logic_not = !es_rust_genial;             // Operador NOT (negación)

    println!("Lógica -> AND: {}, OR: {}, NOT: {}", logic_and, logic_or, logic_not);

    // --- TIPOS CHAR (Unicode) ---
    let letra: char = 'A';               // Carácter simple
    let salto: char = '\n';              // Carácter de escape (salto de línea)
    let emoji: char = '\u{1F600}';       // Carácter Unicode con escape hexadecimal
    let byte_a: u8 = b'a';               // Un u8 es un byte (ASCII), no un char

    println!("Char: {}, Emoji: {}", letra, emoji);
    println!("Diferencia: char es Unicode (4 bytes), b'a' es u8 (1 byte)");
}

Explicación del Código

– pi es una variable de tipo f64 que almacena un valor decimal estándar.
– notacion usa la sintaxis 1e10 para representar $1 \times 10^{10}$.
– precision_baja es de tipo f32, diferenciado mediante el sufijo f32 en el literal.
– nan_val se obtiene de la constante f64::NAN; la comparación nan_val == nan_val resulta false por definición matemática del estándar.
– infinito utiliza la constante f64::INFINITY.
– El método .abs() se aplica a numero para obtener su valor absoluto (5.7).
– Los métodos .floor() y .sqrt() son funciones integradas de los tipos flotantes para redondear hacia abajo y calcular la raíz cuadrada, respectivamente.
– es_rust_genial y es_difil son de tipo bool.
– logic_and, logic_or y logic_not utilizan los operadores lógicos &&, || y ! para transformar los valores booleanos.
– lettera es un char que representa el carácter ‘A’.
– salto es un char especial que representa un salto de línea.
– emoji demuestra la potencia de char al usar la secuencia de escape Unicode \u{1F600} para representar una cara sonriente.
– byte_a es de tipo u8, lo que ilustra que un byte es una representación más pequeña y limitada (ASCII) que un char de 4 bytes.

N° 14