diff --git a/compiler/builtins/bitcode/src/lib.rs b/compiler/builtins/bitcode/src/lib.rs index 7e9031bfef..34fbe4bc18 100644 --- a/compiler/builtins/bitcode/src/lib.rs +++ b/compiler/builtins/bitcode/src/lib.rs @@ -45,3 +45,203 @@ pub fn pow_int_(mut base: i64, mut exp: i64) -> i64 { pub fn is_finite_(num: f64) -> bool { f64::is_finite(num) } + +/// Adapted from Rust's libm module, by the Rust core team, +/// licensed under the Apache License, version 2.0 - https://www.apache.org/licenses/LICENSE-2.0 +/// https://github.com/rust-lang/libm/blob/master/LICENSE-APACHE +/// +/// Thank you, Rust core team! + +// From https://github.com/rust-lang/libm/blob/master/src/math/mod.rs +#[cfg(not(debug_assertions))] +macro_rules! i { + ($array:expr, $index:expr) => { + unsafe { *$array.get_unchecked($index) } + }; + ($array:expr, $index:expr, = , $rhs:expr) => { + unsafe { + *$array.get_unchecked_mut($index) = $rhs; + } + }; + ($array:expr, $index:expr, += , $rhs:expr) => { + unsafe { + *$array.get_unchecked_mut($index) += $rhs; + } + }; + ($array:expr, $index:expr, -= , $rhs:expr) => { + unsafe { + *$array.get_unchecked_mut($index) -= $rhs; + } + }; + ($array:expr, $index:expr, &= , $rhs:expr) => { + unsafe { + *$array.get_unchecked_mut($index) &= $rhs; + } + }; + ($array:expr, $index:expr, == , $rhs:expr) => { + unsafe { *$array.get_unchecked_mut($index) == $rhs } + }; +} + +#[cfg(debug_assertions)] +macro_rules! i { + ($array:expr, $index:expr) => { + *$array.get($index).unwrap() + }; + ($array:expr, $index:expr, = , $rhs:expr) => { + *$array.get_mut($index).unwrap() = $rhs; + }; + ($array:expr, $index:expr, -= , $rhs:expr) => { + *$array.get_mut($index).unwrap() -= $rhs; + }; + ($array:expr, $index:expr, += , $rhs:expr) => { + *$array.get_mut($index).unwrap() += $rhs; + }; + ($array:expr, $index:expr, &= , $rhs:expr) => { + *$array.get_mut($index).unwrap() &= $rhs; + }; + ($array:expr, $index:expr, == , $rhs:expr) => { + *$array.get_mut($index).unwrap() == $rhs + }; +} + +macro_rules! llvm_intrinsically_optimized { + (#[cfg($($clause:tt)*)] $e:expr) => { + #[cfg(all(feature = "unstable", $($clause)*))] + { + if true { // thwart the dead code lint + $e + } + } + }; +} + +macro_rules! force_eval { + ($e:expr) => { + unsafe { + ::core::ptr::read_volatile(&$e); + } + }; +} + +// From https://github.com/rust-lang/libm/blob/master/src/math/atan.rs + +// Clippy fails CI if we don't include overrides below. Since this is copied +// straight from the libm crate, I figure they had a reason to include +// the extra percision, so we just silence this warning. + +#[allow(clippy::excessive_precision)] +const ATANHI: [f64; 4] = [ + 4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */ + 7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */ + 9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */ + 1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */ +]; + +#[allow(clippy::excessive_precision)] +const ATANLO: [f64; 4] = [ + 2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */ + 3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */ + 1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */ + 6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */ +]; + +#[allow(clippy::excessive_precision)] +const AT: [f64; 11] = [ + 3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */ + -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */ + 1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */ + -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */ + 9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */ + -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */ + 6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */ + -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */ + 4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */ + -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */ + 1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */ +]; + +#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)] +pub fn fabs(x: f64) -> f64 { + // On wasm32 we know that LLVM's intrinsic will compile to an optimized + // `f64.abs` native instruction, so we can leverage this for both code size + // and speed. + llvm_intrinsically_optimized! { + #[cfg(target_arch = "wasm32")] { + return unsafe { ::core::intrinsics::fabsf64(x) } + } + } + f64::from_bits(x.to_bits() & (u64::MAX / 2)) +} + +#[no_mangle] +#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)] +pub fn atan_(x: f64) -> f64 { + let mut x = x; + let mut ix = (x.to_bits() >> 32) as u32; + let sign = ix >> 31; + ix &= 0x7fff_ffff; + if ix >= 0x4410_0000 { + if x.is_nan() { + return x; + } + + let z = ATANHI[3] + f64::from_bits(0x0380_0000); // 0x1p-120f + return if sign != 0 { -z } else { z }; + } + + let id = if ix < 0x3fdc_0000 { + /* |x| < 0.4375 */ + if ix < 0x3e40_0000 { + /* |x| < 2^-27 */ + if ix < 0x0010_0000 { + /* raise underflow for subnormal x */ + force_eval!(x as f32); + } + + return x; + } + + -1 + } else { + x = fabs(x); + if ix < 0x3ff30000 { + /* |x| < 1.1875 */ + if ix < 0x3fe60000 { + /* 7/16 <= |x| < 11/16 */ + x = (2. * x - 1.) / (2. + x); + 0 + } else { + /* 11/16 <= |x| < 19/16 */ + x = (x - 1.) / (x + 1.); + 1 + } + } else if ix < 0x40038000 { + /* |x| < 2.4375 */ + x = (x - 1.5) / (1. + 1.5 * x); + 2 + } else { + /* 2.4375 <= |x| < 2^66 */ + x = -1. / x; + 3 + } + }; + + let z = x * x; + let w = z * z; + /* break sum from i=0 to 10 AT[i]z**(i+1) into odd and even poly */ + let s1 = z * (AT[0] + w * (AT[2] + w * (AT[4] + w * (AT[6] + w * (AT[8] + w * AT[10]))))); + let s2 = w * (AT[1] + w * (AT[3] + w * (AT[5] + w * (AT[7] + w * AT[9])))); + + if id < 0 { + return x - x * (s1 + s2); + } + + let z = i!(ATANHI, id as usize) - (x * (s1 + s2) - i!(ATANLO, id as usize) - x); + + if sign != 0 { + -z + } else { + z + } +} diff --git a/compiler/builtins/src/std.rs b/compiler/builtins/src/std.rs index a2d3088482..bc9e833b31 100644 --- a/compiler/builtins/src/std.rs +++ b/compiler/builtins/src/std.rs @@ -456,6 +456,12 @@ pub fn types() -> MutMap { SolvedType::Func(vec![float_type()], Box::new(int_type())), ); + // atan : Float -> Float + add_type( + Symbol::NUM_ATAN, + SolvedType::Func(vec![float_type()], Box::new(float_type())), + ); + // Bool module // and : Bool, Bool -> Bool diff --git a/compiler/builtins/src/unique.rs b/compiler/builtins/src/unique.rs index 4c13ab1716..a7fd715fc5 100644 --- a/compiler/builtins/src/unique.rs +++ b/compiler/builtins/src/unique.rs @@ -495,6 +495,12 @@ pub fn types() -> MutMap { unique_function(vec![float_type(star1)], int_type(star2)) }); + // atan : Float -> Float + add_type(Symbol::NUM_ATAN, { + let_tvars! { star1, star2 }; + unique_function(vec![float_type(star1)], float_type(star2)) + }); + // Bool module // isEq or (==) : Attr * a, Attr * a -> Attr * Bool diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs index de7074f154..4c68bf592e 100644 --- a/compiler/can/src/builtins.rs +++ b/compiler/can/src/builtins.rs @@ -97,6 +97,7 @@ pub fn builtin_defs(var_store: &mut VarStore) -> MutMap { Symbol::NUM_CEILING => num_ceiling, Symbol::NUM_POW_INT => num_pow_int, Symbol::NUM_FLOOR => num_floor, + Symbol::NUM_ATAN => num_atan, } } @@ -765,6 +766,26 @@ fn num_floor(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } +/// Num.atan : Float -> Float +fn num_atan(symbol: Symbol, var_store: &mut VarStore) -> Def { + let arg_float_var = var_store.fresh(); + let ret_float_var = var_store.fresh(); + + let body = RunLowLevel { + op: LowLevel::NumAtan, + args: vec![(arg_float_var, Var(Symbol::ARG_1))], + ret_var: ret_float_var, + }; + + defn( + symbol, + vec![(arg_float_var, Symbol::ARG_1)], + var_store, + body, + ret_float_var, + ) +} + /// List.isEmpty : List * -> Bool fn list_is_empty(symbol: Symbol, var_store: &mut VarStore) -> Def { let list_var = var_store.fresh(); diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index c05bb4fe6c..de0b7a18b2 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -2106,7 +2106,7 @@ fn run_low_level<'a, 'ctx, 'env>( list_join(env, inplace, parent, list, outer_list_layout) } NumAbs | NumNeg | NumRound | NumSqrtUnchecked | NumSin | NumCos | NumCeiling | NumFloor - | NumToFloat | NumIsFinite => { + | NumToFloat | NumIsFinite | NumAtan => { debug_assert_eq!(args.len(), 1); let (arg, arg_layout) = load_symbol_and_layout(env, scope, &args[0]); @@ -2659,6 +2659,7 @@ fn build_float_unary_op<'a, 'ctx, 'env>( "num_floor", ), NumIsFinite => call_bitcode_fn(NumIsFinite, env, &[arg.into()], "is_finite_"), + NumAtan => call_bitcode_fn(NumAtan, env, &[arg.into()], "atan_"), _ => { unreachable!("Unrecognized int unary operation: {:?}", op); } diff --git a/compiler/gen/src/llvm/builtins.bc b/compiler/gen/src/llvm/builtins.bc index 746943b393..1f90c0c4f8 100644 Binary files a/compiler/gen/src/llvm/builtins.bc and b/compiler/gen/src/llvm/builtins.bc differ diff --git a/compiler/gen/tests/gen_num.rs b/compiler/gen/tests/gen_num.rs index b468030030..16129a03f3 100644 --- a/compiler/gen/tests/gen_num.rs +++ b/compiler/gen/tests/gen_num.rs @@ -686,6 +686,11 @@ mod gen_num { assert_evals_to!("Num.powInt 2 3", 8, i64); } + #[test] + fn atan() { + assert_evals_to!("Num.atan 10", 1.4711276743037347, f64); + } + #[test] #[should_panic(expected = r#"Roc failed with message: "integer addition overflowed!"#)] fn int_overflow() { diff --git a/compiler/module/src/low_level.rs b/compiler/module/src/low_level.rs index 2076921ba8..10f85bec53 100644 --- a/compiler/module/src/low_level.rs +++ b/compiler/module/src/low_level.rs @@ -43,6 +43,7 @@ pub enum LowLevel { NumPowInt, NumFloor, NumIsFinite, + NumAtan, Eq, NotEq, And, diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index 8566b1156e..b8bc4beafc 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -646,6 +646,7 @@ define_builtins! { 41 NUM_FLOOR: "floor" 42 NUM_ADD_WRAP: "addWrap" 43 NUM_ADD_CHECKED: "addChecked" + 44 NUM_ATAN: "atan" } 2 BOOL: "Bool" => { 0 BOOL_BOOL: "Bool" imported // the Bool.Bool type alias diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index efc849f2d2..4f209d9dd3 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -526,6 +526,6 @@ pub fn lowlevel_borrow_signature(arena: &Bump, op: LowLevel) -> &[bool] { | NumPowInt => arena.alloc_slice_copy(&[irrelevant, irrelevant]), NumAbs | NumNeg | NumSin | NumCos | NumSqrtUnchecked | NumRound | NumCeiling | NumFloor - | NumToFloat | Not | NumIsFinite => arena.alloc_slice_copy(&[irrelevant]), + | NumToFloat | Not | NumIsFinite | NumAtan => arena.alloc_slice_copy(&[irrelevant]), } } diff --git a/compiler/solve/tests/solve_expr.rs b/compiler/solve/tests/solve_expr.rs index 34dc4fdefd..189f736d42 100644 --- a/compiler/solve/tests/solve_expr.rs +++ b/compiler/solve/tests/solve_expr.rs @@ -2430,6 +2430,18 @@ mod solve_expr { ); } + #[test] + fn atan() { + infer_eq_without_problem( + indoc!( + r#" + Num.atan + "# + ), + "Float -> Float", + ); + } + #[test] fn reconstruct_path() { infer_eq_without_problem( diff --git a/shell.nix b/shell.nix index 0e7fd26188..176b8d07a5 100644 --- a/shell.nix +++ b/shell.nix @@ -11,9 +11,9 @@ let in { pkgs ? pinnedPkgs }: let - isOsX = builtins.currentSystem == "x86_64-darwin"; + isMacOS = builtins.currentSystem == "x86_64-darwin"; darwin-frameworks = - if isOsX then + if isMacOS then with pkgs.darwin.apple_sdk.frameworks; [ AppKit CoreFoundation @@ -26,6 +26,7 @@ let else [ ]; llvm = pkgs.llvm_10; + lld = pkgs.lld_10; # this should match llvm's version inputs = [ pkgs.rustup @@ -35,6 +36,8 @@ let pkgs.libffi pkgs.libxml2 pkgs.zlib + # faster builds - see https://github.com/rtfeldman/roc/blob/trunk/BUILDING_FROM_SOURCE.md#use-lld-for-the-linker + lld ]; in pkgs.mkShell { buildInputs = inputs ++ darwin-frameworks;