Operadores

// Operadores aritméticos, precedência e parênteses.
fn main() {
    let prova: f64 = 8.0;
    let trabalho: f64 = 6.5;
    let participacao: f64 = 9.0;

    // * e / vêm antes de + e -; os parênteses mudam a ordem.
    let sem_parenteses = prova + trabalho / 2.0;
    let com_parenteses = (prova + trabalho) / 2.0;
    println!("Sem parênteses: {sem_parenteses}");
    println!("Com parênteses: {com_parenteses}");

    // Média ponderada: pesos 5, 3 e 2.
    let media = (prova * 5.0 + trabalho * 3.0 + participacao * 2.0) / 10.0;
    println!("Média ponderada: {media:.2}");

    // Entre inteiros, / descarta a fração e % devolve o resto.
    let aulas: i32 = 75;
    let faltas: i32 = 11;
    let presenca = (aulas - faltas) * 100 / aulas;
    println!(
        "Presença: {presenca}% (resto {})",
        (aulas - faltas) * 100 % aulas
    );

    // Rust não tem ++ nem --: use += e -=.
    let mut pontos_extras = 0;
    pontos_extras += 1;
    pontos_extras *= 3;
    println!("Pontos extras: {pontos_extras}");

    // Potência é um método, não um operador.
    let quadrado = 7_i32.pow(2);
    let raiz = 2.0_f64.powf(0.5);
    println!("7² = {quadrado}, 2^0,5 = {raiz:.3}");

    // O - unário inverte o sinal.
    let ajuste = -0.5;
    println!("Média ajustada: {:.2}", media + ajuste);
}

// Operadores bit a bit: cada bit de um u8 guarda uma opção.
const MOVER: u8 = 1 << 0; // 0000_0001
const ATACAR: u8 = 1 << 1; // 0000_0010
const VOAR: u8 = 1 << 2; // 0000_0100
const NADAR: u8 = 1 << 3; // 0000_1000

fn main() {
    // | junta opções num único valor.
    let mut habilidades = MOVER | ATACAR;
    println!("Início:      {habilidades:08b}");

    // |= liga um bit sem mexer nos outros.
    habilidades |= NADAR;
    println!("Com nado:    {habilidades:08b}");

    // & testa se um bit está ligado.
    let pode_voar = habilidades & VOAR != 0;
    let pode_nadar = habilidades & NADAR != 0;
    println!("Voa? {pode_voar}, nada? {pode_nadar}");

    // &= com !bit desliga um bit (! inverte todos os bits do u8).
    habilidades &= !ATACAR;
    println!("Sem ataque:  {habilidades:08b}");

    // ^= alterna: liga se estava desligado e vice-versa.
    habilidades ^= VOAR;
    println!("Voo trocado: {habilidades:08b}");

    // count_ones conta quantos bits estão ligados.
    println!("Habilidades ativas: {}", habilidades.count_ones());

    // << e >> deslocam bits: multiplicam ou dividem por potências de 2.
    let moedas: u32 = 5;
    println!("{moedas} << 3 = {}, 40 >> 2 = {}", moedas << 3, 40_u32 >> 2);
}

// Estouro de inteiros: checked, saturating e wrapping.
fn main() {
    let estoque: u8 = 250;
    let chegada: u8 = 10;

    // checked_add devolve Some(valor) ou None quando o resultado não cabe.
    match estoque.checked_add(chegada) {
        Some(total) => println!("Novo estoque: {total}"),
        None => println!("Estouro: {estoque} + {chegada} não cabe em u8"),
    }

    // saturating_* para no limite do tipo em vez de estourar.
    println!("Saturando a soma: {}", estoque.saturating_add(chegada));
    let reservados: u8 = 3;
    println!("Saturando a subtração: {}", reservados.saturating_sub(5));

    // wrapping_* dá a volta, como um hodômetro.
    println!("Dando a volta: {}", estoque.wrapping_add(chegada));

    // checked_sub evita tirar mais do que existe.
    let pedido: u8 = 4;
    match reservados.checked_sub(pedido) {
        Some(resto) => println!("Sobram {resto} reservados"),
        None => println!("Pedido de {pedido} recusado: só há {reservados}"),
    }

    // Com negativos, % mantém o sinal; rem_euclid devolve sempre >= 0.
    let saldo: i32 = -7;
    println!("-7 % 3 = {}", saldo % 3);
    println!("(-7).rem_euclid(3) = {}", saldo.rem_euclid(3));
    println!(
        "-7 / 3 = {}, (-7).div_euclid(3) = {}",
        saldo / 3,
        saldo.div_euclid(3)
    );
}