Funções Matemáticas em Java

Convertendo String para Numérica

Números Inteiros

Long.parseLong

fn main() {
    // Exemplo simples
    let numero_string = "123456";
    match numero_string.parse::<i64>() {
        Ok(numero_long) => println!("Número convertido: {}", numero_long),
        Err(_) => println!("Erro: A string não é um número válido."),
    }

    // Tratamento de exceção para entrada inválida
    let entrada_invalida = "abc";
    match entrada_invalida.parse::<i64>() {
        Ok(resultado) => println!("Número convertido: {}", resultado),
        Err(_) => println!("Erro: A string não é um número válido."),
    }
}

Números Reais

Double.parseDouble

fn main() {
    // Exemplo simples
    let numero_string = "123.456";
    match numero_string.parse::<f64>() {
        Ok(numero_double) => println!("Número convertido: {}", numero_double),
        Err(_) => println!("Erro: A string não é um número válido."),
    }

    // Tratamento de exceção para entrada inválida
    let entrada_invalida = "abc";
    match entrada_invalida.parse::<f64>() {
        Ok(resultado) => println!("Número convertido: {}", resultado),
        Err(_) => println!("Erro: A string não é um número válido."),
    }
}

Boleanos

Boolean.parseBoolean

fn parse_boolean(input: &str) -> bool {
    input.eq_ignore_ascii_case("true")
}

fn main() {
    // Exemplos simples
    let true_string = "true";
    let boolean_true = parse_boolean(true_string);
    println!("Valor booleano: {}", boolean_true);

    let false_string = "false";
    let boolean_false = parse_boolean(false_string);
    println!("Valor booleano: {}", boolean_false);

    // Tratamento de entrada inválida
    let entrada_invalida = "abc";
    let resultado = parse_boolean(entrada_invalida);
    println!("Valor booleano: {}", resultado);
    // Como "abc" não é "true", o resultado será false
}

Arredondando valores

Math.floor

fn main() {
    let numero_original: f64 = 7.8;
    let numero_arredondado = numero_original.floor();

    println!("Número original: {}", numero_original);
    println!("Número arredondado para baixo: {}", numero_arredondado);
}

Math.ceil

fn main() {
    let numero_original: f64 = 7.2;
    let numero_arredondado = numero_original.ceil();

    println!("Número original: {}", numero_original);
    println!("Número arredondado para cima: {}", numero_arredondado);
}

Math.round

fn main() {
    let numero_original: f64 = 7.5;
    let numero_arredondado: i64 = numero_original.round() as i64;

    println!("Número original: {}", numero_original);
    println!("Número arredondado: {}", numero_arredondado);
}

Math.trunc

Digite um número com 3 casas decimais

fn main() {
    let numero: f64 = 123.456789;

    // Formatar com 3 casas decimais
    let numero_formatado = format!("{:.3}", numero);

    println!("{}", numero_formatado);
}

Formatar moeda

toLocaleString

use num_format::{Locale, ToFormattedString};

fn main() {
    let numero: f64 = 1234567.89; // parte inteira pode ter underscores, mas aqui mantive sem

    // Separando parte inteira e decimal
    let inteiro = numero.trunc() as u64;
    let decimal = ((numero.fract() * 100.0).round()) as u8;

    // Formatando parte inteira no padrão brasileiro
    let inteiro_formatado = inteiro.to_formatted_string(&Locale::pt_BR);

    // Montando a string final no formato "R$ 1.234.567,89"
    let formato_brasileiro = format!("R$ {},{:02}", inteiro_formatado, decimal);

    println!("{}", formato_brasileiro);
}

Funções matemáticas comuns

Math.random

use rand::Rng;

fn main() {
    // Gerar número aleatório no intervalo [0.0, 1.0)
    let mut rng = rand::thread_rng();
    let numero_aleatorio: f64 = rng.gen::<f64>();

    println!("Número aleatório: {}", numero_aleatorio);
}

let numero_aleatorio_no_intervalo: f64 = rng.gen::<f64>() * (max - min) + min;

use rand::Rng;

fn main() {
    // Gerar número aleatório no intervalo [5.0, 10.0)
    let mut rng = rand::thread_rng();
    let numero_aleatorio_intervalo: f64 = rng.gen_range(5.0..10.0);

    println!("Número aleatório no intervalo: {}", numero_aleatorio_intervalo);
}

