mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-19 21:10:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Port tests\core\math, math\linalg\glsl and math\noise

Browse Source
This commit is contained in:
Jeroen van Rijn
2024-05-30 19:42:44 +02:00
committed by Feoramund
parent d7bfbe0552
commit b0faab29e0
5 changed files with 180 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
tests/core/Makefile
View File

@@ -68,21 +68,21 @@ image_test:
i18n_test:
$(ODIN) test text/i18n $(COMMON) -out:test_core_i18n
math_test:
$(ODIN) test math $(COMMON) -out:test_core_math
linalg_glsl_math_test:
$(ODIN) run math/linalg/glsl $(COMMON) $(COLLECTION) -out:test_linalg_glsl_math
$(ODIN) test math/linalg/glsl $(COMMON) -out:test_linalg_glsl_math
noise_test:
$(ODIN) test math/noise $(COMMON) -out:test_noise
match_test:
$(ODIN) run text/match $(COMMON) -out:test_core_match
math_test:
$(ODIN) run math $(COMMON) $(COLLECTION) -out:test_core_math
net_test:
$(ODIN) run net $(COMMON) -out:test_core_net
noise_test:
$(ODIN) run math/noise $(COMMON) -out:test_noise
os_exit_test:
$(ODIN) run os/test_core_os_exit.odin -file -out:test_core_os_exit && exit 1 || exit 0

6
tests/core/build.bat
View File

@@ -62,17 +62,17 @@ echo ---
echo ---
echo Running core:math tests
echo ---
%PATH_TO_ODIN% run math %COMMON% %COLLECTION% -out:test_core_math.exe || exit /b
%PATH_TO_ODIN% test math %COMMON% -out:test_core_math.exe || exit /b
echo ---
echo Running core:math/linalg/glsl tests
echo ---
%PATH_TO_ODIN% run math/linalg/glsl %COMMON% %COLLECTION% -out:test_linalg_glsl.exe || exit /b
%PATH_TO_ODIN% test math/linalg/glsl %COMMON% -out:test_linalg_glsl.exe || exit /b
echo ---
echo Running core:math/noise tests
echo ---
%PATH_TO_ODIN% run math/noise %COMMON% -out:test_noise.exe || exit /b
%PATH_TO_ODIN% test math/noise %COMMON% -out:test_noise.exe || exit /b
echo ---
echo Running core:net

20
tests/core/math/linalg/glsl/test_linalg_glsl_math.odin
View File

@@ -1,24 +1,10 @@
// Tests "linalg_glsl_math.odin" in "core:math/linalg/glsl".
// Must be run with `-collection:tests=` flag, e.g.
// ./odin run tests/core/math/linalg/glsl/test_linalg_glsl_math.odin -collection:tests=./tests
package test_core_math_linalg_glsl_math
import glsl "core:math/linalg/glsl"
import "core:fmt"
import "core:math"
import "core:testing"
import tc "tests:common"
main :: proc() {
t := testing.T{}
test_fract_f32(&t)
test_fract_f64(&t)
tc.report(&t)
}
@test
test_fract_f32 :: proc(t: ^testing.T) {
@@ -45,7 +31,7 @@ test_fract_f32 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = glsl.fract(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%v (%h)) -> %v (%h) != %v", i, #procedure, d.v, d.v, r, r, d.e))
testing.expectf(t, r == d.e, "%v (%h) -> %v (%h) != %v", d.v, d.v, r, r, d.e)
}
}
@@ -74,6 +60,6 @@ test_fract_f64 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = glsl.fract(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%v (%h)) -> %v (%h) != %v", i, #procedure, d.v, d.v, r, r, d.e))
testing.expectf(t, r == d.e, "%v (%h) -> %v (%h) != %v", d.v, d.v, r, r, d.e)
}
}
}

195
tests/core/math/noise/test_core_math_noise.odin
View File

