archives/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2026-03-08 02:44:43 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Add f16, f80 and f128 support for atan

Browse source
This commit is contained in:
lzm-build 2026-01-30 07:18:13 +08:00 • committed by Andrew Kelley
parent ad0458f582
commit ccd82ae7cc
12 changed files with 550 additions and 662 deletions
Download patch file Download diff file Expand all files Collapse all files

67
lib/c/math.zig
View file

@ -1,4 +1,5 @@
const std = @import("std");
const math = std.math;
const common = @import("common.zig");
const builtin = @import("builtin");
@ -11,20 +12,20 @@ comptime {
@export(&isnanl, .{ .name = "isnanl", .linkage = common.linkage, .visibility = common.visibility });
@export(&isnanl, .{ .name = "__isnanl", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.nan(f64), .{ .name = "__QNAN", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.snan(f64), .{ .name = "__SNAN", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.inf(f64), .{ .name = "__INF", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.floatTrueMin(f64), .{ .name = "__DENORM", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.nan(f64), .{ .name = "__QNAN", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.snan(f64), .{ .name = "__SNAN", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.inf(f64), .{ .name = "__INF", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.floatTrueMin(f64), .{ .name = "__DENORM", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.nan(f32), .{ .name = "__QNANF", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.snan(f32), .{ .name = "__SNANF", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.inf(f32), .{ .name = "__INFF", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.floatTrueMin(f32), .{ .name = "__DENORMF", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.nan(f32), .{ .name = "__QNANF", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.snan(f32), .{ .name = "__SNANF", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.inf(f32), .{ .name = "__INFF", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.floatTrueMin(f32), .{ .name = "__DENORMF", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.nan(c_longdouble), .{ .name = "__QNANL", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.snan(c_longdouble), .{ .name = "__SNANL", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.inf(c_longdouble), .{ .name = "__INFL", .linkage = common.linkage, .visibility = common.visibility });
@export(&std.math.floatTrueMin(c_longdouble), .{ .name = "__DENORML", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.nan(c_longdouble), .{ .name = "__QNANL", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.snan(c_longdouble), .{ .name = "__SNANL", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.inf(c_longdouble), .{ .name = "__INFL", .linkage = common.linkage, .visibility = common.visibility });
@export(&math.floatTrueMin(c_longdouble), .{ .name = "__DENORML", .linkage = common.linkage, .visibility = common.visibility });
}
if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@ -35,6 +36,9 @@ comptime {
if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@export(&acos, .{ .name = "acos", .linkage = common.linkage, .visibility = common.visibility });
@export(&atanf, .{ .name = "atanf", .linkage = common.linkage, .visibility = common.visibility });
@export(&atan, .{ .name = "atan", .linkage = common.linkage, .visibility = common.visibility });
@export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility });
}
if (builtin.target.isMuslLibC()) {
@ -45,41 +49,60 @@ comptime {
}
fn acos(x: f64) callconv(.c) f64 {
return std.math.acos(x);
return math.acos(x);
}
fn atanf(x: f32) callconv(.c) f32 {
return math.atan(x);
}
fn atan(x: f64) callconv(.c) f64 {
return math.atan(x);
}
fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
return switch (@typeInfo(@TypeOf(x)).float.bits) {
16 => math.atan(@as(f16, @floatCast(x))),
32 => math.atan(@as(f32, @floatCast(x))),
64 => math.atan(@as(f64, @floatCast(x))),
80 => math.atan(@as(f80, @floatCast(x))),
128 => math.atan(@as(f128, @floatCast(x))),
else => unreachable,
};
}
fn isnan(x: f64) callconv(.c) c_int {
return if (std.math.isNan(x)) 1 else 0;
return if (math.isNan(x)) 1 else 0;
}
fn isnanf(x: f32) callconv(.c) c_int {
return if (std.math.isNan(x)) 1 else 0;
return if (math.isNan(x)) 1 else 0;
}
fn isnanl(x: c_longdouble) callconv(.c) c_int {
return if (std.math.isNan(x)) 1 else 0;
return if (math.isNan(x)) 1 else 0;
}
fn nan(_: [*:0]const c_char) callconv(.c) f64 {
return std.math.nan(f64);
return math.nan(f64);
}
fn nanf(_: [*:0]const c_char) callconv(.c) f32 {
return std.math.nan(f32);
return math.nan(f32);
}
fn nanl(_: [*:0]const c_char) callconv(.c) c_longdouble {
return std.math.nan(c_longdouble);
return math.nan(c_longdouble);
}
fn copysignf(x: f32, y: f32) callconv(.c) f32 {
return std.math.copysign(x, y);
return math.copysign(x, y);
}
fn copysign(x: f64, y: f64) callconv(.c) f64 {
return std.math.copysign(x, y);
return math.copysign(x, y);
}
fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
return std.math.copysign(x, y);
return math.copysign(x, y);
}

116
lib/libc/musl/src/math/atan.c vendored
View file

@ -1,116 +0,0 @@
/* origin: FreeBSD /usr/src/lib/msun/src/s_atan.c */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
/* atan(x)
* Method
* 1. Reduce x to positive by atan(x) = -atan(-x).
* 2. According to the integer k=4t+0.25 chopped, t=x, the argument
* is further reduced to one of the following intervals and the
* arctangent of t is evaluated by the corresponding formula:
*
* [0,7/16] atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...)
* [7/16,11/16] atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) )
* [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) )
* [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) )
* [39/16,INF] atan(x) = atan(INF) + atan( -1/t )
*
* Constants:
* The hexadecimal values are the intended ones for the following
* constants. The decimal values may be used, provided that the
* compiler will convert from decimal to binary accurately enough
* to produce the hexadecimal values shown.
*/
#include "libm.h"
static const double atanhi[] = {
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 */
};
static const double atanlo[] = {
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 */
};
static const double aT[] = {
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 */
};
double atan(double x)
{
double_t w,s1,s2,z;
uint32_t ix,sign;
int id;
GET_HIGH_WORD(ix, x);
sign = ix >> 31;
ix &= 0x7fffffff;
if (ix >= 0x44100000) { /* if |x| >= 2^66 */
if (isnan(x))
return x;
z = atanhi[3] + 0x1p-120f;
return sign ? -z : z;
}
if (ix < 0x3fdc0000) { /* |x| < 0.4375 */
if (ix < 0x3e400000) { /* |x| < 2^-27 */
if (ix < 0x00100000)
/* raise underflow for subnormal x */
FORCE_EVAL((float)x);
return x;
}
id = -1;
} else {
x = fabs(x);
if (ix < 0x3ff30000) { /* |x| < 1.1875 */
if (ix < 0x3fe60000) { /* 7/16 <= |x| < 11/16 */
id = 0;
x = (2.0*x-1.0)/(2.0+x);
} else { /* 11/16 <= |x| < 19/16 */
id = 1;
x = (x-1.0)/(x+1.0);
}
} else {
if (ix < 0x40038000) { /* |x| < 2.4375 */
id = 2;
x = (x-1.5)/(1.0+1.5*x);
} else { /* 2.4375 <= |x| < 2^66 */
id = 3;
x = -1.0/x;
}
}
}
/* end of argument reduction */
z = x*x;
w = z*z;
/* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
if (id < 0)
return x - x*(s1+s2);
z = atanhi[id] - (x*(s1+s2) - atanlo[id] - x);
return sign ? -z : z;
}

94
lib/libc/musl/src/math/atanf.c vendored
View file

@ -1,94 +0,0 @@
/* origin: FreeBSD /usr/src/lib/msun/src/s_atanf.c */
/*
* Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
*/
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
#include "libm.h"
static const float atanhi[] = {
4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
};
static const float atanlo[] = {
5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
};
static const float aT[] = {
3.3333328366e-01,
-1.9999158382e-01,
1.4253635705e-01,
-1.0648017377e-01,
6.1687607318e-02,
};
float atanf(float x)
{
float_t w,s1,s2,z;
uint32_t ix,sign;
int id;
GET_FLOAT_WORD(ix, x);
sign = ix>>31;
ix &= 0x7fffffff;
if (ix >= 0x4c800000) { /* if |x| >= 2**26 */
if (isnan(x))
return x;
z = atanhi[3] + 0x1p-120f;
return sign ? -z : z;
}
if (ix < 0x3ee00000) { /* |x| < 0.4375 */
if (ix < 0x39800000) { /* |x| < 2**-12 */
if (ix < 0x00800000)
/* raise underflow for subnormal x */
FORCE_EVAL(x*x);
return x;
}
id = -1;
} else {
x = fabsf(x);
if (ix < 0x3f980000) { /* |x| < 1.1875 */
if (ix < 0x3f300000) { /* 7/16 <= |x| < 11/16 */
id = 0;
x = (2.0f*x - 1.0f)/(2.0f + x);
} else { /* 11/16 <= |x| < 19/16 */
id = 1;
x = (x - 1.0f)/(x + 1.0f);
}
} else {
if (ix < 0x401c0000) { /* |x| < 2.4375 */
id = 2;
x = (x - 1.5f)/(1.0f + 1.5f*x);
} else { /* 2.4375 <= |x| < 2**26 */
id = 3;
x = -1.0f/x;
}
}
}
/* end of argument reduction */
z = x*x;
w = z*z;
/* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
s1 = z*(aT[0]+w*(aT[2]+w*aT[4]));
s2 = w*(aT[1]+w*aT[3]);
if (id < 0)
return x - x*(s1+s2);
z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
return sign ? -z : z;
}

184
lib/libc/musl/src/math/atanl.c vendored
View file

@ -1,184 +0,0 @@
/* origin: FreeBSD /usr/src/lib/msun/src/s_atanl.c */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
/*
* See comments in atan.c.
* Converted to long double by David Schultz <das@FreeBSD.ORG>.
*/
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
long double atanl(long double x)
{
return atan(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#if LDBL_MANT_DIG == 64
#define EXPMAN(u) ((u.i.se & 0x7fff)<<8 | (u.i.m>>55 & 0xff))
static const long double atanhi[] = {
4.63647609000806116202e-01L,
7.85398163397448309628e-01L,
9.82793723247329067960e-01L,
1.57079632679489661926e+00L,
};
static const long double atanlo[] = {
1.18469937025062860669e-20L,
-1.25413940316708300586e-20L,
2.55232234165405176172e-20L,
-2.50827880633416601173e-20L,
};
static const long double aT[] = {
3.33333333333333333017e-01L,
-1.99999999999999632011e-01L,
1.42857142857046531280e-01L,
-1.11111111100562372733e-01L,
9.09090902935647302252e-02L,
-7.69230552476207730353e-02L,
6.66661718042406260546e-02L,
-5.88158892835030888692e-02L,
5.25499891539726639379e-02L,
-4.70119845393155721494e-02L,
4.03539201366454414072e-02L,
-2.91303858419364158725e-02L,
1.24822046299269234080e-02L,
};
static long double T_even(long double x)
{
return aT[0] + x * (aT[2] + x * (aT[4] + x * (aT[6] +
x * (aT[8] + x * (aT[10] + x * aT[12])))));
}
static long double T_odd(long double x)
{
return aT[1] + x * (aT[3] + x * (aT[5] + x * (aT[7] +
x * (aT[9] + x * aT[11]))));
}
#elif LDBL_MANT_DIG == 113
#define EXPMAN(u) ((u.i.se & 0x7fff)<<8 | u.i.top>>8)
static const long double atanhi[] = {
4.63647609000806116214256231461214397e-01L,
7.85398163397448309615660845819875699e-01L,
9.82793723247329067985710611014666038e-01L,
1.57079632679489661923132169163975140e+00L,
};
static const long double atanlo[] = {
4.89509642257333492668618435220297706e-36L,
2.16795253253094525619926100651083806e-35L,
-2.31288434538183565909319952098066272e-35L,
4.33590506506189051239852201302167613e-35L,
};
static const long double aT[] = {
3.33333333333333333333333333333333125e-01L,
-1.99999999999999999999999999999180430e-01L,
1.42857142857142857142857142125269827e-01L,
-1.11111111111111111111110834490810169e-01L,
9.09090909090909090908522355708623681e-02L,
-7.69230769230769230696553844935357021e-02L,
6.66666666666666660390096773046256096e-02L,
-5.88235294117646671706582985209643694e-02L,
5.26315789473666478515847092020327506e-02L,
-4.76190476189855517021024424991436144e-02L,
4.34782608678695085948531993458097026e-02L,
-3.99999999632663469330634215991142368e-02L,
3.70370363987423702891250829918659723e-02L,
-3.44827496515048090726669907612335954e-02L,
3.22579620681420149871973710852268528e-02L,
-3.03020767654269261041647570626778067e-02L,
2.85641979882534783223403715930946138e-02L,
-2.69824879726738568189929461383741323e-02L,
2.54194698498808542954187110873675769e-02L,
-2.35083879708189059926183138130183215e-02L,
2.04832358998165364349957325067131428e-02L,
-1.54489555488544397858507248612362957e-02L,
8.64492360989278761493037861575248038e-03L,
-2.58521121597609872727919154569765469e-03L,
};
static long double T_even(long double x)
{
return (aT[0] + x * (aT[2] + x * (aT[4] + x * (aT[6] + x * (aT[8] +
x * (aT[10] + x * (aT[12] + x * (aT[14] + x * (aT[16] +
x * (aT[18] + x * (aT[20] + x * aT[22])))))))))));
}
static long double T_odd(long double x)
{
return (aT[1] + x * (aT[3] + x * (aT[5] + x * (aT[7] + x * (aT[9] +
x * (aT[11] + x * (aT[13] + x * (aT[15] + x * (aT[17] +
x * (aT[19] + x * (aT[21] + x * aT[23])))))))))));
}
#endif
long double atanl(long double x)
{
union ldshape u = {x};
long double w, s1, s2, z;
int id;
unsigned e = u.i.se & 0x7fff;
unsigned sign = u.i.se >> 15;
unsigned expman;
if (e >= 0x3fff + LDBL_MANT_DIG + 1) { /* if |x| is large, atan(x)~=pi/2 */
if (isnan(x))
return x;
return sign ? -atanhi[3] : atanhi[3];
}
/* Extract the exponent and the first few bits of the mantissa. */
expman = EXPMAN(u);
if (expman < ((0x3fff - 2) << 8) + 0xc0) { /* |x| < 0.4375 */
if (e < 0x3fff - (LDBL_MANT_DIG+1)/2) { /* if |x| is small, atanl(x)~=x */
/* raise underflow if subnormal */
if (e == 0)
FORCE_EVAL((float)x);
return x;
}
id = -1;
} else {
x = fabsl(x);
if (expman < (0x3fff << 8) + 0x30) { /* |x| < 1.1875 */
if (expman < ((0x3fff - 1) << 8) + 0x60) { /* 7/16 <= |x| < 11/16 */
id = 0;
x = (2.0*x-1.0)/(2.0+x);
} else { /* 11/16 <= |x| < 19/16 */
id = 1;
x = (x-1.0)/(x+1.0);
}
} else {
if (expman < ((0x3fff + 1) << 8) + 0x38) { /* |x| < 2.4375 */
id = 2;
x = (x-1.5)/(1.0+1.5*x);
} else { /* 2.4375 <= |x| */
id = 3;
x = -1.0/x;
}
}
}
/* end of argument reduction */
z = x*x;
w = z*z;
/* break sum aT[i]z**(i+1) into odd and even poly */
s1 = z*T_even(w);
s2 = w*T_odd(w);
if (id < 0)
return x - x*(s1+s2);
z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
return sign ? -z : z;
}
#endif

16
lib/libc/musl/src/math/i386/atan.s vendored
View file

@ -1,16 +0,0 @@
.global atan
.type atan,@function
atan:
fldl 4(%esp)
mov 8(%esp),%eax
add %eax,%eax
cmp $0x00200000,%eax
jb 1f
fld1
fpatan
fstpl 4(%esp)
fldl 4(%esp)
ret
# subnormal x, return x with underflow
1: fsts 4(%esp)
ret

18
lib/libc/musl/src/math/i386/atanf.s vendored
View file

@ -1,18 +0,0 @@
.global atanf
.type atanf,@function
atanf:
flds 4(%esp)
mov 4(%esp),%eax
add %eax,%eax
cmp $0x01000000,%eax
jb 1f
fld1
fpatan
fstps 4(%esp)
flds 4(%esp)
ret
# subnormal x, return x with underflow
1: fld %st(0)
fmul %st(1)
fstps 4(%esp)
ret

7
lib/libc/musl/src/math/i386/atanl.s vendored
View file

@ -1,7 +0,0 @@
.global atanl
.type atanl,@function
atanl:
fldt 4(%esp)
fld1
fpatan
ret

7
lib/libc/musl/src/math/x32/atanl.s vendored
View file

@ -1,7 +0,0 @@
.global atanl
.type atanl,@function
atanl:
fldt 8(%esp)
fld1
fpatan
ret

7
lib/libc/musl/src/math/x86_64/atanl.s vendored
View file

@ -1,7 +0,0 @@
.global atanl
.type atanl,@function
atanl:
fldt 8(%rsp)
fld1
fpatan
ret

685
lib/std/math/atan.zig
View file

@ -3,11 +3,12 @@
//
// https://git.musl-libc.org/cgit/musl/tree/src/math/atanf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/atan.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/atanl.c
const std = @import("../std.zig");
const math = std.math;
const mem = std.mem;
const expect = std.testing.expect;
const testing = std.testing;
/// Returns the arc-tangent of x.
///
@ -17,28 +18,100 @@ const expect = std.testing.expect;
pub fn atan(x: anytype) @TypeOf(x) {
const T = @TypeOf(x);
return switch (T) {
f32 => atan32(x),
f64 => atan64(x),
f16 => atanBinary16(x),
f32 => atanBinary32(x),
f64 => atanBinary64(x),
f80 => atanExtended80(x),
f128 => atanBinary128(x),
else => @compileError("atan not implemented for " ++ @typeName(T)),
};
}
fn atan32(x_: f32) f32 {
const atanhi = [_]f32{
4.6364760399e-01, // atan(0.5)hi
7.8539812565e-01, // atan(1.0)hi
9.8279368877e-01, // atan(1.5)hi
1.5707962513e+00, // atan(inf)hi
fn atanBinary16(x: f16) f16 {
const atanhi: []const f32 = &.{
4.6364760399e-01, // atan(0.5)hi 0x3eed6338
7.8539812565e-01, // atan(1.0)hi 0x3f490fda
9.8279368877e-01, // atan(1.5)hi 0x3f7b985e
1.5707962513e+00, // atan(inf)hi 0x3fc90fda
};
const aT: []const f32 = &.{
0x1.fffcccp-1,
-0x1.52e8ccp-2,
0x1.522336p-3,
};
const atanlo = [_]f32{
5.0121582440e-09, // atan(0.5)lo
3.7748947079e-08, // atan(1.0)lo
3.4473217170e-08, // atan(1.5)lo
7.5497894159e-08, // atan(inf)lo
const hx: u16 = @bitCast(x);
const ix = hx & 0x7fff;
const sign = (hx >> 15) != 0;
// if |x| >= 2^11
if (ix >= 0x6800) {
if (math.isNan(x)) {
return x;
}
const z = atanhi[3] + 0x1p-120;
return @floatCast(if (sign) -z else z);
}
const x_: f32, const id: ?usize = blk: {
// |x| < 0.4375
if (ix < 0x3700) {
// |x| < 2^(-6)
if (ix < 0x2400) {
if (ix < 0x400) {
// raise underflow for subnormal x
mem.doNotOptimizeAway(x * x);
}
return x;
}
break :blk .{ @floatCast(x), null };
} else {
const x_: f32 = @floatCast(@abs(x));
// |x| < 1.1875
if (ix < 0x3cc0) {
// 7/16 <= |x| < 11/16
if (ix < 0x3980) {
break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
}
// 11/16 <= |x| < 19/16
else {
break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
}
} else {
// |x| < 2.4375
if (ix < 0x40e0) {
break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
}
// 2.4375 <= |x| < 2^11
else {
break :blk .{ -1.0 / x_, 3 };
}
}
}
};
// end of argument reduction
const z = x_ * x_;
const s = aT[0] + z * (aT[1] + z * aT[2]);
if (id) |id_| {
const z_ = atanhi[id_] + x_ * s;
return @floatCast(if (sign) -z_ else z_);
} else {
return @floatCast(x_ * s);
}
}
const aT = [_]f32{
fn atanBinary32(x: f32) f32 {
const atanhi: []const f32 = &.{
4.6364760399e-01, // atan(0.5)hi 0x3eed6338
7.8539812565e-01, // atan(1.0)hi 0x3f490fda
9.8279368877e-01, // atan(1.5)hi 0x3f7b985e
1.5707962513e+00, // atan(inf)hi 0x3fc90fda
};
const atanlo: []const f32 = &.{
5.0121582440e-09, // atan(0.5)lo 0x31ac3769
3.7748947079e-08, // atan(1.0)lo 0x33222168
3.4473217170e-08, // atan(1.5)lo 0x33140fb4
7.5497894159e-08, // atan(inf)lo 0x33a22168
};
const aT: []const f32 = &.{
3.3333328366e-01,
-1.9999158382e-01,
1.4253635705e-01,
@ -46,211 +119,463 @@ fn atan32(x_: f32) f32 {
6.1687607318e-02,
};
var x = x_;
var ix: u32 = @as(u32, @bitCast(x));
const sign = ix >> 31;
ix &= 0x7FFFFFFF;
// |x| >= 2^26
if (ix >= 0x4C800000) {
const hx: u32 = @bitCast(x);
const ix = hx & 0x7fff_ffff;
const sign = (hx >> 31) != 0;
// if |x| >= 2^26
if (ix >= 0x4c80_0000) {
if (math.isNan(x)) {
return x;
} else {
const z = atanhi[3] + 0x1.0p-120;
return if (sign != 0) -z else z;
}
const z = atanhi[3] + 0x1p-120;
return if (sign) -z else z;
}
var id: ?usize = undefined;
// |x| < 0.4375
if (ix < 0x3EE00000) {
// |x| < 2^(-12)
if (ix < 0x39800000) {
if (ix < 0x00800000) {
mem.doNotOptimizeAway(x * x);
}
return x;
}
id = null;
} else {
x = @abs(x);
// |x| < 1.1875
if (ix < 0x3F980000) {
// 7/16 <= |x| < 11/16
if (ix < 0x3F300000) {
id = 0;
x = (2.0 * x - 1.0) / (2.0 + x);
}
// 11/16 <= |x| < 19/16
else {
id = 1;
x = (x - 1.0) / (x + 1.0);
const x_, const id: ?usize = blk: {
// |x| < 0.4375
if (ix < 0x3ee00000) {
// |x| < 2^(-12)
if (ix < 0x39800000) {
if (ix < 0x00800000) {
// raise underflow for subnormal x
mem.doNotOptimizeAway(x * x);
}
return x;
}
break :blk .{ x, null };
} else {
// |x| < 2.4375
if (ix < 0x401C0000) {
id = 2;
x = (x - 1.5) / (1.0 + 1.5 * x);
}
// 2.4375 <= |x| < 2^26
else {
id = 3;
x = -1.0 / x;
const x_ = @abs(x);
// |x| < 1.1875
if (ix < 0x3f98_0000) {
// 7/16 <= |x| < 11/16
if (ix < 0x3f30_0000) {
break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
}
// 11/16 <= |x| < 19/16
else {
break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
}
} else {
// |x| < 2.4375
if (ix < 0x401c_0000) {
break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
}
// 2.4375 <= |x| < 2^26
else {
break :blk .{ -1.0 / x_, 3 };
}
}
}
}
const z = x * x;
};
// end of argument reduction
const z = x_ * x_;
const w = z * z;
// break sum from i=0 to 10 aT[i]z^(i+1) into odd and even poly
const s1 = z * (aT[0] + w * (aT[2] + w * aT[4]));
const s2 = w * (aT[1] + w * aT[3]);
if (id) |id_value| {
const zz = atanhi[id_value] - ((x * (s1 + s2) - atanlo[id_value]) - x);
return if (sign != 0) -zz else zz;
if (id) |id_| {
const z_ = atanhi[id_] - ((x_ * (s1 + s2) - atanlo[id_]) - x_);
return if (sign) -z_ else z_;
} else {
return x - x * (s1 + s2);
return x_ - x_ * (s1 + s2);
}
}
fn atan64(x_: f64) f64 {
const atanhi = [_]f64{
4.63647609000806093515e-01, // atan(0.5)hi
7.85398163397448278999e-01, // atan(1.0)hi
9.82793723247329054082e-01, // atan(1.5)hi
1.57079632679489655800e+00, // atan(inf)hi
fn atanBinary64(x: f64) f64 {
const atanhi: []const f64 = &.{
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
};
const atanlo: []const f64 = &.{
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
};
const aT: []const f64 = &.{
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
};
const atanlo = [_]f64{
2.26987774529616870924e-17, // atan(0.5)lo
3.06161699786838301793e-17, // atan(1.0)lo
1.39033110312309984516e-17, // atan(1.5)lo
6.12323399573676603587e-17, // atan(inf)lo
};
const aT = [_]f64{
3.33333333333329318027e-01,
-1.99999999998764832476e-01,
1.42857142725034663711e-01,
-1.11111104054623557880e-01,
9.09088713343650656196e-02,
-7.69187620504482999495e-02,
6.66107313738753120669e-02,
-5.83357013379057348645e-02,
4.97687799461593236017e-02,
-3.65315727442169155270e-02,
1.62858201153657823623e-02,
};
var x = x_;
const ux: u64 = @bitCast(x);
var ix: u32 = @intCast(ux >> 32);
const sign = ix >> 31;
ix &= 0x7FFFFFFF;
// |x| >= 2^66
const hx: u64 = @bitCast(x);
const ix: u32 = @truncate((hx >> 32) & 0x7fffffff);
const sign = (hx >> 63) != 0;
// if |x| >= 2^66
if (ix >= 0x44100000) {
if (math.isNan(x)) {
return x;
} else {
const z = atanhi[3] + 0x1.0p-120;
return if (sign != 0) -z else z;
}
const z = atanhi[3] + 0x1p-120;
return if (sign) -z else z;
}
var id: ?usize = undefined;
// |x| < 0.4375
if (ix < 0x3FDC0000) {
// |x| < 2^(-27)
if (ix < 0x3E400000) {
if (ix < 0x00100000) {
mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
}
return x;
}
id = null;
} else {
x = @abs(x);
// |x| < 1.1875
if (ix < 0x3FF30000) {
// 7/16 <= |x| < 11/16
if (ix < 0x3FE60000) {
id = 0;
x = (2.0 * x - 1.0) / (2.0 + x);
}
// 11/16 <= |x| < 19/16
else {
id = 1;
x = (x - 1.0) / (x + 1.0);
const x_, const id: ?usize = blk: {
// |x| < 0.4375
if (ix < 0x3fdc_0000) {
// |x| < 2^(-27)
if (ix < 0x3e40_0000) {
if (ix < 0x0010_0000) {
// raise underflow for subnormal x
mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
}
return x;
}
break :blk .{ x, null };
} else {
// |x| < 2.4375
if (ix < 0x40038000) {
id = 2;
x = (x - 1.5) / (1.0 + 1.5 * x);
}
// 2.4375 <= |x| < 2^66
else {
id = 3;
x = -1.0 / x;
const x_ = @abs(x);
// |x| < 1.1875
if (ix < 0x3ff3_0000) {
// 7/16 <= |x| < 11/16
if (ix < 0x3fe6_0000) {
break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
}
// 11/16 <= |x| < 19/16
else {
break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
}
} else {
// |x| < 2.4375
if (ix < 0x4003_8000) {
break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
}
// 2.4375 <= |x| < 2^66
else {
break :blk .{ -1.0 / x_, 3 };
}
}
}
}
const z = x * x;
};
// end of argument reduction
const z = x_ * x_;
const w = z * z;
// break sum from i=0 to 10 aT[i]z^(i+1) into odd and even poly
const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
if (id) |id_value| {
const zz = atanhi[id_value] - ((x * (s1 + s2) - atanlo[id_value]) - x);
return if (sign != 0) -zz else zz;
if (id) |id_| {
const z_ = atanhi[id_] - (x_ * (s1 + s2) - atanlo[id_] - x_);
return if (sign) -z_ else z_;
} else {
return x - x * (s1 + s2);
return x_ - x_ * (s1 + s2);
}
}
test atan {
try expect(@as(u32, @bitCast(atan(@as(f32, 0.2)))) == @as(u32, @bitCast(atan32(0.2))));
try expect(atan(@as(f64, 0.2)) == atan64(0.2));
fn atanExtended80(x: f80) f80 {
const atanhi: []const f80 = &.{
4.63647609000806116202e-01,
7.85398163397448309628e-01,
9.82793723247329067960e-01,
1.57079632679489661926e+00,
};
const atanlo: []const f80 = &.{
1.18469937025062860669e-20,
-1.25413940316708300586e-20,
2.55232234165405176172e-20,
-2.50827880633416601173e-20,
};
const aT: []const f80 = &.{
3.33333333333333333017e-01,
-1.99999999999999632011e-01,
1.42857142857046531280e-01,
-1.11111111100562372733e-01,
9.09090902935647302252e-02,
-7.69230552476207730353e-02,
6.66661718042406260546e-02,
-5.88158892835030888692e-02,
5.25499891539726639379e-02,
-4.70119845393155721494e-02,
4.03539201366454414072e-02,
-2.91303858419364158725e-02,
1.24822046299269234080e-02,
};
const hx: u80 = @bitCast(x);
const se: u16 = @truncate(hx >> 64);
const e = se & 0x7fff;
const sign = se >> 15 != 0;
// if |x| is large, atan(x)~=pi/2
if (e >= 0x3fff + math.floatMantissaBits(f80) + 1) {
if (math.isNan(x)) {
return x;
}
return if (sign) -atanhi[3] else atanhi[3];
}
// Extract the exponent and the first few bits of the mantissa.
const m: u64 = @truncate(hx & 0x0000_ffff_ffff_ffff_ffff);
const expman = ((@as(u32, @intCast(se)) & 0x7fff) << 8) | (@as(u32, @truncate(m >> 55)) & 0xff);
const x_, const id: ?usize = blk: {
// |x| < 0.4375
if (expman < ((0x3fff - 2) << 8) + 0xc0) {
// if |x| is small, atanl(x)~=x
if (e < 0x3fff - (math.floatMantissaBits(f80) + 1) / 2) {
// raise underflow if subnormal
if (e == 0) {
std.mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
}
return x;
}
break :blk .{ x, null };
} else {
const x_ = @abs(x);
// |x| < 1.1875
if (expman < (0x3fff << 8) + 0x30) {
// 7/16 <= |x| < 11/16
if (expman < ((0x3fff - 1) << 8) + 0x60) {
break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
}
// 11/16 <= |x| < 19/16
else {
break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
}
} else {
// |x| < 2.4375
if (expman < ((0x3fff + 1) << 8) + 0x38) {
break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
}
// 2.4375 <= |x|
else {
break :blk .{ -1.0 / x_, 3 };
}
}
}
};
// end of argument reduction
const z = x_ * x_;
const w = z * z;
// break sum aT[i]z^(i+1) into odd and even poly
const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * (aT[10] + w * aT[12]))))));
const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * (aT[9] + w * aT[11])))));
if (id) |id_| {
const z_ = atanhi[id_] - ((x_ * (s1 + s2) - atanlo[id_]) - x_);
return if (sign) -z_ else z_;
} else {
return x_ - x_ * (s1 + s2);
}
}
test atan32 {
const epsilon = 0.000001;
fn atanBinary128(x: f128) f128 {
const atanhi: []const f128 = &.{
4.63647609000806116214256231461214397e-01,
7.85398163397448309615660845819875699e-01,
9.82793723247329067985710611014666038e-01,
1.57079632679489661923132169163975140e+00,
};
const atanlo: []const f128 = &.{
4.89509642257333492668618435220297706e-36,
2.16795253253094525619926100651083806e-35,
-2.31288434538183565909319952098066272e-35,
4.33590506506189051239852201302167613e-35,
};
const aT: []const f128 = &.{
3.33333333333333333333333333333333125e-01,
-1.99999999999999999999999999999180430e-01,
1.42857142857142857142857142125269827e-01,
-1.11111111111111111111110834490810169e-01,
9.09090909090909090908522355708623681e-02,
-7.69230769230769230696553844935357021e-02,
6.66666666666666660390096773046256096e-02,
-5.88235294117646671706582985209643694e-02,
5.26315789473666478515847092020327506e-02,
-4.76190476189855517021024424991436144e-02,
4.34782608678695085948531993458097026e-02,
-3.99999999632663469330634215991142368e-02,
3.70370363987423702891250829918659723e-02,
-3.44827496515048090726669907612335954e-02,
3.22579620681420149871973710852268528e-02,
-3.03020767654269261041647570626778067e-02,
2.85641979882534783223403715930946138e-02,
-2.69824879726738568189929461383741323e-02,
2.54194698498808542954187110873675769e-02,
-2.35083879708189059926183138130183215e-02,
2.04832358998165364349957325067131428e-02,
-1.54489555488544397858507248612362957e-02,
8.64492360989278761493037861575248038e-03,
-2.58521121597609872727919154569765469e-03,
};
try expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));
try expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon));
try expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon));
try expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon));
try expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));
const hx: u128 = @bitCast(x);
const se: u16 = @truncate(hx >> 112);
const e = se & 0x7fff;
const sign = se >> 15 != 0;
// if |x| is large, atan(x)~=pi/2
if (e >= 0x3fff + math.floatMantissaBits(f128) + 2) {
if (math.isNan(x)) {
return x;
}
return if (sign) -atanhi[3] else atanhi[3];
}
// Extract the exponent and the first few bits of the mantissa.
const top: u16 = @truncate((hx >> 96) & 0x0000_ffff);
const expman = ((@as(u32, @intCast(se)) & 0x7fff) << 8) | (@as(u32, @intCast(top)) >> 8);
const x_, const id: ?usize = blk: {
// |x| < 0.4375
if (expman < ((0x3fff - 2) << 8) + 0xc0) {
// if |x| is small, atanl(x)~=x
if (e < 0x3fff - (math.floatMantissaBits(f128) + 2) / 2) {
// raise underflow if subnormal
if (e == 0) {
mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
}
return x;
}
break :blk .{ x, null };
} else {
const x_ = @abs(x);
// |x| < 1.1875
if (expman < (0x3fff << 8) + 0x30) {
// 7/16 <= |x| < 11/16
if (expman < ((0x3fff - 1) << 8) + 0x60) {
break :blk .{ (2.0 * x_ - 1.0) / (2.0 + x_), 0 };
}
// 11/16 <= |x| < 19/16
else {
break :blk .{ (x_ - 1.0) / (x_ + 1.0), 1 };
}
} else {
// |x| < 2.4375
if (expman < ((0x3fff + 1) << 8) + 0x38) {
break :blk .{ (x_ - 1.5) / (1.0 + 1.5 * x_), 2 };
}
// 2.4375 <= |x|
else {
break :blk .{ -1.0 / x_, 3 };
}
}
}
};
// end of argument reduction
const z = x_ * x_;
const w = z * z;
// break sum aT[i]z^(i+1) into odd and even poly
const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * (aT[10] + w * (aT[12] + w * (aT[14] + w * (aT[16] + w * (aT[18] + w * (aT[20] + w * aT[22])))))))))));
const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * (aT[9] + w * (aT[11] + w * (aT[13] + w * (aT[15] + w * (aT[17] + w * (aT[19] + w * (aT[21] + w * aT[23])))))))))));
if (id) |id_| {
const z_ = atanhi[id_] - ((x_ * (s1 + s2) - atanlo[id_]) - x_);
return if (sign) -z_ else z_;
} else {
return x_ - x_ * (s1 + s2);
}
}
test atan64 {
const epsilon = 0.000001;
try expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));
try expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon));
try expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon));
try expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon));
try expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));
test "atanBinary16.special" {
try testing.expectEqual(atanBinary16(0x0p+0), 0x0p+0);
try testing.expectEqual(atanBinary16(-0x0p+0), -0x0p+0);
try testing.expectApproxEqAbs(atanBinary16(0x1p+0), 0x1.92p-1, math.floatEpsAt(f16, 0x1.92p-1));
try testing.expectApproxEqAbs(atanBinary16(-0x1p+0), -0x1.92p-1, math.floatEpsAt(f16, -0x1.92p-1));
try testing.expectApproxEqAbs(atanBinary16(math.inf(f16)), 0x1.92p0, math.floatEpsAt(f16, 0x1.92p0));
try testing.expectApproxEqAbs(atanBinary16(-math.inf(f16)), -0x1.92p0, math.floatEpsAt(f16, -0x1.92p0));
try testing.expect(math.isNan(atanBinary16(math.nan(f16))));
}
test "atan32.special" {
const epsilon = 0.000001;
try expect(math.isPositiveZero(atan32(0.0)));
try expect(math.isNegativeZero(atan32(-0.0)));
try expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
try expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
test "atanBinary16" {
try testing.expectApproxEqAbs(atanBinary16(-0x1.864p-2), -0x1.74cp-2, math.floatEpsAt(f16, -0x1.74cp-2));
try testing.expectApproxEqAbs(atanBinary16(-0x1.59cp1), -0x1.374p0, math.floatEpsAt(f16, -0x1.374p0));
try testing.expectApproxEqAbs(atanBinary16(-0x1.d2cp0), -0x1.11cp0, math.floatEpsAt(f16, -0x1.11cp0));
try testing.expectApproxEqAbs(atanBinary16(-0x1.5f4p-1), -0x1.33cp-1, math.floatEpsAt(f16, -0x1.33cp-1));
try testing.expectApproxEqAbs(atanBinary16(0x1.588p1), 0x1.37p0, math.floatEpsAt(f16, 0x1.37p0));
try testing.expectApproxEqAbs(atanBinary16(-0x1.b14p-2), -0x1.99cp-2, math.floatEpsAt(f16, -0x1.99cp-2));
try testing.expectApproxEqAbs(atanBinary16(0x1.3ccp1), 0x1.2fcp0, math.floatEpsAt(f16, 0x1.2fcp0));
try testing.expectApproxEqAbs(atanBinary16(-0x1.0ecp-2), -0x1.08cp-2, math.floatEpsAt(f16, -0x1.08cp-2));
try testing.expectApproxEqAbs(atanBinary16(0x1.298p1), 0x1.2ap0, math.floatEpsAt(f16, 0x1.2ap0));
try testing.expectApproxEqAbs(atanBinary16(-0x1.028p1), -0x1.1c8p0, math.floatEpsAt(f16, -0x1.1c8p0));
}
test "atan64.special" {
const epsilon = 0.000001;
try expect(math.isPositiveZero(atan64(0.0)));
try expect(math.isNegativeZero(atan64(-0.0)));
try expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
try expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
test "atanBinary32.special" {
try testing.expectEqual(atanBinary32(0x0p+0), 0x0p+0);
try testing.expectEqual(atanBinary32(-0x0p+0), -0x0p+0);
try testing.expectApproxEqAbs(atanBinary32(0x1p+0), 0x1.921fb6p-1, math.floatEpsAt(f32, 0x1.921fb6p-1));
try testing.expectApproxEqAbs(atanBinary32(-0x1p+0), -0x1.921fb6p-1, math.floatEpsAt(f32, -0x1.921fb6p-1));
try testing.expectApproxEqAbs(atanBinary32(math.inf(f32)), 0x1.921fb6p+0, math.floatEpsAt(f32, 0x1.921fb6p+0));
try testing.expectApproxEqAbs(atanBinary32(-math.inf(f32)), -0x1.921fb6p+0, math.floatEpsAt(f32, -0x1.921fb6p+0));
try testing.expect(math.isNan(atanBinary32(math.nan(f32))));
}
test "atanBinary32" {
try testing.expectApproxEqAbs(atanBinary32(-0x1.8629dp-2), -0x1.74c62p-2, math.floatEpsAt(f32, -0x1.74c62p-2));
try testing.expectApproxEqAbs(atanBinary32(-0x1.59d42ep1), -0x1.375fd8p0, math.floatEpsAt(f32, -0x1.375fd8p0));
try testing.expectApproxEqAbs(atanBinary32(-0x1.d2dbe2p0), -0x1.11b8aep0, math.floatEpsAt(f32, -0x1.11b8aep0));
try testing.expectApproxEqAbs(atanBinary32(-0x1.5f314ep-1), -0x1.33d28cp-1, math.floatEpsAt(f32, -0x1.33d28cp-1));
try testing.expectApproxEqAbs(atanBinary32(0x1.5869bp1), 0x1.37082ep0, math.floatEpsAt(f32, 0x1.37082ep0));
try testing.expectApproxEqAbs(atanBinary32(-0x1.b13a06p-2), -0x1.99d7cap-2, math.floatEpsAt(f32, -0x1.99d7cap-2));
try testing.expectApproxEqAbs(atanBinary32(0x1.3cb0f2p1), 0x1.2fcb12p0, math.floatEpsAt(f32, 0x1.2fcb12p0));
try testing.expectApproxEqAbs(atanBinary32(-0x1.0ed746p-2), -0x1.08c71ap-2, math.floatEpsAt(f32, -0x1.08c71ap-2));
try testing.expectApproxEqAbs(atanBinary32(0x1.299d54p1), 0x1.2a24e2p0, math.floatEpsAt(f32, 0x1.2a24e2p0));
try testing.expectApproxEqAbs(atanBinary32(-0x1.0264fcp1), -0x1.1c6178p0, math.floatEpsAt(f32, -0x1.1c6178p0));
}
test "atanBinary64.special" {
try testing.expectEqual(atanBinary64(0x0p+0), 0x0p+0);
try testing.expectEqual(atanBinary64(-0x0p+0), -0x0p+0);
try testing.expectApproxEqAbs(atanBinary64(0x1p+0), 0x1.921fb54442d18p-1, math.floatEpsAt(f64, 0x1.921fb54442d18p-1));
try testing.expectApproxEqAbs(atanBinary64(-0x1p+0), -0x1.921fb54442d18p-1, math.floatEpsAt(f64, -0x1.921fb54442d18p-1));
try testing.expectApproxEqAbs(atanBinary64(math.inf(f64)), 0x1.921fb54442d18p+0, math.floatEpsAt(f64, 0x1.921fb54442d18p+0));
try testing.expectApproxEqAbs(atanBinary64(-math.inf(f64)), -0x1.921fb54442d18p+0, math.floatEpsAt(f64, -0x1.921fb54442d18p+0));
try testing.expect(math.isNan(atanBinary64(math.nan(f64))));
}
test "atanBinary64" {
try testing.expectApproxEqAbs(atanBinary64(-0x1.8629d0244cdccp-2), -0x1.74c61f4377016p-2, math.floatEpsAt(f64, -0x1.74c61f4377016p-2));
try testing.expectApproxEqAbs(atanBinary64(-0x1.59d42d4659937p1), -0x1.375fd7987cc2p0, math.floatEpsAt(f64, -0x1.375fd7987cc2p0));
try testing.expectApproxEqAbs(atanBinary64(-0x1.d2dbe23d04f06p0), -0x1.11b8adeba5616p0, math.floatEpsAt(f64, -0x1.11b8adeba5616p0));
try testing.expectApproxEqAbs(atanBinary64(-0x1.5f314e72398e8p-1), -0x1.33d28ca762539p-1, math.floatEpsAt(f64, -0x1.33d28ca762539p-1));
try testing.expectApproxEqAbs(atanBinary64(0x1.5869af37b7d08p1), 0x1.37082ce2dd03p0, math.floatEpsAt(f64, 0x1.37082ce2dd03p0));
try testing.expectApproxEqAbs(atanBinary64(-0x1.b13a05a662618p-2), -0x1.99d7cac66dd44p-2, math.floatEpsAt(f64, -0x1.99d7cac66dd44p-2));
try testing.expectApproxEqAbs(atanBinary64(0x1.3cb0f12f39d8ap1), 0x1.2fcb120468e8ep0, math.floatEpsAt(f64, 0x1.2fcb120468e8ep0));
try testing.expectApproxEqAbs(atanBinary64(-0x1.0ed746b39cbb7p-2), -0x1.08c71aa0e509p-2, math.floatEpsAt(f64, -0x1.08c71aa0e509p-2));
try testing.expectApproxEqAbs(atanBinary64(0x1.299d54ac7d6bp1), 0x1.2a24e22d861dfp0, math.floatEpsAt(f64, 0x1.2a24e22d861dfp0));
try testing.expectApproxEqAbs(atanBinary64(-0x1.0264fb9f3d50ep1), -0x1.1c617825f9751p0, math.floatEpsAt(f64, -0x1.1c617825f9751p0));
}
test "atanExtended80.special" {
try testing.expectEqual(atanExtended80(0x0p+0), 0x0p+0);
try testing.expectEqual(atanExtended80(-0x0p+0), -0x0p+0);
try testing.expectApproxEqAbs(atanExtended80(0x1p+0), 0x1.921fb54442d1846ap-1, math.floatEpsAt(f80, 0x1.921fb54442d1846ap-1));
try testing.expectApproxEqAbs(atanExtended80(-0x1p+0), -0x1.921fb54442d1846ap-1, math.floatEpsAt(f80, -0x1.921fb54442d1846ap-1));
try testing.expectApproxEqAbs(atanExtended80(math.inf(f80)), 0x1.921fb54442d1846ap0, math.floatEpsAt(f80, 0x1.921fb54442d1846ap0));
try testing.expectApproxEqAbs(atanExtended80(-math.inf(f80)), -0x1.921fb54442d1846ap0, math.floatEpsAt(f80, -0x1.921fb54442d1846ap0));
try testing.expect(math.isNan(atanExtended80(math.nan(f80))));
}
test "atanExtended80" {
try testing.expectApproxEqAbs(atanExtended80(-0x1.8629d0244cdcbed8p-2), -0x1.74c61f437701661p-2, math.floatEpsAt(f80, -0x1.74c61f437701661p-2));
try testing.expectApproxEqAbs(atanExtended80(-0x1.59d42d4659936d9ep1), -0x1.375fd7987cc1fd02p0, math.floatEpsAt(f80, -0x1.375fd7987cc1fd02p0));
try testing.expectApproxEqAbs(atanExtended80(-0x1.d2dbe23d04f067b4p0), -0x1.11b8adeba5615e04p0, math.floatEpsAt(f80, -0x1.11b8adeba5615e04p0));
try testing.expectApproxEqAbs(atanExtended80(-0x1.5f314e72398e7dbcp-1), -0x1.33d28ca76253964cp-1, math.floatEpsAt(f80, -0x1.33d28ca76253964cp-1));
try testing.expectApproxEqAbs(atanExtended80(0x1.5869af37b7d078cap1), 0x1.37082ce2dd03010cp0, math.floatEpsAt(f80, 0x1.37082ce2dd03010cp0));
try testing.expectApproxEqAbs(atanExtended80(-0x1.b13a05a66261821ap-2), -0x1.99d7cac66dd4438p-2, math.floatEpsAt(f80, -0x1.99d7cac66dd4438p-2));
try testing.expectApproxEqAbs(atanExtended80(0x1.3cb0f12f39d899cp1), 0x1.2fcb120468e8d9ecp0, math.floatEpsAt(f80, 0x1.2fcb120468e8d9ecp0));
try testing.expectApproxEqAbs(atanExtended80(-0x1.0ed746b39cbb7614p-2), -0x1.08c71aa0e5090998p-2, math.floatEpsAt(f80, -0x1.08c71aa0e5090998p-2));
try testing.expectApproxEqAbs(atanExtended80(0x1.299d54ac7d6afc52p1), 0x1.2a24e22d861debfep0, math.floatEpsAt(f80, 0x1.2a24e22d861debfep0));
try testing.expectApproxEqAbs(atanExtended80(-0x1.0264fb9f3d50e4fp1), -0x1.1c617825f97512b8p0, math.floatEpsAt(f80, -0x1.1c617825f97512b8p0));
}
test "atanBinary128.special" {
try testing.expectEqual(atanBinary128(0x0p+0), 0x0p+0);
try testing.expectEqual(atanBinary128(-0x0p+0), -0x0p+0);
try testing.expectApproxEqAbs(atanBinary128(0x1p+0), 0x1.921fb54442d18469898cc51701b8p-1, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p-1));
try testing.expectApproxEqAbs(atanBinary128(-0x1p+0), -0x1.921fb54442d18469898cc51701b8p-1, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p-1));
try testing.expectApproxEqAbs(atanBinary128(math.inf(f128)), 0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, 0x1.921fb54442d18469898cc51701b8p0));
try testing.expectApproxEqAbs(atanBinary128(-math.inf(f128)), -0x1.921fb54442d18469898cc51701b8p0, math.floatEpsAt(f128, -0x1.921fb54442d18469898cc51701b8p0));
try testing.expect(math.isNan(atanBinary128(math.nan(f128))));
}
test "atanBinary128" {
try testing.expectApproxEqAbs(atanBinary128(-0x1.8629d0244cdcbed71792ccdec26dp-2), -0x1.74c61f437701660ff76989d23707p-2, math.floatEpsAt(f128, -0x1.74c61f437701660ff76989d23707p-2));
try testing.expectApproxEqAbs(atanBinary128(-0x1.59d42d4659936d9e22b5dea4faefp1), -0x1.375fd7987cc1fd0119cf0cc5b708p0, math.floatEpsAt(f128, -0x1.375fd7987cc1fd0119cf0cc5b708p0));
try testing.expectApproxEqAbs(atanBinary128(-0x1.d2dbe23d04f067b42da3f8efdf57p0), -0x1.11b8adeba5615e0370722b511231p0, math.floatEpsAt(f128, -0x1.11b8adeba5615e0370722b511231p0));
try testing.expectApproxEqAbs(atanBinary128(-0x1.5f314e72398e7dbbe70fb072983ep-1), -0x1.33d28ca76253964cb5d3581cdd88p-1, math.floatEpsAt(f128, -0x1.33d28ca76253964cb5d3581cdd88p-1));
try testing.expectApproxEqAbs(atanBinary128(0x1.5869af37b7d078caa3456c44aecep1), 0x1.37082ce2dd03010bbea814dc5882p0, math.floatEpsAt(f128, 0x1.37082ce2dd03010bbea814dc5882p0));
try testing.expectApproxEqAbs(atanBinary128(-0x1.b13a05a66261821a364ad8c6c999p-2), -0x1.99d7cac66dd4438077284b491a91p-2, math.floatEpsAt(f128, -0x1.99d7cac66dd4438077284b491a91p-2));
try testing.expectApproxEqAbs(atanBinary128(0x1.3cb0f12f39d899c0d963ac413297p1), 0x1.2fcb120468e8d9ebdb74702314c8p0, math.floatEpsAt(f128, 0x1.2fcb120468e8d9ebdb74702314c8p0));
try testing.expectApproxEqAbs(atanBinary128(-0x1.0ed746b39cbb7614d8735e8315a8p-2), -0x1.08c71aa0e5090998206fbbe2090fp-2, math.floatEpsAt(f128, -0x1.08c71aa0e5090998206fbbe2090fp-2));
try testing.expectApproxEqAbs(atanBinary128(0x1.299d54ac7d6afc5154643b601519p1), 0x1.2a24e22d861debfd6f974500567fp0, math.floatEpsAt(f128, 0x1.2a24e22d861debfd6f974500567fp0));
try testing.expectApproxEqAbs(atanBinary128(-0x1.0264fb9f3d50e4f0f966f0686064p1), -0x1.1c617825f97512b7f38656ab12cdp0, math.floatEpsAt(f128, -0x1.1c617825f97512b7f38656ab12cdp0));
}

8
src/libs/musl.zig
View file

@ -836,12 +836,9 @@ const src_files = [_][]const u8{
"musl/src/math/atan2.c",
"musl/src/math/atan2f.c",
"musl/src/math/atan2l.c",
"musl/src/math/atan.c",
"musl/src/math/atanf.c",
"musl/src/math/atanh.c",
"musl/src/math/atanhf.c",
"musl/src/math/atanhl.c",
"musl/src/math/atanl.c",
"musl/src/math/cbrt.c",
"musl/src/math/cbrtf.c",
"musl/src/math/cbrtl.c",
@ -892,9 +889,6 @@ const src_files = [_][]const u8{
"musl/src/math/i386/atan2f.s",
"musl/src/math/i386/atan2l.s",
"musl/src/math/i386/atan2.s",
"musl/src/math/i386/atanf.s",
"musl/src/math/i386/atanl.s",
"musl/src/math/i386/atan.s",
"musl/src/math/i386/exp2l.s",
"musl/src/math/i386/exp_ld.s",
"musl/src/math/i386/expl.s",
@ -1076,7 +1070,6 @@ const src_files = [_][]const u8{
"musl/src/math/x32/acosl.s",
"musl/src/math/x32/asinl.s",
"musl/src/math/x32/atan2l.s",
"musl/src/math/x32/atanl.s",
"musl/src/math/x32/exp2l.s",
"musl/src/math/x32/expl.s",
"musl/src/math/x32/expm1l.s",
@ -1098,7 +1091,6 @@ const src_files = [_][]const u8{
"musl/src/math/x86_64/acosl.s",
"musl/src/math/x86_64/asinl.s",
"musl/src/math/x86_64/atan2l.s",
"musl/src/math/x86_64/atanl.s",
"musl/src/math/x86_64/exp2l.s",
"musl/src/math/x86_64/expl.s",
"musl/src/math/x86_64/expm1l.s",

3
src/libs/wasi_libc.zig
View file

@ -698,12 +698,9 @@ const libc_top_half_src_files = [_][]const u8{
"musl/src/math/atan2.c",
"musl/src/math/atan2f.c",
"musl/src/math/atan2l.c",
"musl/src/math/atan.c",
"musl/src/math/atanf.c",
"musl/src/math/atanh.c",
"musl/src/math/atanhf.c",
"musl/src/math/atanhl.c",
"musl/src/math/atanl.c",
"musl/src/math/cbrt.c",
"musl/src/math/cbrtf.c",
"musl/src/math/cbrtl.c",