Math.abs

fn main() {
    let numero_inteiro: i32 = -5;
    let numero_longo: i64 = -123456789;
    let numero_float: f32 = -3.14;
    let numero_double: f64 = -2.71828;

    // Calcular o valor absoluto
    let abs_int = numero_inteiro.abs();
    let abs_long = numero_longo.abs();
    let abs_float = numero_float.abs();
    let abs_double = numero_double.abs();

    println!("Valor absoluto de {} = {}", numero_inteiro, abs_int);
    println!("Valor absoluto de {} = {}", numero_longo, abs_long);
    println!("Valor absoluto de {} = {}", numero_float, abs_float);
    println!("Valor absoluto de {} = {}", numero_double, abs_double);
}

Math.max

fn main() {
    // Máximo entre inteiros
    let numero1: i32 = 10;
    let numero2: i32 = 20;
    let maximo_int = numero1.max(numero2);
    println!("Máximo entre {} e {} = {}", numero1, numero2, maximo_int);

    // Máximo entre números de ponto flutuante
    let numero3: f64 = 15.5;
    let numero4: f64 = 12.3;
    let maximo_double = numero3.max(numero4);
    println!("Máximo entre {} e {} = {}", numero3, numero4, maximo_double);
}

int maximoEntreTres = Math.max(Math.max(numero1, numero2), numero3);

Math.min

fn main() {
    // Mínimo entre inteiros
    let numero1: i32 = 10;
    let numero2: i32 = 20;
    let minimo_int = numero1.min(numero2);
    println!("Mínimo entre {} e {} = {}", numero1, numero2, minimo_int);

    // Mínimo entre números de ponto flutuante
    let numero3: f64 = 15.5;
    let numero4: f64 = 12.3;
    let minimo_double = numero3.min(numero4);
    println!("Mínimo entre {} e {} = {}", numero3, numero4, minimo_double);
}

int minimoEntreTres = Math.min(Math.min(numero1, numero2), numero3);

Math.pow

fn main() {
    let base: f64 = 2.0;
    let expoente: f64 = 3.0;

    // Calcular 2^3
    let resultado = base.powf(expoente);

    println!("Resultado: {}", resultado);
}

Math.sqrt

fn main() {
    let numero: f64 = 25.0;

    // Calcular a raiz quadrada
    let raiz_quadrada = numero.sqrt();

    println!("Raiz quadrada de {} = {}", numero, raiz_quadrada);
}

Math.SQRT1_2

fn main() {
    // Raiz quadrada de 1/2
    let raiz_quadrada_de_um_meio = f64::consts::FRAC_1_SQRT_2;

    println!("Raiz quadrada de 1/2: {}", raiz_quadrada_de_um_meio);
}

SQRT1_2 = 0.7071067811865476;

Math.SQRT2

fn main() {
    // Raiz quadrada de 2
    let raiz_quadrada_de_dois = f64::consts::SQRT_2;

    println!("Raiz quadrada de 2: {}", raiz_quadrada_de_dois);
}

SQRT2 = 1.4142135623730951;

Math.cbrt

fn main() {
    let numero: f64 = 27.0;

    // Calcular a raiz cúbica
    let raiz_cubica = numero.cbrt();

    println!("Raiz cúbica de {} = {}", numero, raiz_cubica);
}

Math.sign

fn main() {
    let numero: f64 = -5.5;

    // Obtendo o sinal do número (-1, 0 ou 1)
    let sinal: i32 = numero.signum() as i32;

    println!("Sinal de {} = {}", numero, sinal);
}

Funções trigonométricas

Math.PI

fn main() {
    // Acesso à constante PI
    let pi = std::f64::consts::PI;

    // Exibindo o valor de pi
    println!("O valor de pi é: {}", pi);

    // Exemplo de cálculo usando pi
    let raio: f64 = 5.0;
    let area = pi * raio * raio;
    println!("A área de um círculo com raio {} é: {}", raio, area);
}

function radianos(){
return Math.PI/180
}

fn main() {
    let graus: f64 = 45.0;
    let radianos = converter_para_radianos(graus);

    println!("{} graus é equivalente a {} radianos.", graus, radianos);
}