@@ -2,42 +2,6 @@ package test_core_math_noise
import "core:testing"
import "core:math/noise"
import "core:fmt"
import "core:os"
TEST_count := 0
TEST_fail := 0
V2 :: noise.Vec2
V3 :: noise.Vec3
V4 :: noise.Vec4
when ODIN_TEST {
expect :: testing.expect
log :: testing.log
} else {
expect :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) {
TEST_count += 1
if !condition {
TEST_fail += 1
fmt.printf("[%v] %v\n", loc, message)
return
}
}
log :: proc(t: ^testing.T, v: any, loc := #caller_location) {
fmt.printf("[%v] ", loc)
fmt.printf("log: %v\n", v)
}
}
main :: proc() {
t := testing.T{}
noise_test(&t)
fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
if TEST_fail > 0 {
os.exit(1)
}
}
Test_Vector :: struct {
seed: i64,
@@ -51,6 +15,10 @@ Test_Vector :: struct {
},
}
V2 :: noise.Vec2
V3 :: noise.Vec3
V4 :: noise.Vec4
SEED_1 :: 2324223232
SEED_2 :: 932466901
SEED_3 :: 9321
@@ -59,93 +27,78 @@ COORD_1 :: V4{ 242.0, 3433.0, 920.0, 222312.0}
COORD_2 :: V4{ 590.0, 9411.0, 5201.0, 942124256.0}
COORD_3 :: V4{12090.0, 19411.0, 81950901.0, 4224219.0}
Noise_Tests := []Test_Vector{
/*
`noise_2d` tests.
*/
{SEED_1, COORD_1.xy, 0.25010583, noise.noise_2d},
{SEED_2, COORD_2.xy, -0.92513955, noise.noise_2d},
{SEED_3, COORD_3.xy, 0.67327416, noise.noise_2d},
/*
`noise_2d_improve_x` tests.
*/
{SEED_1, COORD_1.xy, 0.17074019, noise.noise_2d_improve_x},
{SEED_2, COORD_2.xy, 0.72330487, noise.noise_2d_improve_x},
{SEED_3, COORD_3.xy, -0.032076947, noise.noise_2d_improve_x},
/*
`noise_3d_improve_xy` tests.
*/
{SEED_1, COORD_1.xyz, 0.14819577, noise.noise_3d_improve_xy},
{SEED_2, COORD_2.xyz, -0.065345764, noise.noise_3d_improve_xy},
{SEED_3, COORD_3.xyz, -0.37761918, noise.noise_3d_improve_xy},
/*
`noise_3d_improve_xz` tests.
*/
{SEED_1, COORD_1.xyz, -0.50075006, noise.noise_3d_improve_xz},
{SEED_2, COORD_2.xyz, -0.36039603, noise.noise_3d_improve_xz},
{SEED_3, COORD_3.xyz, -0.3479203, noise.noise_3d_improve_xz},
/*
`noise_3d_fallback` tests.
*/
{SEED_1, COORD_1.xyz, 0.6557345, noise.noise_3d_fallback},
{SEED_2, COORD_2.xyz, 0.55452216, noise.noise_3d_fallback},
{SEED_3, COORD_3.xyz, -0.26408964, noise.noise_3d_fallback},
/*
`noise_3d_fallback` tests.
*/
{SEED_1, COORD_1.xyz, 0.6557345, noise.noise_3d_fallback},
{SEED_2, COORD_2.xyz, 0.55452216, noise.noise_3d_fallback},
{SEED_3, COORD_3.xyz, -0.26408964, noise.noise_3d_fallback},
/*
`noise_4d_improve_xyz_improve_xy` tests.
*/
{SEED_1, COORD_1, 0.44929826, noise.noise_4d_improve_xyz_improve_xy},
{SEED_2, COORD_2, -0.13270882, noise.noise_4d_improve_xyz_improve_xy},
{SEED_3, COORD_3, 0.10298563, noise.noise_4d_improve_xyz_improve_xy},
/*
`noise_4d_improve_xyz_improve_xz` tests.
*/
{SEED_1, COORD_1, -0.078514606, noise.noise_4d_improve_xyz_improve_xz},
{SEED_2, COORD_2, -0.032157656, noise.noise_4d_improve_xyz_improve_xz},
{SEED_3, COORD_3, -0.38607058, noise.noise_4d_improve_xyz_improve_xz},
/*
`noise_4d_improve_xyz` tests.
*/
{SEED_1, COORD_1, -0.4442258, noise.noise_4d_improve_xyz},
{SEED_2, COORD_2, 0.36822623, noise.noise_4d_improve_xyz},
{SEED_3, COORD_3, 0.22628775, noise.noise_4d_improve_xyz},
/*
`noise_4d_fallback` tests.
*/
{SEED_1, COORD_1, -0.14233987, noise.noise_4d_fallback},
{SEED_2, COORD_2, 0.1354035, noise.noise_4d_fallback},
{SEED_3, COORD_3, 0.14565045, noise.noise_4d_fallback},
@(test)
test_noise_2d :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1.xy, 0.25010583, noise.noise_2d})
test(t, {SEED_2, COORD_2.xy, -0.92513955, noise.noise_2d})
test(t, {SEED_3, COORD_3.xy, 0.67327416, noise.noise_2d})
}
noise_test :: proc(t: ^testing.T) {
for test in Noise_Tests {
output: f32
@(test)
test_noise_2d_improve_x :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1.xy, 0.17074019, noise.noise_2d_improve_x})
test(t, {SEED_2, COORD_2.xy, 0.72330487, noise.noise_2d_improve_x})
test(t, {SEED_3, COORD_3.xy, -0.032076947, noise.noise_2d_improve_x})
}
switch coord in test.coord {
case V2:
output = test.test_proc.(proc(_: i64, _: V2) -> f32)(test.seed, test.coord.(V2))
case V3:
output = test.test_proc.(proc(_: i64, _: V3) -> f32)(test.seed, test.coord.(V3))
case V4:
output = test.test_proc.(proc(_: i64, _: V4) -> f32)(test.seed, test.coord.(V4))
}
error := fmt.tprintf("Seed %v, Coord: %v, Expected: %3.8f. Got %3.8f", test.seed, test.coord, test.expected, output)
expect(t, test.expected == output, error)
@(test)
test_noise_3d_improve_xy :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1.xyz, 0.14819577, noise.noise_3d_improve_xy})
test(t, {SEED_2, COORD_2.xyz, -0.065345764, noise.noise_3d_improve_xy})
test(t, {SEED_3, COORD_3.xyz, -0.37761918, noise.noise_3d_improve_xy})
}
@(test)
test_noise_3d_improve_xz :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1.xyz, -0.50075006, noise.noise_3d_improve_xz})
test(t, {SEED_2, COORD_2.xyz, -0.36039603, noise.noise_3d_improve_xz})
test(t, {SEED_3, COORD_3.xyz, -0.3479203, noise.noise_3d_improve_xz})
}
@(test)
test_noise_3d_fallback :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1.xyz, 0.6557345, noise.noise_3d_fallback})
test(t, {SEED_2, COORD_2.xyz, 0.55452216, noise.noise_3d_fallback})
test(t, {SEED_3, COORD_3.xyz, -0.26408964, noise.noise_3d_fallback})
}
@(test)
test_noise_4d_improve_xyz_improve_xy :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1, 0.44929826, noise.noise_4d_improve_xyz_improve_xy})
test(t, {SEED_2, COORD_2, -0.13270882, noise.noise_4d_improve_xyz_improve_xy})
test(t, {SEED_3, COORD_3, 0.10298563, noise.noise_4d_improve_xyz_improve_xy})
}
@(test)
test_noise_4d_improve_xyz_improve_xz :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1, -0.078514606, noise.noise_4d_improve_xyz_improve_xz})
test(t, {SEED_2, COORD_2, -0.032157656, noise.noise_4d_improve_xyz_improve_xz})
test(t, {SEED_3, COORD_3, -0.38607058, noise.noise_4d_improve_xyz_improve_xz})
}
@(test)
test_noise_4d_improve_xyz :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1, -0.4442258, noise.noise_4d_improve_xyz})
test(t, {SEED_2, COORD_2, 0.36822623, noise.noise_4d_improve_xyz})
test(t, {SEED_3, COORD_3, 0.22628775, noise.noise_4d_improve_xyz})
}
@(test)
test_noise_4d_fallback :: proc(t: ^testing.T) {
test(t, {SEED_1, COORD_1, -0.14233987, noise.noise_4d_fallback})
test(t, {SEED_2, COORD_2, 0.1354035, noise.noise_4d_fallback})
test(t, {SEED_3, COORD_3, 0.14565045, noise.noise_4d_fallback})
}
test :: proc(t: ^testing.T, test: Test_Vector) {
output: f32
switch coord in test.coord {
case V2:
output = test.test_proc.(proc(_: i64, _: V2) -> f32)(test.seed, test.coord.(V2))
case V3:
output = test.test_proc.(proc(_: i64, _: V3) -> f32)(test.seed, test.coord.(V3))
case V4:
output = test.test_proc.(proc(_: i64, _: V4) -> f32)(test.seed, test.coord.(V4))
}
testing.expectf(t, test.expected == output, "Seed %v, Coord: %v, Expected: %3.8f. Got %3.8f", test.seed, test.coord, test.expected, output)
}

