mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-05-23 05:42:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Pay off more technical debt

Browse source 
This makes breaking changes to add underscores to many non-standard
function names provided by the c library. MODE=tiny is now tinier and
we now use smaller locks that are better for tiny apps in this mode.
Some headers have been renamed to be in the same folder as the build
package, so it'll be easier to know which build dependency is needed.
Certain old misguided interfaces have been removed. Intel intrinsics
headers are now listed in libc/isystem (but not in the amalgamation)
to help further improve open source compatibility. Header complexity
has also been reduced. Lastly, more shell scripts are now available.
This commit is contained in:
Justine Tunney 2022-09-12 23:10:38 -07:00
parent b69f3d2488
commit 6f7d0cb1c3
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
960 changed files with 4072 additions and 4873 deletions
Download patch file Download diff file Expand all files Collapse all files

18
test/libc/tinymath/acos_test.c
View file

@ -17,22 +17,22 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/mem/gc.h"
#include "libc/stdio/rand.h"
#include "libc/runtime/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
double acos_(double) asm("acos");
#define acos acos_
TEST(acos, test) {
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", acos(0.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", acos(-0.))));
EXPECT_STREQ("1.0471975511966", gc(xasprintf("%.15g", acos(.5))));
EXPECT_STREQ("2.0943951023932", gc(xasprintf("%.15g", acos(-.5))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", acos(1.))));
EXPECT_STREQ("3.14159265358979", gc(xasprintf("%.15g", acos(-1.))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", acos(0.))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", acos(-0.))));
EXPECT_STREQ("1.0471975511966", _gc(xasprintf("%.15g", acos(.5))));
EXPECT_STREQ("2.0943951023932", _gc(xasprintf("%.15g", acos(-.5))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", acos(1.))));
EXPECT_STREQ("3.14159265358979", _gc(xasprintf("%.15g", acos(-1.))));
EXPECT_TRUE(isnan(acos(1.5)));
EXPECT_TRUE(isnan(acos(-1.5)));
EXPECT_TRUE(isnan(acos(2.)));
@ -40,7 +40,7 @@ TEST(acos, test) {
EXPECT_TRUE(isnan(acos(-NAN)));
EXPECT_TRUE(isnan(acos(INFINITY)));
EXPECT_TRUE(isnan(acos(-INFINITY)));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", acos(__DBL_MIN__))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", acos(__DBL_MIN__))));
EXPECT_TRUE(isnan(acos(__DBL_MAX__)));
}

2
test/libc/tinymath/acosh_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

18
test/libc/tinymath/asin_test.c
View file

@ -17,22 +17,22 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/mem/gc.h"
#include "libc/stdio/rand.h"
#include "libc/runtime/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
double asin_(double) asm("asin");
#define asin asin_
TEST(asin, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", asin(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", asin(-0.))));
EXPECT_STREQ("0.523598775598299", gc(xasprintf("%.15g", asin(.5))));
EXPECT_STREQ("-0.523598775598299", gc(xasprintf("%.15g", asin(-.5))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", asin(1.))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", asin(-1.))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", asin(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", asin(-0.))));
EXPECT_STREQ("0.523598775598299", _gc(xasprintf("%.15g", asin(.5))));
EXPECT_STREQ("-0.523598775598299", _gc(xasprintf("%.15g", asin(-.5))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", asin(1.))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", asin(-1.))));
EXPECT_TRUE(isnan(asin(1.5)));
EXPECT_TRUE(isnan(asin(-1.5)));
EXPECT_TRUE(isnan(asin(NAN)));
@ -40,7 +40,7 @@ TEST(asin, test) {
EXPECT_TRUE(isnan(asin(INFINITY)));
EXPECT_TRUE(isnan(asin(-INFINITY)));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", asin(__DBL_MIN__))));
_gc(xasprintf("%.15g", asin(__DBL_MIN__))));
EXPECT_TRUE(isnan(asin(__DBL_MAX__)));
}

35
test/libc/tinymath/asinh_test.c
View file

@ -17,36 +17,37 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define asinhl(x) asinhl(VEIL("t", (long double)(x)))
#define asinh(x) asinh(VEIL("x", (double)(x)))
#define asinhf(x) asinhf(VEIL("x", (float)(x)))
TEST(asinh, test) {
EXPECT_STREQ(".481211825059603", gc(xdtoa(asinh(+.5))));
EXPECT_STREQ("-.481211825059603", gc(xdtoa(asinh(-.5))));
EXPECT_STREQ("0", gc(xdtoa(asinh(0))));
EXPECT_STREQ("NAN", gc(xdtoa(asinh(NAN))));
EXPECT_STREQ("INFINITY", gc(xdtoa(asinh(INFINITY))));
EXPECT_STREQ(".481211825059603", _gc(xdtoa(asinh(+.5))));
EXPECT_STREQ("-.481211825059603", _gc(xdtoa(asinh(-.5))));
EXPECT_STREQ("0", _gc(xdtoa(asinh(0))));
EXPECT_STREQ("NAN", _gc(xdtoa(asinh(NAN))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(asinh(INFINITY))));
EXPECT_STREQ("-2.1073424255447e-08",
gc(xasprintf("%.15g", asinh(-2.1073424255447e-08))));
_gc(xasprintf("%.15g", asinh(-2.1073424255447e-08))));
}
TEST(asinhf, test) {
EXPECT_STREQ(".481212", gc(xdtoaf(asinhf(+.5))));
EXPECT_STREQ("-.481212", gc(xdtoaf(asinhf(-.5))));
EXPECT_STREQ("0", gc(xdtoaf(asinhf(0))));
EXPECT_STREQ("NAN", gc(xdtoaf(asinhf(NAN))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(asinhf(INFINITY))));
EXPECT_STREQ(".481212", _gc(xdtoaf(asinhf(+.5))));
EXPECT_STREQ("-.481212", _gc(xdtoaf(asinhf(-.5))));
EXPECT_STREQ("0", _gc(xdtoaf(asinhf(0))));
EXPECT_STREQ("NAN", _gc(xdtoaf(asinhf(NAN))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(asinhf(INFINITY))));
}
TEST(asinhl, test) {
EXPECT_STREQ(".4812118250596034", gc(xdtoal(asinhl(+.5))));
EXPECT_STREQ("-.4812118250596034", gc(xdtoal(asinhl(-.5))));
EXPECT_STREQ("0", gc(xdtoal(asinhl(0))));
EXPECT_STREQ("NAN", gc(xdtoal(asinhl(NAN))));
EXPECT_STREQ("INFINITY", gc(xdtoal(asinhl(INFINITY))));
EXPECT_STREQ(".4812118250596034", _gc(xdtoal(asinhl(+.5))));
EXPECT_STREQ("-.4812118250596034", _gc(xdtoal(asinhl(-.5))));
EXPECT_STREQ("0", _gc(xdtoal(asinhl(0))));
EXPECT_STREQ("NAN", _gc(xdtoal(asinhl(NAN))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(asinhl(INFINITY))));
}

308
test/libc/tinymath/atan2_test.c
View file

