mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
use std::f64::consts::LN_2;

use super::{C, INF, NAN, multiply, polar, radial};

fn log_abs((x, y): C) -> f64 {
    if x.is_nan() || y.is_nan() {
        return NAN;
    }
    let a = x.abs().max(y.abs());
    let b = x.abs().min(y.abs());
    if a == INF {
        return INF;
    }
    if a == 0.0 {
        return -INF;
    }
    a.ln() + 0.5 * ((b / a).powi(2)).ln_1p()
}
pub(super) fn log(z: C) -> C {
    (log_abs(z), z.1.atan2(z.0))
}
pub(super) fn log_base(z: C, base: f64) -> C {
    let (a, b) = log(z);
    (a / base, b / base)
}
pub(super) fn sqrt((x, y): C) -> C {
    if y.abs() == INF {
        return (INF, y);
    }
    if x == INF {
        return (INF, if y.is_nan() { NAN } else { 0.0_f64.copysign(y) });
    }
    if x == -INF {
        return (if y.is_nan() { NAN } else { 0.0 }, INF.copysign(y));
    }
    if x.is_nan() || y.is_nan() {
        return (NAN, NAN);
    }
    let s = x.abs().max(y.abs());
    if s == 0.0 {
        return (0.0, y);
    }
    let t = s.sqrt() * (((x / s).hypot(y / s) + x.abs() / s) / 2.0).sqrt();
    if x >= 0.0 {
        (t, y / t / 2.0)
    } else {
        (y.abs() / t / 2.0, t.copysign(y))
    }
}
pub(super) fn exp((x, y): C) -> C {
    polar(x.exp(), y)
}
pub(super) fn expm1((x, y): C) -> C {
    (
        x.exp_m1() * y.cos() - 2.0 * (y / 2.0).sin().powi(2),
        radial(x.exp(), y.sin()),
    )
}
pub(super) fn log1p((x, y): C) -> C {
    let re = if x.abs() < 0.5 && y.abs() < 0.5 {
        0.5 * (x * (2.0 + x) + y * y).ln_1p()
    } else {
        log_abs((1.0 + x, y))
    };
    (re, y.atan2(1.0 + x))
}
pub(super) fn pow(z: C, w: C) -> C {
    if w.0 == 0.0 && w.1 == 0.0 {
        return (1.0, 0.0);
    }
    if w.0 == 1.0 && w.1 == 0.0 {
        return z;
    }
    if z.0 == 0.0 && z.1 == 0.0 {
        if w.1 != 0.0 || w.0.is_nan() {
            return (NAN, NAN);
        }
        return polar(if w.0 > 0.0 { 0.0 } else { INF }, w.0 * z.1.atan2(z.0));
    }
    if w.1 == 0.0 {
        if z.1 == 0.0 && w.0.is_finite() && w.0.trunc() == w.0 {
            return (z.0.powf(w.0), 0.0_f64.copysign(z.1));
        }
        return polar((log_abs(z) * w.0).exp(), z.1.atan2(z.0) * w.0);
    }
    exp(multiply(w, log(z)))
}
pub(super) fn cbrt(z: C) -> C {
    polar((log_abs(z) / 3.0).exp(), z.1.atan2(z.0) / 3.0)
}
pub(super) fn sin((x, y): C) -> C {
    (radial(y.cosh(), x.sin()), radial(y.sinh(), x.cos()))
}
pub(super) fn cos((x, y): C) -> C {
    (radial(y.cosh(), x.cos()), -radial(y.sinh(), x.sin()))
}
pub(super) fn sinh((x, y): C) -> C {
    (radial(x.sinh(), y.cos()), radial(x.cosh(), y.sin()))
}
pub(super) fn cosh((x, y): C) -> C {
    (radial(x.cosh(), y.cos()), radial(x.sinh(), y.sin()))
}
pub(super) fn tan((x, y): C) -> C {
    let t = (-2.0 * y.abs()).exp();
    let denominator = (1.0 - t).powi(2) + 4.0 * t * x.cos().powi(2);
    (
        4.0 * t * x.sin() * x.cos() / denominator,
        (-(-4.0 * y.abs()).exp_m1() / denominator).copysign(y),
    )
}
pub(super) fn tanh((x, y): C) -> C {
    let (a, b) = tan((y, x));
    (b, a)
}
pub(super) fn asin((x, y): C) -> C {
    if y == 0.0 && x.abs() <= 1.0 {
        return (x.asin(), y);
    }
    let s = if x.is_nan() || y.is_nan() {
        NAN
    } else {
        x.abs().max(y.abs())
    };
    if s > 1e150 {
        return (x.atan2(y.abs()), (log_abs((x, y)) + LN_2).copysign(y));
    }
    let (h, im) = inverse_geometry(x, y);
    (x.atan2(h), im)
}
fn inverse_geometry(x: f64, y: f64) -> C {
    let ax = x.abs();
    let r = (ax + 1.0).hypot(y);
    let t = (ax - 1.0).hypot(y);
    let a = r / 2.0 + t / 2.0;
    let delta = if ax <= 1.0 {
        (y / (r + (1.0 + ax)).sqrt()).hypot(y / (t + (1.0 - ax)).sqrt()) / std::f64::consts::SQRT_2
    } else {
        (a - 1.0).sqrt()
    };
    let gap = if ax <= 1.0 {
        (1.0 - ax).sqrt().hypot(delta)
    } else {
        (y / (r + (ax + 1.0)).sqrt()).hypot(y / (t + (ax - 1.0)).sqrt()) / std::f64::consts::SQRT_2
    };
    (
        gap * (a + ax).sqrt(),
        (delta * (delta + (a + 1.0).sqrt())).ln_1p().copysign(y),
    )
}
pub(super) fn acos((x, y): C) -> C {
    if y == 0.0 && x.abs() <= 1.0 {
        return (x.acos(), -y);
    }
    if !x.is_nan() && !y.is_nan() && x.abs().max(y.abs()) > 1e150 {
        return (y.abs().atan2(x), -(log_abs((x, y)) + LN_2).copysign(y));
    }
    let (h, im) = inverse_geometry(x, y);
    (h.atan2(x), -im)
}
pub(super) fn atan((x, y): C) -> C {
    if y == 0.0 {
        return (x.atan(), y);
    }
    let re = (x.atan2(1.0 - y) + x.atan2(1.0 + y)) / 2.0;
    let h = x.hypot(y - 1.0);
    let im = if h == 0.0 {
        INF
    } else if y.abs() < 0.5 * h {
        0.25 * ((4.0 * y / h) / h).ln_1p()
    } else {
        (log_abs((x, y + 1.0)) - log_abs((x, y - 1.0))) / 2.0
    };
    (re, im)
}
pub(super) fn asinh((x, y): C) -> C {
    let (a, b) = asin((-y, x));
    (b, -a)
}
pub(super) fn acosh(z: C) -> C {
    let (a, b) = acos(z);
    (b.abs(), a.copysign(z.1))
}
pub(super) fn atanh((x, y): C) -> C {
    let (a, b) = atan((-y, x));
    (b, -a)
}