// Função para converter graus para radianos
fn converter_para_radianos(graus: f64) -> f64 {
    graus * (std::f64::consts::PI / 180.0)
}

Math.sin

fn main() {
    // Ângulo em radianos
    let angulo_em_radianos: f64 = std::f64::consts::PI / 4.0;

    // Calculando o seno do ângulo
    let seno_do_angulo = angulo_em_radianos.sin();

    // Exibindo o resultado
    println!(
        "O seno de {} radianos é: {}",
        angulo_em_radianos, seno_do_angulo
    );
}

Math.cos

fn main() {
    // Ângulo em radianos
    let angulo_em_radianos: f64 = std::f64::consts::PI / 3.0;

    // Calculando o cosseno do ângulo
    let cosseno_do_angulo = angulo_em_radianos.cos();

    // Exibindo o resultado
    println!(
        "O cosseno de {} radianos é: {}",
        angulo_em_radianos, cosseno_do_angulo
    );
}

Math.tan

fn main() {
    // Ângulo em radianos
    let angulo_em_radianos: f64 = std::f64::consts::PI / 6.0;

    // Calculando a tangente do ângulo
    let tangente_do_angulo = angulo_em_radianos.tan();

    // Exibindo o resultado
    println!(
        "A tangente de {} radianos é: {}",
        angulo_em_radianos, tangente_do_angulo
    );
}

Math.asin

fn main() {
    // Valor para o qual queremos calcular o arco seno
    let valor: f64 = 0.5;

    // Calculando o arco seno do valor
    let arco_seno = valor.asin();

    // Exibindo o resultado em radianos
    println!(
        "O arco seno de {} é: {} radianos.",
        valor, arco_seno
    );
}

Math.acos

fn main() {
    // Valor para o qual queremos calcular o arco cosseno
    let valor: f64 = 0.5;

    // Calculando o arco cosseno do valor
    let arco_cosseno = valor.acos();

    // Exibindo o resultado em radianos
    println!(
        "O arco cosseno de {} é: {} radianos.",
        valor, arco_cosseno
    );
}

Math.atan

fn main() {
    // Valor para o qual queremos calcular o arco tangente
    let valor: f64 = 0.5;

    // Calculando o arco tangente do valor
    let arco_tangente = valor.atan();

    // Exibindo o resultado em radianos
    println!(
        "O arco tangente de {} é: {} radianos.",
        valor, arco_tangente
    );
}

Math.sinh

fn main() {
    // Valor para o qual queremos calcular o seno hiperbólico
    let valor: f64 = 2.0;

    // Calculando o seno hiperbólico do valor
    let seno_hiperbolico = valor.sinh();

    // Exibindo o resultado
    println!(
        "O seno hiperbólico de {} é: {}",
        valor, seno_hiperbolico
    );
}

Math.cosh

fn main() {
    // Valor para o qual queremos calcular o cosseno hiperbólico
    let valor: f64 = 2.0;

    // Calculando o cosseno hiperbólico do valor
    let cosseno_hiperbolico = valor.cosh();

    // Exibindo o resultado
    println!(
        "O cosseno hiperbólico de {} é: {}",
        valor, cosseno_hiperbolico
    );
}

Math.tanh

fn main() {
    // Valor para o qual queremos calcular a tangente hiperbólica
    let valor: f64 = 2.0;

    // Calculando a tangente hiperbólica do valor
    let tangente_hiperbolica = valor.tanh();

    // Exibindo o resultado
    println!(
        "A tangente hiperbólica de {} é: {}",
        valor, tangente_hiperbolica
    );
}

Math.asinh

fn main() {
    // Valor para o qual queremos calcular o arco seno hiperbólico
    let valor: f64 = 2.0;

    // Calculando o arco seno hiperbólico do valor
    let arco_seno_hiperbolico = asinh(valor);

    // Exibindo o resultado
    println!(
        "O arco seno hiperbólico de {} é: {}",
        valor, arco_seno_hiperbolico
    );
}

// Função para calcular o arco seno hiperbólico
fn asinh(x: f64) -> f64 {
    (x + (x * x + 1.0).sqrt()).ln()
}

asinh(x) = ln(x + sqrt(x^2 + 1))

Math.acosh