@ -17,149 +17,149 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(atan2, yx) {
EXPECT_STREQ("-0.321750554396642", gc(xasprintf("%.15g", atan(-.5 / 1.5))));
EXPECT_STREQ("-0.321750554396642", gc(xasprintf("%.15g", atan2(-.5, 1.5))));
EXPECT_STREQ("-0.321750554396642", _gc(xasprintf("%.15g", atan(-.5 / 1.5))));
EXPECT_STREQ("-0.321750554396642", _gc(xasprintf("%.15g", atan2(-.5, 1.5))));
}
TEST(atan2, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., 0.))));
EXPECT_STREQ("3.14159265358979", gc(xasprintf("%.15g", atan2(0., -0.))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., .5))));
EXPECT_STREQ("3.14159265358979", gc(xasprintf("%.15g", atan2(0., -.5))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., 1.))));
EXPECT_STREQ("3.14159265358979", gc(xasprintf("%.15g", atan2(0., -1.))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., 1.5))));
EXPECT_STREQ("3.14159265358979", gc(xasprintf("%.15g", atan2(0., -1.5))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., 0.))));
EXPECT_STREQ("3.14159265358979", _gc(xasprintf("%.15g", atan2(0., -0.))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., .5))));
EXPECT_STREQ("3.14159265358979", _gc(xasprintf("%.15g", atan2(0., -.5))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., 1.))));
EXPECT_STREQ("3.14159265358979", _gc(xasprintf("%.15g", atan2(0., -1.))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., 1.5))));
EXPECT_STREQ("3.14159265358979", _gc(xasprintf("%.15g", atan2(0., -1.5))));
EXPECT_TRUE(isnan(atan2(0., NAN)));
EXPECT_TRUE(isnan(atan2(0., -NAN)));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., INFINITY))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(0., -INFINITY))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., __DBL_MIN__))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(0., __DBL_MAX__))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., 0.))));
EXPECT_STREQ("-3.14159265358979", gc(xasprintf("%.15g", atan2(-0., -0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., .5))));
EXPECT_STREQ("-3.14159265358979", gc(xasprintf("%.15g", atan2(-0., -.5))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., 1.))));
EXPECT_STREQ("-3.14159265358979", gc(xasprintf("%.15g", atan2(-0., -1.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., 1.5))));
EXPECT_STREQ("-3.14159265358979", gc(xasprintf("%.15g", atan2(-0., -1.5))));
_gc(xasprintf("%.15g", atan2(0., -INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., __DBL_MIN__))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(0., __DBL_MAX__))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., 0.))));
EXPECT_STREQ("-3.14159265358979", _gc(xasprintf("%.15g", atan2(-0., -0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., .5))));
EXPECT_STREQ("-3.14159265358979", _gc(xasprintf("%.15g", atan2(-0., -.5))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., 1.))));
EXPECT_STREQ("-3.14159265358979", _gc(xasprintf("%.15g", atan2(-0., -1.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., 1.5))));
EXPECT_STREQ("-3.14159265358979", _gc(xasprintf("%.15g", atan2(-0., -1.5))));
EXPECT_TRUE(isnan(atan2(-0., NAN)));
EXPECT_TRUE(isnan(atan2(-0., -NAN)));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., INFINITY))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., INFINITY))));
EXPECT_STREQ("-3.14159265358979",
gc(xasprintf("%.15g", atan2(-0., -INFINITY))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., __DBL_MIN__))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-0., __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(.5, 0.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(.5, -0.))));
EXPECT_STREQ("0.785398163397448", gc(xasprintf("%.15g", atan2(.5, .5))));
EXPECT_STREQ("2.35619449019234", gc(xasprintf("%.15g", atan2(.5, -.5))));
EXPECT_STREQ("0.463647609000806", gc(xasprintf("%.15g", atan2(.5, 1.))));
EXPECT_STREQ("2.67794504458899", gc(xasprintf("%.15g", atan2(.5, -1.))));
EXPECT_STREQ("0.321750554396642", gc(xasprintf("%.15g", atan2(.5, 1.5))));
EXPECT_STREQ("2.81984209919315", gc(xasprintf("%.15g", atan2(.5, -1.5))));
_gc(xasprintf("%.15g", atan2(-0., -INFINITY))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., __DBL_MIN__))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-0., __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(.5, 0.))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(.5, -0.))));
EXPECT_STREQ("0.785398163397448", _gc(xasprintf("%.15g", atan2(.5, .5))));
EXPECT_STREQ("2.35619449019234", _gc(xasprintf("%.15g", atan2(.5, -.5))));
EXPECT_STREQ("0.463647609000806", _gc(xasprintf("%.15g", atan2(.5, 1.))));
EXPECT_STREQ("2.67794504458899", _gc(xasprintf("%.15g", atan2(.5, -1.))));
EXPECT_STREQ("0.321750554396642", _gc(xasprintf("%.15g", atan2(.5, 1.5))));
EXPECT_STREQ("2.81984209919315", _gc(xasprintf("%.15g", atan2(.5, -1.5))));
EXPECT_TRUE(isnan(atan2(.5, NAN)));
EXPECT_TRUE(isnan(atan2(.5, -NAN)));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(.5, INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(.5, INFINITY))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(.5, -INFINITY))));
_gc(xasprintf("%.15g", atan2(.5, -INFINITY))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(.5, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(.5, __DBL_MIN__))));
EXPECT_STREQ("2.781342323134e-309",
gc(xasprintf("%.15g", atan2(.5, __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan2(-.5, 0.))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan2(-.5, -0.))));
EXPECT_STREQ("-0.785398163397448", gc(xasprintf("%.15g", atan2(-.5, .5))));
EXPECT_STREQ("-2.35619449019234", gc(xasprintf("%.15g", atan2(-.5, -.5))));
EXPECT_STREQ("-0.463647609000806", gc(xasprintf("%.15g", atan2(-.5, 1.))));
EXPECT_STREQ("-2.67794504458899", gc(xasprintf("%.15g", atan2(-.5, -1.))));
EXPECT_STREQ("-0.321750554396642", gc(xasprintf("%.15g", atan2(-.5, 1.5))));
EXPECT_STREQ("-2.81984209919315", gc(xasprintf("%.15g", atan2(-.5, -1.5))));
_gc(xasprintf("%.15g", atan2(.5, __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan2(-.5, 0.))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan2(-.5, -0.))));
EXPECT_STREQ("-0.785398163397448", _gc(xasprintf("%.15g", atan2(-.5, .5))));
EXPECT_STREQ("-2.35619449019234", _gc(xasprintf("%.15g", atan2(-.5, -.5))));
EXPECT_STREQ("-0.463647609000806", _gc(xasprintf("%.15g", atan2(-.5, 1.))));
EXPECT_STREQ("-2.67794504458899", _gc(xasprintf("%.15g", atan2(-.5, -1.))));
EXPECT_STREQ("-0.321750554396642", _gc(xasprintf("%.15g", atan2(-.5, 1.5))));
EXPECT_STREQ("-2.81984209919315", _gc(xasprintf("%.15g", atan2(-.5, -1.5))));
EXPECT_TRUE(isnan(atan2(-.5, NAN)));
EXPECT_TRUE(isnan(atan2(-.5, -NAN)));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-.5, INFINITY))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-.5, INFINITY))));
EXPECT_STREQ("-3.14159265358979",
gc(xasprintf("%.15g", atan2(-.5, -INFINITY))));
_gc(xasprintf("%.15g", atan2(-.5, -INFINITY))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-.5, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(-.5, __DBL_MIN__))));
EXPECT_STREQ("-2.781342323134e-309",
gc(xasprintf("%.15g", atan2(-.5, __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(1., 0.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(1., -0.))));
EXPECT_STREQ("1.10714871779409", gc(xasprintf("%.15g", atan2(1., .5))));
EXPECT_STREQ("2.0344439357957", gc(xasprintf("%.15g", atan2(1., -.5))));
EXPECT_STREQ("0.785398163397448", gc(xasprintf("%.15g", atan2(1., 1.))));
EXPECT_STREQ("2.35619449019234", gc(xasprintf("%.15g", atan2(1., -1.))));
EXPECT_STREQ("0.588002603547568", gc(xasprintf("%.15g", atan2(1., 1.5))));
EXPECT_STREQ("2.55359005004223", gc(xasprintf("%.15g", atan2(1., -1.5))));
_gc(xasprintf("%.15g", atan2(-.5, __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(1., 0.))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(1., -0.))));
EXPECT_STREQ("1.10714871779409", _gc(xasprintf("%.15g", atan2(1., .5))));
EXPECT_STREQ("2.0344439357957", _gc(xasprintf("%.15g", atan2(1., -.5))));
EXPECT_STREQ("0.785398163397448", _gc(xasprintf("%.15g", atan2(1., 1.))));
EXPECT_STREQ("2.35619449019234", _gc(xasprintf("%.15g", atan2(1., -1.))));
EXPECT_STREQ("0.588002603547568", _gc(xasprintf("%.15g", atan2(1., 1.5))));
EXPECT_STREQ("2.55359005004223", _gc(xasprintf("%.15g", atan2(1., -1.5))));
EXPECT_TRUE(isnan(atan2(1., NAN)));
EXPECT_TRUE(isnan(atan2(1., -NAN)));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(1., INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(1., INFINITY))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(1., -INFINITY))));
_gc(xasprintf("%.15g", atan2(1., -INFINITY))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(1., __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(1., __DBL_MIN__))));
EXPECT_STREQ("5.562684646268e-309",
gc(xasprintf("%.15g", atan2(1., __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan2(-1., 0.))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan2(-1., -0.))));
EXPECT_STREQ("-1.10714871779409", gc(xasprintf("%.15g", atan2(-1., .5))));
EXPECT_STREQ("-2.0344439357957", gc(xasprintf("%.15g", atan2(-1., -.5))));
EXPECT_STREQ("-0.785398163397448", gc(xasprintf("%.15g", atan2(-1., 1.))));
EXPECT_STREQ("-2.35619449019234", gc(xasprintf("%.15g", atan2(-1., -1.))));
EXPECT_STREQ("-0.588002603547568", gc(xasprintf("%.15g", atan2(-1., 1.5))));
EXPECT_STREQ("-2.55359005004223", gc(xasprintf("%.15g", atan2(-1., -1.5))));
_gc(xasprintf("%.15g", atan2(1., __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan2(-1., 0.))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan2(-1., -0.))));
EXPECT_STREQ("-1.10714871779409", _gc(xasprintf("%.15g", atan2(-1., .5))));
EXPECT_STREQ("-2.0344439357957", _gc(xasprintf("%.15g", atan2(-1., -.5))));
EXPECT_STREQ("-0.785398163397448", _gc(xasprintf("%.15g", atan2(-1., 1.))));
EXPECT_STREQ("-2.35619449019234", _gc(xasprintf("%.15g", atan2(-1., -1.))));
EXPECT_STREQ("-0.588002603547568", _gc(xasprintf("%.15g", atan2(-1., 1.5))));
EXPECT_STREQ("-2.55359005004223", _gc(xasprintf("%.15g", atan2(-1., -1.5))));
EXPECT_TRUE(isnan(atan2(-1., NAN)));
EXPECT_TRUE(isnan(atan2(-1., -NAN)));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-1., INFINITY))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-1., INFINITY))));
EXPECT_STREQ("-3.14159265358979",
gc(xasprintf("%.15g", atan2(-1., -INFINITY))));
_gc(xasprintf("%.15g", atan2(-1., -INFINITY))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-1., __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(-1., __DBL_MIN__))));
EXPECT_STREQ("-5.562684646268e-309",
gc(xasprintf("%.15g", atan2(-1., __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(1.5, 0.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(1.5, -0.))));
EXPECT_STREQ("1.24904577239825", gc(xasprintf("%.15g", atan2(1.5, .5))));
EXPECT_STREQ("1.89254688119154", gc(xasprintf("%.15g", atan2(1.5, -.5))));
EXPECT_STREQ("0.982793723247329", gc(xasprintf("%.15g", atan2(1.5, 1.))));
EXPECT_STREQ("2.15879893034246", gc(xasprintf("%.15g", atan2(1.5, -1.))));
EXPECT_STREQ("0.785398163397448", gc(xasprintf("%.15g", atan2(1.5, 1.5))));
EXPECT_STREQ("2.35619449019234", gc(xasprintf("%.15g", atan2(1.5, -1.5))));
_gc(xasprintf("%.15g", atan2(-1., __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(1.5, 0.))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(1.5, -0.))));
EXPECT_STREQ("1.24904577239825", _gc(xasprintf("%.15g", atan2(1.5, .5))));
EXPECT_STREQ("1.89254688119154", _gc(xasprintf("%.15g", atan2(1.5, -.5))));
EXPECT_STREQ("0.982793723247329", _gc(xasprintf("%.15g", atan2(1.5, 1.))));
EXPECT_STREQ("2.15879893034246", _gc(xasprintf("%.15g", atan2(1.5, -1.))));
EXPECT_STREQ("0.785398163397448", _gc(xasprintf("%.15g", atan2(1.5, 1.5))));
EXPECT_STREQ("2.35619449019234", _gc(xasprintf("%.15g", atan2(1.5, -1.5))));
EXPECT_TRUE(isnan(atan2(1.5, NAN)));
EXPECT_TRUE(isnan(atan2(1.5, -NAN)));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(1.5, INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(1.5, INFINITY))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(1.5, -INFINITY))));
_gc(xasprintf("%.15g", atan2(1.5, -INFINITY))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(1.5, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(1.5, __DBL_MIN__))));
EXPECT_STREQ("8.34402696940201e-309",
gc(xasprintf("%.15g", atan2(1.5, __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan2(-1.5, 0.))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan2(-1.5, -0.))));
EXPECT_STREQ("-1.24904577239825", gc(xasprintf("%.15g", atan2(-1.5, .5))));
EXPECT_STREQ("-1.89254688119154", gc(xasprintf("%.15g", atan2(-1.5, -.5))));
EXPECT_STREQ("-0.982793723247329", gc(xasprintf("%.15g", atan2(-1.5, 1.))));
EXPECT_STREQ("-2.15879893034246", gc(xasprintf("%.15g", atan2(-1.5, -1.))));
EXPECT_STREQ("-0.785398163397448", gc(xasprintf("%.15g", atan2(-1.5, 1.5))));
EXPECT_STREQ("-2.35619449019234", gc(xasprintf("%.15g", atan2(-1.5, -1.5))));
_gc(xasprintf("%.15g", atan2(1.5, __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan2(-1.5, 0.))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan2(-1.5, -0.))));
EXPECT_STREQ("-1.24904577239825", _gc(xasprintf("%.15g", atan2(-1.5, .5))));
EXPECT_STREQ("-1.89254688119154", _gc(xasprintf("%.15g", atan2(-1.5, -.5))));
EXPECT_STREQ("-0.982793723247329", _gc(xasprintf("%.15g", atan2(-1.5, 1.))));
EXPECT_STREQ("-2.15879893034246", _gc(xasprintf("%.15g", atan2(-1.5, -1.))));
EXPECT_STREQ("-0.785398163397448", _gc(xasprintf("%.15g", atan2(-1.5, 1.5))));
EXPECT_STREQ("-2.35619449019234", _gc(xasprintf("%.15g", atan2(-1.5, -1.5))));
EXPECT_TRUE(isnan(atan2(-1.5, NAN)));
EXPECT_TRUE(isnan(atan2(-1.5, -NAN)));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-1.5, INFINITY))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-1.5, INFINITY))));
EXPECT_STREQ("-3.14159265358979",
gc(xasprintf("%.15g", atan2(-1.5, -INFINITY))));
_gc(xasprintf("%.15g", atan2(-1.5, -INFINITY))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-1.5, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(-1.5, __DBL_MIN__))));
EXPECT_STREQ("-8.34402696940201e-309",
gc(xasprintf("%.15g", atan2(-1.5, __DBL_MAX__))));
_gc(xasprintf("%.15g", atan2(-1.5, __DBL_MAX__))));
EXPECT_TRUE(isnan(atan2(NAN, 0.)));
EXPECT_TRUE(isnan(atan2(NAN, -0.)));
EXPECT_TRUE(isnan(atan2(NAN, .5)));
@ -188,107 +188,111 @@ TEST(atan2, test) {
EXPECT_TRUE(isnan(atan2(-NAN, -INFINITY)));
EXPECT_TRUE(isnan(atan2(-NAN, __DBL_MIN__)));
EXPECT_TRUE(isnan(atan2(-NAN, __DBL_MAX__)));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, 0.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, -0.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, .5))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, -.5))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, 1.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, -1.))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan2(INFINITY, 1.5))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(INFINITY, 0.))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(INFINITY, -1.5))));
_gc(xasprintf("%.15g", atan2(INFINITY, -0.))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(INFINITY, .5))));
EXPECT_STREQ("1.5707963267949",
_gc(xasprintf("%.15g", atan2(INFINITY, -.5))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan2(INFINITY, 1.))));
EXPECT_STREQ("1.5707963267949",
_gc(xasprintf("%.15g", atan2(INFINITY, -1.))));
EXPECT_STREQ("1.5707963267949",
_gc(xasprintf("%.15g", atan2(INFINITY, 1.5))));
EXPECT_STREQ("1.5707963267949",
_gc(xasprintf("%.15g", atan2(INFINITY, -1.5))));
EXPECT_TRUE(isnan(atan2(INFINITY, NAN)));
EXPECT_TRUE(isnan(atan2(INFINITY, -NAN)));
EXPECT_STREQ("0.785398163397448",
gc(xasprintf("%.15g", atan2(INFINITY, INFINITY))));
_gc(xasprintf("%.15g", atan2(INFINITY, INFINITY))));
EXPECT_STREQ("2.35619449019234",
gc(xasprintf("%.15g", atan2(INFINITY, -INFINITY))));
_gc(xasprintf("%.15g", atan2(INFINITY, -INFINITY))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(INFINITY, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(INFINITY, __DBL_MIN__))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(INFINITY, __DBL_MAX__))));
_gc(xasprintf("%.15g", atan2(INFINITY, __DBL_MAX__))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, 0.))));
_gc(xasprintf("%.15g", atan2(-INFINITY, 0.))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, -0.))));
_gc(xasprintf("%.15g", atan2(-INFINITY, -0.))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, .5))));
_gc(xasprintf("%.15g", atan2(-INFINITY, .5))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, -.5))));
_gc(xasprintf("%.15g", atan2(-INFINITY, -.5))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, 1.))));
_gc(xasprintf("%.15g", atan2(-INFINITY, 1.))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, -1.))));
_gc(xasprintf("%.15g", atan2(-INFINITY, -1.))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, 1.5))));
_gc(xasprintf("%.15g", atan2(-INFINITY, 1.5))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, -1.5))));
_gc(xasprintf("%.15g", atan2(-INFINITY, -1.5))));
EXPECT_TRUE(isnan(atan2(-INFINITY, NAN)));
EXPECT_TRUE(isnan(atan2(-INFINITY, -NAN)));
EXPECT_STREQ("-0.785398163397448",
gc(xasprintf("%.15g", atan2(-INFINITY, INFINITY))));
_gc(xasprintf("%.15g", atan2(-INFINITY, INFINITY))));
EXPECT_STREQ("-2.35619449019234",
gc(xasprintf("%.15g", atan2(-INFINITY, -INFINITY))));
_gc(xasprintf("%.15g", atan2(-INFINITY, -INFINITY))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(-INFINITY, __DBL_MIN__))));
EXPECT_STREQ("-1.5707963267949",
gc(xasprintf("%.15g", atan2(-INFINITY, __DBL_MAX__))));
_gc(xasprintf("%.15g", atan2(-INFINITY, __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, 0.))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, 0.))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, -0.))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, -0.))));
EXPECT_STREQ("4.4501477170144e-308",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, .5))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, .5))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, -.5))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, -.5))));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, 1.))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, 1.))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, -1.))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, -1.))));
EXPECT_STREQ("1.48338257233813e-308",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, 1.5))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, 1.5))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, -1.5))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, -1.5))));
EXPECT_TRUE(isnan(atan2(__DBL_MIN__, NAN)));
EXPECT_TRUE(isnan(atan2(__DBL_MIN__, -NAN)));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(__DBL_MIN__, INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(__DBL_MIN__, INFINITY))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, -INFINITY))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, -INFINITY))));
EXPECT_STREQ("0.785398163397448",
gc(xasprintf("%.15g", atan2(__DBL_MIN__, __DBL_MIN__))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(__DBL_MIN__, __DBL_MAX__))));
_gc(xasprintf("%.15g", atan2(__DBL_MIN__, __DBL_MIN__))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(__DBL_MIN__, __DBL_MAX__))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, 0.))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, 0.))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, -0.))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, -0.))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, .5))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, .5))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, -.5))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, -.5))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, 1.))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, 1.))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, -1.))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, -1.))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, 1.5))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, 1.5))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, -1.5))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, -1.5))));
EXPECT_TRUE(isnan(atan2(__DBL_MAX__, NAN)));
EXPECT_TRUE(isnan(atan2(__DBL_MAX__, -NAN)));
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan2(__DBL_MAX__, INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan2(__DBL_MAX__, INFINITY))));
EXPECT_STREQ("3.14159265358979",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, -INFINITY))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, -INFINITY))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, __DBL_MIN__))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, __DBL_MIN__))));
EXPECT_STREQ("0.785398163397448",
gc(xasprintf("%.15g", atan2(__DBL_MAX__, __DBL_MAX__))));
_gc(xasprintf("%.15g", atan2(__DBL_MAX__, __DBL_MAX__))));
EXPECT_STREQ("-0",
gc(xasprintf("%.15g", atan2(-0.000000000000001, INFINITY))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan2(-1, INFINITY))));
_gc(xasprintf("%.15g", atan2(-0.000000000000001, INFINITY))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan2(-1, INFINITY))));
EXPECT_STREQ(
"-0", gc(xasprintf("%.15g", atan2(-1.7976931348623157e308, INFINITY))));
"-0", _gc(xasprintf("%.15g", atan2(-1.7976931348623157e308, INFINITY))));
EXPECT_STREQ("1.5707963267949",
gc(xasprintf("%.15g", atan2(1.4142135623731, 0))));
_gc(xasprintf("%.15g", atan2(1.4142135623731, 0))));
}
BENCH(atan2, bench) {

53
test/libc/tinymath/atan2l_test.c
View file

@ -17,39 +17,40 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(atan2l, test) {
volatile double a = -.9816175436063843;
volatile double b = -.1908585813741899;
EXPECT_STREQ("-2.95", gc(xasprintf("%.2f", atan2f(b, a))));
EXPECT_STREQ("-2.95", gc(xasprintf("%.2f", atan2(b, a))));
EXPECT_STREQ("-2.95", gc(xasprintf("%.2Lf", atan2l(b, a))));
EXPECT_STREQ("-2.95", _gc(xasprintf("%.2f", atan2f(b, a))));
EXPECT_STREQ("-2.95", _gc(xasprintf("%.2f", atan2(b, a))));
EXPECT_STREQ("-2.95", _gc(xasprintf("%.2Lf", atan2l(b, a))));
}
TEST(atan2, testSpecialCases) {
ASSERT_STREQ("NAN", gc(xdtoa(atan2(NAN, 0))));
ASSERT_STREQ("NAN", gc(xdtoa(atan2(0, NAN))));
ASSERT_STREQ("0", gc(xdtoa(atan2(+0., +0.))));
ASSERT_STREQ("0", gc(xdtoa(atan2(+0., +1.))));
ASSERT_STREQ("0", gc(xdtoa(atan2(+0., +2.))));
ASSERT_STREQ("0", gc(xdtoa(atan2(1, INFINITY))));
ASSERT_STREQ("3.141592653589793", gc(xdtoal(atan2(+0., -0.))));
ASSERT_STREQ("3.141592653589793", gc(xdtoal(atan2(+0., -1.))));
ASSERT_STREQ("3.141592653589793", gc(xdtoal(atan2(+0., -2.))));
ASSERT_STREQ("-1.570796326794897", gc(xdtoal(atan2(-1., -0.))));
ASSERT_STREQ("-1.570796326794897", gc(xdtoal(atan2(-1., +0.))));
ASSERT_STREQ("-1.570796326794897", gc(xdtoal(atan2(-2., -0.))));
ASSERT_STREQ("-1.570796326794897", gc(xdtoal(atan2(-2., +0.))));
ASSERT_STREQ("1.570796326794897", gc(xdtoal(atan2(+1., -0.))));
ASSERT_STREQ("1.570796326794897", gc(xdtoal(atan2(+1., +0.))));
ASSERT_STREQ("1.570796326794897", gc(xdtoal(atan2(+2., -0.))));
ASSERT_STREQ("1.570796326794897", gc(xdtoal(atan2(+2., +0.))));
ASSERT_STREQ("1.570796326794897", gc(xdtoal(atan2(INFINITY, 1))));
ASSERT_STREQ("1.570796326794897", gc(xdtoal(atan2(INFINITY, -1))));
ASSERT_STREQ("3.141592653589793", gc(xdtoal(atan2(1, -INFINITY))));
ASSERT_STREQ("2.356194490192345", gc(xdtoal(atan2(INFINITY, -INFINITY))));
ASSERT_STREQ(".7853981633974483", gc(xdtoal(atan2(INFINITY, INFINITY))));
ASSERT_STREQ("NAN", _gc(xdtoa(atan2(NAN, 0))));
ASSERT_STREQ("NAN", _gc(xdtoa(atan2(0, NAN))));
ASSERT_STREQ("0", _gc(xdtoa(atan2(+0., +0.))));
ASSERT_STREQ("0", _gc(xdtoa(atan2(+0., +1.))));
ASSERT_STREQ("0", _gc(xdtoa(atan2(+0., +2.))));
ASSERT_STREQ("0", _gc(xdtoa(atan2(1, INFINITY))));
ASSERT_STREQ("3.141592653589793", _gc(xdtoal(atan2(+0., -0.))));
ASSERT_STREQ("3.141592653589793", _gc(xdtoal(atan2(+0., -1.))));
ASSERT_STREQ("3.141592653589793", _gc(xdtoal(atan2(+0., -2.))));
ASSERT_STREQ("-1.570796326794897", _gc(xdtoal(atan2(-1., -0.))));
ASSERT_STREQ("-1.570796326794897", _gc(xdtoal(atan2(-1., +0.))));
ASSERT_STREQ("-1.570796326794897", _gc(xdtoal(atan2(-2., -0.))));
ASSERT_STREQ("-1.570796326794897", _gc(xdtoal(atan2(-2., +0.))));
ASSERT_STREQ("1.570796326794897", _gc(xdtoal(atan2(+1., -0.))));
ASSERT_STREQ("1.570796326794897", _gc(xdtoal(atan2(+1., +0.))));
ASSERT_STREQ("1.570796326794897", _gc(xdtoal(atan2(+2., -0.))));
ASSERT_STREQ("1.570796326794897", _gc(xdtoal(atan2(+2., +0.))));
ASSERT_STREQ("1.570796326794897", _gc(xdtoal(atan2(INFINITY, 1))));
ASSERT_STREQ("1.570796326794897", _gc(xdtoal(atan2(INFINITY, -1))));
ASSERT_STREQ("3.141592653589793", _gc(xdtoal(atan2(1, -INFINITY))));
ASSERT_STREQ("2.356194490192345", _gc(xdtoal(atan2(INFINITY, -INFINITY))));
ASSERT_STREQ(".7853981633974483", _gc(xdtoal(atan2(INFINITY, INFINITY))));
}

32
test/libc/tinymath/atan_test.c
View file

@ -17,27 +17,27 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(atan, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", atan(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", atan(-0.))));
EXPECT_STREQ("0.463647609000806", gc(xasprintf("%.15g", atan(.5))));
EXPECT_STREQ("-0.463647609000806", gc(xasprintf("%.15g", atan(-.5))));
EXPECT_STREQ("0.785398163397448", gc(xasprintf("%.15g", atan(1.))));
EXPECT_STREQ("-0.785398163397448", gc(xasprintf("%.15g", atan(-1.))));
EXPECT_STREQ("0.982793723247329", gc(xasprintf("%.15g", atan(1.5))));
EXPECT_STREQ("-0.982793723247329", gc(xasprintf("%.15g", atan(-1.5))));
EXPECT_STREQ("nan", gc(xasprintf("%.15g", atan(NAN))));
EXPECT_STREQ("-nan", gc(xasprintf("%.15g", atan(-NAN))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan(INFINITY))));
EXPECT_STREQ("-1.5707963267949", gc(xasprintf("%.15g", atan(-INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", atan(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", atan(-0.))));
EXPECT_STREQ("0.463647609000806", _gc(xasprintf("%.15g", atan(.5))));
EXPECT_STREQ("-0.463647609000806", _gc(xasprintf("%.15g", atan(-.5))));
EXPECT_STREQ("0.785398163397448", _gc(xasprintf("%.15g", atan(1.))));
EXPECT_STREQ("-0.785398163397448", _gc(xasprintf("%.15g", atan(-1.))));
EXPECT_STREQ("0.982793723247329", _gc(xasprintf("%.15g", atan(1.5))));
EXPECT_STREQ("-0.982793723247329", _gc(xasprintf("%.15g", atan(-1.5))));
EXPECT_STREQ("nan", _gc(xasprintf("%.15g", atan(NAN))));
EXPECT_STREQ("-nan", _gc(xasprintf("%.15g", atan(-NAN))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan(INFINITY))));
EXPECT_STREQ("-1.5707963267949", _gc(xasprintf("%.15g", atan(-INFINITY))));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", atan(__DBL_MIN__))));
EXPECT_STREQ("1.5707963267949", gc(xasprintf("%.15g", atan(__DBL_MAX__))));
_gc(xasprintf("%.15g", atan(__DBL_MIN__))));
EXPECT_STREQ("1.5707963267949", _gc(xasprintf("%.15g", atan(__DBL_MAX__))));
}
BENCH(atanl, bench) {

41
test/libc/tinymath/atanh_test.c
View file

@ -17,46 +17,47 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define atanhl(x) atanhl(VEIL("t", (long double)(x)))
#define atanh(x) atanh(VEIL("x", (double)(x)))
#define atanhf(x) atanhf(VEIL("x", (float)(x)))
TEST(atanh, test) {
EXPECT_STREQ("0", gc(xdtoa(atanh(0))));
EXPECT_STREQ("-0", gc(xdtoa(atanh(-0.))));
EXPECT_STREQ(".549306144334055", gc(xdtoa(atanh(.5))));
EXPECT_STREQ("-.549306144334055", gc(xdtoa(atanh(-.5))));
EXPECT_STREQ("INFINITY", gc(xdtoa(atanh(+1))));
EXPECT_STREQ("-INFINITY", gc(xdtoa(atanh(-1))));
EXPECT_STREQ("0", _gc(xdtoa(atanh(0))));
EXPECT_STREQ("-0", _gc(xdtoa(atanh(-0.))));
EXPECT_STREQ(".549306144334055", _gc(xdtoa(atanh(.5))));
EXPECT_STREQ("-.549306144334055", _gc(xdtoa(atanh(-.5))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(atanh(+1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoa(atanh(-1))));
EXPECT_TRUE(isnan(atanh(+1.1)));
EXPECT_TRUE(isnan(atanh(-1.1)));
EXPECT_STREQ("-2.1073424255447e-08",
gc(xasprintf("%.15g", atanh(-2.1073424255447e-08))));
_gc(xasprintf("%.15g", atanh(-2.1073424255447e-08))));
}
TEST(atanhl, test) {
EXPECT_STREQ("0", gc(xdtoal(atanhl(0))));
EXPECT_STREQ("-0", gc(xdtoal(atanhl(-0.))));
EXPECT_STREQ(".5493061443340548", gc(xdtoal(atanhl(.5))));
EXPECT_STREQ("-.5493061443340548", gc(xdtoal(atanhl(-.5))));
EXPECT_STREQ("INFINITY", gc(xdtoal(atanhl(+1))));
EXPECT_STREQ("-INFINITY", gc(xdtoal(atanhl(-1))));
EXPECT_STREQ("0", _gc(xdtoal(atanhl(0))));
EXPECT_STREQ("-0", _gc(xdtoal(atanhl(-0.))));
EXPECT_STREQ(".5493061443340548", _gc(xdtoal(atanhl(.5))));
EXPECT_STREQ("-.5493061443340548", _gc(xdtoal(atanhl(-.5))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(atanhl(+1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoal(atanhl(-1))));
EXPECT_TRUE(isnan(atanhl(+1.1)));
EXPECT_TRUE(isnan(atanhl(-1.1)));
}
TEST(atanhf, test) {
EXPECT_STREQ("0", gc(xdtoaf(atanhf(0))));
EXPECT_STREQ("-0", gc(xdtoaf(atanhf(-0.))));
EXPECT_STREQ(".549306", gc(xdtoaf(atanhf(.5))));
EXPECT_STREQ("-.549306", gc(xdtoaf(atanhf(-.5))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(atanhf(+1))));
EXPECT_STREQ("-INFINITY", gc(xdtoaf(atanhf(-1))));
EXPECT_STREQ("0", _gc(xdtoaf(atanhf(0))));
EXPECT_STREQ("-0", _gc(xdtoaf(atanhf(-0.))));
EXPECT_STREQ(".549306", _gc(xdtoaf(atanhf(.5))));
EXPECT_STREQ("-.549306", _gc(xdtoaf(atanhf(-.5))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(atanhf(+1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoaf(atanhf(-1))));
EXPECT_TRUE(isnan(atanhf(+1.1)));
EXPECT_TRUE(isnan(atanhf(-1.1)));
}

2
test/libc/tinymath/atanl_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

32
test/libc/tinymath/cbrt_test.c
View file

@ -17,25 +17,25 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(cbrt, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", cbrt(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", cbrt(-0.))));
EXPECT_STREQ("0.7937005259841", gc(xasprintf("%.15g", cbrt(.5))));
EXPECT_STREQ("-0.7937005259841", gc(xasprintf("%.15g", cbrt(-.5))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", cbrt(1.))));
EXPECT_STREQ("-1", gc(xasprintf("%.15g", cbrt(-1.))));
EXPECT_STREQ("1.14471424255333", gc(xasprintf("%.15g", cbrt(1.5))));
EXPECT_STREQ("-1.14471424255333", gc(xasprintf("%.15g", cbrt(-1.5))));
EXPECT_STREQ("nan", gc(xasprintf("%.15g", cbrt(NAN))));
EXPECT_STREQ("-nan", gc(xasprintf("%.15g", cbrt(-NAN))));
EXPECT_STREQ("inf", gc(xasprintf("%.15g", cbrt(INFINITY))));
EXPECT_STREQ("-inf", gc(xasprintf("%.15g", cbrt(-INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", cbrt(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", cbrt(-0.))));
EXPECT_STREQ("0.7937005259841", _gc(xasprintf("%.15g", cbrt(.5))));
EXPECT_STREQ("-0.7937005259841", _gc(xasprintf("%.15g", cbrt(-.5))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", cbrt(1.))));
EXPECT_STREQ("-1", _gc(xasprintf("%.15g", cbrt(-1.))));
EXPECT_STREQ("1.14471424255333", _gc(xasprintf("%.15g", cbrt(1.5))));
EXPECT_STREQ("-1.14471424255333", _gc(xasprintf("%.15g", cbrt(-1.5))));
EXPECT_STREQ("nan", _gc(xasprintf("%.15g", cbrt(NAN))));
EXPECT_STREQ("-nan", _gc(xasprintf("%.15g", cbrt(-NAN))));
EXPECT_STREQ("inf", _gc(xasprintf("%.15g", cbrt(INFINITY))));
EXPECT_STREQ("-inf", _gc(xasprintf("%.15g", cbrt(-INFINITY))));
EXPECT_STREQ("2.81264428523626e-103",
gc(xasprintf("%.15g", cbrt(__DBL_MIN__))));
_gc(xasprintf("%.15g", cbrt(__DBL_MIN__))));
EXPECT_STREQ("5.64380309412236e+102",
gc(xasprintf("%.15g", cbrt(__DBL_MAX__))));
_gc(xasprintf("%.15g", cbrt(__DBL_MAX__))));
}

2
test/libc/tinymath/ceil_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/copysign_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

34
test/libc/tinymath/cos_test.c
View file

@ -17,32 +17,32 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(cos, test) {
EXPECT_STREQ("1", gc(xasprintf("%.15g", cos(0.))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", cos(-0.))));
EXPECT_STREQ("0.995004165278026", gc(xasprintf("%.15g", cos(.1))));
EXPECT_STREQ("0.995004165278026", gc(xasprintf("%.15g", cos(-.1))));
EXPECT_STREQ("0.877582561890373", gc(xasprintf("%.15g", cos(.5))));
EXPECT_STREQ("0.877582561890373", gc(xasprintf("%.15g", cos(-.5))));
EXPECT_STREQ("0.54030230586814", gc(xasprintf("%.15g", cos(1.))));
EXPECT_STREQ("0.54030230586814", gc(xasprintf("%.15g", cos(-1.))));
EXPECT_STREQ("0.0707372016677029", gc(xasprintf("%.15g", cos(1.5))));
EXPECT_STREQ("0.0707372016677029", gc(xasprintf("%.15g", cos(-1.5))));
EXPECT_STREQ("-0.416146836547142", gc(xasprintf("%.15g", cos(2.))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", cos(0.))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", cos(-0.))));
EXPECT_STREQ("0.995004165278026", _gc(xasprintf("%.15g", cos(.1))));
EXPECT_STREQ("0.995004165278026", _gc(xasprintf("%.15g", cos(-.1))));
EXPECT_STREQ("0.877582561890373", _gc(xasprintf("%.15g", cos(.5))));
EXPECT_STREQ("0.877582561890373", _gc(xasprintf("%.15g", cos(-.5))));
EXPECT_STREQ("0.54030230586814", _gc(xasprintf("%.15g", cos(1.))));
EXPECT_STREQ("0.54030230586814", _gc(xasprintf("%.15g", cos(-1.))));
EXPECT_STREQ("0.0707372016677029", _gc(xasprintf("%.15g", cos(1.5))));
EXPECT_STREQ("0.0707372016677029", _gc(xasprintf("%.15g", cos(-1.5))));
EXPECT_STREQ("-0.416146836547142", _gc(xasprintf("%.15g", cos(2.))));
EXPECT_TRUE(isnan(cos(NAN)));
EXPECT_TRUE(isnan(cos(-NAN)));
EXPECT_TRUE(isnan(cos(INFINITY)));
EXPECT_TRUE(isnan(cos(-INFINITY)));
EXPECT_STREQ("1", gc(xasprintf("%.15g", cos(__DBL_MIN__))));
EXPECT_STREQ("-0.99998768942656", gc(xasprintf("%.15g", cos(__DBL_MAX__))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", cos(__DBL_MIN__))));
EXPECT_STREQ("-0.99998768942656", _gc(xasprintf("%.15g", cos(__DBL_MAX__))));
EXPECT_STREQ("0.54030230586814",
gc(xasprintf("%.15g", cos(-1.0000000000000002))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", cos(-2.1073424255447e-08))));
_gc(xasprintf("%.15g", cos(-1.0000000000000002))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", cos(-2.1073424255447e-08))));
}
BENCH(cos, bench) {

2
test/libc/tinymath/cosh_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

7
test/libc/tinymath/csqrt_test.c
View file

@ -17,12 +17,11 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/complex.h"
#include "libc/fmt/fmt.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(csqrt, test) {
complex double x = csqrt(-1);
EXPECT_STREQ("0 1", gc(xasprintf("%g %g", creal(x), cimag(x))));
EXPECT_STREQ("0 1", _gc(xasprintf("%g %g", creal(x), cimag(x))));
}

2
test/libc/tinymath/erf_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/exp10_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/exp2_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/exp2l_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

51
test/libc/tinymath/exp_test.c
View file

@ -17,50 +17,51 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/stdio/stdio.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define expl(x) expl(VEIL("t", (long double)(x)))
#define exp(x) exp(VEIL("x", (double)(x)))
#define expf(x) expf(VEIL("x", (float)(x)))
TEST(expl, test) {
EXPECT_STREQ("1", gc(xdtoal(expl(0))));
EXPECT_STREQ("1", gc(xdtoal(expl(-0.))));
EXPECT_STREQ("INFINITY", gc(xdtoal(expl(INFINITY))));
EXPECT_STREQ("0", gc(xdtoal(expl(-INFINITY))));
EXPECT_STREQ("NAN", gc(xdtoal(expl(NAN))));
EXPECT_STREQ("0", gc(xdtoal(expl(-132098844872390))));
EXPECT_STREQ("INFINITY", gc(xdtoal(expl(132098844872390))));
EXPECT_STREQ("1", _gc(xdtoal(expl(0))));
EXPECT_STREQ("1", _gc(xdtoal(expl(-0.))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(expl(INFINITY))));
EXPECT_STREQ("0", _gc(xdtoal(expl(-INFINITY))));
EXPECT_STREQ("NAN", _gc(xdtoal(expl(NAN))));
EXPECT_STREQ("0", _gc(xdtoal(expl(-132098844872390))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(expl(132098844872390))));
}
TEST(exp, test) {
EXPECT_STREQ("1", gc(xdtoa(exp(0))));
EXPECT_STREQ("1", gc(xdtoa(exp(-0.))));
EXPECT_STREQ("INFINITY", gc(xdtoa(exp(INFINITY))));
EXPECT_STREQ("0", gc(xdtoa(exp(-INFINITY))));
EXPECT_STREQ("NAN", gc(xdtoa(exp(NAN))));
EXPECT_STREQ("0", gc(xdtoa(exp(-132098844872390))));
EXPECT_STREQ("INFINITY", gc(xdtoa(exp(132098844872390))));
EXPECT_STREQ("1", _gc(xdtoa(exp(0))));
EXPECT_STREQ("1", _gc(xdtoa(exp(-0.))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(exp(INFINITY))));
EXPECT_STREQ("0", _gc(xdtoa(exp(-INFINITY))));
EXPECT_STREQ("NAN", _gc(xdtoa(exp(NAN))));
EXPECT_STREQ("0", _gc(xdtoa(exp(-132098844872390))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(exp(132098844872390))));
}
TEST(expf, test) {
EXPECT_STREQ("1", gc(xdtoaf(expf(0))));
EXPECT_STREQ("1", gc(xdtoaf(expf(-0.))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(expf(INFINITY))));
EXPECT_STREQ("0", gc(xdtoaf(expf(-INFINITY))));
EXPECT_STREQ("NAN", gc(xdtoaf(expf(NAN))));
EXPECT_STREQ("0", gc(xdtoaf(expf(-132098844872390))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(expf(132098844872390))));
EXPECT_STREQ("1", _gc(xdtoaf(expf(0))));
EXPECT_STREQ("1", _gc(xdtoaf(expf(-0.))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(expf(INFINITY))));
EXPECT_STREQ("0", _gc(xdtoaf(expf(-INFINITY))));
EXPECT_STREQ("NAN", _gc(xdtoaf(expf(NAN))));
EXPECT_STREQ("0", _gc(xdtoaf(expf(-132098844872390))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(expf(132098844872390))));
}
TEST(exp, fun) {
ASSERT_STREQ("7.389056", gc(xasprintf("%f", exp(2.0))));
ASSERT_STREQ("6.389056", gc(xasprintf("%f", expm1(2.0))));
ASSERT_STREQ("6.389056", gc(xasprintf("%f", exp(2.0) - 1.0)));
ASSERT_STREQ("7.389056", _gc(xasprintf("%f", exp(2.0))));
ASSERT_STREQ("6.389056", _gc(xasprintf("%f", expm1(2.0))));
ASSERT_STREQ("6.389056", _gc(xasprintf("%f", exp(2.0) - 1.0)));
}
BENCH(expl, bench) {

75
test/libc/tinymath/expm1_test.c
View file

@ -17,58 +17,59 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define expm1l(x) expm1l(VEIL("t", (long double)(x)))
#define expm1(x) expm1(VEIL("x", (double)(x)))
#define expm1f(x) expm1f(VEIL("x", (float)(x)))
TEST(expm1, test) {
EXPECT_STREQ("0", gc(xdtoa(expm1(0))));
EXPECT_STREQ("-0", gc(xdtoa(expm1(-0.))));
EXPECT_STREQ("NAN", gc(xdtoa(expm1(NAN))));
EXPECT_STREQ("-1", gc(xdtoa(expm1(-INFINITY))));
EXPECT_STREQ("INFINITY", gc(xdtoa(expm1(INFINITY))));
/* EXPECT_STREQ("-INFINITY", gc(xdtoa(expm1(-132098844872390)))); */
/* EXPECT_STREQ("INFINITY", gc(xdtoa(expm1(132098844872390)))); */
EXPECT_STREQ("0", gc(xasprintf("%.15g", expm1(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", expm1(-0.))));
EXPECT_STREQ("0.648721270700128", gc(xasprintf("%.15g", expm1(.5))));
EXPECT_STREQ("-0.393469340287367", gc(xasprintf("%.15g", expm1(-.5))));
EXPECT_STREQ("1.71828182845905", gc(xasprintf("%.15g", expm1(1.))));
EXPECT_STREQ("-0.632120558828558", gc(xasprintf("%.15g", expm1(-1.))));
EXPECT_STREQ("3.48168907033806", gc(xasprintf("%.15g", expm1(1.5))));
EXPECT_STREQ("-0.77686983985157", gc(xasprintf("%.15g", expm1(-1.5))));
EXPECT_STREQ("6.38905609893065", gc(xasprintf("%.15g", expm1(2.))));
EXPECT_STREQ("0", _gc(xdtoa(expm1(0))));
EXPECT_STREQ("-0", _gc(xdtoa(expm1(-0.))));
EXPECT_STREQ("NAN", _gc(xdtoa(expm1(NAN))));
EXPECT_STREQ("-1", _gc(xdtoa(expm1(-INFINITY))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(expm1(INFINITY))));
/* EXPECT_STREQ("-INFINITY", _gc(xdtoa(expm1(-132098844872390)))); */
/* EXPECT_STREQ("INFINITY", _gc(xdtoa(expm1(132098844872390)))); */
EXPECT_STREQ("0", _gc(xasprintf("%.15g", expm1(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", expm1(-0.))));
EXPECT_STREQ("0.648721270700128", _gc(xasprintf("%.15g", expm1(.5))));
EXPECT_STREQ("-0.393469340287367", _gc(xasprintf("%.15g", expm1(-.5))));
EXPECT_STREQ("1.71828182845905", _gc(xasprintf("%.15g", expm1(1.))));
EXPECT_STREQ("-0.632120558828558", _gc(xasprintf("%.15g", expm1(-1.))));
EXPECT_STREQ("3.48168907033806", _gc(xasprintf("%.15g", expm1(1.5))));
EXPECT_STREQ("-0.77686983985157", _gc(xasprintf("%.15g", expm1(-1.5))));
EXPECT_STREQ("6.38905609893065", _gc(xasprintf("%.15g", expm1(2.))));
EXPECT_TRUE(isnan(expm1(NAN)));
EXPECT_TRUE(isnan(expm1(-NAN)));
EXPECT_STREQ("inf", gc(xasprintf("%.15g", expm1(INFINITY))));
EXPECT_STREQ("-1", gc(xasprintf("%.15g", expm1(-INFINITY))));
EXPECT_STREQ("inf", _gc(xasprintf("%.15g", expm1(INFINITY))));
EXPECT_STREQ("-1", _gc(xasprintf("%.15g", expm1(-INFINITY))));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", expm1(__DBL_MIN__))));
EXPECT_STREQ("inf", gc(xasprintf("%.15g", expm1(__DBL_MAX__))));
_gc(xasprintf("%.15g", expm1(__DBL_MIN__))));
EXPECT_STREQ("inf", _gc(xasprintf("%.15g", expm1(__DBL_MAX__))));
}
TEST(expm1l, test) {
EXPECT_STREQ("1.718281828459045", gc(xdtoal(expm1l(1))));
EXPECT_STREQ("1.718281828459045", gc(xdtoal(expl(1) - 1)));
EXPECT_STREQ("0", gc(xdtoal(expm1l(0))));
EXPECT_STREQ("-0", gc(xdtoal(expm1l(-0.))));
EXPECT_STREQ("NAN", gc(xdtoal(expm1l(NAN))));
EXPECT_STREQ("-1", gc(xdtoal(expm1l(-INFINITY))));
EXPECT_STREQ("INFINITY", gc(xdtoal(expm1l(INFINITY))));
/* EXPECT_STREQ("-INFINITY", gc(xdtoal(expm1l(-132098844872390)))); */
/* EXPECT_STREQ("INFINITY", gc(xdtoal(expm1l(132098844872390)))); */
EXPECT_STREQ("1.718281828459045", _gc(xdtoal(expm1l(1))));
EXPECT_STREQ("1.718281828459045", _gc(xdtoal(expl(1) - 1)));
EXPECT_STREQ("0", _gc(xdtoal(expm1l(0))));
EXPECT_STREQ("-0", _gc(xdtoal(expm1l(-0.))));
EXPECT_STREQ("NAN", _gc(xdtoal(expm1l(NAN))));
EXPECT_STREQ("-1", _gc(xdtoal(expm1l(-INFINITY))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(expm1l(INFINITY))));
/* EXPECT_STREQ("-INFINITY", _gc(xdtoal(expm1l(-132098844872390)))); */
/* EXPECT_STREQ("INFINITY", _gc(xdtoal(expm1l(132098844872390)))); */
}
TEST(expm1f, test) {
EXPECT_STREQ("0", gc(xdtoaf(expm1f(0))));
EXPECT_STREQ("-0", gc(xdtoaf(expm1f(-0.))));
EXPECT_STREQ("NAN", gc(xdtoaf(expm1f(NAN))));
EXPECT_STREQ("-1", gc(xdtoaf(expm1f(-INFINITY))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(expm1f(INFINITY))));
/* EXPECT_STREQ("-INFINITY", gc(xdtoaf(expm1f(-132098844872390)))); */
/* EXPECT_STREQ("INFINITY", gc(xdtoaf(expm1f(132098844872390)))); */
EXPECT_STREQ("0", _gc(xdtoaf(expm1f(0))));
EXPECT_STREQ("-0", _gc(xdtoaf(expm1f(-0.))));
EXPECT_STREQ("NAN", _gc(xdtoaf(expm1f(NAN))));
EXPECT_STREQ("-1", _gc(xdtoaf(expm1f(-INFINITY))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(expm1f(INFINITY))));
/* EXPECT_STREQ("-INFINITY", _gc(xdtoaf(expm1f(-132098844872390)))); */
/* EXPECT_STREQ("INFINITY", _gc(xdtoaf(expm1f(132098844872390)))); */
}

2
test/libc/tinymath/fabs_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/floor_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/fmod_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/stdio/rand.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"

8
test/libc/tinymath/fsum_test.c
View file

@ -18,10 +18,10 @@
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/macros.internal.h"
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define N 100000
@ -41,11 +41,11 @@ void SetUp(void) {
}
TEST(fsum, test) {
EXPECT_STREQ("500000000.6", gc(xasprintf("%.15g", fsum(D, N) / N)));
EXPECT_STREQ("500000000.6", _gc(xasprintf("%.15g", fsum(D, N) / N)));
}
TEST(fsumf, test) {
EXPECT_STREQ("500.6", gc(xasprintf("%.7g", fsumf(F, N) / N)));
EXPECT_STREQ("500.6", _gc(xasprintf("%.7g", fsumf(F, N) / N)));
}
BENCH(fsum, bench) {

2
test/libc/tinymath/gamma_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/hypot_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

131
test/libc/tinymath/ldexp_test.c
View file

@ -17,12 +17,13 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/mem/gc.h"
#include "libc/stdio/rand.h"
#include "libc/runtime/gc.internal.h"
#include "libc/stdio/stdio.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
int rando;
@ -32,83 +33,83 @@ void SetUp(void) {
TEST(ldexpl, test) {
EXPECT_EQ(rando, ldexpl(rando, 0));
EXPECT_STREQ("NAN", gc(xdtoal(ldexpl(NAN, 0))));
EXPECT_STREQ("-NAN", gc(xdtoal(ldexpl(-NAN, 0))));
EXPECT_STREQ("INFINITY", gc(xdtoal(ldexpl(INFINITY, 0))));
EXPECT_STREQ("-INFINITY", gc(xdtoal(ldexpl(-INFINITY, 0))));
EXPECT_STREQ("NAN", gc(xdtoal(ldexpl(NAN, 1))));
EXPECT_STREQ("-NAN", gc(xdtoal(ldexpl(-NAN, 1))));
EXPECT_STREQ("INFINITY", gc(xdtoal(ldexpl(INFINITY, 1))));
EXPECT_STREQ("-INFINITY", gc(xdtoal(ldexpl(-INFINITY, 1))));
EXPECT_STREQ("16384", gc(xdtoal(log2l(LDBL_MAX))));
EXPECT_STREQ(".00390625", gc(xdtoal(ldexpl(1, -8))));
EXPECT_STREQ("0", gc(xdtoal(ldexpl(0, -8))));
EXPECT_STREQ("0", gc(xdtoal(ldexpl(0, 8))));
EXPECT_STREQ("256", gc(xdtoal(ldexpl(1, 8))));
EXPECT_STREQ("512", gc(xdtoal(ldexpl(2, 8))));
EXPECT_STREQ("768", gc(xdtoal(ldexpl(3, 8))));
EXPECT_STREQ("6.997616471358197e+3461", gc(xdtoal(ldexpl(1, 11500))));
EXPECT_STREQ("INFINITY", gc(xdtoal(ldexpl(1, 999999))));
EXPECT_STREQ("0", gc(xdtoal(ldexpl(1, -999999))));
EXPECT_STREQ("NAN", _gc(xdtoal(ldexpl(NAN, 0))));
EXPECT_STREQ("-NAN", _gc(xdtoal(ldexpl(-NAN, 0))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(ldexpl(INFINITY, 0))));
EXPECT_STREQ("-INFINITY", _gc(xdtoal(ldexpl(-INFINITY, 0))));
EXPECT_STREQ("NAN", _gc(xdtoal(ldexpl(NAN, 1))));
EXPECT_STREQ("-NAN", _gc(xdtoal(ldexpl(-NAN, 1))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(ldexpl(INFINITY, 1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoal(ldexpl(-INFINITY, 1))));
EXPECT_STREQ("16384", _gc(xdtoal(log2l(LDBL_MAX))));
EXPECT_STREQ(".00390625", _gc(xdtoal(ldexpl(1, -8))));
EXPECT_STREQ("0", _gc(xdtoal(ldexpl(0, -8))));
EXPECT_STREQ("0", _gc(xdtoal(ldexpl(0, 8))));
EXPECT_STREQ("256", _gc(xdtoal(ldexpl(1, 8))));
EXPECT_STREQ("512", _gc(xdtoal(ldexpl(2, 8))));
EXPECT_STREQ("768", _gc(xdtoal(ldexpl(3, 8))));
EXPECT_STREQ("6.997616471358197e+3461", _gc(xdtoal(ldexpl(1, 11500))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(ldexpl(1, 999999))));
EXPECT_STREQ("0", _gc(xdtoal(ldexpl(1, -999999))));
}
TEST(ldexp, test) {
EXPECT_EQ(rando, ldexp(rando, 0));
EXPECT_STREQ("NAN", gc(xdtoa(ldexp(NAN, 0))));
EXPECT_STREQ("-NAN", gc(xdtoa(ldexp(-NAN, 0))));
EXPECT_STREQ("INFINITY", gc(xdtoa(ldexp(INFINITY, 0))));
EXPECT_STREQ("-INFINITY", gc(xdtoa(ldexp(-INFINITY, 0))));
EXPECT_STREQ("NAN", gc(xdtoa(ldexp(NAN, 1))));
EXPECT_STREQ("-NAN", gc(xdtoa(ldexp(-NAN, 1))));
EXPECT_STREQ("INFINITY", gc(xdtoa(ldexp(INFINITY, 1))));
EXPECT_STREQ("-INFINITY", gc(xdtoa(ldexp(-INFINITY, 1))));
EXPECT_STREQ("16384", gc(xdtoa(log2l(LDBL_MAX))));
EXPECT_STREQ(".00390625", gc(xdtoa(ldexp(1, -8))));
EXPECT_STREQ("0", gc(xdtoa(ldexp(0, -8))));
EXPECT_STREQ("0", gc(xdtoa(ldexp(0, 8))));
EXPECT_STREQ("256", gc(xdtoa(ldexp(1, 8))));
EXPECT_STREQ("512", gc(xdtoa(ldexp(2, 8))));
EXPECT_STREQ("768", gc(xdtoa(ldexp(3, 8))));
EXPECT_STREQ("INFINITY", gc(xdtoa(ldexp(1, 999999))));
EXPECT_STREQ("0", gc(xdtoa(ldexp(1, -999999))));
EXPECT_STREQ("NAN", _gc(xdtoa(ldexp(NAN, 0))));
EXPECT_STREQ("-NAN", _gc(xdtoa(ldexp(-NAN, 0))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(ldexp(INFINITY, 0))));
EXPECT_STREQ("-INFINITY", _gc(xdtoa(ldexp(-INFINITY, 0))));
EXPECT_STREQ("NAN", _gc(xdtoa(ldexp(NAN, 1))));
EXPECT_STREQ("-NAN", _gc(xdtoa(ldexp(-NAN, 1))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(ldexp(INFINITY, 1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoa(ldexp(-INFINITY, 1))));
EXPECT_STREQ("16384", _gc(xdtoa(log2l(LDBL_MAX))));
EXPECT_STREQ(".00390625", _gc(xdtoa(ldexp(1, -8))));
EXPECT_STREQ("0", _gc(xdtoa(ldexp(0, -8))));
EXPECT_STREQ("0", _gc(xdtoa(ldexp(0, 8))));
EXPECT_STREQ("256", _gc(xdtoa(ldexp(1, 8))));
EXPECT_STREQ("512", _gc(xdtoa(ldexp(2, 8))));
EXPECT_STREQ("768", _gc(xdtoa(ldexp(3, 8))));
EXPECT_STREQ("INFINITY", _gc(xdtoa(ldexp(1, 999999))));
EXPECT_STREQ("0", _gc(xdtoa(ldexp(1, -999999))));
}
TEST(ldexpf, test) {
EXPECT_EQ(rando, ldexpf(rando, 0));
EXPECT_STREQ("NAN", gc(xdtoaf(ldexpf(NAN, 0))));
EXPECT_STREQ("-NAN", gc(xdtoaf(ldexpf(-NAN, 0))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(ldexpf(INFINITY, 0))));
EXPECT_STREQ("-INFINITY", gc(xdtoaf(ldexpf(-INFINITY, 0))));
EXPECT_STREQ("NAN", gc(xdtoaf(ldexpf(NAN, 1))));
EXPECT_STREQ("-NAN", gc(xdtoaf(ldexpf(-NAN, 1))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(ldexpf(INFINITY, 1))));
EXPECT_STREQ("-INFINITY", gc(xdtoaf(ldexpf(-INFINITY, 1))));
EXPECT_STREQ("16384", gc(xdtoaf(log2l(LDBL_MAX))));
EXPECT_STREQ(".00390625", gc(xdtoaf(ldexpf(1, -8))));
EXPECT_STREQ("0", gc(xdtoaf(ldexpf(0, -8))));
EXPECT_STREQ("0", gc(xdtoaf(ldexpf(0, 8))));
EXPECT_STREQ("256", gc(xdtoaf(ldexpf(1, 8))));
EXPECT_STREQ("512", gc(xdtoaf(ldexpf(2, 8))));
EXPECT_STREQ("768", gc(xdtoaf(ldexpf(3, 8))));
EXPECT_STREQ("INFINITY", gc(xdtoaf(ldexpf(1, 999999))));
EXPECT_STREQ("0", gc(xdtoaf(ldexpf(1, -999999))));
EXPECT_STREQ("NAN", _gc(xdtoaf(ldexpf(NAN, 0))));
EXPECT_STREQ("-NAN", _gc(xdtoaf(ldexpf(-NAN, 0))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(ldexpf(INFINITY, 0))));
EXPECT_STREQ("-INFINITY", _gc(xdtoaf(ldexpf(-INFINITY, 0))));
EXPECT_STREQ("NAN", _gc(xdtoaf(ldexpf(NAN, 1))));
EXPECT_STREQ("-NAN", _gc(xdtoaf(ldexpf(-NAN, 1))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(ldexpf(INFINITY, 1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoaf(ldexpf(-INFINITY, 1))));
EXPECT_STREQ("16384", _gc(xdtoaf(log2l(LDBL_MAX))));
EXPECT_STREQ(".00390625", _gc(xdtoaf(ldexpf(1, -8))));
EXPECT_STREQ("0", _gc(xdtoaf(ldexpf(0, -8))));
EXPECT_STREQ("0", _gc(xdtoaf(ldexpf(0, 8))));
EXPECT_STREQ("256", _gc(xdtoaf(ldexpf(1, 8))));
EXPECT_STREQ("512", _gc(xdtoaf(ldexpf(2, 8))));
EXPECT_STREQ("768", _gc(xdtoaf(ldexpf(3, 8))));
EXPECT_STREQ("INFINITY", _gc(xdtoaf(ldexpf(1, 999999))));
EXPECT_STREQ("0", _gc(xdtoaf(ldexpf(1, -999999))));
}
TEST(ldexp, stuff) {
volatile int twopow = 5;
volatile double pi = 3.14;
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", ldexp(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", ldexpf(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2Lf", ldexpl(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", scalb(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", scalbf(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2Lf", scalbl(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", scalbn(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", scalbnf(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2Lf", scalbnl(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", scalbln(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2f", scalblnf(pi, twopow))));
ASSERT_STREQ("100.48", gc(xasprintf("%.2Lf", scalblnl(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", ldexp(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", ldexpf(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2Lf", ldexpl(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", scalb(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", scalbf(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2Lf", scalbl(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", scalbn(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", scalbnf(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2Lf", scalbnl(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", scalbln(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2f", scalblnf(pi, twopow))));
ASSERT_STREQ("100.48", _gc(xasprintf("%.2Lf", scalblnl(pi, twopow))));
}
BENCH(ldexpl, bench) {

2
test/libc/tinymath/log10_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/log1p_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/log2_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/log_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/measureentropy_test.c
View file

@ -18,7 +18,7 @@
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/stdio/rand.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/hyperion.h"
#include "libc/testlib/testlib.h"

129
test/libc/tinymath/powl_test.c
View file

@ -23,15 +23,16 @@
#include "libc/fmt/fmt.h"
#include "libc/macros.internal.h"
#include "libc/math.h"
#include "libc/stdio/rand.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/runtime/pc.internal.h"
#include "libc/stdio/rand.h"
#include "libc/stdio/stdio.h"
#include "libc/sysv/consts/sa.h"
#include "libc/sysv/consts/sig.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
int rando;
char buf[128];
@ -55,57 +56,57 @@ static char *fmtf(float x) {
}
TEST(powl, test) {
EXPECT_STREQ("27", gc(xdtoal(powl(3, 3))));
EXPECT_STREQ("-27", gc(xdtoal(powl(-3, 3))));
EXPECT_STREQ("1e+4932", gc(xdtoal(powl(10, 4932))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(10, 4933))));
EXPECT_STREQ("0", gc(xdtoal(powl(10, -5000))));
EXPECT_STREQ("1.063382396627933e+37", gc(xdtoal(powl(2, 123))));
EXPECT_STARTSWITH(".4248496805467504", gc(xdtoal(powl(.7, 2.4))));
EXPECT_STREQ("1", gc(xdtoal(powl(1, NAN))));
EXPECT_STREQ("1", gc(xdtoal(powl(1, rando))));
EXPECT_STREQ("1", gc(xdtoal(powl(NAN, 0))));
EXPECT_STREQ("1", gc(xdtoal(powl(rando, 0))));
EXPECT_STREQ("0", gc(xdtoal(powl(0, 1))));
EXPECT_STREQ("0", gc(xdtoal(powl(0, 2))));
EXPECT_STREQ("0", gc(xdtoal(powl(0, 2.1))));
EXPECT_STREQ("1", gc(xdtoal(powl(-1, INFINITY))));
EXPECT_STREQ("1", gc(xdtoal(powl(-1, -INFINITY))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(1. / MAX(2, rando), -INFINITY))));
EXPECT_STREQ("0", gc(xdtoal(powl(1.1, -INFINITY))));
EXPECT_STREQ("0", gc(xdtoal(powl(MAX(2, rando), -INFINITY))));
EXPECT_STREQ("0", gc(xdtoal(powl(1. / MAX(2, rando), INFINITY))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(MAX(2, rando), INFINITY))));
EXPECT_STREQ("-0", gc(xdtoal(powl(-INFINITY, -1))));
EXPECT_STREQ("0", gc(xdtoal(powl(-INFINITY, -1.1))));
EXPECT_STREQ("0", gc(xdtoal(powl(-INFINITY, -2))));
EXPECT_STREQ("0", gc(xdtoal(powl(-INFINITY, -2.1))));
EXPECT_STREQ("-0", gc(xdtoal(powl(-INFINITY, -3))));
EXPECT_STREQ("0", gc(xdtoal(powl(-INFINITY, -3.1))));
EXPECT_STREQ("-INFINITY", gc(xdtoal(powl(-INFINITY, 1))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(-INFINITY, 1.1))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(-INFINITY, 2))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(-INFINITY, 2.1))));
EXPECT_STREQ("-INFINITY", gc(xdtoal(powl(-INFINITY, 3))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(-INFINITY, 3.1))));
EXPECT_STREQ("0", gc(xdtoal(powl(INFINITY, -1))));
EXPECT_STREQ("0", gc(xdtoal(powl(INFINITY, -.1))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(INFINITY, 1))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(INFINITY, .1))));
EXPECT_STREQ("1", gc(xdtoal(powl(INFINITY, 0))));
EXPECT_STREQ("1", gc(xdtoal(powl(INFINITY, -0.))));
EXPECT_STREQ("1", gc(xdtoal(powl(0, 0))));
EXPECT_STREQ("1", gc(xdtoal(powl(0, -0.))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(0, -(MAX(rando, 1) | 1)))));
EXPECT_STREQ("-INFINITY", gc(xdtoal(powl(-0., -(MAX(rando, 1) | 1)))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(0, -(rando & -2)))));
EXPECT_STREQ("INFINITY", gc(xdtoal(powl(-0., -(rando & -2)))));
EXPECT_STREQ("27", _gc(xdtoal(powl(3, 3))));
EXPECT_STREQ("-27", _gc(xdtoal(powl(-3, 3))));
EXPECT_STREQ("1e+4932", _gc(xdtoal(powl(10, 4932))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(10, 4933))));
EXPECT_STREQ("0", _gc(xdtoal(powl(10, -5000))));
EXPECT_STREQ("1.063382396627933e+37", _gc(xdtoal(powl(2, 123))));
EXPECT_STARTSWITH(".4248496805467504", _gc(xdtoal(powl(.7, 2.4))));
EXPECT_STREQ("1", _gc(xdtoal(powl(1, NAN))));
EXPECT_STREQ("1", _gc(xdtoal(powl(1, rando))));
EXPECT_STREQ("1", _gc(xdtoal(powl(NAN, 0))));
EXPECT_STREQ("1", _gc(xdtoal(powl(rando, 0))));
EXPECT_STREQ("0", _gc(xdtoal(powl(0, 1))));
EXPECT_STREQ("0", _gc(xdtoal(powl(0, 2))));
EXPECT_STREQ("0", _gc(xdtoal(powl(0, 2.1))));
EXPECT_STREQ("1", _gc(xdtoal(powl(-1, INFINITY))));
EXPECT_STREQ("1", _gc(xdtoal(powl(-1, -INFINITY))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(1. / MAX(2, rando), -INFINITY))));
EXPECT_STREQ("0", _gc(xdtoal(powl(1.1, -INFINITY))));
EXPECT_STREQ("0", _gc(xdtoal(powl(MAX(2, rando), -INFINITY))));
EXPECT_STREQ("0", _gc(xdtoal(powl(1. / MAX(2, rando), INFINITY))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(MAX(2, rando), INFINITY))));
EXPECT_STREQ("-0", _gc(xdtoal(powl(-INFINITY, -1))));
EXPECT_STREQ("0", _gc(xdtoal(powl(-INFINITY, -1.1))));
EXPECT_STREQ("0", _gc(xdtoal(powl(-INFINITY, -2))));
EXPECT_STREQ("0", _gc(xdtoal(powl(-INFINITY, -2.1))));
EXPECT_STREQ("-0", _gc(xdtoal(powl(-INFINITY, -3))));
EXPECT_STREQ("0", _gc(xdtoal(powl(-INFINITY, -3.1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoal(powl(-INFINITY, 1))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(-INFINITY, 1.1))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(-INFINITY, 2))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(-INFINITY, 2.1))));
EXPECT_STREQ("-INFINITY", _gc(xdtoal(powl(-INFINITY, 3))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(-INFINITY, 3.1))));
EXPECT_STREQ("0", _gc(xdtoal(powl(INFINITY, -1))));
EXPECT_STREQ("0", _gc(xdtoal(powl(INFINITY, -.1))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(INFINITY, 1))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(INFINITY, .1))));
EXPECT_STREQ("1", _gc(xdtoal(powl(INFINITY, 0))));
EXPECT_STREQ("1", _gc(xdtoal(powl(INFINITY, -0.))));
EXPECT_STREQ("1", _gc(xdtoal(powl(0, 0))));
EXPECT_STREQ("1", _gc(xdtoal(powl(0, -0.))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(0, -(MAX(rando, 1) | 1)))));
EXPECT_STREQ("-INFINITY", _gc(xdtoal(powl(-0., -(MAX(rando, 1) | 1)))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(0, -(rando & -2)))));
EXPECT_STREQ("INFINITY", _gc(xdtoal(powl(-0., -(rando & -2)))));
EXPECT_TRUE(isnan(powl(-3, 1. / MAX(rando, 2))));
EXPECT_TRUE(isnan(powl(-3, -(1. / MAX(rando, 2)))));
EXPECT_STREQ("-.3333333333333333", gc(xdtoal(powl(-3, -1))));
EXPECT_STREQ(".1111111111111111", gc(xdtoal(powl(-3, -2))));
EXPECT_STREQ("-0", gc(xdtoal(powl(-0., MAX(1, rando) | 1))));
EXPECT_STREQ("0", gc(xdtoal(powl(-0., MAX(1, rando) & ~1))));
EXPECT_STREQ("-.3333333333333333", _gc(xdtoal(powl(-3, -1))));
EXPECT_STREQ(".1111111111111111", _gc(xdtoal(powl(-3, -2))));
EXPECT_STREQ("-0", _gc(xdtoal(powl(-0., MAX(1, rando) | 1))));
EXPECT_STREQ("0", _gc(xdtoal(powl(-0., MAX(1, rando) & ~1))));
}
TEST(pow, test) {
@ -156,8 +157,8 @@ TEST(pow, test) {
EXPECT_STREQ("inf", fmtd(pow(-0., -(rando & -2))));
EXPECT_STREQ("-0.333333333333333", fmtd(pow(-3, -1)));
EXPECT_STREQ("0.111111111111111", fmtd(pow(-3, -2)));
EXPECT_STREQ("-0", gc(xdtoa(pow(-0., MAX(1, rando) | 1))));
EXPECT_STREQ("0", gc(xdtoa(pow(-0., MAX(1, rando) & ~1))));
EXPECT_STREQ("-0", _gc(xdtoa(pow(-0., MAX(1, rando) | 1))));
EXPECT_STREQ("0", _gc(xdtoa(pow(-0., MAX(1, rando) & ~1))));
}
TEST(powf, test) {
@ -208,8 +209,8 @@ TEST(powf, test) {
EXPECT_STREQ("inf", fmtf(powf(-0., -(rando & -2))));
EXPECT_STREQ("-0.333333", fmtf(powf(-3, -1)));
EXPECT_STREQ("0.111111", fmtf(powf(-3, -2)));
EXPECT_STREQ("-0", gc(xdtoaf(powf(-0., MAX(1, rando) | 1))));
EXPECT_STREQ("0", gc(xdtoaf(powf(-0., MAX(1, rando) & ~1))));
EXPECT_STREQ("-0", _gc(xdtoaf(powf(-0., MAX(1, rando) | 1))));
EXPECT_STREQ("0", _gc(xdtoaf(powf(-0., MAX(1, rando) & ~1))));
}
TEST(powl, errors) {
@ -547,15 +548,15 @@ TEST(powl, errors) {
errno = 0;
EXPECT_STREQ("inf", fmtd(POW(__DBL_MAX__, __DBL_MAX__)));
/* EXPECT_EQ(ERANGE, errno); */
EXPECT_STREQ("1", gc(xasprintf("%.15g", POW(0., 0))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", POW(-0., 0))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", POW(-0., 1))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", POW(-0., 11))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", POW(-0., 111))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", POW(-0., 2))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", POW(-0., 22))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", POW(-0., 222))));
EXPECT_STREQ("0", gc(xasprintf("%.15g", POW(-0., 2.5))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", POW(0., 0))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", POW(-0., 0))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", POW(-0., 1))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", POW(-0., 11))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", POW(-0., 111))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", POW(-0., 2))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", POW(-0., 22))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", POW(-0., 222))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", POW(-0., 2.5))));
}
BENCH(powl, bench) {

2
test/libc/tinymath/round_test.c
View file

@ -18,7 +18,7 @@
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

58
test/libc/tinymath/sin_test.c
View file

@ -17,59 +17,61 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define sinl(x) sinl(VEIL("t", (long double)(x)))
#define sin(x) sin(VEIL("x", (double)(x)))
#define sinf(x) sinf(VEIL("x", (float)(x)))
TEST(sinl, test) {
EXPECT_STREQ("NAN", gc(xdtoal(sinl(NAN))));
EXPECT_STREQ("-NAN", gc(xdtoal(sinl(+INFINITY))));
EXPECT_STREQ("-NAN", gc(xdtoal(sinl(-INFINITY))));
EXPECT_STREQ(".479425538604203", gc(xdtoal(sinl(.5))));
EXPECT_STREQ("-.479425538604203", gc(xdtoal(sinl(-.5))));
EXPECT_STREQ(".8414709794048734", gc(xdtoal(sinl(.99999999))));
/* EXPECT_STREQ("-.998836772397", gc(xdtoal(sinl(555555555555)))); */
/* EXPECT_STREQ("1", gc(xdtoal(sinl(5.319372648326541e+255L)))); */
EXPECT_STREQ("NAN", _gc(xdtoal(sinl(NAN))));
EXPECT_STREQ("-NAN", _gc(xdtoal(sinl(+INFINITY))));
EXPECT_STREQ("-NAN", _gc(xdtoal(sinl(-INFINITY))));
EXPECT_STREQ(".479425538604203", _gc(xdtoal(sinl(.5))));
EXPECT_STREQ("-.479425538604203", _gc(xdtoal(sinl(-.5))));
EXPECT_STREQ(".8414709794048734", _gc(xdtoal(sinl(.99999999))));
/* EXPECT_STREQ("-.998836772397", _gc(xdtoal(sinl(555555555555)))); */
/* EXPECT_STREQ("1", _gc(xdtoal(sinl(5.319372648326541e+255L)))); */
}
TEST(sin, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", sin(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", sin(-0.))));
EXPECT_STREQ("0.0998334166468282", gc(xasprintf("%.15g", sin(.1))));
EXPECT_STREQ("-0.0998334166468282", gc(xasprintf("%.15g", sin(-.1))));
EXPECT_STREQ("0.479425538604203", gc(xasprintf("%.15g", sin(.5))));
EXPECT_STREQ("-0.479425538604203", gc(xasprintf("%.15g", sin(-.5))));
EXPECT_STREQ("0.841470984807897", gc(xasprintf("%.15g", sin(1.))));
EXPECT_STREQ("-0.841470984807897", gc(xasprintf("%.15g", sin(-1.))));
EXPECT_STREQ("0.997494986604054", gc(xasprintf("%.15g", sin(1.5))));
EXPECT_STREQ("-0.997494986604054", gc(xasprintf("%.15g", sin(-1.5))));
EXPECT_STREQ("0.909297426825682", gc(xasprintf("%.15g", sin(2.))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", sin(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", sin(-0.))));
EXPECT_STREQ("0.0998334166468282", _gc(xasprintf("%.15g", sin(.1))));
EXPECT_STREQ("-0.0998334166468282", _gc(xasprintf("%.15g", sin(-.1))));
EXPECT_STREQ("0.479425538604203", _gc(xasprintf("%.15g", sin(.5))));
EXPECT_STREQ("-0.479425538604203", _gc(xasprintf("%.15g", sin(-.5))));
EXPECT_STREQ("0.841470984807897", _gc(xasprintf("%.15g", sin(1.))));
EXPECT_STREQ("-0.841470984807897", _gc(xasprintf("%.15g", sin(-1.))));
EXPECT_STREQ("0.997494986604054", _gc(xasprintf("%.15g", sin(1.5))));
EXPECT_STREQ("-0.997494986604054", _gc(xasprintf("%.15g", sin(-1.5))));
EXPECT_STREQ("0.909297426825682", _gc(xasprintf("%.15g", sin(2.))));
EXPECT_TRUE(isnan(sin(NAN)));
EXPECT_TRUE(isnan(sin(-NAN)));
EXPECT_TRUE(isnan(sin(INFINITY)));
EXPECT_TRUE(isnan(sin(-INFINITY)));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", sin(__DBL_MIN__))));
EXPECT_STREQ("0.00496195478918406", gc(xasprintf("%.15g", sin(__DBL_MAX__))));
_gc(xasprintf("%.15g", sin(__DBL_MIN__))));
EXPECT_STREQ("0.00496195478918406",
_gc(xasprintf("%.15g", sin(__DBL_MAX__))));
EXPECT_STREQ("-0.841470984807897",
gc(xasprintf("%.15g", sin(-1.0000000000000002))));
_gc(xasprintf("%.15g", sin(-1.0000000000000002))));
EXPECT_STREQ("-2.1073424255447e-08",
gc(xasprintf("%.15g", sin(-2.1073424255447e-08))));
_gc(xasprintf("%.15g", sin(-2.1073424255447e-08))));
}
TEST(sinf, test) {
EXPECT_TRUE(isnan(sinf(NAN)));
EXPECT_TRUE(isnan(sinf(+INFINITY)));
EXPECT_TRUE(isnan(sinf(-INFINITY)));
EXPECT_STREQ("NAN", gc(xdtoaf(sinf(NAN))));
EXPECT_STARTSWITH(".479426", gc(xdtoaf(sinf(.5f))));
EXPECT_STARTSWITH("-.479426", gc(xdtoaf(sinf(-.5f))));
EXPECT_STARTSWITH(".873283", gc(xdtoaf(sinf(555))));
EXPECT_STREQ("NAN", _gc(xdtoaf(sinf(NAN))));
EXPECT_STARTSWITH(".479426", _gc(xdtoaf(sinf(.5f))));
EXPECT_STARTSWITH("-.479426", _gc(xdtoaf(sinf(-.5f))));
EXPECT_STARTSWITH(".873283", _gc(xdtoaf(sinf(555))));
}
BENCH(sin, bench) {

16
test/libc/tinymath/sincos_test.c
View file

@ -17,30 +17,30 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(sincos, test) {
double sine, cosine;
sincos(.1, &sine, &cosine);
EXPECT_STREQ("0.0998334166468282", gc(xasprintf("%.15g", sine)));
EXPECT_STREQ("0.995004165278026", gc(xasprintf("%.15g", cosine)));
EXPECT_STREQ("0.0998334166468282", _gc(xasprintf("%.15g", sine)));
EXPECT_STREQ("0.995004165278026", _gc(xasprintf("%.15g", cosine)));
}
TEST(sincosf, test) {
float sine, cosine;
sincosf(.1, &sine, &cosine);
EXPECT_STREQ("0.0998334", gc(xasprintf("%.6g", sine)));
EXPECT_STREQ("0.995004", gc(xasprintf("%.6g", cosine)));
EXPECT_STREQ("0.0998334", _gc(xasprintf("%.6g", sine)));
EXPECT_STREQ("0.995004", _gc(xasprintf("%.6g", cosine)));
}
TEST(sincosl, test) {
long double sine, cosine;
sincosl(.1, &sine, &cosine);
EXPECT_STREQ("0.0998334166468282", gc(xasprintf("%.15Lg", sine)));
EXPECT_STREQ("0.995004165278026", gc(xasprintf("%.15Lg", cosine)));
EXPECT_STREQ("0.0998334166468282", _gc(xasprintf("%.15Lg", sine)));
EXPECT_STREQ("0.995004165278026", _gc(xasprintf("%.15Lg", cosine)));
}
#define NUM .123

2
test/libc/tinymath/sinh_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

2
test/libc/tinymath/sqrt_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"

10
test/libc/tinymath/strtod_test.c
View file

@ -18,12 +18,12 @@
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/fmt/fmt.h"
#include "libc/macros.internal.h"
#include "libc/mem/gc.h"
#include "libc/mem/mem.h"
#include "libc/runtime/fenv.h"
#include "libc/runtime/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#include "third_party/double-conversion/wrapper.h"
#include "third_party/gdtoa/gdtoa.h"
@ -379,19 +379,19 @@ TEST(strtod, test) {
TEST(strtod, testNearest) {
fesetround(FE_TONEAREST);
EXPECT_STREQ("-1.79769313486231e+308",
gc(xasprintf("%.15g", strtod("-1.79769313486231e+308", NULL))));
_gc(xasprintf("%.15g", strtod("-1.79769313486231e+308", NULL))));
}
TEST(strtod, testDownward) {
fesetround(FE_DOWNWARD);
EXPECT_STREQ("-1.79769313486232e+308",
gc(xasprintf("%.15g", strtod("-1.79769313486231e+308", NULL))));
_gc(xasprintf("%.15g", strtod("-1.79769313486231e+308", NULL))));
}
TEST(strtod, testUpward) {
fesetround(FE_UPWARD);
EXPECT_STREQ("-1.7976931348623e+308",
gc(xasprintf("%.15g", strtod("-1.79769313486231e+308", NULL))));
_gc(xasprintf("%.15g", strtod("-1.79769313486231e+308", NULL))));
}
TEST(strtod, testTowardzero) {

33
test/libc/tinymath/tan_test.c
View file

@ -17,27 +17,28 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(tan, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", tan(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", tan(-0.))));
EXPECT_STREQ("0.54630248984379", gc(xasprintf("%.15g", tan(.5))));
EXPECT_STREQ("-0.54630248984379", gc(xasprintf("%.15g", tan(-.5))));
EXPECT_STREQ("1.5574077246549", gc(xasprintf("%.15g", tan(1.))));
EXPECT_STREQ("-1.5574077246549", gc(xasprintf("%.15g", tan(-1.))));
EXPECT_STREQ("14.1014199471717", gc(xasprintf("%.15g", tan(1.5))));
EXPECT_STREQ("-14.1014199471717", gc(xasprintf("%.15g", tan(-1.5))));
EXPECT_STREQ("nan", gc(xasprintf("%.15g", tan(NAN))));
EXPECT_STREQ("-nan", gc(xasprintf("%.15g", tan(-NAN))));
EXPECT_STREQ("-nan", gc(xasprintf("%.15g", tan(INFINITY))));
EXPECT_STREQ("-nan", gc(xasprintf("%.15g", tan(-INFINITY))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", tan(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", tan(-0.))));
EXPECT_STREQ("0.54630248984379", _gc(xasprintf("%.15g", tan(.5))));
EXPECT_STREQ("-0.54630248984379", _gc(xasprintf("%.15g", tan(-.5))));
EXPECT_STREQ("1.5574077246549", _gc(xasprintf("%.15g", tan(1.))));
EXPECT_STREQ("-1.5574077246549", _gc(xasprintf("%.15g", tan(-1.))));
EXPECT_STREQ("14.1014199471717", _gc(xasprintf("%.15g", tan(1.5))));
EXPECT_STREQ("-14.1014199471717", _gc(xasprintf("%.15g", tan(-1.5))));
EXPECT_STREQ("nan", _gc(xasprintf("%.15g", tan(NAN))));
EXPECT_STREQ("-nan", _gc(xasprintf("%.15g", tan(-NAN))));
EXPECT_STREQ("-nan", _gc(xasprintf("%.15g", tan(INFINITY))));
EXPECT_STREQ("-nan", _gc(xasprintf("%.15g", tan(-INFINITY))));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", tan(__DBL_MIN__))));
EXPECT_STREQ("-0.0049620158744449", gc(xasprintf("%.15g", tan(__DBL_MAX__))));
_gc(xasprintf("%.15g", tan(__DBL_MIN__))));
EXPECT_STREQ("-0.0049620158744449",
_gc(xasprintf("%.15g", tan(__DBL_MAX__))));
}
BENCH(tan, bench) {

61
test/libc/tinymath/tanh_test.c
View file

@ -17,55 +17,56 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
#define tanhl(x) tanhl(VEIL("t", (long double)(x)))
#define tanh(x) tanh(VEIL("x", (double)(x)))
#define tanhf(x) tanhf(VEIL("x", (float)(x)))
TEST(tanhl, test) {
EXPECT_STREQ(".09966799462495582", gc(xdtoal(tanhl(+.1))));
EXPECT_STREQ("-.09966799462495582", gc(xdtoal(tanhl(-.1))));
EXPECT_STREQ("0", gc(xdtoal(tanhl(0))));
EXPECT_STREQ("-0", gc(xdtoal(tanhl(-0.))));
EXPECT_STREQ(".09966799462495582", _gc(xdtoal(tanhl(+.1))));
EXPECT_STREQ("-.09966799462495582", _gc(xdtoal(tanhl(-.1))));
EXPECT_STREQ("0", _gc(xdtoal(tanhl(0))));
EXPECT_STREQ("-0", _gc(xdtoal(tanhl(-0.))));
EXPECT_TRUE(isnan(tanhl(NAN)));
EXPECT_STREQ("1", gc(xdtoal(tanhl(INFINITY))));
EXPECT_STREQ("-1", gc(xdtoal(tanhl(-INFINITY))));
EXPECT_STREQ("1", _gc(xdtoal(tanhl(INFINITY))));
EXPECT_STREQ("-1", _gc(xdtoal(tanhl(-INFINITY))));
}
TEST(tanh, test) {
EXPECT_STREQ("0", gc(xasprintf("%.15g", tanh(0.))));
EXPECT_STREQ("-0", gc(xasprintf("%.15g", tanh(-0.))));
EXPECT_STREQ("0.0996679946249558", gc(xasprintf("%.15g", tanh(.1))));
EXPECT_STREQ("-0.0996679946249558", gc(xasprintf("%.15g", tanh(-.1))));
EXPECT_STREQ("0.46211715726001", gc(xasprintf("%.15g", tanh(.5))));
EXPECT_STREQ("-0.46211715726001", gc(xasprintf("%.15g", tanh(-.5))));
EXPECT_STREQ("0.761594155955765", gc(xasprintf("%.15g", tanh(1.))));
EXPECT_STREQ("-0.761594155955765", gc(xasprintf("%.15g", tanh(-1.))));
EXPECT_STREQ("0.905148253644866", gc(xasprintf("%.15g", tanh(1.5))));
EXPECT_STREQ("-0.905148253644866", gc(xasprintf("%.15g", tanh(-1.5))));
EXPECT_STREQ("0.964027580075817", gc(xasprintf("%.15g", tanh(2.))));
EXPECT_STREQ("0", _gc(xasprintf("%.15g", tanh(0.))));
EXPECT_STREQ("-0", _gc(xasprintf("%.15g", tanh(-0.))));
EXPECT_STREQ("0.0996679946249558", _gc(xasprintf("%.15g", tanh(.1))));
EXPECT_STREQ("-0.0996679946249558", _gc(xasprintf("%.15g", tanh(-.1))));
EXPECT_STREQ("0.46211715726001", _gc(xasprintf("%.15g", tanh(.5))));
EXPECT_STREQ("-0.46211715726001", _gc(xasprintf("%.15g", tanh(-.5))));
EXPECT_STREQ("0.761594155955765", _gc(xasprintf("%.15g", tanh(1.))));
EXPECT_STREQ("-0.761594155955765", _gc(xasprintf("%.15g", tanh(-1.))));
EXPECT_STREQ("0.905148253644866", _gc(xasprintf("%.15g", tanh(1.5))));
EXPECT_STREQ("-0.905148253644866", _gc(xasprintf("%.15g", tanh(-1.5))));
EXPECT_STREQ("0.964027580075817", _gc(xasprintf("%.15g", tanh(2.))));
EXPECT_TRUE(isnan(tanh(NAN)));
EXPECT_TRUE(isnan(tanh(-NAN)));
EXPECT_STREQ("1", gc(xasprintf("%.15g", tanh(INFINITY))));
EXPECT_STREQ("-1", gc(xasprintf("%.15g", tanh(-INFINITY))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", tanh(INFINITY))));
EXPECT_STREQ("-1", _gc(xasprintf("%.15g", tanh(-INFINITY))));
EXPECT_STREQ("2.2250738585072e-308",
gc(xasprintf("%.15g", tanh(__DBL_MIN__))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", tanh(__DBL_MAX__))));
_gc(xasprintf("%.15g", tanh(__DBL_MIN__))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", tanh(__DBL_MAX__))));
EXPECT_STREQ("-0.761594155955765",
gc(xasprintf("%.15g", tanh(-1.0000000000000002))));
_gc(xasprintf("%.15g", tanh(-1.0000000000000002))));
EXPECT_STREQ("-2.1073424255447e-08",
gc(xasprintf("%.15g", tanh(-2.1073424255447e-08))));
_gc(xasprintf("%.15g", tanh(-2.1073424255447e-08))));
}
TEST(tanhf, test) {
EXPECT_STREQ(".099668", gc(xdtoaf(tanhf(+.1))));
EXPECT_STREQ("-.099668", gc(xdtoaf(tanhf(-.1))));
EXPECT_STREQ("0", gc(xdtoaf(tanhf(0))));
EXPECT_STREQ("-0", gc(xdtoaf(tanhf(-0.))));
EXPECT_STREQ(".099668", _gc(xdtoaf(tanhf(+.1))));
EXPECT_STREQ("-.099668", _gc(xdtoaf(tanhf(-.1))));
EXPECT_STREQ("0", _gc(xdtoaf(tanhf(0))));
EXPECT_STREQ("-0", _gc(xdtoaf(tanhf(-0.))));
EXPECT_TRUE(isnan(tanhf(NAN)));
EXPECT_STREQ("1", gc(xdtoaf(tanhf(INFINITY))));
EXPECT_STREQ("-1", gc(xdtoaf(tanhf(-INFINITY))));
EXPECT_STREQ("1", _gc(xdtoaf(tanhf(INFINITY))));
EXPECT_STREQ("-1", _gc(xdtoaf(tanhf(-INFINITY))));
}

34
test/libc/tinymath/tgamma_test.c
View file

@ -17,31 +17,31 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
TEST(tgamma, test) {
EXPECT_STREQ("inf", gc(xasprintf("%.15g", tgamma(0.))));
EXPECT_STREQ("-inf", gc(xasprintf("%.15g", tgamma(-0.))));
EXPECT_STREQ("9.51350769866873", gc(xasprintf("%.15g", tgamma(.1))));
EXPECT_STREQ("-10.6862870211932", gc(xasprintf("%.15g", tgamma(-.1))));
EXPECT_STREQ("1.77245385090552", gc(xasprintf("%.15g", tgamma(.5))));
EXPECT_STREQ("-3.54490770181103", gc(xasprintf("%.15g", tgamma(-.5))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", tgamma(1.))));
EXPECT_STREQ("inf", _gc(xasprintf("%.15g", tgamma(0.))));
EXPECT_STREQ("-inf", _gc(xasprintf("%.15g", tgamma(-0.))));
EXPECT_STREQ("9.51350769866873", _gc(xasprintf("%.15g", tgamma(.1))));
EXPECT_STREQ("-10.6862870211932", _gc(xasprintf("%.15g", tgamma(-.1))));
EXPECT_STREQ("1.77245385090552", _gc(xasprintf("%.15g", tgamma(.5))));
EXPECT_STREQ("-3.54490770181103", _gc(xasprintf("%.15g", tgamma(-.5))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", tgamma(1.))));
EXPECT_TRUE(isnan(tgamma(-1.)));
EXPECT_STREQ("0.886226925452758", gc(xasprintf("%.15g", tgamma(1.5))));
EXPECT_STREQ("2.36327180120735", gc(xasprintf("%.15g", tgamma(-1.5))));
EXPECT_STREQ("1", gc(xasprintf("%.15g", tgamma(2.))));
EXPECT_STREQ("0.886226925452758", _gc(xasprintf("%.15g", tgamma(1.5))));
EXPECT_STREQ("2.36327180120735", _gc(xasprintf("%.15g", tgamma(-1.5))));
EXPECT_STREQ("1", _gc(xasprintf("%.15g", tgamma(2.))));
EXPECT_TRUE(isnan(tgamma(NAN)));
EXPECT_TRUE(isnan(tgamma(-NAN)));
EXPECT_STREQ("inf", gc(xasprintf("%.15g", tgamma(INFINITY))));
EXPECT_STREQ("inf", _gc(xasprintf("%.15g", tgamma(INFINITY))));
EXPECT_TRUE(isnan(tgamma(-INFINITY)));
EXPECT_STREQ("4.49423283715579e+307",
gc(xasprintf("%.15g", tgamma(__DBL_MIN__))));
EXPECT_STREQ("inf", gc(xasprintf("%.15g", tgamma(__DBL_MAX__))));
_gc(xasprintf("%.15g", tgamma(__DBL_MIN__))));
EXPECT_STREQ("inf", _gc(xasprintf("%.15g", tgamma(__DBL_MAX__))));
EXPECT_STREQ("4.5035996273705e+15",
gc(xasprintf("%.14g", tgamma(-1.0000000000000002))));
_gc(xasprintf("%.14g", tgamma(-1.0000000000000002))));
EXPECT_STREQ("-47453133.3893415",
gc(xasprintf("%.15g", tgamma(-2.1073424255447e-08))));
_gc(xasprintf("%.15g", tgamma(-2.1073424255447e-08))));
}

2
test/libc/tinymath/trunc_test.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/math.h"
#include "libc/runtime/gc.internal.h"
#include "libc/mem/gc.internal.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"