Compiler Explorer

Source code

#![no_std]

use core::ops::Neg;

#[inline(always)]
pub fn shift_round(x: i32, shift: usize) -> i32 {
    (x + (1 << (shift - 1))) >> shift
}

fn abs<T>(x: T) -> T
where
    T: PartialOrd + Default + Neg<Output = T>,
{
    if x >= T::default() {
        x
    } else {
        -x
    }
}

/// 2-argument arctangent function.
///
/// This implementation uses all integer arithmetic for fast
/// computation. It is designed to have high accuracy near the axes
/// and lower away from the axes. It is additionally designed so that
/// the error changes slowly with respect to the angle.
///
/// # Arguments
///
/// * `y` - Y-axis component.
/// * `x` - X-axis component.
///
/// # Returns
///
/// The angle between the x-axis and the ray to the point (x,y). The
/// result range is from i32::MIN to i32::MAX, where i32::MIN
/// corresponds to an angle of -pi and i32::MAX corresponds to an
/// angle of +pi.
pub fn atan2(y: i32, x: i32) -> i32 {
    let y = y >> 16;
    let x = x >> 16;

let ux = abs::<i32>(x);
    let uy = abs::<i32>(y);

// Uses the general procedure described in the following
    // Mathematics stack exchange answer:
    //
    // https://math.stackexchange.com/a/1105038/583981
    //
    // The atan approximation method has been modified to be cheaper
    // to compute and to be more compatible with integer
    // arithmetic. The approximation technique used here is
    //
    // pi / 4 * x + 0.285 * x * (1 - abs(x))
    //
    // which is taken from Rajan 2006: Efficient Approximations for
    // the Arctangent Function.
    let (min, max) = if ux < uy { (ux, uy) } else { (uy, ux) };

if max == 0 {
        return 0;
    }

let ratio = (min << 15) / max;

let mut angle = {
        // pi/4, referenced to i16::MAX
        const PI_4_FACTOR: i32 = 25735;
        // 0.285, referenced to i16::MAX
        const FACTOR_0285: i32 = 9339;
        // 1/pi, referenced to u16::MAX
        const PI_INVERTED_FACTOR: i32 = 20861;

let r1 = shift_round(ratio * PI_4_FACTOR, 15);
        let r2 = shift_round(
            (shift_round(ratio * FACTOR_0285, 15)) * (i16::MAX as i32 - ratio),
            15,
        );
        (r1 + r2) * PI_INVERTED_FACTOR
    };

if uy > ux {
        angle = (i32::MAX >> 1) - angle;
    }

if x < 0 {
        angle = i32::MAX - angle;
    }

if y < 0 {
        angle *= -1;
    }

angle
}

pub fn main() {}