fn main() {
    // Valor para o qual queremos calcular o arco cosseno hiperbólico
    let valor: f64 = 2.0;

    // Calculando o arco cosseno hiperbólico do valor
    let arco_cosseno_hiperbolico = acosh(valor);

    // Exibindo o resultado
    println!(
        "O arco cosseno hiperbólico de {} é: {}",
        valor, arco_cosseno_hiperbolico
    );
}

// Função para calcular o arco cosseno hiperbólico
fn acosh(x: f64) -> f64 {
    (x + (x * x - 1.0).sqrt()).ln()
}

acosh(x) = ln(x + sqrt(x^2 - 1))

Math.atanh

fn main() {
    // Valor para o qual queremos calcular o arco tangente hiperbólico
    let valor: f64 = 0.5;

    // Calculando o arco tangente hiperbólico do valor
    let arco_tangente_hiperbolico = atanh(valor);

    // Exibindo o resultado
    println!(
        "O arco tangente hiperbólico de {} é: {}",
        valor, arco_tangente_hiperbolico
    );
}

// Função para calcular o arco tangente hiperbólico
fn atanh(x: f64) -> f64 {
    0.5 * ((1.0 + x) / (1.0 - x)).ln()
}

atanh(x) = 0.5 * ln((1 + x) / (1 - x))

Logarítmos

Math.log

fn main() {
    // Número para o qual queremos calcular o logaritmo natural
    let numero: f64 = 10.0;

    // Calculando o logaritmo natural
    let logaritmo_natural = numero.ln();

    // Exibindo o resultado
    println!("O logaritmo natural de {} é: {}", numero, logaritmo_natural);
}

Math.log10

fn main() {
    // Número para o qual queremos calcular o logaritmo na base 10
    let numero: f64 = 1000.0;

    // Calculando o logaritmo na base 10
    let logaritmo_base10 = numero.log10();

    // Exibindo o resultado
    println!("O logaritmo na base 10 de {} é: {}", numero, logaritmo_base10);
}

Math.E

fn main() {
    // Acesso à constante f64::consts::E
    let constante_e: f64 = std::f64::consts::E;

    // Exibindo o valor da constante E
    println!("O valor da constante E é: {}", constante_e);
}

Math.LN2

fn main() {
    // Acesso à constante f64::consts::LN_2
    let ln2: f64 = std::f64::consts::LN_2;

    // Exibindo o valor do logaritmo natural de 2
    println!("O valor do logaritmo natural de 2 é: {}", ln2);
}

Math.LOG2E

fn main() {
    // Acesso à constante f64::consts::LOG2_E
    let log2e: f64 = std::f64::consts::LOG2_E;

    // Exibindo o valor do logaritmo na base 2 de e
    println!("O valor do logaritmo na base 2 de e é: {}", log2e);
}

Math.LN10

fn main() {
    // Acesso à constante f64::consts::LN_10
    let ln10: f64 = std::f64::consts::LN_10;

    // Exibindo o valor do logaritmo natural de 10
    println!("O valor do logaritmo natural de 10 é: {}", ln10);
}

Math.LOG10E

fn main() {
    // Acesso à constante f64::consts::LOG10_E
    let log10e: f64 = std::f64::consts::LOG10_E;

    // Exibindo o valor do logaritmo natural de base 10 de e
    println!("O valor do logaritmo natural de base 10 de e é: {}", log10e);
}

Math.exp

fn main() {
    // Expoente para o qual queremos calcular a exponenciação
    let expoente: f64 = 2.0;

    // Calculando a exponenciação de e elevado ao expoente
    let resultado = expoente.exp();

    // Exibindo o resultado
    println!("O resultado de e elevado a {} é: {}", expoente, resultado);
}

Math.log2

fn main() {
    // Número para o qual queremos calcular o logaritmo de base 2
    let numero: f64 = 8.0;

    // Calculando o logaritmo de base 2 do número
    let log2 = numero.log2();

    // Exibindo o resultado
    println!("O logaritmo de base 2 de {} é: {}", numero, log2);
}

log2(x) = ln(x) / ln(2)

Math.log1p

fn main() {
    // Valor para o qual queremos calcular o logaritmo natural de 1 mais um
    let valor: f64 = 0.5;

    // Calculando o logaritmo natural de 1 mais o valor
    let resultado = valor.ln_1p();

    // Exibindo o resultado
    println!("O logaritmo natural de 1 mais {} é: {}", valor, resultado);
}