2020-01-02 12:27:43 +08:00
|
|
|
const std = @import("std");
|
|
|
|
const expect = std.testing.expect;
|
|
|
|
const math = std.math;
|
|
|
|
const pi = std.math.pi;
|
|
|
|
const e = std.math.e;
|
2020-04-28 13:46:09 +08:00
|
|
|
const Vector = std.meta.Vector;
|
2019-06-22 05:18:59 +08:00
|
|
|
|
2020-01-03 03:01:48 +08:00
|
|
|
const epsilon = 0.000001;
|
|
|
|
|
2019-06-22 05:18:59 +08:00
|
|
|
test "@sqrt" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testSqrt();
|
|
|
|
try testSqrt();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testSqrt() !void {
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 4;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sqrt(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f32 = 9;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sqrt(a) == 3);
|
2020-01-03 03:01:48 +08:00
|
|
|
var b: f32 = 1.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon));
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 25;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sqrt(a) == 5);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
const a: comptime_float = 25.0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sqrt(a) == 5.0);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-02 12:27:43 +08:00
|
|
|
// TODO https://github.com/ziglang/zig/issues/4026
|
2019-06-22 05:18:59 +08:00
|
|
|
//{
|
|
|
|
// var a: f128 = 49;
|
2021-05-05 02:23:22 +08:00
|
|
|
//try expect(@sqrt(a) == 7);
|
2019-06-22 05:18:59 +08:00
|
|
|
//}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @sqrt(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2020-01-02 12:27:43 +08:00
|
|
|
test "more @sqrt f16 tests" {
|
|
|
|
// TODO these are not all passing at comptime
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sqrt(@as(f16, 0.0)) == 0.0);
|
|
|
|
try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
|
|
|
|
try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
|
|
|
|
try expect(@sqrt(@as(f16, 4.0)) == 2.0);
|
|
|
|
try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
|
|
|
|
try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
|
|
|
|
try expect(@sqrt(@as(f16, 64.0)) == 8.0);
|
|
|
|
try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
|
|
|
|
try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
|
2020-01-02 12:27:43 +08:00
|
|
|
|
|
|
|
// special cases
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16)))));
|
|
|
|
try expect(@sqrt(@as(f16, 0.0)) == 0.0);
|
|
|
|
try expect(@sqrt(@as(f16, -0.0)) == -0.0);
|
|
|
|
try expect(math.isNan(@sqrt(@as(f16, -1.0))));
|
|
|
|
try expect(math.isNan(@sqrt(@as(f16, math.nan(f16)))));
|
2020-01-02 12:27:43 +08:00
|
|
|
}
|
|
|
|
|
2019-06-22 05:18:59 +08:00
|
|
|
test "@sin" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testSin();
|
|
|
|
try testSin();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testSin() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sin(a) == 0);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sin(a) == 0);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@sin(a) == 0);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @sin(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@cos" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testCos();
|
|
|
|
try testCos();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testCos() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@cos(a) == 1);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@cos(a) == 1);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@cos(a) == 1);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @cos(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@exp" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testExp();
|
|
|
|
try testExp();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testExp() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@exp(a) == 1);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@exp(a) == 1);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@exp(a) == 1);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @exp(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@exp2" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testExp2();
|
|
|
|
try testExp2();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testExp2() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 2;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@exp2(a) == 4);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 2;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@exp2(a) == 4);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 2;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@exp2(a) == 4);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @exp2(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2020-01-03 03:01:48 +08:00
|
|
|
test "@log" {
|
2019-06-22 05:18:59 +08:00
|
|
|
// Old musl (and glibc?), and our current math.ln implementation do not return 1
|
|
|
|
// so also accept those values.
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testLog();
|
|
|
|
try testLog();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testLog() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = e;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f16, @log(a), 1, epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = e;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log(a) == 1 or @log(a) == @bitCast(f32, @as(u32, 0x3f7fffff)));
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = e;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @log(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon));
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
test "@log2" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testLog2();
|
|
|
|
try testLog2();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testLog2() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 4;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log2(a) == 2);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 4;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log2(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 4;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log2(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @log2(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@log10" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testLog10();
|
|
|
|
try testLog10();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testLog10() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 100;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log10(a) == 2);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 100;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log10(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 1000;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@log10(a) == 3);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @log10(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@fabs" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testFabs();
|
|
|
|
try testFabs();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testFabs() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = -2.5;
|
|
|
|
var b: f16 = 2.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@fabs(a) == 2.5);
|
|
|
|
try expect(@fabs(b) == 2.5);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = -2.5;
|
|
|
|
var b: f32 = 2.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@fabs(a) == 2.5);
|
|
|
|
try expect(@fabs(b) == 2.5);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = -2.5;
|
|
|
|
var b: f64 = 2.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@fabs(a) == 2.5);
|
|
|
|
try expect(@fabs(b) == 2.5);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @fabs(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@floor" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testFloor();
|
|
|
|
try testFloor();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testFloor() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@floor(a) == 2);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@floor(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 3.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@floor(a) == 3);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @floor(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@ceil" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testCeil();
|
|
|
|
try testCeil();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testCeil() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@ceil(a) == 3);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@ceil(a) == 3);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = 3.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@ceil(a) == 4);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @ceil(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
test "@trunc" {
|
2021-05-05 02:23:22 +08:00
|
|
|
comptime try testTrunc();
|
|
|
|
try testTrunc();
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testTrunc() !void {
|
2020-01-03 03:01:48 +08:00
|
|
|
// TODO test f128, and c_longdouble
|
2020-01-02 12:27:43 +08:00
|
|
|
// https://github.com/ziglang/zig/issues/4026
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
|
|
|
var a: f16 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@trunc(a) == 2);
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
{
|
|
|
|
var a: f32 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@trunc(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
{
|
|
|
|
var a: f64 = -3.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(@trunc(a) == -3);
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
2020-01-03 03:01:48 +08:00
|
|
|
{
|
2020-04-28 13:46:09 +08:00
|
|
|
var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
|
2020-01-03 03:01:48 +08:00
|
|
|
var result = @trunc(v);
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
|
|
|
|
try expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
|
2020-01-03 03:01:48 +08:00
|
|
|
}
|
2019-06-22 05:18:59 +08:00
|
|
|
}
|
|
|
|
|
2020-01-21 17:43:05 +08:00
|
|
|
test "floating point comparisons" {
|
2021-05-05 02:23:22 +08:00
|
|
|
try testFloatComparisons();
|
|
|
|
comptime try testFloatComparisons();
|
2020-01-21 17:43:05 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testFloatComparisons() !void {
|
2020-01-21 17:43:05 +08:00
|
|
|
inline for ([_]type{ f16, f32, f64, f128 }) |ty| {
|
|
|
|
// No decimal part
|
|
|
|
{
|
|
|
|
const x: ty = 1.0;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(x == 1);
|
|
|
|
try expect(x != 0);
|
|
|
|
try expect(x > 0);
|
|
|
|
try expect(x < 2);
|
|
|
|
try expect(x >= 1);
|
|
|
|
try expect(x <= 1);
|
2020-01-21 17:43:05 +08:00
|
|
|
}
|
|
|
|
// Non-zero decimal part
|
|
|
|
{
|
|
|
|
const x: ty = 1.5;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(x != 1);
|
|
|
|
try expect(x != 2);
|
|
|
|
try expect(x > 1);
|
|
|
|
try expect(x < 2);
|
|
|
|
try expect(x >= 1);
|
|
|
|
try expect(x <= 2);
|
2020-01-21 17:43:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-20 22:50:37 +08:00
|
|
|
test "different sized float comparisons" {
|
2021-05-05 02:23:22 +08:00
|
|
|
try testDifferentSizedFloatComparisons();
|
|
|
|
comptime try testDifferentSizedFloatComparisons();
|
2020-07-20 22:50:37 +08:00
|
|
|
}
|
|
|
|
|
2021-05-05 02:23:22 +08:00
|
|
|
fn testDifferentSizedFloatComparisons() !void {
|
2020-07-20 22:50:37 +08:00
|
|
|
var a: f16 = 1;
|
|
|
|
var b: f64 = 2;
|
2021-05-05 02:23:22 +08:00
|
|
|
try expect(a < b);
|
2020-07-20 22:50:37 +08:00
|
|
|
}
|
|
|
|
|
2020-01-02 12:27:43 +08:00
|
|
|
// TODO This is waiting on library support for the Windows build (not sure why the other's don't need it)
|
2020-01-03 03:01:48 +08:00
|
|
|
//test "@nearbyint" {
|
2019-06-22 05:18:59 +08:00
|
|
|
// comptime testNearbyInt();
|
|
|
|
// testNearbyInt();
|
|
|
|
//}
|
|
|
|
|
|
|
|
//fn testNearbyInt() void {
|
2020-01-02 12:27:43 +08:00
|
|
|
// // TODO test f16, f128, and c_longdouble
|
|
|
|
// // https://github.com/ziglang/zig/issues/4026
|
2019-06-22 05:18:59 +08:00
|
|
|
// {
|
|
|
|
// var a: f32 = 2.1;
|
2021-05-05 02:23:22 +08:00
|
|
|
// try expect(@nearbyint(a) == 2);
|
2019-06-22 05:18:59 +08:00
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// var a: f64 = -3.75;
|
2021-05-05 02:23:22 +08:00
|
|
|
// try expect(@nearbyint(a) == -4);
|
2019-06-22 05:18:59 +08:00
|
|
|
// }
|
|
|
|
//}
|