258
tests/core/math/test_core_math.odin
View File

@@ -1,49 +1,8 @@
// Tests "math.odin" in "core:math".
// Must be run with `-collection:tests=` flag, e.g.
// ./odin run tests/core/math/test_core_math.odin -collection:tests=./tests
package test_core_math
import "core:fmt"
import "core:math"
import "core:testing"
import tc "tests:common"
main :: proc() {
t := testing.T{}
test_classify_f16(&t)
test_classify_f32(&t)
test_classify_f64(&t)
test_trunc_f16(&t)
test_trunc_f32(&t)
test_trunc_f64(&t)
test_round_f16(&t)
test_round_f32(&t)
test_round_f64(&t)
test_nan(&t)
test_acos(&t)
test_acosh(&t)
test_asin(&t)
test_asinh(&t)
test_atan(&t)
test_atanh(&t)
test_atan2(&t)
test_cos(&t)
test_cosh(&t)
test_sin(&t)
test_sinh(&t)
test_sqrt(&t)
test_tan(&t)
test_tanh(&t)
test_large_cos(&t)
test_large_sin(&t)
test_large_tan(&t)
tc.report(&t)
}
@test
test_classify_f16 :: proc(t: ^testing.T) {
@@ -68,7 +27,7 @@ test_classify_f16 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.classify_f16(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %v != %v", d.v, r, d.e)
}
/* Check all subnormals (exponent 0, 10-bit significand non-zero) */
@@ -76,7 +35,7 @@ test_classify_f16 :: proc(t: ^testing.T) {
v := transmute(f16)i
r = math.classify_f16(v)
e :: math.Float_Class.Subnormal
tc.expect(t, r == e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, v, r, e))
testing.expectf(t, r == e, "%h -> %v != %v", v, r, e)
}
}
@@ -103,7 +62,7 @@ test_classify_f32 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.classify_f32(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %v != %v", d.v, r, d.e)
}
}
@@ -130,7 +89,7 @@ test_classify_f64 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.classify_f64(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %v != %v", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %v != %v", d.v, r, d.e)
}
}
@@ -175,16 +134,16 @@ test_trunc_f16 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.trunc_f16(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %h != %h", d.v, r, d.e)
}
v = math.SNAN_F16
r = math.trunc_f16(v)
tc.expect(t, math.is_nan_f16(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f16(r), "%f != NaN", v, r)
v = math.QNAN_F16
r = math.trunc_f16(v)
tc.expect(t, math.is_nan_f16(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f16(r), "%f != NaN", v, r)
}
@test
@@ -237,16 +196,16 @@ test_trunc_f32 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.trunc_f32(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %h != %h", d.v, r, d.e)
}
v = math.SNAN_F32
r = math.trunc_f32(v)
tc.expect(t, math.is_nan_f32(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f32(r), "%f -> %f != NaN", v, r)
v = math.QNAN_F32
r = math.trunc_f32(v)
tc.expect(t, math.is_nan_f32(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f32(r), "%f -> %f != NaN", v, r)
}
@test
@@ -299,16 +258,16 @@ test_trunc_f64 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.trunc_f64(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %h != %h", d.v, r, d.e)
}
v = math.SNAN_F64
r = math.trunc_f64(v)
tc.expect(t, math.is_nan_f64(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f64(r), "%f -> %f != NaN", v, r)
v = math.QNAN_F64
r = math.trunc_f64(v)
tc.expect(t, math.is_nan_f64(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f64(r), "%f -> %f != NaN", v, r)
}
@test
@@ -352,16 +311,16 @@ test_round_f16 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.round_f16(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %h != %h", d.v, r, d.e)
}
v = math.SNAN_F16
r = math.round_f16(v)
tc.expect(t, math.is_nan_f16(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f16(r), "%f -> %f != NaN", v, r)
v = math.QNAN_F16
r = math.round_f16(v)
tc.expect(t, math.is_nan_f16(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f16(r), "%f -> %f != NaN", v, r)
}
@test
@@ -414,16 +373,16 @@ test_round_f32 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.round_f32(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %h != %h", i, d.v, r, d.e)
}
v = math.SNAN_F32
r = math.round_f32(v)
tc.expect(t, math.is_nan_f32(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f32(r), "%f -> %f != NaN", v, r)
v = math.QNAN_F32
r = math.round_f32(v)
tc.expect(t, math.is_nan_f32(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f32(r), "%f -> %f != NaN", v, r)
}
@test
@@ -476,16 +435,16 @@ test_round_f64 :: proc(t: ^testing.T) {
for d, i in data {
assert(i == d.i)
r = math.round_f64(d.v)
tc.expect(t, r == d.e, fmt.tprintf("i:%d %s(%h) -> %h != %h", i, #procedure, d.v, r, d.e))
testing.expectf(t, r == d.e, "%h -> %h != %h", d.v, r, d.e)
}
v = math.SNAN_F64
r = math.round_f64(v)
tc.expect(t, math.is_nan_f64(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f64(r), "%f -> %f != NaN", v, r)
v = math.QNAN_F64
r = math.round_f64(v)
tc.expect(t, math.is_nan_f64(r), fmt.tprintf("%s(%f) -> %f != NaN", #procedure, v, r))
testing.expectf(t, math.is_nan_f64(r), "%f -> %f != NaN", v, r)
}
@@ -1033,17 +992,17 @@ tolerance :: proc(a, b, e: f64) -> bool {
}
close :: proc(t: ^testing.T, a, b: f64, loc := #caller_location) -> bool {
ok := tolerance(a, b, 1e-9)
// tc.expect(t, ok, fmt.tprintf("%.15g is not close to %.15g", a, b), loc)
testing.expectf(t, ok, "%.15g is not close to %.15g", a, b, loc=loc)
return ok
}
veryclose :: proc(t: ^testing.T, a, b: f64, loc := #caller_location) -> bool {
ok := tolerance(a, b, 4e-14)
// tc.expect(t, ok, fmt.tprintf("%.15g is not veryclose to %.15g", a, b), loc)
testing.expectf(t, ok, "%.15g is not veryclose to %.15g", a, b, loc=loc)
return ok
}
soclose :: proc(t: ^testing.T, a, b, e: f64, loc := #caller_location) -> bool {
ok := tolerance(a, b, e)
// tc.expect(t, ok, fmt.tprintf("%.15g is not soclose to %.15g", a, b), loc)
testing.expectf(t, ok, "%.15g is not soclose to %.15g", a, b, loc=loc)
return ok
}
alike :: proc(t: ^testing.T, a, b: f64, loc := #caller_location) -> bool {
@@ -1054,34 +1013,34 @@ alike :: proc(t: ^testing.T, a, b: f64, loc := #caller_location) -> bool {
case a == b:
ok = math.signbit(a) == math.signbit(b)
}
// tc.expect(t, ok, fmt.tprintf("%.15g is not alike to %.15g", a, b), loc)
testing.expectf(t, ok, "%.15g is not alike to %.15g", a, b, loc=loc)
return ok
}
@test
test_nan :: proc(t: ^testing.T) {
test_nan32 :: proc(t: ^testing.T) {
float32 := f32(NaN)
equal := float32 == float32
testing.expectf(t, !equal, "float32(NaN) is %.15g, expected NaN", float32)
}
@test
test_nan64 :: proc(t: ^testing.T) {
float64 := NaN
if float64 == float64 {
tc.errorf(t, "NaN returns %.15g, expected NaN", float64)
}
float32 := f32(float64)
if float32 == float32 {
tc.errorf(t, "float32(NaN) is %.15g, expected NaN", float32)
}
equal := float64 == float64
testing.expectf(t, !equal, "NaN returns %.15g, expected NaN", float64)
}
@test
test_acos :: proc(t: ^testing.T) {
for _, i in vf {
a := vf[i] / 10
if f := math.acos(a); !close(t, acos[i], f) {
tc.errorf(t, "math.acos(%.15g) = %.15g, want %.15g", a, f, acos[i])
}
f := math.acos(a)
testing.expectf(t, close(t, acos[i], f), "math.acos(%.15g) = %.15g, want %.15g", a, f, acos[i])
}
for _, i in vfacos_sc {
if f := math.acos(vfacos_sc[i]); !alike(t, acos_sc[i], f) {
tc.errorf(t, "math.acos(%.15g) = %.15g, want %.15g", vfacos_sc[i], f, acos_sc[i])
}
f := math.acos(vfacos_sc[i])
testing.expectf(t, alike(t, acos_sc[i], f), "math.acos(%.15g) = %.15g, want %.15g", vfacos_sc[i], f, acos_sc[i])
}
}
@@ -1089,14 +1048,12 @@ test_acos :: proc(t: ^testing.T) {
test_acosh :: proc(t: ^testing.T) {
for _, i in vf {
a := 1 + abs(vf[i])
if f := math.acosh(a); !veryclose(t, acosh[i], f) {
tc.errorf(t, "math.acosh(%.15g) = %.15g, want %.15g", a, f, acosh[i])
}
f := math.acosh(a)
testing.expectf(t, veryclose(t, acosh[i], f), "math.acosh(%.15g) = %.15g, want %.15g", a, f, acosh[i])
}
for _, i in vfacosh_sc {
if f := math.acosh(vfacosh_sc[i]); !alike(t, acosh_sc[i], f) {
tc.errorf(t, "math.acosh(%.15g) = %.15g, want %.15g", vfacosh_sc[i], f, acosh_sc[i])
}
f := math.acosh(vfacosh_sc[i])
testing.expectf(t, alike(t, acosh_sc[i], f), "math.acosh(%.15g) = %.15g, want %.15g", vfacosh_sc[i], f, acosh_sc[i])
}
}
@@ -1104,42 +1061,36 @@ test_acosh :: proc(t: ^testing.T) {
test_asin :: proc(t: ^testing.T) {
for _, i in vf {
a := vf[i] / 10
if f := math.asin(a); !veryclose(t, asin[i], f) {
tc.errorf(t, "math.asin(%.15g) = %.15g, want %.15g", a, f, asin[i])
}
f := math.asin(a)
testing.expectf(t, veryclose(t, asin[i], f), "math.asin(%.15g) = %.15g, want %.15g", a, f, asin[i])
}
for _, i in vfasin_sc {
if f := math.asin(vfasin_sc[i]); !alike(t, asin_sc[i], f) {
tc.errorf(t, "math.asin(%.15g) = %.15g, want %.15g", vfasin_sc[i], f, asin_sc[i])
}
f := math.asin(vfasin_sc[i])
testing.expectf(t, alike(t, asin_sc[i], f), "math.asin(%.15g) = %.15g, want %.15g", vfasin_sc[i], f, asin_sc[i])
}
}
@test
test_asinh :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.asinh(vf[i]); !veryclose(t, asinh[i], f) {
tc.errorf(t, "math.asinh(%.15g) = %.15g, want %.15g", vf[i], f, asinh[i])
}
f := math.asinh(vf[i])
testing.expectf(t, veryclose(t, asinh[i], f), "math.asinh(%.15g) = %.15g, want %.15g", vf[i], f, asinh[i])
}
for _, i in vfasinh_sc {
if f := math.asinh(vfasinh_sc[i]); !alike(t, asinh_sc[i], f) {
tc.errorf(t, "math.asinh(%.15g) = %.15g, want %.15g", vfasinh_sc[i], f, asinh_sc[i])
}
f := math.asinh(vfasinh_sc[i])
testing.expectf(t, alike(t, asinh_sc[i], f), "math.asinh(%.15g) = %.15g, want %.15g", vfasinh_sc[i], f, asinh_sc[i])
}
}
@test
test_atan :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.atan(vf[i]); !veryclose(t, atan[i], f) {
tc.errorf(t, "math.atan(%.15g) = %.15g, want %.15g", vf[i], f, atan[i])
}
f := math.atan(vf[i])
testing.expectf(t, veryclose(t, atan[i], f), "math.atan(%.15g) = %.15g, want %.15g", vf[i], f, atan[i])
}
for _, i in vfatan_sc {
if f := math.atan(vfatan_sc[i]); !alike(t, atan_sc[i], f) {
tc.errorf(t, "math.atan(%.15g) = %.15g, want %.15g", vfatan_sc[i], f, atan_sc[i])
}
f := math.atan(vfatan_sc[i])
testing.expectf(t, alike(t, atan_sc[i], f), "math.atan(%.15g) = %.15g, want %.15g", vfatan_sc[i], f, atan_sc[i])
}
}
@@ -1147,84 +1098,72 @@ test_atan :: proc(t: ^testing.T) {
test_atanh :: proc(t: ^testing.T) {
for _, i in vf {
a := vf[i] / 10
if f := math.atanh(a); !veryclose(t, atanh[i], f) {
tc.errorf(t, "math.atanh(%.15g) = %.15g, want %.15g", a, f, atanh[i])
}
f := math.atanh(a)
testing.expectf(t, veryclose(t, atanh[i], f), "math.atanh(%.15g) = %.15g, want %.15g", a, f, atanh[i])
}
for _, i in vfatanh_sc {
if f := math.atanh(vfatanh_sc[i]); !alike(t, atanh_sc[i], f) {
tc.errorf(t, "math.atanh(%.15g) = %.15g, want %.15g", vfatanh_sc[i], f, atanh_sc[i])
}
f := math.atanh(vfatanh_sc[i])
testing.expectf(t, alike(t, atanh_sc[i], f), "math.atanh(%.15g) = %.15g, want %.15g", vfatanh_sc[i], f, atanh_sc[i])
}
}
@test
test_atan2 :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.atan2(10, vf[i]); !veryclose(t, atan2[i], f) {
tc.errorf(t, "math.atan2(10, %.15g) = %.15g, want %.15g", vf[i], f, atan2[i])
}
f := math.atan2(10, vf[i])
testing.expectf(t, veryclose(t, atan2[i], f), "math.atan2(10, %.15g) = %.15g, want %.15g", vf[i], f, atan2[i])
}
for _, i in vfatan2_sc {
if f := math.atan2(vfatan2_sc[i][0], vfatan2_sc[i][1]); !alike(t, atan2_sc[i], f) {
tc.errorf(t, "math.atan2(%.15g, %.15g) = %.15g, want %.15g", vfatan2_sc[i][0], vfatan2_sc[i][1], f, atan2_sc[i])
}
f := math.atan2(vfatan2_sc[i][0], vfatan2_sc[i][1])
testing.expectf(t, alike(t, atan2_sc[i], f), "math.atan2(%.15g, %.15g) = %.15g, want %.15g", vfatan2_sc[i][0], vfatan2_sc[i][1], f, atan2_sc[i])
}
}
@test
test_cos :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.cos(vf[i]); !veryclose(t, cos[i], f) {
tc.errorf(t, "math.cos(%.15g) = %.15g, want %.15g", vf[i], f, cos[i])
}
f := math.cos(vf[i])
testing.expectf(t, veryclose(t, cos[i], f), "math.cos(%.15g) = %.15g, want %.15g", vf[i], f, cos[i])
}
for _, i in vfcos_sc {
if f := math.cos(vfcos_sc[i]); !alike(t, cos_sc[i], f) {
tc.errorf(t, "math.cos(%.15g) = %.15g, want %.15g", vfcos_sc[i], f, cos_sc[i])
}
f := math.cos(vfcos_sc[i])
testing.expectf(t, alike(t, cos_sc[i], f), "math.cos(%.15g) = %.15g, want %.15g", vfcos_sc[i], f, cos_sc[i])
}
}
@test
test_cosh :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.cosh(vf[i]); !close(t, cosh[i], f) {
tc.errorf(t, "math.cosh(%.15g) = %.15g, want %.15g", vf[i], f, cosh[i])
}
f := math.cosh(vf[i])
testing.expectf(t, close(t, cosh[i], f), "math.cosh(%.15g) = %.15g, want %.15g", vf[i], f, cosh[i])
}
for _, i in vfcosh_sc {
if f := math.cosh(vfcosh_sc[i]); !alike(t, cosh_sc[i], f) {
tc.errorf(t, "math.cosh(%.15g) = %.15g, want %.15g", vfcosh_sc[i], f, cosh_sc[i])
}
f := math.cosh(vfcosh_sc[i])
testing.expectf(t, alike(t, cosh_sc[i], f), "math.cosh(%.15g) = %.15g, want %.15g", vfcosh_sc[i], f, cosh_sc[i])
}
}
@test
test_sin :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.sin(vf[i]); !veryclose(t, sin[i], f) {
tc.errorf(t, "math.sin(%.15g) = %.15g, want %.15g", vf[i], f, sin[i])
}
f := math.sin(vf[i])
testing.expectf(t, veryclose(t, sin[i], f), "math.sin(%.15g) = %.15g, want %.15g", vf[i], f, sin[i])
}
for _, i in vfsin_sc {
if f := math.sin(vfsin_sc[i]); !alike(t, sin_sc[i], f) {
tc.errorf(t, "math.sin(%.15g) = %.15g, want %.15g", vfsin_sc[i], f, sin_sc[i])
}
f := math.sin(vfsin_sc[i])
testing.expectf(t, alike(t, sin_sc[i], f), "math.sin(%.15g) = %.15g, want %.15g", vfsin_sc[i], f, sin_sc[i])
}
}
@test
test_sinh :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.sinh(vf[i]); !close(t, sinh[i], f) {
tc.errorf(t, "math.sinh(%.15g) = %.15g, want %.15g", vf[i], f, sinh[i])
}
f := math.sinh(vf[i])
testing.expectf(t, close(t, sinh[i], f), "math.sinh(%.15g) = %.15g, want %.15g", vf[i], f, sinh[i])
}
for _, i in vfsinh_sc {
if f := math.sinh(vfsinh_sc[i]); !alike(t, sinh_sc[i], f) {
tc.errorf(t, "math.sinh(%.15g) = %.15g, want %.15g", vfsinh_sc[i], f, sinh_sc[i])
}
f := math.sinh(vfsinh_sc[i])
testing.expectf(t, alike(t, sinh_sc[i], f), "math.sinh(%.15g) = %.15g, want %.15g", vfsinh_sc[i], f, sinh_sc[i])
}
}
@@ -1232,38 +1171,33 @@ test_sinh :: proc(t: ^testing.T) {
test_sqrt :: proc(t: ^testing.T) {
for _, i in vf {
a := abs(vf[i])
if f := math.sqrt(a); !veryclose(t, sqrt[i], f) {
tc.errorf(t, "math.sqrt(%.15g) = %.15g, want %.15g", a, f, sqrt[i])
}
f := math.sqrt(a)
testing.expectf(t, veryclose(t, sqrt[i], f), "math.sqrt(%.15g) = %.15g, want %.15g", a, f, sqrt[i])
}
}
@test
test_tan :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.tan(vf[i]); !veryclose(t, tan[i], f) {
tc.errorf(t, "math.tan(%.15g) = %.15g, want %.15g", vf[i], f, tan[i])
}
f := math.tan(vf[i])
testing.expectf(t, veryclose(t, tan[i], f), "math.tan(%.15g) = %.15g, want %.15g", vf[i], f, tan[i])
}
// same special cases as Sin
for _, i in vfsin_sc {
if f := math.tan(vfsin_sc[i]); !alike(t, sin_sc[i], f) {
tc.errorf(t, "math.tan(%.15g) = %.15g, want %.15g", vfsin_sc[i], f, sin_sc[i])
}
f := math.tan(vfsin_sc[i])
testing.expectf(t, alike(t, sin_sc[i], f), "math.tan(%.15g) = %.15g, want %.15g", vfsin_sc[i], f, sin_sc[i])
}
}
@test
test_tanh :: proc(t: ^testing.T) {
for _, i in vf {
if f := math.tanh(vf[i]); !veryclose(t, tanh[i], f) {
tc.errorf(t, "math.tanh(%.15g) = %.15g, want %.15g", vf[i], f, tanh[i])
}
f := math.tanh(vf[i])
testing.expectf(t, veryclose(t, tanh[i], f), "math.tanh(%.15g) = %.15g, want %.15g", vf[i], f, tanh[i])
}
for _, i in vftanh_sc {
if f := math.tanh(vftanh_sc[i]); !alike(t, tanh_sc[i], f) {
tc.errorf(t, "math.tanh(%.15g) = %.15g, want %.15g", vftanh_sc[i], f, tanh_sc[i])
}
f := math.tanh(vftanh_sc[i])
testing.expectf(t, alike(t, tanh_sc[i], f), "math.tanh(%.15g) = %.15g, want %.15g", vftanh_sc[i], f, tanh_sc[i])
}
}
@@ -1273,9 +1207,7 @@ test_large_cos :: proc(t: ^testing.T) {
for _, i in vf {
f1 := cosLarge[i]
f2 := math.cos(vf[i] + large)
if !close(t, f1, f2) {
tc.errorf(t, "math.cos(%.15g) = %.15g, want %.15g", vf[i]+large, f2, f1)
}
testing.expectf(t, close(t, f1, f2), "math.cos(%.15g) = %.15g, want %.15g", vf[i]+large, f2, f1)
}
}
@@ -1285,9 +1217,7 @@ test_large_sin :: proc(t: ^testing.T) {
for _, i in vf {
f1 := sinLarge[i]
f2 := math.sin(vf[i] + large)
if !close(t, f1, f2) {
tc.errorf(t, "math.sin(%.15g) = %.15g, want %.15g", vf[i]+large, f2, f1)
}
testing.expectf(t, close(t, f1, f2), "math.sin(%.15g) = %.15g, want %.15g", vf[i]+large, f2, f1)
}
}
@@ -1297,8 +1227,6 @@ test_large_tan :: proc(t: ^testing.T) {
for _, i in vf {
f1 := tanLarge[i]
f2 := math.tan(vf[i] + large)
if !close(t, f1, f2) {
tc.errorf(t, "math.tan(%.15g) = %.15g, want %.15g", vf[i]+large, f2, f1)
}
testing.expectf(t, close(t, f1, f2), "math.tan(%.15g) = %.15g, want %.15g", vf[i]+large, f2, f1)
}
}