pub fn sqrt(value: f64) -> f64 {
if value.is_nan() || value < 0.0 {
return f64::NAN;
}
if value == 0.0 || value.is_infinite() {
return value;
}
let mut guess = f64::from_bits((value.to_bits() >> 1) + (1023u64 << 51));
for _ in 0..5 {
guess = 0.5 * (guess + value / guess);
}
guess
}
pub fn floor(value: f64) -> f64 {
if !value.is_finite() || value == 0.0 {
return value;
}
let whole = trunc(value);
if whole > value { whole - 1.0 } else { whole }
}
pub fn ceil(value: f64) -> f64 {
if !value.is_finite() || value == 0.0 {
return value;
}
let whole = trunc(value);
if whole < value { whole + 1.0 } else { whole }
}
pub fn trunc(value: f64) -> f64 {
if !value.is_finite() || value.abs() >= 4503599627370496.0 {
return value;
}
let whole = value as i64;
whole as f64
}
pub fn fract(value: f64) -> f64 {
if !value.is_finite() {
return f64::NAN;
}
value - trunc(value)
}
pub fn round(value: f64) -> f64 {
if !value.is_finite() || value == 0.0 {
return value;
}
let floor = floor(value);
let difference = value - floor;
if difference > 0.5 || (difference == 0.5 && value > 0.0) {
floor + 1.0
} else {
floor
}
}
const PI: f64 = core::f64::consts::PI;
const LN_2: f64 = core::f64::consts::LN_2;
const LOG10_E: f64 = core::f64::consts::LOG10_E;
const SQRT_2: f64 = core::f64::consts::SQRT_2;
pub fn pow(base: f64, exponent: f64) -> f64 {
if exponent == 0.0 {
return 1.0;
}
if base == 0.0 {
return if exponent > 0.0 { 0.0 } else { f64::INFINITY };
}
if base < 0.0 {
if exponent != trunc(exponent) {
return f64::NAN;
}
let magnitude = exp(exponent * ln(-base));
let odd = (exponent % 2.0) != 0.0;
return if odd { -magnitude } else { magnitude };
}
exp(exponent * ln(base))
}
pub fn powi(value: f64, exponent: i32) -> f64 {
let mut result = 1.0f64;
let mut base = value;
let mut power = exponent.unsigned_abs();
while power > 0 {
if power & 1 == 1 {
result *= base;
}
base *= base;
power >>= 1;
}
if exponent < 0 { 1.0 / result } else { result }
}
pub fn exp(value: f64) -> f64 {
if value.is_nan() {
return f64::NAN;
}
if value > 709.782712893384 {
return f64::INFINITY;
}
if value < -745.1332191019411 {
return 0.0;
}
let turns = round(value / LN_2);
let rest = value - turns * LN_2;
let mut term = 1.0f64;
let mut sum = 1.0f64;
for step in 1..=22 {
term *= rest / step as f64;
sum += term;
}
sum * f64::from_bits(((1023 + turns as i64) as u64) << 52)
}
pub fn ln(value: f64) -> f64 {
if value.is_nan() || value < 0.0 {
return f64::NAN;
}
if value == 0.0 {
return f64::NEG_INFINITY;
}
if value.is_infinite() {
return f64::INFINITY;
}
let bits = value.to_bits();
let mut exponent = ((bits >> 52) & 0x7FF) as i64 - 1023;
let mut mantissa = f64::from_bits((bits & 0x000F_FFFF_FFFF_FFFF) | (1023u64 << 52));
if mantissa > SQRT_2 {
mantissa /= 2.0;
exponent += 1;
}
let t = (mantissa - 1.0) / (mantissa + 1.0);
let square = t * t;
let mut term = t;
let mut sum = 0.0f64;
let mut divisor = 1.0f64;
for _ in 0..30 {
sum += term / divisor;
term *= square;
divisor += 2.0;
}
2.0 * sum + exponent as f64 * LN_2
}
pub fn log10(value: f64) -> f64 {
ln(value) * LOG10_E
}
pub fn sin(value: f64) -> f64 {
if !value.is_finite() {
return f64::NAN;
}
let (rest, quadrant) = the_quarter(value);
let sine = the_sine_of_small(rest);
let cosine = the_cosine_of_small(rest);
match quadrant {
0 => sine,
1 => cosine,
2 => -sine,
_ => -cosine,
}
}
pub fn cos(value: f64) -> f64 {
if !value.is_finite() {
return f64::NAN;
}
let (rest, quadrant) = the_quarter(value);
let sine = the_sine_of_small(rest);
let cosine = the_cosine_of_small(rest);
match quadrant {
0 => cosine,
1 => -sine,
2 => -cosine,
_ => sine,
}
}
fn the_quarter(value: f64) -> (f64, u8) {
let quarters = round(value / (PI / 2.0));
let rest = value - quarters * (PI / 2.0);
let base = (quarters as i64).rem_euclid(4);
if rest < 0.0 {
(PI / 2.0 + rest, ((base + 3).rem_euclid(4)) as u8)
} else {
(rest, base as u8)
}
}
fn the_sine_of_small(value: f64) -> f64 {
let square = value * value;
let mut term = value;
let mut sum = value;
for step in 1..=14 {
term *= -square / (((2 * step) * (2 * step + 1)) as f64);
sum += term;
}
sum
}
fn the_cosine_of_small(value: f64) -> f64 {
let square = value * value;
let mut term = 1.0f64;
let mut sum = 1.0f64;
for step in 1..=14 {
term *= -square / (((2 * step - 1) * (2 * step)) as f64);
sum += term;
}
sum
}
pub fn tan(value: f64) -> f64 {
let sine = sin(value);
let cosine = cos(value);
if cosine == 0.0 {
return if sine > 0.0 { f64::INFINITY } else { f64::NEG_INFINITY };
}
sine / cosine
}
pub fn asin(value: f64) -> f64 {
if value.is_nan() || value.abs() > 1.0 {
return f64::NAN;
}
if value == 1.0 {
return PI / 2.0;
}
if value == -1.0 {
return -PI / 2.0;
}
atan(value / sqrt(1.0 - value * value))
}
pub fn acos(value: f64) -> f64 {
if value.is_nan() || value.abs() > 1.0 {
return f64::NAN;
}
PI / 2.0 - asin(value)
}
pub fn atan(value: f64) -> f64 {
if value.is_nan() {
return f64::NAN;
}
if value == 0.0 {
return value;
}
if value.is_infinite() {
return if value > 0.0 { PI / 2.0 } else { -PI / 2.0 };
}
if value.abs() > 1.0 {
let turned = atan(1.0 / value.abs());
return if value > 0.0 {
PI / 2.0 - turned
} else {
turned - PI / 2.0
};
}
let sign = if value < 0.0 { -1.0 } else { 1.0 };
let mut magnitude = value.abs();
let mut double = 0u32;
while magnitude > 0.2679491924311227 {
magnitude = magnitude / (1.0 + sqrt(1.0 + magnitude * magnitude));
double += 1;
}
let square = magnitude * magnitude;
let mut term = magnitude;
let mut sum = magnitude;
for step in 1..=20 {
term *= -square;
sum += term / (2 * step + 1) as f64;
}
sign * sum * (1u32 << double) as f64
}
pub fn atan2(y: f64, x: f64) -> f64 {
if y.is_nan() || x.is_nan() {
return f64::NAN;
}
if x == 0.0 && y == 0.0 {
return 0.0;
}
if x == 0.0 {
return if y > 0.0 { PI / 2.0 } else { -PI / 2.0 };
}
if y == 0.0 {
return if x > 0.0 { 0.0 } else { PI };
}
let quotient = atan(y / x);
if x > 0.0 {
quotient
} else if y > 0.0 {
PI + quotient
} else {
quotient - PI
}
}
pub fn sinh(value: f64) -> f64 {
let raised = exp(value);
(raised - 1.0 / raised) / 2.0
}
pub fn cosh(value: f64) -> f64 {
let raised = exp(value);
(raised + 1.0 / raised) / 2.0
}
pub fn tanh(value: f64) -> f64 {
let raised = exp(2.0 * value);
(raised - 1.0) / (raised + 1.0)
}
#[cfg(test)]
mod tests {
use super::{acos, asin, atan, ceil, cos, exp, floor, fract, ln, log10, pow, powi, round, sin, sqrt, tan, trunc};
fn close(answer: f64, expected: f64) {
let tolerance = expected.abs() * 1e-12 + 1e-12;
assert!(
(answer - expected).abs() <= tolerance,
"the answer {answer} is not {expected}"
);
}
#[test]
fn the_whole_part_is_the_number_without_its_fraction() {
assert_eq!(trunc(2.7), 2.0);
assert_eq!(trunc(-2.7), -2.0);
assert_eq!(trunc(0.0), 0.0);
assert_eq!(trunc(f64::INFINITY), f64::INFINITY);
}
#[test]
fn the_floor_and_the_ceiling_are_the_whole_numbers_beside_it() {
assert_eq!(floor(2.7), 2.0);
assert_eq!(floor(-2.1), -3.0);
assert_eq!(ceil(2.1), 3.0);
assert_eq!(ceil(-2.7), -2.0);
assert_eq!(floor(3.0), 3.0);
assert_eq!(ceil(3.0), 3.0);
}
#[test]
fn the_round_takes_a_half_away_from_zero() {
assert_eq!(round(2.4), 2.0);
assert_eq!(round(2.5), 3.0);
assert_eq!(round(-2.5), -3.0);
assert_eq!(round(2.6), 3.0);
}
#[test]
fn the_fraction_keeps_the_sign_of_the_value() {
close(fract(2.75), 0.75);
close(fract(-2.75), -0.75);
}
#[test]
fn the_square_root_is_the_one_of_the_reference() {
for value in [0.0, 1.0, 2.0, 4.0, 9.0, 0.25, 1e10, 1e-10] {
close(sqrt(value), value.sqrt());
}
assert!(sqrt(-1.0).is_nan());
assert_eq!(sqrt(f64::INFINITY), f64::INFINITY);
}
#[test]
fn the_exponential_and_the_logarithm_are_the_ones_of_the_reference() {
for value in [0.0, 1.0, -1.0, 2.5, 10.0, -10.0] {
close(exp(value), value.exp());
}
for value in [1.0, 2.0, 10.0, 0.5, 100.0] {
close(ln(value), value.ln());
close(log10(value), value.log10());
}
}
#[test]
fn the_trigonometry_is_the_one_of_the_reference() {
for value in [0.0, 0.5, 1.0, -1.0, 3.0] {
close(sin(value), value.sin());
close(cos(value), value.cos());
close(tan(value), value.tan());
}
for value in [0.0, 0.5, -0.5, 1.0, -1.0] {
close(asin(value), value.asin());
close(acos(value), value.acos());
}
for value in [0.0, 0.5, -0.5, 1.0, 2.0, 100.0, -100.0] {
close(atan(value), value.atan());
}
}
#[test]
fn the_power_is_the_one_of_the_reference() {
for (base, exponent) in [(2.0, 3.0), (2.0, 0.5), (9.0, 0.5), (2.0, -1.0), (2.0, 0.0)] {
close(pow(base, exponent), base.powf(exponent));
}
assert!(pow(-2.0, 0.5).is_nan());
close(pow(-2.0, 3.0), -8.0);
close(powi(2.0, 10), 1024.0);
close(powi(2.0, -2), 0.25);
}
}