`f64::to_radians` în Rust

to_radians transformă grade în radiani; sin, cos și tan primesc unghiul în radiani.

Sintaxă

fn to_radians(self) -> f64
fn to_degrees(self) -> f64
fn sin(self) -> f64   // la fel: cos, tan, asin, acos, atan, atan2

Ce face `f64::to_radians`

Funcțiile trigonometrice din Rust (sin, cos, tan) lucrează în radiani, nu în grade: un cerc complet are 2π radiani. grade.to_radians() face conversia (înmulțește cu π / 180), iar radiani.to_degrees() face invers.

Rezultatele sunt aproximări în f64: 30.0.to_radians().sin() dă 0.49999999999999994, nu exact 0.5. Rotunjește la afișare. Constanta π este std::f64::consts::PI. Funcțiile inverse (asin, acos, atan, atan2) returnează radiani.

Ce returnează

f64.

Exemple

Exemplul 1: Sinusul unor unghiuri cunoscute

Valorile exacte (0.5, 0) apar doar după rotunjirea la afișare: sin(180°) dă un număr foarte mic, nu exact 0, pentru că π nu poate fi reprezentat exact.

fn main() {
    for grade in [0.0_f64, 30.0, 45.0, 90.0, 180.0] {
        let rad = grade.to_radians();
        println!("sin({grade:>5}°) = {:<22} ≈ {:.4}", rad.sin(), rad.sin());
    }
    println!("π radiani = {}°", std::f64::consts::PI.to_degrees());
}

Rezultat

sin(    0°) = 0                      ≈ 0.0000
sin(   30°) = 0.49999999999999994    ≈ 0.5000
sin(   45°) = 0.7071067811865475     ≈ 0.7071
sin(   90°) = 1                      ≈ 1.0000
sin(  180°) = 0.00000000000000012246467991473532 ≈ 0.0000
π radiani = 180°

Exemplul 2: Înălțimea unei clădiri din unghi

Stai la 40 m de clădire și vezi vârful sub un unghi de 35°: înălțimea este 40 · tan(35°). atan2 face calculul invers.

fn main() {
    let distanta = 40.0_f64;
    let unghi = 35.0_f64;
    let inaltime = distanta * unghi.to_radians().tan();
    println!("înălțime: {inaltime:.2} m");

    let inapoi = inaltime.atan2(distanta).to_degrees();
    println!("unghiul calculat înapoi: {inapoi:.1}°");

    let rampa = 1.0_f64.atan2(12.0).to_degrees();
    println!("o rampă 1:12 are {rampa:.2}°");
}