| author |  Andrew Kelley <andrew@ziglang.org> 2020-11-06 14:09:31-05:00 |
| committer |  GitHub <noreply@github.com> 2020-11-06 14:09:31-05:00 |
| log | d1b1f053b0fa8bf5bf716bae79fd656ce8aaec27 |
| tree | 82795b82ea092ebe4c777ed75db4fe503704c9ad |
| parent | b9391c9564dd56a46fbf83d8c536af1a3ad14678 |
| parent | ff14451b4a328ca6862637a88912000d11aa2bf3 |
| signature |  Signed by PGP key 4AEE18F83AFDEB23 |
Merge pull request #6941 from LemonBoy/floateqapprox
std: Implement more useful approxEq semantics51 files changed, 574 insertions(+), 470 deletions(-)
lib/std/fmt/parse_float.zig+9-9
| ... | @@ -370,7 +370,7 @@ test "fmt.parseFloat" { | ... | @@ -370,7 +370,7 @@ test "fmt.parseFloat" { |
| 370 | const testing = std.testing; | 370 | const testing = std.testing; |
| 371 | const expect = testing.expect; | 371 | const expect = testing.expect; |
| 372 | const expectEqual = testing.expectEqual; | 372 | const expectEqual = testing.expectEqual; |
| 373 | const approxEq = std.math.approxEq; | 373 | const approxEqAbs = std.math.approxEqAbs; |
| 374 | const epsilon = 1e-7; | 374 | const epsilon = 1e-7; |
| 375 | 375 | ||
| 376 | inline for ([_]type{ f16, f32, f64, f128 }) |T| { | 376 | inline for ([_]type{ f16, f32, f64, f128 }) |T| { |
| ... | @@ -392,8 +392,8 @@ test "fmt.parseFloat" { | ... | @@ -392,8 +392,8 @@ test "fmt.parseFloat" { |
| 392 | expectEqual(try parseFloat(T, "-1e0"), -1.0); | 392 | expectEqual(try parseFloat(T, "-1e0"), -1.0); |
| 393 | expectEqual(try parseFloat(T, "1.234e3"), 1234); | 393 | expectEqual(try parseFloat(T, "1.234e3"), 1234); |
| 394 | 394 | ||
| 395 | expect(approxEq(T, try parseFloat(T, "3.141"), 3.141, epsilon)); | 395 | expect(approxEqAbs(T, try parseFloat(T, "3.141"), 3.141, epsilon)); |
| 396 | expect(approxEq(T, try parseFloat(T, "-3.141"), -3.141, epsilon)); | 396 | expect(approxEqAbs(T, try parseFloat(T, "-3.141"), -3.141, epsilon)); |
| 397 | 397 | ||
| 398 | expectEqual(try parseFloat(T, "1e-700"), 0); | 398 | expectEqual(try parseFloat(T, "1e-700"), 0); |
| 399 | expectEqual(try parseFloat(T, "1e+700"), std.math.inf(T)); | 399 | expectEqual(try parseFloat(T, "1e+700"), std.math.inf(T)); |
| ... | @@ -405,13 +405,13 @@ test "fmt.parseFloat" { | ... | @@ -405,13 +405,13 @@ test "fmt.parseFloat" { |
| 405 | expectEqual(try parseFloat(T, "0.4e0066999999999999999999999999999999999999999999999999999"), std.math.inf(T)); | 405 | expectEqual(try parseFloat(T, "0.4e0066999999999999999999999999999999999999999999999999999"), std.math.inf(T)); |
| 406 | 406 | ||
| 407 | if (T != f16) { | 407 | if (T != f16) { |
| 408 | expect(approxEq(T, try parseFloat(T, "1e-2"), 0.01, epsilon)); | 408 | expect(approxEqAbs(T, try parseFloat(T, "1e-2"), 0.01, epsilon)); |
| 409 | expect(approxEq(T, try parseFloat(T, "1234e-2"), 12.34, epsilon)); | 409 | expect(approxEqAbs(T, try parseFloat(T, "1234e-2"), 12.34, epsilon)); |
| 410 | 410 | ||
| 411 | expect(approxEq(T, try parseFloat(T, "123142.1"), 123142.1, epsilon)); | 411 | expect(approxEqAbs(T, try parseFloat(T, "123142.1"), 123142.1, epsilon)); |
| 412 | expect(approxEq(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon)); | 412 | expect(approxEqAbs(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon)); |
| 413 | expect(approxEq(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon)); | 413 | expect(approxEqAbs(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon)); |
| 414 | expect(approxEq(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon)); | 414 | expect(approxEqAbs(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon)); |
| 415 | } | 415 | } |
| 416 | } | 416 | } |
| 417 | } | 417 | } |
lib/std/math.zig+87-2
| ... | @@ -64,6 +64,8 @@ pub const f16_max = 65504; | ... | @@ -64,6 +64,8 @@ pub const f16_max = 65504; |
| 64 | pub const f16_epsilon = 0.0009765625; // 2**-10 | 64 | pub const f16_epsilon = 0.0009765625; // 2**-10 |
| 65 | pub const f16_toint = 1.0 / f16_epsilon; | 65 | pub const f16_toint = 1.0 / f16_epsilon; |
| 66 | 66 | ||
| 67 | pub const epsilon = @import("math/epsilon.zig").epsilon; | ||
| 68 | |||
| 67 | pub const nan_u16 = @as(u16, 0x7C01); | 69 | pub const nan_u16 = @as(u16, 0x7C01); |
| 68 | pub const nan_f16 = @bitCast(f16, nan_u16); | 70 | pub const nan_f16 = @bitCast(f16, nan_u16); |
| 69 | 71 | ||
| ... | @@ -104,9 +106,92 @@ pub const nan = @import("math/nan.zig").nan; | ... | @@ -104,9 +106,92 @@ pub const nan = @import("math/nan.zig").nan; |
| 104 | pub const snan = @import("math/nan.zig").snan; | 106 | pub const snan = @import("math/nan.zig").snan; |
| 105 | pub const inf = @import("math/inf.zig").inf; | 107 | pub const inf = @import("math/inf.zig").inf; |
| 106 | 108 | ||
| 107 | pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool { | 109 | /// Performs an approximate comparison of two floating point values `x` and `y`. |
| 110 | /// Returns true if the absolute difference between them is less or equal than | ||
| 111 | /// the specified tolerance. | ||
| 112 | /// | ||
| 113 | /// The `tolerance` parameter is the absolute tolerance used when determining if | ||
| 114 | /// the two numbers are close enough, a good value for this parameter is a small | ||
| 115 | /// multiple of `epsilon(T)`. | ||
| 116 | /// | ||
| 117 | /// Note that this function is recommended for for comparing small numbers | ||
| 118 | /// around zero, using `approxEqRel` is suggested otherwise. | ||
| 119 | /// | ||
| 120 | /// NaN values are never considered equal to any value. | ||
| 121 | pub fn approxEqAbs(comptime T: type, x: T, y: T, tolerance: T) bool { | ||
| 122 | assert(@typeInfo(T) == .Float); | ||
| 123 | assert(tolerance >= 0); | ||
| 124 | |||
| 125 | // Fast path for equal values (and signed zeros and infinites). | ||
| 126 | if (x == y) | ||
| 127 | return true; | ||
| 128 | |||
| 129 | if (isNan(x) or isNan(y)) | ||
| 130 | return false; | ||
| 131 | |||
| 132 | return fabs(x - y) <= tolerance; | ||
| 133 | } | ||
| 134 | |||
| 135 | /// Performs an approximate comparison of two floating point values `x` and `y`. | ||
| 136 | /// Returns true if the absolute difference between them is less or equal than | ||
| 137 | /// `max(|x|, |y|) * tolerance`, where `tolerance` is a positive number greater | ||
| 138 | /// than zero. | ||
| 139 | /// | ||
| 140 | /// The `tolerance` parameter is the relative tolerance used when determining if | ||
| 141 | /// the two numbers are close enough, a good value for this parameter is usually | ||
| 142 | /// `sqrt(epsilon(T))`, meaning that the two numbers are considered equal if at | ||
| 143 | /// least half of the digits are equal. | ||
| 144 | /// | ||
| 145 | /// Note that for comparisons of small numbers around zero this function won't | ||
| 146 | /// give meaningful results, use `approxEqAbs` instead. | ||
| 147 | /// | ||
| 148 | /// NaN values are never considered equal to any value. | ||
| 149 | pub fn approxEqRel(comptime T: type, x: T, y: T, tolerance: T) bool { | ||
| 108 | assert(@typeInfo(T) == .Float); | 150 | assert(@typeInfo(T) == .Float); |
| 109 | return fabs(x - y) < epsilon; | 151 | assert(tolerance > 0); |
| 152 | |||
| 153 | // Fast path for equal values (and signed zeros and infinites). | ||
| 154 | if (x == y) | ||
| 155 | return true; | ||
| 156 | |||
| 157 | if (isNan(x) or isNan(y)) | ||
| 158 | return false; | ||
| 159 | |||
| 160 | return fabs(x - y) <= max(fabs(x), fabs(y)) * tolerance; | ||
| 161 | } | ||
| 162 | |||
| 163 | /// Deprecated, use `approxEqAbs` or `approxEqRel`. | ||
| 164 | pub const approxEq = approxEqAbs; | ||
| 165 | |||
| 166 | test "approxEqAbs and approxEqRel" { | ||
| 167 | inline for ([_]type{ f16, f32, f64, f128 }) |T| { | ||
| 168 | const eps_value = comptime epsilon(T); | ||
| 169 | const sqrt_eps_value = comptime sqrt(eps_value); | ||
| 170 | const nan_value = comptime nan(T); | ||
| 171 | const inf_value = comptime inf(T); | ||
| 172 | const min_value: T = switch (T) { | ||
| 173 | f16 => f16_min, | ||
| 174 | f32 => f32_min, | ||
| 175 | f64 => f64_min, | ||
| 176 | f128 => f128_min, | ||
| 177 | else => unreachable, | ||
| 178 | }; | ||
| 179 | |||
| 180 | testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value)); | ||
| 181 | testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value)); | ||
| 182 | testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value)); | ||
| 183 | testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value)); | ||
| 184 | testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value)); | ||
| 185 | testing.expect(!approxEqAbs(T, 1.0 + 2 * epsilon(T), 1.0, eps_value)); | ||
| 186 | testing.expect(approxEqAbs(T, 1.0 + 1 * epsilon(T), 1.0, eps_value)); | ||
| 187 | testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value)); | ||
| 188 | testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value)); | ||
| 189 | testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value)); | ||
| 190 | testing.expect(approxEqRel(T, min_value, min_value, sqrt_eps_value)); | ||
| 191 | testing.expect(approxEqRel(T, -min_value, -min_value, sqrt_eps_value)); | ||
| 192 | testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2)); | ||
| 193 | testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2)); | ||
| 194 | } | ||
| 110 | } | 195 | } |
| 111 | 196 | ||
| 112 | pub fn doNotOptimizeAway(value: anytype) void { | 197 | pub fn doNotOptimizeAway(value: anytype) void { |
lib/std/math/acos.zig+12-12
| ... | @@ -161,23 +161,23 @@ test "math.acos" { | ... | @@ -161,23 +161,23 @@ test "math.acos" { |
| 161 | test "math.acos32" { | 161 | test "math.acos32" { |
| 162 | const epsilon = 0.000001; | 162 | const epsilon = 0.000001; |
| 163 | 163 | ||
| 164 | expect(math.approxEq(f32, acos32(0.0), 1.570796, epsilon)); | 164 | expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon)); |
| 165 | expect(math.approxEq(f32, acos32(0.2), 1.369438, epsilon)); | 165 | expect(math.approxEqAbs(f32, acos32(0.2), 1.369438, epsilon)); |
| 166 | expect(math.approxEq(f32, acos32(0.3434), 1.220262, epsilon)); | 166 | expect(math.approxEqAbs(f32, acos32(0.3434), 1.220262, epsilon)); |
| 167 | expect(math.approxEq(f32, acos32(0.5), 1.047198, epsilon)); | 167 | expect(math.approxEqAbs(f32, acos32(0.5), 1.047198, epsilon)); |
| 168 | expect(math.approxEq(f32, acos32(0.8923), 0.468382, epsilon)); | 168 | expect(math.approxEqAbs(f32, acos32(0.8923), 0.468382, epsilon)); |
| 169 | expect(math.approxEq(f32, acos32(-0.2), 1.772154, epsilon)); | 169 | expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon)); |
| 170 | } | 170 | } |
| 171 | 171 | ||
| 172 | test "math.acos64" { | 172 | test "math.acos64" { |
| 173 | const epsilon = 0.000001; | 173 | const epsilon = 0.000001; |
| 174 | 174 | ||
| 175 | expect(math.approxEq(f64, acos64(0.0), 1.570796, epsilon)); | 175 | expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon)); |
| 176 | expect(math.approxEq(f64, acos64(0.2), 1.369438, epsilon)); | 176 | expect(math.approxEqAbs(f64, acos64(0.2), 1.369438, epsilon)); |
| 177 | expect(math.approxEq(f64, acos64(0.3434), 1.220262, epsilon)); | 177 | expect(math.approxEqAbs(f64, acos64(0.3434), 1.220262, epsilon)); |
| 178 | expect(math.approxEq(f64, acos64(0.5), 1.047198, epsilon)); | 178 | expect(math.approxEqAbs(f64, acos64(0.5), 1.047198, epsilon)); |
| 179 | expect(math.approxEq(f64, acos64(0.8923), 0.468382, epsilon)); | 179 | expect(math.approxEqAbs(f64, acos64(0.8923), 0.468382, epsilon)); |
| 180 | expect(math.approxEq(f64, acos64(-0.2), 1.772154, epsilon)); | 180 | expect(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon)); |
| 181 | } | 181 | } |
| 182 | 182 | ||
| 183 | test "math.acos32.special" { | 183 | test "math.acos32.special" { |
lib/std/math/acosh.zig+8-8
| ... | @@ -73,19 +73,19 @@ test "math.acosh" { | ... | @@ -73,19 +73,19 @@ test "math.acosh" { |
| 73 | test "math.acosh32" { | 73 | test "math.acosh32" { |
| 74 | const epsilon = 0.000001; | 74 | const epsilon = 0.000001; |
| 75 | 75 | ||
| 76 | expect(math.approxEq(f32, acosh32(1.5), 0.962424, epsilon)); | 76 | expect(math.approxEqAbs(f32, acosh32(1.5), 0.962424, epsilon)); |
| 77 | expect(math.approxEq(f32, acosh32(37.45), 4.315976, epsilon)); | 77 | expect(math.approxEqAbs(f32, acosh32(37.45), 4.315976, epsilon)); |
| 78 | expect(math.approxEq(f32, acosh32(89.123), 5.183133, epsilon)); | 78 | expect(math.approxEqAbs(f32, acosh32(89.123), 5.183133, epsilon)); |
| 79 | expect(math.approxEq(f32, acosh32(123123.234375), 12.414088, epsilon)); | 79 | expect(math.approxEqAbs(f32, acosh32(123123.234375), 12.414088, epsilon)); |
| 80 | } | 80 | } |
| 81 | 81 | ||
| 82 | test "math.acosh64" { | 82 | test "math.acosh64" { |
| 83 | const epsilon = 0.000001; | 83 | const epsilon = 0.000001; |
| 84 | 84 | ||
| 85 | expect(math.approxEq(f64, acosh64(1.5), 0.962424, epsilon)); | 85 | expect(math.approxEqAbs(f64, acosh64(1.5), 0.962424, epsilon)); |
| 86 | expect(math.approxEq(f64, acosh64(37.45), 4.315976, epsilon)); | 86 | expect(math.approxEqAbs(f64, acosh64(37.45), 4.315976, epsilon)); |
| 87 | expect(math.approxEq(f64, acosh64(89.123), 5.183133, epsilon)); | 87 | expect(math.approxEqAbs(f64, acosh64(89.123), 5.183133, epsilon)); |
| 88 | expect(math.approxEq(f64, acosh64(123123.234375), 12.414088, epsilon)); | 88 | expect(math.approxEqAbs(f64, acosh64(123123.234375), 12.414088, epsilon)); |
| 89 | } | 89 | } |
| 90 | 90 | ||
| 91 | test "math.acosh32.special" { | 91 | test "math.acosh32.special" { |
lib/std/math/asin.zig+12-12
| ... | @@ -154,23 +154,23 @@ test "math.asin" { | ... | @@ -154,23 +154,23 @@ test "math.asin" { |
| 154 | test "math.asin32" { | 154 | test "math.asin32" { |
| 155 | const epsilon = 0.000001; | 155 | const epsilon = 0.000001; |
| 156 | 156 | ||
| 157 | expect(math.approxEq(f32, asin32(0.0), 0.0, epsilon)); | 157 | expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon)); |
| 158 | expect(math.approxEq(f32, asin32(0.2), 0.201358, epsilon)); | 158 | expect(math.approxEqAbs(f32, asin32(0.2), 0.201358, epsilon)); |
| 159 | expect(math.approxEq(f32, asin32(-0.2), -0.201358, epsilon)); | 159 | expect(math.approxEqAbs(f32, asin32(-0.2), -0.201358, epsilon)); |
| 160 | expect(math.approxEq(f32, asin32(0.3434), 0.350535, epsilon)); | 160 | expect(math.approxEqAbs(f32, asin32(0.3434), 0.350535, epsilon)); |
| 161 | expect(math.approxEq(f32, asin32(0.5), 0.523599, epsilon)); | 161 | expect(math.approxEqAbs(f32, asin32(0.5), 0.523599, epsilon)); |
| 162 | expect(math.approxEq(f32, asin32(0.8923), 1.102415, epsilon)); | 162 | expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon)); |
| 163 | } | 163 | } |
| 164 | 164 | ||
| 165 | test "math.asin64" { | 165 | test "math.asin64" { |
| 166 | const epsilon = 0.000001; | 166 | const epsilon = 0.000001; |
| 167 | 167 | ||
| 168 | expect(math.approxEq(f64, asin64(0.0), 0.0, epsilon)); | 168 | expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon)); |
| 169 | expect(math.approxEq(f64, asin64(0.2), 0.201358, epsilon)); | 169 | expect(math.approxEqAbs(f64, asin64(0.2), 0.201358, epsilon)); |
| 170 | expect(math.approxEq(f64, asin64(-0.2), -0.201358, epsilon)); | 170 | expect(math.approxEqAbs(f64, asin64(-0.2), -0.201358, epsilon)); |
| 171 | expect(math.approxEq(f64, asin64(0.3434), 0.350535, epsilon)); | 171 | expect(math.approxEqAbs(f64, asin64(0.3434), 0.350535, epsilon)); |
| 172 | expect(math.approxEq(f64, asin64(0.5), 0.523599, epsilon)); | 172 | expect(math.approxEqAbs(f64, asin64(0.5), 0.523599, epsilon)); |
| 173 | expect(math.approxEq(f64, asin64(0.8923), 1.102415, epsilon)); | 173 | expect(math.approxEqAbs(f64, asin64(0.8923), 1.102415, epsilon)); |
| 174 | } | 174 | } |
| 175 | 175 | ||
| 176 | test "math.asin32.special" { | 176 | test "math.asin32.special" { |
lib/std/math/asinh.zig+14-14
| ... | @@ -101,25 +101,25 @@ test "math.asinh" { | ... | @@ -101,25 +101,25 @@ test "math.asinh" { |
| 101 | test "math.asinh32" { | 101 | test "math.asinh32" { |
| 102 | const epsilon = 0.000001; | 102 | const epsilon = 0.000001; |
| 103 | 103 | ||
| 104 | expect(math.approxEq(f32, asinh32(0.0), 0.0, epsilon)); | 104 | expect(math.approxEqAbs(f32, asinh32(0.0), 0.0, epsilon)); |
| 105 | expect(math.approxEq(f32, asinh32(0.2), 0.198690, epsilon)); | 105 | expect(math.approxEqAbs(f32, asinh32(0.2), 0.198690, epsilon)); |
| 106 | expect(math.approxEq(f32, asinh32(0.8923), 0.803133, epsilon)); | 106 | expect(math.approxEqAbs(f32, asinh32(0.8923), 0.803133, epsilon)); |
| 107 | expect(math.approxEq(f32, asinh32(1.5), 1.194763, epsilon)); | 107 | expect(math.approxEqAbs(f32, asinh32(1.5), 1.194763, epsilon)); |
| 108 | expect(math.approxEq(f32, asinh32(37.45), 4.316332, epsilon)); | 108 | expect(math.approxEqAbs(f32, asinh32(37.45), 4.316332, epsilon)); |
| 109 | expect(math.approxEq(f32, asinh32(89.123), 5.183196, epsilon)); | 109 | expect(math.approxEqAbs(f32, asinh32(89.123), 5.183196, epsilon)); |
| 110 | expect(math.approxEq(f32, asinh32(123123.234375), 12.414088, epsilon)); | 110 | expect(math.approxEqAbs(f32, asinh32(123123.234375), 12.414088, epsilon)); |
| 111 | } | 111 | } |
| 112 | 112 | ||
| 113 | test "math.asinh64" { | 113 | test "math.asinh64" { |
| 114 | const epsilon = 0.000001; | 114 | const epsilon = 0.000001; |
| 115 | 115 | ||
| 116 | expect(math.approxEq(f64, asinh64(0.0), 0.0, epsilon)); | 116 | expect(math.approxEqAbs(f64, asinh64(0.0), 0.0, epsilon)); |
| 117 | expect(math.approxEq(f64, asinh64(0.2), 0.198690, epsilon)); | 117 | expect(math.approxEqAbs(f64, asinh64(0.2), 0.198690, epsilon)); |
| 118 | expect(math.approxEq(f64, asinh64(0.8923), 0.803133, epsilon)); | 118 | expect(math.approxEqAbs(f64, asinh64(0.8923), 0.803133, epsilon)); |
| 119 | expect(math.approxEq(f64, asinh64(1.5), 1.194763, epsilon)); | 119 | expect(math.approxEqAbs(f64, asinh64(1.5), 1.194763, epsilon)); |
| 120 | expect(math.approxEq(f64, asinh64(37.45), 4.316332, epsilon)); | 120 | expect(math.approxEqAbs(f64, asinh64(37.45), 4.316332, epsilon)); |
| 121 | expect(math.approxEq(f64, asinh64(89.123), 5.183196, epsilon)); | 121 | expect(math.approxEqAbs(f64, asinh64(89.123), 5.183196, epsilon)); |
| 122 | expect(math.approxEq(f64, asinh64(123123.234375), 12.414088, epsilon)); | 122 | expect(math.approxEqAbs(f64, asinh64(123123.234375), 12.414088, epsilon)); |
| 123 | } | 123 | } |
| 124 | 124 | ||
| 125 | test "math.asinh32.special" { | 125 | test "math.asinh32.special" { |
lib/std/math/atan.zig+14-14
| ... | @@ -224,21 +224,21 @@ test "math.atan" { | ... | @@ -224,21 +224,21 @@ test "math.atan" { |
| 224 | test "math.atan32" { | 224 | test "math.atan32" { |
| 225 | const epsilon = 0.000001; | 225 | const epsilon = 0.000001; |
| 226 | 226 | ||
| 227 | expect(math.approxEq(f32, atan32(0.2), 0.197396, epsilon)); | 227 | expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon)); |
| 228 | expect(math.approxEq(f32, atan32(-0.2), -0.197396, epsilon)); | 228 | expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon)); |
| 229 | expect(math.approxEq(f32, atan32(0.3434), 0.330783, epsilon)); | 229 | expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon)); |
| 230 | expect(math.approxEq(f32, atan32(0.8923), 0.728545, epsilon)); | 230 | expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon)); |
| 231 | expect(math.approxEq(f32, atan32(1.5), 0.982794, epsilon)); | 231 | expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon)); |
| 232 | } | 232 | } |
| 233 | 233 | ||
| 234 | test "math.atan64" { | 234 | test "math.atan64" { |
| 235 | const epsilon = 0.000001; | 235 | const epsilon = 0.000001; |
| 236 | 236 | ||
| 237 | expect(math.approxEq(f64, atan64(0.2), 0.197396, epsilon)); | 237 | expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon)); |
| 238 | expect(math.approxEq(f64, atan64(-0.2), -0.197396, epsilon)); | 238 | expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon)); |
| 239 | expect(math.approxEq(f64, atan64(0.3434), 0.330783, epsilon)); | 239 | expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon)); |
| 240 | expect(math.approxEq(f64, atan64(0.8923), 0.728545, epsilon)); | 240 | expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon)); |
| 241 | expect(math.approxEq(f64, atan64(1.5), 0.982794, epsilon)); | 241 | expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon)); |
| 242 | } | 242 | } |
| 243 | 243 | ||
| 244 | test "math.atan32.special" { | 244 | test "math.atan32.special" { |
| ... | @@ -246,8 +246,8 @@ test "math.atan32.special" { | ... | @@ -246,8 +246,8 @@ test "math.atan32.special" { |
| 246 | 246 | ||
| 247 | expect(atan32(0.0) == 0.0); | 247 | expect(atan32(0.0) == 0.0); |
| 248 | expect(atan32(-0.0) == -0.0); | 248 | expect(atan32(-0.0) == -0.0); |
| 249 | expect(math.approxEq(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon)); | 249 | expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon)); |
| 250 | expect(math.approxEq(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon)); | 250 | expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon)); |
| 251 | } | 251 | } |
| 252 | 252 | ||
| 253 | test "math.atan64.special" { | 253 | test "math.atan64.special" { |
| ... | @@ -255,6 +255,6 @@ test "math.atan64.special" { | ... | @@ -255,6 +255,6 @@ test "math.atan64.special" { |
| 255 | 255 | ||
| 256 | expect(atan64(0.0) == 0.0); | 256 | expect(atan64(0.0) == 0.0); |
| 257 | expect(atan64(-0.0) == -0.0); | 257 | expect(atan64(-0.0) == -0.0); |
| 258 | expect(math.approxEq(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon)); | 258 | expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon)); |
| 259 | expect(math.approxEq(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon)); | 259 | expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon)); |
| 260 | } | 260 | } |
lib/std/math/atan2.zig+42-42
| ... | @@ -224,25 +224,25 @@ test "math.atan2" { | ... | @@ -224,25 +224,25 @@ test "math.atan2" { |
| 224 | test "math.atan2_32" { | 224 | test "math.atan2_32" { |
| 225 | const epsilon = 0.000001; | 225 | const epsilon = 0.000001; |
| 226 | 226 | ||
| 227 | expect(math.approxEq(f32, atan2_32(0.0, 0.0), 0.0, epsilon)); | 227 | expect(math.approxEqAbs(f32, atan2_32(0.0, 0.0), 0.0, epsilon)); |
| 228 | expect(math.approxEq(f32, atan2_32(0.2, 0.2), 0.785398, epsilon)); | 228 | expect(math.approxEqAbs(f32, atan2_32(0.2, 0.2), 0.785398, epsilon)); |
| 229 | expect(math.approxEq(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon)); | 229 | expect(math.approxEqAbs(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon)); |
| 230 | expect(math.approxEq(f32, atan2_32(0.2, -0.2), 2.356194, epsilon)); | 230 | expect(math.approxEqAbs(f32, atan2_32(0.2, -0.2), 2.356194, epsilon)); |
| 231 | expect(math.approxEq(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon)); | 231 | expect(math.approxEqAbs(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon)); |
| 232 | expect(math.approxEq(f32, atan2_32(0.34, -0.4), 2.437099, epsilon)); | 232 | expect(math.approxEqAbs(f32, atan2_32(0.34, -0.4), 2.437099, epsilon)); |
| 233 | expect(math.approxEq(f32, atan2_32(0.34, 1.243), 0.267001, epsilon)); | 233 | expect(math.approxEqAbs(f32, atan2_32(0.34, 1.243), 0.267001, epsilon)); |
| 234 | } | 234 | } |
| 235 | 235 | ||
| 236 | test "math.atan2_64" { | 236 | test "math.atan2_64" { |
| 237 | const epsilon = 0.000001; | 237 | const epsilon = 0.000001; |
| 238 | 238 | ||
| 239 | expect(math.approxEq(f64, atan2_64(0.0, 0.0), 0.0, epsilon)); | 239 | expect(math.approxEqAbs(f64, atan2_64(0.0, 0.0), 0.0, epsilon)); |
| 240 | expect(math.approxEq(f64, atan2_64(0.2, 0.2), 0.785398, epsilon)); | 240 | expect(math.approxEqAbs(f64, atan2_64(0.2, 0.2), 0.785398, epsilon)); |
| 241 | expect(math.approxEq(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon)); | 241 | expect(math.approxEqAbs(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon)); |
| 242 | expect(math.approxEq(f64, atan2_64(0.2, -0.2), 2.356194, epsilon)); | 242 | expect(math.approxEqAbs(f64, atan2_64(0.2, -0.2), 2.356194, epsilon)); |
| 243 | expect(math.approxEq(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon)); | 243 | expect(math.approxEqAbs(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon)); |
| 244 | expect(math.approxEq(f64, atan2_64(0.34, -0.4), 2.437099, epsilon)); | 244 | expect(math.approxEqAbs(f64, atan2_64(0.34, -0.4), 2.437099, epsilon)); |
| 245 | expect(math.approxEq(f64, atan2_64(0.34, 1.243), 0.267001, epsilon)); | 245 | expect(math.approxEqAbs(f64, atan2_64(0.34, 1.243), 0.267001, epsilon)); |
| 246 | } | 246 | } |
| 247 | 247 | ||
| 248 | test "math.atan2_32.special" { | 248 | test "math.atan2_32.special" { |
| ... | @@ -252,21 +252,21 @@ test "math.atan2_32.special" { | ... | @@ -252,21 +252,21 @@ test "math.atan2_32.special" { |
| 252 | expect(math.isNan(atan2_32(math.nan(f32), 1.0))); | 252 | expect(math.isNan(atan2_32(math.nan(f32), 1.0))); |
| 253 | expect(atan2_32(0.0, 5.0) == 0.0); | 253 | expect(atan2_32(0.0, 5.0) == 0.0); |
| 254 | expect(atan2_32(-0.0, 5.0) == -0.0); | 254 | expect(atan2_32(-0.0, 5.0) == -0.0); |
| 255 | expect(math.approxEq(f32, atan2_32(0.0, -5.0), math.pi, epsilon)); | 255 | expect(math.approxEqAbs(f32, atan2_32(0.0, -5.0), math.pi, epsilon)); |
| 256 | //expect(math.approxEq(f32, atan2_32(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero? | 256 | //expect(math.approxEqAbs(f32, atan2_32(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero? |
| 257 | expect(math.approxEq(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon)); | 257 | expect(math.approxEqAbs(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon)); |
| 258 | expect(math.approxEq(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon)); | 258 | expect(math.approxEqAbs(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon)); |
| 259 | expect(math.approxEq(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon)); | 259 | expect(math.approxEqAbs(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon)); |
| 260 | expect(math.approxEq(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon)); | 260 | expect(math.approxEqAbs(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon)); |
| 261 | expect(math.approxEq(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon)); | 261 | expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon)); |
| 262 | expect(math.approxEq(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon)); | 262 | expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon)); |
| 263 | expect(math.approxEq(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon)); | 263 | expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon)); |
| 264 | expect(math.approxEq(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon)); | 264 | expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon)); |
| 265 | expect(atan2_32(1.0, math.inf(f32)) == 0.0); | 265 | expect(atan2_32(1.0, math.inf(f32)) == 0.0); |
| 266 | expect(math.approxEq(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon)); | 266 | expect(math.approxEqAbs(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon)); |
| 267 | expect(math.approxEq(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon)); | 267 | expect(math.approxEqAbs(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon)); |
| 268 | expect(math.approxEq(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon)); | 268 | expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon)); |
| 269 | expect(math.approxEq(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon)); | 269 | expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon)); |
| 270 | } | 270 | } |
| 271 | 271 | ||
| 272 | test "math.atan2_64.special" { | 272 | test "math.atan2_64.special" { |
| ... | @@ -276,19 +276,19 @@ test "math.atan2_64.special" { | ... | @@ -276,19 +276,19 @@ test "math.atan2_64.special" { |
| 276 | expect(math.isNan(atan2_64(math.nan(f64), 1.0))); | 276 | expect(math.isNan(atan2_64(math.nan(f64), 1.0))); |
| 277 | expect(atan2_64(0.0, 5.0) == 0.0); | 277 | expect(atan2_64(0.0, 5.0) == 0.0); |
| 278 | expect(atan2_64(-0.0, 5.0) == -0.0); | 278 | expect(atan2_64(-0.0, 5.0) == -0.0); |
| 279 | expect(math.approxEq(f64, atan2_64(0.0, -5.0), math.pi, epsilon)); | 279 | expect(math.approxEqAbs(f64, atan2_64(0.0, -5.0), math.pi, epsilon)); |
| 280 | //expect(math.approxEq(f64, atan2_64(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero? | 280 | //expect(math.approxEqAbs(f64, atan2_64(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero? |
| 281 | expect(math.approxEq(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon)); | 281 | expect(math.approxEqAbs(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon)); |
| 282 | expect(math.approxEq(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon)); | 282 | expect(math.approxEqAbs(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon)); |
| 283 | expect(math.approxEq(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon)); | 283 | expect(math.approxEqAbs(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon)); |
| 284 | expect(math.approxEq(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon)); | 284 | expect(math.approxEqAbs(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon)); |
| 285 | expect(math.approxEq(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon)); | 285 | expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon)); |
| 286 | expect(math.approxEq(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon)); | 286 | expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon)); |
| 287 | expect(math.approxEq(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon)); | 287 | expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon)); |
| 288 | expect(math.approxEq(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon)); | 288 | expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon)); |
| 289 | expect(atan2_64(1.0, math.inf(f64)) == 0.0); | 289 | expect(atan2_64(1.0, math.inf(f64)) == 0.0); |
| 290 | expect(math.approxEq(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon)); | 290 | expect(math.approxEqAbs(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon)); |
| 291 | expect(math.approxEq(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon)); | 291 | expect(math.approxEqAbs(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon)); |
| 292 | expect(math.approxEq(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon)); | 292 | expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon)); |
| 293 | expect(math.approxEq(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon)); | 293 | expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon)); |
| 294 | } | 294 | } |
lib/std/math/atanh.zig+6-6
| ... | @@ -96,17 +96,17 @@ test "math.atanh" { | ... | @@ -96,17 +96,17 @@ test "math.atanh" { |
| 96 | test "math.atanh_32" { | 96 | test "math.atanh_32" { |
| 97 | const epsilon = 0.000001; | 97 | const epsilon = 0.000001; |
| 98 | 98 | ||
| 99 | expect(math.approxEq(f32, atanh_32(0.0), 0.0, epsilon)); | 99 | expect(math.approxEqAbs(f32, atanh_32(0.0), 0.0, epsilon)); |
| 100 | expect(math.approxEq(f32, atanh_32(0.2), 0.202733, epsilon)); | 100 | expect(math.approxEqAbs(f32, atanh_32(0.2), 0.202733, epsilon)); |
| 101 | expect(math.approxEq(f32, atanh_32(0.8923), 1.433099, epsilon)); | 101 | expect(math.approxEqAbs(f32, atanh_32(0.8923), 1.433099, epsilon)); |
| 102 | } | 102 | } |
| 103 | 103 | ||
| 104 | test "math.atanh_64" { | 104 | test "math.atanh_64" { |
| 105 | const epsilon = 0.000001; | 105 | const epsilon = 0.000001; |
| 106 | 106 | ||
| 107 | expect(math.approxEq(f64, atanh_64(0.0), 0.0, epsilon)); | 107 | expect(math.approxEqAbs(f64, atanh_64(0.0), 0.0, epsilon)); |
| 108 | expect(math.approxEq(f64, atanh_64(0.2), 0.202733, epsilon)); | 108 | expect(math.approxEqAbs(f64, atanh_64(0.2), 0.202733, epsilon)); |
| 109 | expect(math.approxEq(f64, atanh_64(0.8923), 1.433099, epsilon)); | 109 | expect(math.approxEqAbs(f64, atanh_64(0.8923), 1.433099, epsilon)); |
| 110 | } | 110 | } |
| 111 | 111 | ||
| 112 | test "math.atanh32.special" { | 112 | test "math.atanh32.special" { |
lib/std/math/cbrt.zig+10-10
| ... | @@ -133,22 +133,22 @@ test "math.cbrt32" { | ... | @@ -133,22 +133,22 @@ test "math.cbrt32" { |
| 133 | const epsilon = 0.000001; | 133 | const epsilon = 0.000001; |
| 134 | 134 | ||
| 135 | expect(cbrt32(0.0) == 0.0); | 135 | expect(cbrt32(0.0) == 0.0); |
| 136 | expect(math.approxEq(f32, cbrt32(0.2), 0.584804, epsilon)); | 136 | expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon)); |
| 137 | expect(math.approxEq(f32, cbrt32(0.8923), 0.962728, epsilon)); | 137 | expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon)); |
| 138 | expect(math.approxEq(f32, cbrt32(1.5), 1.144714, epsilon)); | 138 | expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon)); |
| 139 | expect(math.approxEq(f32, cbrt32(37.45), 3.345676, epsilon)); | 139 | expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon)); |
| 140 | expect(math.approxEq(f32, cbrt32(123123.234375), 49.748501, epsilon)); | 140 | expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon)); |
| 141 | } | 141 | } |
| 142 | 142 | ||
| 143 | test "math.cbrt64" { | 143 | test "math.cbrt64" { |
| 144 | const epsilon = 0.000001; | 144 | const epsilon = 0.000001; |
| 145 | 145 | ||
| 146 | expect(cbrt64(0.0) == 0.0); | 146 | expect(cbrt64(0.0) == 0.0); |
| 147 | expect(math.approxEq(f64, cbrt64(0.2), 0.584804, epsilon)); | 147 | expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon)); |
| 148 | expect(math.approxEq(f64, cbrt64(0.8923), 0.962728, epsilon)); | 148 | expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon)); |
| 149 | expect(math.approxEq(f64, cbrt64(1.5), 1.144714, epsilon)); | 149 | expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon)); |
| 150 | expect(math.approxEq(f64, cbrt64(37.45), 3.345676, epsilon)); | 150 | expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon)); |
| 151 | expect(math.approxEq(f64, cbrt64(123123.234375), 49.748501, epsilon)); | 151 | expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon)); |
| 152 | } | 152 | } |
| 153 | 153 | ||
| 154 | test "math.cbrt.special" { | 154 | test "math.cbrt.special" { |
lib/std/math/complex.zig+5-5
| ... | @@ -138,8 +138,8 @@ test "complex.div" { | ... | @@ -138,8 +138,8 @@ test "complex.div" { |
| 138 | const b = Complex(f32).new(2, 7); | 138 | const b = Complex(f32).new(2, 7); |
| 139 | const c = a.div(b); | 139 | const c = a.div(b); |
| 140 | 140 | ||
| 141 | testing.expect(math.approxEq(f32, c.re, @as(f32, 31) / 53, epsilon) and | 141 | testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 31) / 53, epsilon) and |
| 142 | math.approxEq(f32, c.im, @as(f32, -29) / 53, epsilon)); | 142 | math.approxEqAbs(f32, c.im, @as(f32, -29) / 53, epsilon)); |
| 143 | } | 143 | } |
| 144 | 144 | ||
| 145 | test "complex.conjugate" { | 145 | test "complex.conjugate" { |
| ... | @@ -153,15 +153,15 @@ test "complex.reciprocal" { | ... | @@ -153,15 +153,15 @@ test "complex.reciprocal" { |
| 153 | const a = Complex(f32).new(5, 3); | 153 | const a = Complex(f32).new(5, 3); |
| 154 | const c = a.reciprocal(); | 154 | const c = a.reciprocal(); |
| 155 | 155 | ||
| 156 | testing.expect(math.approxEq(f32, c.re, @as(f32, 5) / 34, epsilon) and | 156 | testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 5) / 34, epsilon) and |
| 157 | math.approxEq(f32, c.im, @as(f32, -3) / 34, epsilon)); | 157 | math.approxEqAbs(f32, c.im, @as(f32, -3) / 34, epsilon)); |
| 158 | } | 158 | } |
| 159 | 159 | ||
| 160 | test "complex.magnitude" { | 160 | test "complex.magnitude" { |
| 161 | const a = Complex(f32).new(5, 3); | 161 | const a = Complex(f32).new(5, 3); |
| 162 | const c = a.magnitude(); | 162 | const c = a.magnitude(); |
| 163 | 163 | ||
| 164 | testing.expect(math.approxEq(f32, c, 5.83095, epsilon)); | 164 | testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon)); |
| 165 | } | 165 | } |
| 166 | 166 | ||
| 167 | test "complex.cmath" { | 167 | test "complex.cmath" { |
lib/std/math/complex/abs.zig+1-1
| ... | @@ -20,5 +20,5 @@ const epsilon = 0.0001; | ... | @@ -20,5 +20,5 @@ const epsilon = 0.0001; |
| 20 | test "complex.cabs" { | 20 | test "complex.cabs" { |
| 21 | const a = Complex(f32).new(5, 3); | 21 | const a = Complex(f32).new(5, 3); |
| 22 | const c = abs(a); | 22 | const c = abs(a); |
| 23 | testing.expect(math.approxEq(f32, c, 5.83095, epsilon)); | 23 | testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon)); |
| 24 | } | 24 | } |
lib/std/math/complex/acos.zig+2-2
| ... | @@ -22,6 +22,6 @@ test "complex.cacos" { | ... | @@ -22,6 +22,6 @@ test "complex.cacos" { |
| 22 | const a = Complex(f32).new(5, 3); | 22 | const a = Complex(f32).new(5, 3); |
| 23 | const c = acos(a); | 23 | const c = acos(a); |
| 24 | 24 | ||
| 25 | testing.expect(math.approxEq(f32, c.re, 0.546975, epsilon)); | 25 | testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon)); |
| 26 | testing.expect(math.approxEq(f32, c.im, -2.452914, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon)); |
| 27 | } | 27 | } |
lib/std/math/complex/acosh.zig+2-2
| ... | @@ -22,6 +22,6 @@ test "complex.cacosh" { | ... | @@ -22,6 +22,6 @@ test "complex.cacosh" { |
| 22 | const a = Complex(f32).new(5, 3); | 22 | const a = Complex(f32).new(5, 3); |
| 23 | const c = acosh(a); | 23 | const c = acosh(a); |
| 24 | 24 | ||
| 25 | testing.expect(math.approxEq(f32, c.re, 2.452914, epsilon)); | 25 | testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon)); |
| 26 | testing.expect(math.approxEq(f32, c.im, 0.546975, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon)); |
| 27 | } | 27 | } |
lib/std/math/complex/arg.zig+1-1
| ... | @@ -20,5 +20,5 @@ const epsilon = 0.0001; | ... | @@ -20,5 +20,5 @@ const epsilon = 0.0001; |
| 20 | test "complex.carg" { | 20 | test "complex.carg" { |
| 21 | const a = Complex(f32).new(5, 3); | 21 | const a = Complex(f32).new(5, 3); |
| 22 | const c = arg(a); | 22 | const c = arg(a); |
| 23 | testing.expect(math.approxEq(f32, c, 0.540420, epsilon)); | 23 | testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon)); |
| 24 | } | 24 | } |
lib/std/math/complex/asin.zig+2-2
| ... | @@ -28,6 +28,6 @@ test "complex.casin" { | ... | @@ -28,6 +28,6 @@ test "complex.casin" { |
| 28 | const a = Complex(f32).new(5, 3); | 28 | const a = Complex(f32).new(5, 3); |
| 29 | const c = asin(a); | 29 | const c = asin(a); |
| 30 | 30 | ||
| 31 | testing.expect(math.approxEq(f32, c.re, 1.023822, epsilon)); | 31 | testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon)); |
| 32 | testing.expect(math.approxEq(f32, c.im, 2.452914, epsilon)); | 32 | testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon)); |
| 33 | } | 33 | } |
lib/std/math/complex/asinh.zig+2-2
| ... | @@ -23,6 +23,6 @@ test "complex.casinh" { | ... | @@ -23,6 +23,6 @@ test "complex.casinh" { |
| 23 | const a = Complex(f32).new(5, 3); | 23 | const a = Complex(f32).new(5, 3); |
| 24 | const c = asinh(a); | 24 | const c = asinh(a); |
| 25 | 25 | ||
| 26 | testing.expect(math.approxEq(f32, c.re, 2.459831, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon)); |
| 27 | testing.expect(math.approxEq(f32, c.im, 0.533999, epsilon)); | 27 | testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon)); |
| 28 | } | 28 | } |
lib/std/math/complex/atan.zig+4-4
| ... | @@ -130,14 +130,14 @@ test "complex.catan32" { | ... | @@ -130,14 +130,14 @@ test "complex.catan32" { |
| 130 | const a = Complex(f32).new(5, 3); | 130 | const a = Complex(f32).new(5, 3); |
| 131 | const c = atan(a); | 131 | const c = atan(a); |
| 132 | 132 | ||
| 133 | testing.expect(math.approxEq(f32, c.re, 1.423679, epsilon)); | 133 | testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon)); |
| 134 | testing.expect(math.approxEq(f32, c.im, 0.086569, epsilon)); | 134 | testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon)); |
| 135 | } | 135 | } |
| 136 | 136 | ||
| 137 | test "complex.catan64" { | 137 | test "complex.catan64" { |
| 138 | const a = Complex(f64).new(5, 3); | 138 | const a = Complex(f64).new(5, 3); |
| 139 | const c = atan(a); | 139 | const c = atan(a); |
| 140 | 140 | ||
| 141 | testing.expect(math.approxEq(f64, c.re, 1.423679, epsilon)); | 141 | testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon)); |
| 142 | testing.expect(math.approxEq(f64, c.im, 0.086569, epsilon)); | 142 | testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon)); |
| 143 | } | 143 | } |
lib/std/math/complex/atanh.zig+2-2
| ... | @@ -23,6 +23,6 @@ test "complex.catanh" { | ... | @@ -23,6 +23,6 @@ test "complex.catanh" { |
| 23 | const a = Complex(f32).new(5, 3); | 23 | const a = Complex(f32).new(5, 3); |
| 24 | const c = atanh(a); | 24 | const c = atanh(a); |
| 25 | 25 | ||
| 26 | testing.expect(math.approxEq(f32, c.re, 0.146947, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon)); |
| 27 | testing.expect(math.approxEq(f32, c.im, 1.480870, epsilon)); | 27 | testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon)); |
| 28 | } | 28 | } |
lib/std/math/complex/cos.zig+2-2
| ... | @@ -22,6 +22,6 @@ test "complex.ccos" { | ... | @@ -22,6 +22,6 @@ test "complex.ccos" { |
| 22 | const a = Complex(f32).new(5, 3); | 22 | const a = Complex(f32).new(5, 3); |
| 23 | const c = cos(a); | 23 | const c = cos(a); |
| 24 | 24 | ||
| 25 | testing.expect(math.approxEq(f32, c.re, 2.855815, epsilon)); | 25 | testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon)); |
| 26 | testing.expect(math.approxEq(f32, c.im, 9.606383, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon)); |
| 27 | } | 27 | } |
lib/std/math/complex/cosh.zig+4-4
| ... | @@ -165,14 +165,14 @@ test "complex.ccosh32" { | ... | @@ -165,14 +165,14 @@ test "complex.ccosh32" { |
| 165 | const a = Complex(f32).new(5, 3); | 165 | const a = Complex(f32).new(5, 3); |
| 166 | const c = cosh(a); | 166 | const c = cosh(a); |
| 167 | 167 | ||
| 168 | testing.expect(math.approxEq(f32, c.re, -73.467300, epsilon)); | 168 | testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon)); |
| 169 | testing.expect(math.approxEq(f32, c.im, 10.471557, epsilon)); | 169 | testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon)); |
| 170 | } | 170 | } |
| 171 | 171 | ||
| 172 | test "complex.ccosh64" { | 172 | test "complex.ccosh64" { |
| 173 | const a = Complex(f64).new(5, 3); | 173 | const a = Complex(f64).new(5, 3); |
| 174 | const c = cosh(a); | 174 | const c = cosh(a); |
| 175 | 175 | ||
| 176 | testing.expect(math.approxEq(f64, c.re, -73.467300, epsilon)); | 176 | testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon)); |
| 177 | testing.expect(math.approxEq(f64, c.im, 10.471557, epsilon)); | 177 | testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon)); |
| 178 | } | 178 | } |
lib/std/math/complex/exp.zig+4-4
| ... | @@ -131,14 +131,14 @@ test "complex.cexp32" { | ... | @@ -131,14 +131,14 @@ test "complex.cexp32" { |
| 131 | const a = Complex(f32).new(5, 3); | 131 | const a = Complex(f32).new(5, 3); |
| 132 | const c = exp(a); | 132 | const c = exp(a); |
| 133 | 133 | ||
| 134 | testing.expect(math.approxEq(f32, c.re, -146.927917, epsilon)); | 134 | testing.expect(math.approxEqAbs(f32, c.re, -146.927917, epsilon)); |
| 135 | testing.expect(math.approxEq(f32, c.im, 20.944065, epsilon)); | 135 | testing.expect(math.approxEqAbs(f32, c.im, 20.944065, epsilon)); |
| 136 | } | 136 | } |
| 137 | 137 | ||
| 138 | test "complex.cexp64" { | 138 | test "complex.cexp64" { |
| 139 | const a = Complex(f64).new(5, 3); | 139 | const a = Complex(f64).new(5, 3); |
| 140 | const c = exp(a); | 140 | const c = exp(a); |
| 141 | 141 | ||
| 142 | testing.expect(math.approxEq(f64, c.re, -146.927917, epsilon)); | 142 | testing.expect(math.approxEqAbs(f64, c.re, -146.927917, epsilon)); |
| 143 | testing.expect(math.approxEq(f64, c.im, 20.944065, epsilon)); | 143 | testing.expect(math.approxEqAbs(f64, c.im, 20.944065, epsilon)); |
| 144 | } | 144 | } |
lib/std/math/complex/log.zig+2-2
| ... | @@ -24,6 +24,6 @@ test "complex.clog" { | ... | @@ -24,6 +24,6 @@ test "complex.clog" { |
| 24 | const a = Complex(f32).new(5, 3); | 24 | const a = Complex(f32).new(5, 3); |
| 25 | const c = log(a); | 25 | const c = log(a); |
| 26 | 26 | ||
| 27 | testing.expect(math.approxEq(f32, c.re, 1.763180, epsilon)); | 27 | testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon)); |
| 28 | testing.expect(math.approxEq(f32, c.im, 0.540419, epsilon)); | 28 | testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon)); |
| 29 | } | 29 | } |
lib/std/math/complex/pow.zig+2-2
| ... | @@ -23,6 +23,6 @@ test "complex.cpow" { | ... | @@ -23,6 +23,6 @@ test "complex.cpow" { |
| 23 | const b = Complex(f32).new(2.3, -1.3); | 23 | const b = Complex(f32).new(2.3, -1.3); |
| 24 | const c = pow(Complex(f32), a, b); | 24 | const c = pow(Complex(f32), a, b); |
| 25 | 25 | ||
| 26 | testing.expect(math.approxEq(f32, c.re, 58.049110, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon)); |
| 27 | testing.expect(math.approxEq(f32, c.im, -101.003433, epsilon)); | 27 | testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon)); |
| 28 | } | 28 | } |
lib/std/math/complex/sin.zig+2-2
| ... | @@ -23,6 +23,6 @@ test "complex.csin" { | ... | @@ -23,6 +23,6 @@ test "complex.csin" { |
| 23 | const a = Complex(f32).new(5, 3); | 23 | const a = Complex(f32).new(5, 3); |
| 24 | const c = sin(a); | 24 | const c = sin(a); |
| 25 | 25 | ||
| 26 | testing.expect(math.approxEq(f32, c.re, -9.654126, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon)); |
| 27 | testing.expect(math.approxEq(f32, c.im, 2.841692, epsilon)); | 27 | testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon)); |
| 28 | } | 28 | } |
lib/std/math/complex/sinh.zig+4-4
| ... | @@ -164,14 +164,14 @@ test "complex.csinh32" { | ... | @@ -164,14 +164,14 @@ test "complex.csinh32" { |
| 164 | const a = Complex(f32).new(5, 3); | 164 | const a = Complex(f32).new(5, 3); |
| 165 | const c = sinh(a); | 165 | const c = sinh(a); |
| 166 | 166 | ||
| 167 | testing.expect(math.approxEq(f32, c.re, -73.460617, epsilon)); | 167 | testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon)); |
| 168 | testing.expect(math.approxEq(f32, c.im, 10.472508, epsilon)); | 168 | testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon)); |
| 169 | } | 169 | } |
| 170 | 170 | ||
| 171 | test "complex.csinh64" { | 171 | test "complex.csinh64" { |
| 172 | const a = Complex(f64).new(5, 3); | 172 | const a = Complex(f64).new(5, 3); |
| 173 | const c = sinh(a); | 173 | const c = sinh(a); |
| 174 | 174 | ||
| 175 | testing.expect(math.approxEq(f64, c.re, -73.460617, epsilon)); | 175 | testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon)); |
| 176 | testing.expect(math.approxEq(f64, c.im, 10.472508, epsilon)); | 176 | testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon)); |
| 177 | } | 177 | } |
lib/std/math/complex/sqrt.zig+4-4
| ... | @@ -138,14 +138,14 @@ test "complex.csqrt32" { | ... | @@ -138,14 +138,14 @@ test "complex.csqrt32" { |
| 138 | const a = Complex(f32).new(5, 3); | 138 | const a = Complex(f32).new(5, 3); |
| 139 | const c = sqrt(a); | 139 | const c = sqrt(a); |
| 140 | 140 | ||
| 141 | testing.expect(math.approxEq(f32, c.re, 2.327117, epsilon)); | 141 | testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon)); |
| 142 | testing.expect(math.approxEq(f32, c.im, 0.644574, epsilon)); | 142 | testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon)); |
| 143 | } | 143 | } |
| 144 | 144 | ||
| 145 | test "complex.csqrt64" { | 145 | test "complex.csqrt64" { |
| 146 | const a = Complex(f64).new(5, 3); | 146 | const a = Complex(f64).new(5, 3); |
| 147 | const c = sqrt(a); | 147 | const c = sqrt(a); |
| 148 | 148 | ||
| 149 | testing.expect(math.approxEq(f64, c.re, 2.3271175190399496, epsilon)); | 149 | testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon)); |
| 150 | testing.expect(math.approxEq(f64, c.im, 0.6445742373246469, epsilon)); | 150 | testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon)); |
| 151 | } | 151 | } |
lib/std/math/complex/tan.zig+2-2
| ... | @@ -23,6 +23,6 @@ test "complex.ctan" { | ... | @@ -23,6 +23,6 @@ test "complex.ctan" { |
| 23 | const a = Complex(f32).new(5, 3); | 23 | const a = Complex(f32).new(5, 3); |
| 24 | const c = tan(a); | 24 | const c = tan(a); |
| 25 | 25 | ||
| 26 | testing.expect(math.approxEq(f32, c.re, -0.002708233, epsilon)); | 26 | testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon)); |
| 27 | testing.expect(math.approxEq(f32, c.im, 1.004165, epsilon)); | 27 | testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon)); |
| 28 | } | 28 | } |
lib/std/math/complex/tanh.zig+4-4
| ... | @@ -113,14 +113,14 @@ test "complex.ctanh32" { | ... | @@ -113,14 +113,14 @@ test "complex.ctanh32" { |
| 113 | const a = Complex(f32).new(5, 3); | 113 | const a = Complex(f32).new(5, 3); |
| 114 | const c = tanh(a); | 114 | const c = tanh(a); |
| 115 | 115 | ||
| 116 | testing.expect(math.approxEq(f32, c.re, 0.999913, epsilon)); | 116 | testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon)); |
| 117 | testing.expect(math.approxEq(f32, c.im, -0.000025, epsilon)); | 117 | testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon)); |
| 118 | } | 118 | } |
| 119 | 119 | ||
| 120 | test "complex.ctanh64" { | 120 | test "complex.ctanh64" { |
| 121 | const a = Complex(f64).new(5, 3); | 121 | const a = Complex(f64).new(5, 3); |
| 122 | const c = tanh(a); | 122 | const c = tanh(a); |
| 123 | 123 | ||
| 124 | testing.expect(math.approxEq(f64, c.re, 0.999913, epsilon)); | 124 | testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon)); |
| 125 | testing.expect(math.approxEq(f64, c.im, -0.000025, epsilon)); | 125 | testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon)); |
| 126 | } | 126 | } |
lib/std/math/cos.zig+14-14
| ... | @@ -95,25 +95,25 @@ test "math.cos" { | ... | @@ -95,25 +95,25 @@ test "math.cos" { |
| 95 | test "math.cos32" { | 95 | test "math.cos32" { |
| 96 | const epsilon = 0.000001; | 96 | const epsilon = 0.000001; |
| 97 | 97 | ||
| 98 | expect(math.approxEq(f32, cos_(f32, 0.0), 1.0, epsilon)); | 98 | expect(math.approxEqAbs(f32, cos_(f32, 0.0), 1.0, epsilon)); |
| 99 | expect(math.approxEq(f32, cos_(f32, 0.2), 0.980067, epsilon)); | 99 | expect(math.approxEqAbs(f32, cos_(f32, 0.2), 0.980067, epsilon)); |
| 100 | expect(math.approxEq(f32, cos_(f32, 0.8923), 0.627623, epsilon)); | 100 | expect(math.approxEqAbs(f32, cos_(f32, 0.8923), 0.627623, epsilon)); |
| 101 | expect(math.approxEq(f32, cos_(f32, 1.5), 0.070737, epsilon)); | 101 | expect(math.approxEqAbs(f32, cos_(f32, 1.5), 0.070737, epsilon)); |
| 102 | expect(math.approxEq(f32, cos_(f32, -1.5), 0.070737, epsilon)); | 102 | expect(math.approxEqAbs(f32, cos_(f32, -1.5), 0.070737, epsilon)); |
| 103 | expect(math.approxEq(f32, cos_(f32, 37.45), 0.969132, epsilon)); | 103 | expect(math.approxEqAbs(f32, cos_(f32, 37.45), 0.969132, epsilon)); |
| 104 | expect(math.approxEq(f32, cos_(f32, 89.123), 0.400798, epsilon)); | 104 | expect(math.approxEqAbs(f32, cos_(f32, 89.123), 0.400798, epsilon)); |
| 105 | } | 105 | } |
| 106 | 106 | ||
| 107 | test "math.cos64" { | 107 | test "math.cos64" { |
| 108 | const epsilon = 0.000001; | 108 | const epsilon = 0.000001; |
| 109 | 109 | ||
| 110 | expect(math.approxEq(f64, cos_(f64, 0.0), 1.0, epsilon)); | 110 | expect(math.approxEqAbs(f64, cos_(f64, 0.0), 1.0, epsilon)); |
| 111 | expect(math.approxEq(f64, cos_(f64, 0.2), 0.980067, epsilon)); | 111 | expect(math.approxEqAbs(f64, cos_(f64, 0.2), 0.980067, epsilon)); |
| 112 | expect(math.approxEq(f64, cos_(f64, 0.8923), 0.627623, epsilon)); | 112 | expect(math.approxEqAbs(f64, cos_(f64, 0.8923), 0.627623, epsilon)); |
| 113 | expect(math.approxEq(f64, cos_(f64, 1.5), 0.070737, epsilon)); | 113 | expect(math.approxEqAbs(f64, cos_(f64, 1.5), 0.070737, epsilon)); |
| 114 | expect(math.approxEq(f64, cos_(f64, -1.5), 0.070737, epsilon)); | 114 | expect(math.approxEqAbs(f64, cos_(f64, -1.5), 0.070737, epsilon)); |
| 115 | expect(math.approxEq(f64, cos_(f64, 37.45), 0.969132, epsilon)); | 115 | expect(math.approxEqAbs(f64, cos_(f64, 37.45), 0.969132, epsilon)); |
| 116 | expect(math.approxEq(f64, cos_(f64, 89.123), 0.40080, epsilon)); | 116 | expect(math.approxEqAbs(f64, cos_(f64, 89.123), 0.40080, epsilon)); |
| 117 | } | 117 | } |
| 118 | 118 | ||
| 119 | test "math.cos32.special" { | 119 | test "math.cos32.special" { |
lib/std/math/cosh.zig+16-16
| ... | @@ -100,27 +100,27 @@ test "math.cosh" { | ... | @@ -100,27 +100,27 @@ test "math.cosh" { |
| 100 | test "math.cosh32" { | 100 | test "math.cosh32" { |
| 101 | const epsilon = 0.000001; | 101 | const epsilon = 0.000001; |
| 102 | 102 | ||
| 103 | expect(math.approxEq(f32, cosh32(0.0), 1.0, epsilon)); | 103 | expect(math.approxEqAbs(f32, cosh32(0.0), 1.0, epsilon)); |
| 104 | expect(math.approxEq(f32, cosh32(0.2), 1.020067, epsilon)); | 104 | expect(math.approxEqAbs(f32, cosh32(0.2), 1.020067, epsilon)); |
| 105 | expect(math.approxEq(f32, cosh32(0.8923), 1.425225, epsilon)); | 105 | expect(math.approxEqAbs(f32, cosh32(0.8923), 1.425225, epsilon)); |
| 106 | expect(math.approxEq(f32, cosh32(1.5), 2.352410, epsilon)); | 106 | expect(math.approxEqAbs(f32, cosh32(1.5), 2.352410, epsilon)); |
| 107 | expect(math.approxEq(f32, cosh32(-0.0), 1.0, epsilon)); | 107 | expect(math.approxEqAbs(f32, cosh32(-0.0), 1.0, epsilon)); |
| 108 | expect(math.approxEq(f32, cosh32(-0.2), 1.020067, epsilon)); | 108 | expect(math.approxEqAbs(f32, cosh32(-0.2), 1.020067, epsilon)); |
| 109 | expect(math.approxEq(f32, cosh32(-0.8923), 1.425225, epsilon)); | 109 | expect(math.approxEqAbs(f32, cosh32(-0.8923), 1.425225, epsilon)); |
| 110 | expect(math.approxEq(f32, cosh32(-1.5), 2.352410, epsilon)); | 110 | expect(math.approxEqAbs(f32, cosh32(-1.5), 2.352410, epsilon)); |
| 111 | } | 111 | } |
| 112 | 112 | ||
| 113 | test "math.cosh64" { | 113 | test "math.cosh64" { |
| 114 | const epsilon = 0.000001; | 114 | const epsilon = 0.000001; |
| 115 | 115 | ||
| 116 | expect(math.approxEq(f64, cosh64(0.0), 1.0, epsilon)); | 116 | expect(math.approxEqAbs(f64, cosh64(0.0), 1.0, epsilon)); |
| 117 | expect(math.approxEq(f64, cosh64(0.2), 1.020067, epsilon)); | 117 | expect(math.approxEqAbs(f64, cosh64(0.2), 1.020067, epsilon)); |
| 118 | expect(math.approxEq(f64, cosh64(0.8923), 1.425225, epsilon)); | 118 | expect(math.approxEqAbs(f64, cosh64(0.8923), 1.425225, epsilon)); |
| 119 | expect(math.approxEq(f64, cosh64(1.5), 2.352410, epsilon)); | 119 | expect(math.approxEqAbs(f64, cosh64(1.5), 2.352410, epsilon)); |
| 120 | expect(math.approxEq(f64, cosh64(-0.0), 1.0, epsilon)); | 120 | expect(math.approxEqAbs(f64, cosh64(-0.0), 1.0, epsilon)); |
| 121 | expect(math.approxEq(f64, cosh64(-0.2), 1.020067, epsilon)); | 121 | expect(math.approxEqAbs(f64, cosh64(-0.2), 1.020067, epsilon)); |
| 122 | expect(math.approxEq(f64, cosh64(-0.8923), 1.425225, epsilon)); | 122 | expect(math.approxEqAbs(f64, cosh64(-0.8923), 1.425225, epsilon)); |
| 123 | expect(math.approxEq(f64, cosh64(-1.5), 2.352410, epsilon)); | 123 | expect(math.approxEqAbs(f64, cosh64(-1.5), 2.352410, epsilon)); |
| 124 | } | 124 | } |
| 125 | 125 | ||
| 126 | test "math.cosh32.special" { | 126 | test "math.cosh32.special" { |
lib/std/math/epsilon.zig created+19
| ... | @@ -0,0 +1,19 @@ | ||
| 1 | // SPDX-License-Identifier: MIT | ||
| 2 | // Copyright (c) 2015-2020 Zig Contributors | ||
| 3 | // This file is part of [zig](https://ziglang.org/), which is MIT licensed. | ||
| 4 | // The MIT license requires this copyright notice to be included in all copies | ||
| 5 | // and substantial portions of the software. | ||
| 6 | const math = @import("../math.zig"); | ||
| 7 | |||
| 8 | /// Returns the machine epsilon for type T. | ||
| 9 | /// This is the smallest value of type T that satisfies the inequality 1.0 + | ||
| 10 | /// epsilon != 1.0. | ||
| 11 | pub fn epsilon(comptime T: type) T { | ||
| 12 | return switch (T) { | ||
| 13 | f16 => math.f16_epsilon, | ||
| 14 | f32 => math.f32_epsilon, | ||
| 15 | f64 => math.f64_epsilon, | ||
| 16 | f128 => math.f128_epsilon, | ||
| 17 | else => @compileError("epsilon not implemented for " ++ @typeName(T)), | ||
| 18 | }; | ||
| 19 | } | ||
lib/std/math/exp.zig+8-8
| ... | @@ -196,20 +196,20 @@ test "math.exp32" { | ... | @@ -196,20 +196,20 @@ test "math.exp32" { |
| 196 | const epsilon = 0.000001; | 196 | const epsilon = 0.000001; |
| 197 | 197 | ||
| 198 | assert(exp32(0.0) == 1.0); | 198 | assert(exp32(0.0) == 1.0); |
| 199 | assert(math.approxEq(f32, exp32(0.0), 1.0, epsilon)); | 199 | assert(math.approxEqAbs(f32, exp32(0.0), 1.0, epsilon)); |
| 200 | assert(math.approxEq(f32, exp32(0.2), 1.221403, epsilon)); | 200 | assert(math.approxEqAbs(f32, exp32(0.2), 1.221403, epsilon)); |
| 201 | assert(math.approxEq(f32, exp32(0.8923), 2.440737, epsilon)); | 201 | assert(math.approxEqAbs(f32, exp32(0.8923), 2.440737, epsilon)); |
| 202 | assert(math.approxEq(f32, exp32(1.5), 4.481689, epsilon)); | 202 | assert(math.approxEqAbs(f32, exp32(1.5), 4.481689, epsilon)); |
| 203 | } | 203 | } |
| 204 | 204 | ||
| 205 | test "math.exp64" { | 205 | test "math.exp64" { |
| 206 | const epsilon = 0.000001; | 206 | const epsilon = 0.000001; |
| 207 | 207 | ||
| 208 | assert(exp64(0.0) == 1.0); | 208 | assert(exp64(0.0) == 1.0); |
| 209 | assert(math.approxEq(f64, exp64(0.0), 1.0, epsilon)); | 209 | assert(math.approxEqAbs(f64, exp64(0.0), 1.0, epsilon)); |
| 210 | assert(math.approxEq(f64, exp64(0.2), 1.221403, epsilon)); | 210 | assert(math.approxEqAbs(f64, exp64(0.2), 1.221403, epsilon)); |
| 211 | assert(math.approxEq(f64, exp64(0.8923), 2.440737, epsilon)); | 211 | assert(math.approxEqAbs(f64, exp64(0.8923), 2.440737, epsilon)); |
| 212 | assert(math.approxEq(f64, exp64(1.5), 4.481689, epsilon)); | 212 | assert(math.approxEqAbs(f64, exp64(1.5), 4.481689, epsilon)); |
| 213 | } | 213 | } |
| 214 | 214 | ||
| 215 | test "math.exp32.special" { | 215 | test "math.exp32.special" { |
lib/std/math/exp2.zig+7-7
| ... | @@ -434,19 +434,19 @@ test "math.exp2_32" { | ... | @@ -434,19 +434,19 @@ test "math.exp2_32" { |
| 434 | const epsilon = 0.000001; | 434 | const epsilon = 0.000001; |
| 435 | 435 | ||
| 436 | expect(exp2_32(0.0) == 1.0); | 436 | expect(exp2_32(0.0) == 1.0); |
| 437 | expect(math.approxEq(f32, exp2_32(0.2), 1.148698, epsilon)); | 437 | expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon)); |
| 438 | expect(math.approxEq(f32, exp2_32(0.8923), 1.856133, epsilon)); | 438 | expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon)); |
| 439 | expect(math.approxEq(f32, exp2_32(1.5), 2.828427, epsilon)); | 439 | expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon)); |
| 440 | expect(math.approxEq(f32, exp2_32(37.45), 187747237888, epsilon)); | 440 | expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon)); |
| 441 | } | 441 | } |
| 442 | 442 | ||
| 443 | test "math.exp2_64" { | 443 | test "math.exp2_64" { |
| 444 | const epsilon = 0.000001; | 444 | const epsilon = 0.000001; |
| 445 | 445 | ||
| 446 | expect(exp2_64(0.0) == 1.0); | 446 | expect(exp2_64(0.0) == 1.0); |
| 447 | expect(math.approxEq(f64, exp2_64(0.2), 1.148698, epsilon)); | 447 | expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon)); |
| 448 | expect(math.approxEq(f64, exp2_64(0.8923), 1.856133, epsilon)); | 448 | expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon)); |
| 449 | expect(math.approxEq(f64, exp2_64(1.5), 2.828427, epsilon)); | 449 | expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon)); |
| 450 | } | 450 | } |
| 451 | 451 | ||
| 452 | test "math.exp2_32.special" { | 452 | test "math.exp2_32.special" { |
lib/std/math/expm1.zig+8-8
| ... | @@ -300,20 +300,20 @@ test "math.expm1_32" { | ... | @@ -300,20 +300,20 @@ test "math.expm1_32" { |
| 300 | const epsilon = 0.000001; | 300 | const epsilon = 0.000001; |
| 301 | 301 | ||
| 302 | expect(expm1_32(0.0) == 0.0); | 302 | expect(expm1_32(0.0) == 0.0); |
| 303 | expect(math.approxEq(f32, expm1_32(0.0), 0.0, epsilon)); | 303 | expect(math.approxEqAbs(f32, expm1_32(0.0), 0.0, epsilon)); |
| 304 | expect(math.approxEq(f32, expm1_32(0.2), 0.221403, epsilon)); | 304 | expect(math.approxEqAbs(f32, expm1_32(0.2), 0.221403, epsilon)); |
| 305 | expect(math.approxEq(f32, expm1_32(0.8923), 1.440737, epsilon)); | 305 | expect(math.approxEqAbs(f32, expm1_32(0.8923), 1.440737, epsilon)); |
| 306 | expect(math.approxEq(f32, expm1_32(1.5), 3.481689, epsilon)); | 306 | expect(math.approxEqAbs(f32, expm1_32(1.5), 3.481689, epsilon)); |
| 307 | } | 307 | } |
| 308 | 308 | ||
| 309 | test "math.expm1_64" { | 309 | test "math.expm1_64" { |
| 310 | const epsilon = 0.000001; | 310 | const epsilon = 0.000001; |
| 311 | 311 | ||
| 312 | expect(expm1_64(0.0) == 0.0); | 312 | expect(expm1_64(0.0) == 0.0); |
| 313 | expect(math.approxEq(f64, expm1_64(0.0), 0.0, epsilon)); | 313 | expect(math.approxEqAbs(f64, expm1_64(0.0), 0.0, epsilon)); |
| 314 | expect(math.approxEq(f64, expm1_64(0.2), 0.221403, epsilon)); | 314 | expect(math.approxEqAbs(f64, expm1_64(0.2), 0.221403, epsilon)); |
| 315 | expect(math.approxEq(f64, expm1_64(0.8923), 1.440737, epsilon)); | 315 | expect(math.approxEqAbs(f64, expm1_64(0.8923), 1.440737, epsilon)); |
| 316 | expect(math.approxEq(f64, expm1_64(1.5), 3.481689, epsilon)); | 316 | expect(math.approxEqAbs(f64, expm1_64(1.5), 3.481689, epsilon)); |
| 317 | } | 317 | } |
| 318 | 318 | ||
| 319 | test "math.expm1_32.special" { | 319 | test "math.expm1_32.special" { |
lib/std/math/fma.zig+14-14
| ... | @@ -155,23 +155,23 @@ test "math.fma" { | ... | @@ -155,23 +155,23 @@ test "math.fma" { |
| 155 | test "math.fma32" { | 155 | test "math.fma32" { |
| 156 | const epsilon = 0.000001; | 156 | const epsilon = 0.000001; |
| 157 | 157 | ||
| 158 | expect(math.approxEq(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon)); | 158 | expect(math.approxEqAbs(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon)); |
| 159 | expect(math.approxEq(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon)); | 159 | expect(math.approxEqAbs(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon)); |
| 160 | expect(math.approxEq(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon)); | 160 | expect(math.approxEqAbs(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon)); |
| 161 | expect(math.approxEq(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon)); | 161 | expect(math.approxEqAbs(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon)); |
| 162 | expect(math.approxEq(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon)); | 162 | expect(math.approxEqAbs(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon)); |
| 163 | expect(math.approxEq(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon)); | 163 | expect(math.approxEqAbs(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon)); |
| 164 | expect(math.approxEq(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); | 164 | expect(math.approxEqAbs(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); |
| 165 | } | 165 | } |
| 166 | 166 | ||
| 167 | test "math.fma64" { | 167 | test "math.fma64" { |
| 168 | const epsilon = 0.000001; | 168 | const epsilon = 0.000001; |
| 169 | 169 | ||
| 170 | expect(math.approxEq(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon)); | 170 | expect(math.approxEqAbs(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon)); |
| 171 | expect(math.approxEq(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon)); | 171 | expect(math.approxEqAbs(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon)); |
| 172 | expect(math.approxEq(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon)); | 172 | expect(math.approxEqAbs(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon)); |
| 173 | expect(math.approxEq(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon)); | 173 | expect(math.approxEqAbs(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon)); |
| 174 | expect(math.approxEq(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon)); | 174 | expect(math.approxEqAbs(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon)); |
| 175 | expect(math.approxEq(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon)); | 175 | expect(math.approxEqAbs(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon)); |
| 176 | expect(math.approxEq(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); | 176 | expect(math.approxEqAbs(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); |
| 177 | } | 177 | } |
lib/std/math/frexp.zig+4-4
| ... | @@ -127,10 +127,10 @@ test "math.frexp32" { | ... | @@ -127,10 +127,10 @@ test "math.frexp32" { |
| 127 | var r: frexp32_result = undefined; | 127 | var r: frexp32_result = undefined; |
| 128 | 128 | ||
| 129 | r = frexp32(1.3); | 129 | r = frexp32(1.3); |
| 130 | expect(math.approxEq(f32, r.significand, 0.65, epsilon) and r.exponent == 1); | 130 | expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1); |
| 131 | 131 | ||
| 132 | r = frexp32(78.0234); | 132 | r = frexp32(78.0234); |
| 133 | expect(math.approxEq(f32, r.significand, 0.609558, epsilon) and r.exponent == 7); | 133 | expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7); |
| 134 | } | 134 | } |
| 135 | 135 | ||
| 136 | test "math.frexp64" { | 136 | test "math.frexp64" { |
| ... | @@ -138,10 +138,10 @@ test "math.frexp64" { | ... | @@ -138,10 +138,10 @@ test "math.frexp64" { |
| 138 | var r: frexp64_result = undefined; | 138 | var r: frexp64_result = undefined; |
| 139 | 139 | ||
| 140 | r = frexp64(1.3); | 140 | r = frexp64(1.3); |
| 141 | expect(math.approxEq(f64, r.significand, 0.65, epsilon) and r.exponent == 1); | 141 | expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1); |
| 142 | 142 | ||
| 143 | r = frexp64(78.0234); | 143 | r = frexp64(78.0234); |
| 144 | expect(math.approxEq(f64, r.significand, 0.609558, epsilon) and r.exponent == 7); | 144 | expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7); |
| 145 | } | 145 | } |
| 146 | 146 | ||
| 147 | test "math.frexp32.special" { | 147 | test "math.frexp32.special" { |
lib/std/math/hypot.zig+14-14
| ... | @@ -133,25 +133,25 @@ test "math.hypot" { | ... | @@ -133,25 +133,25 @@ test "math.hypot" { |
| 133 | test "math.hypot32" { | 133 | test "math.hypot32" { |
| 134 | const epsilon = 0.000001; | 134 | const epsilon = 0.000001; |
| 135 | 135 | ||
| 136 | expect(math.approxEq(f32, hypot32(0.0, -1.2), 1.2, epsilon)); | 136 | expect(math.approxEqAbs(f32, hypot32(0.0, -1.2), 1.2, epsilon)); |
| 137 | expect(math.approxEq(f32, hypot32(0.2, -0.34), 0.394462, epsilon)); | 137 | expect(math.approxEqAbs(f32, hypot32(0.2, -0.34), 0.394462, epsilon)); |
| 138 | expect(math.approxEq(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon)); | 138 | expect(math.approxEqAbs(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon)); |
| 139 | expect(math.approxEq(f32, hypot32(1.5, 5.25), 5.460083, epsilon)); | 139 | expect(math.approxEqAbs(f32, hypot32(1.5, 5.25), 5.460083, epsilon)); |
| 140 | expect(math.approxEq(f32, hypot32(37.45, 159.835), 164.163742, epsilon)); | 140 | expect(math.approxEqAbs(f32, hypot32(37.45, 159.835), 164.163742, epsilon)); |
| 141 | expect(math.approxEq(f32, hypot32(89.123, 382.028905), 392.286865, epsilon)); | 141 | expect(math.approxEqAbs(f32, hypot32(89.123, 382.028905), 392.286865, epsilon)); |
| 142 | expect(math.approxEq(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon)); | 142 | expect(math.approxEqAbs(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon)); |
| 143 | } | 143 | } |
| 144 | 144 | ||
| 145 | test "math.hypot64" { | 145 | test "math.hypot64" { |
| 146 | const epsilon = 0.000001; | 146 | const epsilon = 0.000001; |
| 147 | 147 | ||
| 148 | expect(math.approxEq(f64, hypot64(0.0, -1.2), 1.2, epsilon)); | 148 | expect(math.approxEqAbs(f64, hypot64(0.0, -1.2), 1.2, epsilon)); |
| 149 | expect(math.approxEq(f64, hypot64(0.2, -0.34), 0.394462, epsilon)); | 149 | expect(math.approxEqAbs(f64, hypot64(0.2, -0.34), 0.394462, epsilon)); |
| 150 | expect(math.approxEq(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon)); | 150 | expect(math.approxEqAbs(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon)); |
| 151 | expect(math.approxEq(f64, hypot64(1.5, 5.25), 5.460082, epsilon)); | 151 | expect(math.approxEqAbs(f64, hypot64(1.5, 5.25), 5.460082, epsilon)); |
| 152 | expect(math.approxEq(f64, hypot64(37.45, 159.835), 164.163728, epsilon)); | 152 | expect(math.approxEqAbs(f64, hypot64(37.45, 159.835), 164.163728, epsilon)); |
| 153 | expect(math.approxEq(f64, hypot64(89.123, 382.028905), 392.286876, epsilon)); | 153 | expect(math.approxEqAbs(f64, hypot64(89.123, 382.028905), 392.286876, epsilon)); |
| 154 | expect(math.approxEq(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon)); | 154 | expect(math.approxEqAbs(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon)); |
| 155 | } | 155 | } |
| 156 | 156 | ||
| 157 | test "math.hypot32.special" { | 157 | test "math.hypot32.special" { |
lib/std/math/ln.zig+12-12
| ... | @@ -159,23 +159,23 @@ test "math.ln" { | ... | @@ -159,23 +159,23 @@ test "math.ln" { |
| 159 | test "math.ln32" { | 159 | test "math.ln32" { |
| 160 | const epsilon = 0.000001; | 160 | const epsilon = 0.000001; |
| 161 | 161 | ||
| 162 | expect(math.approxEq(f32, ln_32(0.2), -1.609438, epsilon)); | 162 | expect(math.approxEqAbs(f32, ln_32(0.2), -1.609438, epsilon)); |
| 163 | expect(math.approxEq(f32, ln_32(0.8923), -0.113953, epsilon)); | 163 | expect(math.approxEqAbs(f32, ln_32(0.8923), -0.113953, epsilon)); |
| 164 | expect(math.approxEq(f32, ln_32(1.5), 0.405465, epsilon)); | 164 | expect(math.approxEqAbs(f32, ln_32(1.5), 0.405465, epsilon)); |
| 165 | expect(math.approxEq(f32, ln_32(37.45), 3.623007, epsilon)); | 165 | expect(math.approxEqAbs(f32, ln_32(37.45), 3.623007, epsilon)); |
| 166 | expect(math.approxEq(f32, ln_32(89.123), 4.490017, epsilon)); | 166 | expect(math.approxEqAbs(f32, ln_32(89.123), 4.490017, epsilon)); |
| 167 | expect(math.approxEq(f32, ln_32(123123.234375), 11.720941, epsilon)); | 167 | expect(math.approxEqAbs(f32, ln_32(123123.234375), 11.720941, epsilon)); |
| 168 | } | 168 | } |
| 169 | 169 | ||
| 170 | test "math.ln64" { | 170 | test "math.ln64" { |
| 171 | const epsilon = 0.000001; | 171 | const epsilon = 0.000001; |
| 172 | 172 | ||
| 173 | expect(math.approxEq(f64, ln_64(0.2), -1.609438, epsilon)); | 173 | expect(math.approxEqAbs(f64, ln_64(0.2), -1.609438, epsilon)); |
| 174 | expect(math.approxEq(f64, ln_64(0.8923), -0.113953, epsilon)); | 174 | expect(math.approxEqAbs(f64, ln_64(0.8923), -0.113953, epsilon)); |
| 175 | expect(math.approxEq(f64, ln_64(1.5), 0.405465, epsilon)); | 175 | expect(math.approxEqAbs(f64, ln_64(1.5), 0.405465, epsilon)); |
| 176 | expect(math.approxEq(f64, ln_64(37.45), 3.623007, epsilon)); | 176 | expect(math.approxEqAbs(f64, ln_64(37.45), 3.623007, epsilon)); |
| 177 | expect(math.approxEq(f64, ln_64(89.123), 4.490017, epsilon)); | 177 | expect(math.approxEqAbs(f64, ln_64(89.123), 4.490017, epsilon)); |
| 178 | expect(math.approxEq(f64, ln_64(123123.234375), 11.720941, epsilon)); | 178 | expect(math.approxEqAbs(f64, ln_64(123123.234375), 11.720941, epsilon)); |
| 179 | } | 179 | } |
| 180 | 180 | ||
| 181 | test "math.ln32.special" { | 181 | test "math.ln32.special" { |
lib/std/math/log.zig+3-3
| ... | @@ -61,9 +61,9 @@ test "math.log integer" { | ... | @@ -61,9 +61,9 @@ test "math.log integer" { |
| 61 | test "math.log float" { | 61 | test "math.log float" { |
| 62 | const epsilon = 0.000001; | 62 | const epsilon = 0.000001; |
| 63 | 63 | ||
| 64 | expect(math.approxEq(f32, log(f32, 6, 0.23947), -0.797723, epsilon)); | 64 | expect(math.approxEqAbs(f32, log(f32, 6, 0.23947), -0.797723, epsilon)); |
| 65 | expect(math.approxEq(f32, log(f32, 89, 0.23947), -0.318432, epsilon)); | 65 | expect(math.approxEqAbs(f32, log(f32, 89, 0.23947), -0.318432, epsilon)); |
| 66 | expect(math.approxEq(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon)); | 66 | expect(math.approxEqAbs(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon)); |
| 67 | } | 67 | } |
| 68 | 68 | ||
| 69 | test "math.log float_special" { | 69 | test "math.log float_special" { |
lib/std/math/log10.zig+12-12
| ... | @@ -187,23 +187,23 @@ test "math.log10" { | ... | @@ -187,23 +187,23 @@ test "math.log10" { |
| 187 | test "math.log10_32" { | 187 | test "math.log10_32" { |
| 188 | const epsilon = 0.000001; | 188 | const epsilon = 0.000001; |
| 189 | 189 | ||
| 190 | testing.expect(math.approxEq(f32, log10_32(0.2), -0.698970, epsilon)); | 190 | testing.expect(math.approxEqAbs(f32, log10_32(0.2), -0.698970, epsilon)); |
| 191 | testing.expect(math.approxEq(f32, log10_32(0.8923), -0.049489, epsilon)); | 191 | testing.expect(math.approxEqAbs(f32, log10_32(0.8923), -0.049489, epsilon)); |
| 192 | testing.expect(math.approxEq(f32, log10_32(1.5), 0.176091, epsilon)); | 192 | testing.expect(math.approxEqAbs(f32, log10_32(1.5), 0.176091, epsilon)); |
| 193 | testing.expect(math.approxEq(f32, log10_32(37.45), 1.573452, epsilon)); | 193 | testing.expect(math.approxEqAbs(f32, log10_32(37.45), 1.573452, epsilon)); |
| 194 | testing.expect(math.approxEq(f32, log10_32(89.123), 1.94999, epsilon)); | 194 | testing.expect(math.approxEqAbs(f32, log10_32(89.123), 1.94999, epsilon)); |
| 195 | testing.expect(math.approxEq(f32, log10_32(123123.234375), 5.09034, epsilon)); | 195 | testing.expect(math.approxEqAbs(f32, log10_32(123123.234375), 5.09034, epsilon)); |
| 196 | } | 196 | } |
| 197 | 197 | ||
| 198 | test "math.log10_64" { | 198 | test "math.log10_64" { |
| 199 | const epsilon = 0.000001; | 199 | const epsilon = 0.000001; |
| 200 | 200 | ||
| 201 | testing.expect(math.approxEq(f64, log10_64(0.2), -0.698970, epsilon)); | 201 | testing.expect(math.approxEqAbs(f64, log10_64(0.2), -0.698970, epsilon)); |
| 202 | testing.expect(math.approxEq(f64, log10_64(0.8923), -0.049489, epsilon)); | 202 | testing.expect(math.approxEqAbs(f64, log10_64(0.8923), -0.049489, epsilon)); |
| 203 | testing.expect(math.approxEq(f64, log10_64(1.5), 0.176091, epsilon)); | 203 | testing.expect(math.approxEqAbs(f64, log10_64(1.5), 0.176091, epsilon)); |
| 204 | testing.expect(math.approxEq(f64, log10_64(37.45), 1.573452, epsilon)); | 204 | testing.expect(math.approxEqAbs(f64, log10_64(37.45), 1.573452, epsilon)); |
| 205 | testing.expect(math.approxEq(f64, log10_64(89.123), 1.94999, epsilon)); | 205 | testing.expect(math.approxEqAbs(f64, log10_64(89.123), 1.94999, epsilon)); |
| 206 | testing.expect(math.approxEq(f64, log10_64(123123.234375), 5.09034, epsilon)); | 206 | testing.expect(math.approxEqAbs(f64, log10_64(123123.234375), 5.09034, epsilon)); |
| 207 | } | 207 | } |
| 208 | 208 | ||
| 209 | test "math.log10_32.special" { | 209 | test "math.log10_32.special" { |
lib/std/math/log1p.zig+14-14
| ... | @@ -195,25 +195,25 @@ test "math.log1p" { | ... | @@ -195,25 +195,25 @@ test "math.log1p" { |
| 195 | test "math.log1p_32" { | 195 | test "math.log1p_32" { |
| 196 | const epsilon = 0.000001; | 196 | const epsilon = 0.000001; |
| 197 | 197 | ||
| 198 | expect(math.approxEq(f32, log1p_32(0.0), 0.0, epsilon)); | 198 | expect(math.approxEqAbs(f32, log1p_32(0.0), 0.0, epsilon)); |
| 199 | expect(math.approxEq(f32, log1p_32(0.2), 0.182322, epsilon)); | 199 | expect(math.approxEqAbs(f32, log1p_32(0.2), 0.182322, epsilon)); |
| 200 | expect(math.approxEq(f32, log1p_32(0.8923), 0.637793, epsilon)); | 200 | expect(math.approxEqAbs(f32, log1p_32(0.8923), 0.637793, epsilon)); |
| 201 | expect(math.approxEq(f32, log1p_32(1.5), 0.916291, epsilon)); | 201 | expect(math.approxEqAbs(f32, log1p_32(1.5), 0.916291, epsilon)); |
| 202 | expect(math.approxEq(f32, log1p_32(37.45), 3.649359, epsilon)); | 202 | expect(math.approxEqAbs(f32, log1p_32(37.45), 3.649359, epsilon)); |
| 203 | expect(math.approxEq(f32, log1p_32(89.123), 4.501175, epsilon)); | 203 | expect(math.approxEqAbs(f32, log1p_32(89.123), 4.501175, epsilon)); |
| 204 | expect(math.approxEq(f32, log1p_32(123123.234375), 11.720949, epsilon)); | 204 | expect(math.approxEqAbs(f32, log1p_32(123123.234375), 11.720949, epsilon)); |
| 205 | } | 205 | } |
| 206 | 206 | ||
| 207 | test "math.log1p_64" { | 207 | test "math.log1p_64" { |
| 208 | const epsilon = 0.000001; | 208 | const epsilon = 0.000001; |
| 209 | 209 | ||
| 210 | expect(math.approxEq(f64, log1p_64(0.0), 0.0, epsilon)); | 210 | expect(math.approxEqAbs(f64, log1p_64(0.0), 0.0, epsilon)); |
| 211 | expect(math.approxEq(f64, log1p_64(0.2), 0.182322, epsilon)); | 211 | expect(math.approxEqAbs(f64, log1p_64(0.2), 0.182322, epsilon)); |
| 212 | expect(math.approxEq(f64, log1p_64(0.8923), 0.637793, epsilon)); | 212 | expect(math.approxEqAbs(f64, log1p_64(0.8923), 0.637793, epsilon)); |
| 213 | expect(math.approxEq(f64, log1p_64(1.5), 0.916291, epsilon)); | 213 | expect(math.approxEqAbs(f64, log1p_64(1.5), 0.916291, epsilon)); |
| 214 | expect(math.approxEq(f64, log1p_64(37.45), 3.649359, epsilon)); | 214 | expect(math.approxEqAbs(f64, log1p_64(37.45), 3.649359, epsilon)); |
| 215 | expect(math.approxEq(f64, log1p_64(89.123), 4.501175, epsilon)); | 215 | expect(math.approxEqAbs(f64, log1p_64(89.123), 4.501175, epsilon)); |
| 216 | expect(math.approxEq(f64, log1p_64(123123.234375), 11.720949, epsilon)); | 216 | expect(math.approxEqAbs(f64, log1p_64(123123.234375), 11.720949, epsilon)); |
| 217 | } | 217 | } |
| 218 | 218 | ||
| 219 | test "math.log1p_32.special" { | 219 | test "math.log1p_32.special" { |
lib/std/math/log2.zig+10-10
| ... | @@ -185,21 +185,21 @@ test "math.log2" { | ... | @@ -185,21 +185,21 @@ test "math.log2" { |
| 185 | test "math.log2_32" { | 185 | test "math.log2_32" { |
| 186 | const epsilon = 0.000001; | 186 | const epsilon = 0.000001; |
| 187 | 187 | ||
| 188 | expect(math.approxEq(f32, log2_32(0.2), -2.321928, epsilon)); | 188 | expect(math.approxEqAbs(f32, log2_32(0.2), -2.321928, epsilon)); |
| 189 | expect(math.approxEq(f32, log2_32(0.8923), -0.164399, epsilon)); | 189 | expect(math.approxEqAbs(f32, log2_32(0.8923), -0.164399, epsilon)); |
| 190 | expect(math.approxEq(f32, log2_32(1.5), 0.584962, epsilon)); | 190 | expect(math.approxEqAbs(f32, log2_32(1.5), 0.584962, epsilon)); |
| 191 | expect(math.approxEq(f32, log2_32(37.45), 5.226894, epsilon)); | 191 | expect(math.approxEqAbs(f32, log2_32(37.45), 5.226894, epsilon)); |
| 192 | expect(math.approxEq(f32, log2_32(123123.234375), 16.909744, epsilon)); | 192 | expect(math.approxEqAbs(f32, log2_32(123123.234375), 16.909744, epsilon)); |
| 193 | } | 193 | } |
| 194 | 194 | ||
| 195 | test "math.log2_64" { | 195 | test "math.log2_64" { |
| 196 | const epsilon = 0.000001; | 196 | const epsilon = 0.000001; |
| 197 | 197 | ||
| 198 | expect(math.approxEq(f64, log2_64(0.2), -2.321928, epsilon)); | 198 | expect(math.approxEqAbs(f64, log2_64(0.2), -2.321928, epsilon)); |
| 199 | expect(math.approxEq(f64, log2_64(0.8923), -0.164399, epsilon)); | 199 | expect(math.approxEqAbs(f64, log2_64(0.8923), -0.164399, epsilon)); |
| 200 | expect(math.approxEq(f64, log2_64(1.5), 0.584962, epsilon)); | 200 | expect(math.approxEqAbs(f64, log2_64(1.5), 0.584962, epsilon)); |
| 201 | expect(math.approxEq(f64, log2_64(37.45), 5.226894, epsilon)); | 201 | expect(math.approxEqAbs(f64, log2_64(37.45), 5.226894, epsilon)); |
| 202 | expect(math.approxEq(f64, log2_64(123123.234375), 16.909744, epsilon)); | 202 | expect(math.approxEqAbs(f64, log2_64(123123.234375), 16.909744, epsilon)); |
| 203 | } | 203 | } |
| 204 | 204 | ||
| 205 | test "math.log2_32.special" { | 205 | test "math.log2_32.special" { |
lib/std/math/modf.zig+20-20
| ... | @@ -143,24 +143,24 @@ test "math.modf32" { | ... | @@ -143,24 +143,24 @@ test "math.modf32" { |
| 143 | var r: modf32_result = undefined; | 143 | var r: modf32_result = undefined; |
| 144 | 144 | ||
| 145 | r = modf32(1.0); | 145 | r = modf32(1.0); |
| 146 | expect(math.approxEq(f32, r.ipart, 1.0, epsilon)); | 146 | expect(math.approxEqAbs(f32, r.ipart, 1.0, epsilon)); |
| 147 | expect(math.approxEq(f32, r.fpart, 0.0, epsilon)); | 147 | expect(math.approxEqAbs(f32, r.fpart, 0.0, epsilon)); |
| 148 | 148 | ||
| 149 | r = modf32(2.545); | 149 | r = modf32(2.545); |
| 150 | expect(math.approxEq(f32, r.ipart, 2.0, epsilon)); | 150 | expect(math.approxEqAbs(f32, r.ipart, 2.0, epsilon)); |
| 151 | expect(math.approxEq(f32, r.fpart, 0.545, epsilon)); | 151 | expect(math.approxEqAbs(f32, r.fpart, 0.545, epsilon)); |
| 152 | 152 | ||
| 153 | r = modf32(3.978123); | 153 | r = modf32(3.978123); |
| 154 | expect(math.approxEq(f32, r.ipart, 3.0, epsilon)); | 154 | expect(math.approxEqAbs(f32, r.ipart, 3.0, epsilon)); |
| 155 | expect(math.approxEq(f32, r.fpart, 0.978123, epsilon)); | 155 | expect(math.approxEqAbs(f32, r.fpart, 0.978123, epsilon)); |
| 156 | 156 | ||
| 157 | r = modf32(43874.3); | 157 | r = modf32(43874.3); |
| 158 | expect(math.approxEq(f32, r.ipart, 43874, epsilon)); | 158 | expect(math.approxEqAbs(f32, r.ipart, 43874, epsilon)); |
| 159 | expect(math.approxEq(f32, r.fpart, 0.300781, epsilon)); | 159 | expect(math.approxEqAbs(f32, r.fpart, 0.300781, epsilon)); |
| 160 | 160 | ||
| 161 | r = modf32(1234.340780); | 161 | r = modf32(1234.340780); |
| 162 | expect(math.approxEq(f32, r.ipart, 1234, epsilon)); | 162 | expect(math.approxEqAbs(f32, r.ipart, 1234, epsilon)); |
| 163 | expect(math.approxEq(f32, r.fpart, 0.340820, epsilon)); | 163 | expect(math.approxEqAbs(f32, r.fpart, 0.340820, epsilon)); |
| 164 | } | 164 | } |
| 165 | 165 | ||
| 166 | test "math.modf64" { | 166 | test "math.modf64" { |
| ... | @@ -168,24 +168,24 @@ test "math.modf64" { | ... | @@ -168,24 +168,24 @@ test "math.modf64" { |
| 168 | var r: modf64_result = undefined; | 168 | var r: modf64_result = undefined; |
| 169 | 169 | ||
| 170 | r = modf64(1.0); | 170 | r = modf64(1.0); |
| 171 | expect(math.approxEq(f64, r.ipart, 1.0, epsilon)); | 171 | expect(math.approxEqAbs(f64, r.ipart, 1.0, epsilon)); |
| 172 | expect(math.approxEq(f64, r.fpart, 0.0, epsilon)); | 172 | expect(math.approxEqAbs(f64, r.fpart, 0.0, epsilon)); |
| 173 | 173 | ||
| 174 | r = modf64(2.545); | 174 | r = modf64(2.545); |
| 175 | expect(math.approxEq(f64, r.ipart, 2.0, epsilon)); | 175 | expect(math.approxEqAbs(f64, r.ipart, 2.0, epsilon)); |
| 176 | expect(math.approxEq(f64, r.fpart, 0.545, epsilon)); | 176 | expect(math.approxEqAbs(f64, r.fpart, 0.545, epsilon)); |
| 177 | 177 | ||
| 178 | r = modf64(3.978123); | 178 | r = modf64(3.978123); |
| 179 | expect(math.approxEq(f64, r.ipart, 3.0, epsilon)); | 179 | expect(math.approxEqAbs(f64, r.ipart, 3.0, epsilon)); |
| 180 | expect(math.approxEq(f64, r.fpart, 0.978123, epsilon)); | 180 | expect(math.approxEqAbs(f64, r.fpart, 0.978123, epsilon)); |
| 181 | 181 | ||
| 182 | r = modf64(43874.3); | 182 | r = modf64(43874.3); |
| 183 | expect(math.approxEq(f64, r.ipart, 43874, epsilon)); | 183 | expect(math.approxEqAbs(f64, r.ipart, 43874, epsilon)); |
| 184 | expect(math.approxEq(f64, r.fpart, 0.3, epsilon)); | 184 | expect(math.approxEqAbs(f64, r.fpart, 0.3, epsilon)); |
| 185 | 185 | ||
| 186 | r = modf64(1234.340780); | 186 | r = modf64(1234.340780); |
| 187 | expect(math.approxEq(f64, r.ipart, 1234, epsilon)); | 187 | expect(math.approxEqAbs(f64, r.ipart, 1234, epsilon)); |
| 188 | expect(math.approxEq(f64, r.fpart, 0.340780, epsilon)); | 188 | expect(math.approxEqAbs(f64, r.fpart, 0.340780, epsilon)); |
| 189 | } | 189 | } |
| 190 | 190 | ||
| 191 | test "math.modf32.special" { | 191 | test "math.modf32.special" { |
lib/std/math/pow.zig+14-14
| ... | @@ -191,19 +191,19 @@ fn isOddInteger(x: f64) bool { | ... | @@ -191,19 +191,19 @@ fn isOddInteger(x: f64) bool { |
| 191 | test "math.pow" { | 191 | test "math.pow" { |
| 192 | const epsilon = 0.000001; | 192 | const epsilon = 0.000001; |
| 193 | 193 | ||
| 194 | expect(math.approxEq(f32, pow(f32, 0.0, 3.3), 0.0, epsilon)); | 194 | expect(math.approxEqAbs(f32, pow(f32, 0.0, 3.3), 0.0, epsilon)); |
| 195 | expect(math.approxEq(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon)); | 195 | expect(math.approxEqAbs(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon)); |
| 196 | expect(math.approxEq(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon)); | 196 | expect(math.approxEqAbs(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon)); |
| 197 | expect(math.approxEq(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon)); | 197 | expect(math.approxEqAbs(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon)); |
| 198 | expect(math.approxEq(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon)); | 198 | expect(math.approxEqAbs(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon)); |
| 199 | expect(math.approxEq(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon)); | 199 | expect(math.approxEqAbs(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon)); |
| 200 | 200 | ||
| 201 | expect(math.approxEq(f64, pow(f64, 0.0, 3.3), 0.0, epsilon)); | 201 | expect(math.approxEqAbs(f64, pow(f64, 0.0, 3.3), 0.0, epsilon)); |
| 202 | expect(math.approxEq(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon)); | 202 | expect(math.approxEqAbs(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon)); |
| 203 | expect(math.approxEq(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon)); | 203 | expect(math.approxEqAbs(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon)); |
| 204 | expect(math.approxEq(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon)); | 204 | expect(math.approxEqAbs(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon)); |
| 205 | expect(math.approxEq(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon)); | 205 | expect(math.approxEqAbs(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon)); |
| 206 | expect(math.approxEq(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon)); | 206 | expect(math.approxEqAbs(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon)); |
| 207 | } | 207 | } |
| 208 | 208 | ||
| 209 | test "math.pow.special" { | 209 | test "math.pow.special" { |
| ... | @@ -230,8 +230,8 @@ test "math.pow.special" { | ... | @@ -230,8 +230,8 @@ test "math.pow.special" { |
| 230 | expect(pow(f32, -0.0, 1.0) == -0.0); | 230 | expect(pow(f32, -0.0, 1.0) == -0.0); |
| 231 | expect(pow(f32, 0.0, 2.0) == 0.0); | 231 | expect(pow(f32, 0.0, 2.0) == 0.0); |
| 232 | expect(pow(f32, -0.0, 2.0) == 0.0); | 232 | expect(pow(f32, -0.0, 2.0) == 0.0); |
| 233 | expect(math.approxEq(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon)); | 233 | expect(math.approxEqAbs(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon)); |
| 234 | expect(math.approxEq(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon)); | 234 | expect(math.approxEqAbs(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon)); |
| 235 | expect(math.isPositiveInf(pow(f32, 1.2, math.inf(f32)))); | 235 | expect(math.isPositiveInf(pow(f32, 1.2, math.inf(f32)))); |
| 236 | expect(math.isPositiveInf(pow(f32, -1.2, math.inf(f32)))); | 236 | expect(math.isPositiveInf(pow(f32, -1.2, math.inf(f32)))); |
| 237 | expect(pow(f32, 1.2, -math.inf(f32)) == 0.0); | 237 | expect(pow(f32, 1.2, -math.inf(f32)) == 0.0); |
lib/std/math/sin.zig+14-14
| ... | @@ -97,25 +97,25 @@ test "math.sin" { | ... | @@ -97,25 +97,25 @@ test "math.sin" { |
| 97 | test "math.sin32" { | 97 | test "math.sin32" { |
| 98 | const epsilon = 0.000001; | 98 | const epsilon = 0.000001; |
| 99 | 99 | ||
| 100 | expect(math.approxEq(f32, sin_(f32, 0.0), 0.0, epsilon)); | 100 | expect(math.approxEqAbs(f32, sin_(f32, 0.0), 0.0, epsilon)); |
| 101 | expect(math.approxEq(f32, sin_(f32, 0.2), 0.198669, epsilon)); | 101 | expect(math.approxEqAbs(f32, sin_(f32, 0.2), 0.198669, epsilon)); |
| 102 | expect(math.approxEq(f32, sin_(f32, 0.8923), 0.778517, epsilon)); | 102 | expect(math.approxEqAbs(f32, sin_(f32, 0.8923), 0.778517, epsilon)); |
| 103 | expect(math.approxEq(f32, sin_(f32, 1.5), 0.997495, epsilon)); | 103 | expect(math.approxEqAbs(f32, sin_(f32, 1.5), 0.997495, epsilon)); |
| 104 | expect(math.approxEq(f32, sin_(f32, -1.5), -0.997495, epsilon)); | 104 | expect(math.approxEqAbs(f32, sin_(f32, -1.5), -0.997495, epsilon)); |
| 105 | expect(math.approxEq(f32, sin_(f32, 37.45), -0.246544, epsilon)); | 105 | expect(math.approxEqAbs(f32, sin_(f32, 37.45), -0.246544, epsilon)); |
| 106 | expect(math.approxEq(f32, sin_(f32, 89.123), 0.916166, epsilon)); | 106 | expect(math.approxEqAbs(f32, sin_(f32, 89.123), 0.916166, epsilon)); |
| 107 | } | 107 | } |
| 108 | 108 | ||
| 109 | test "math.sin64" { | 109 | test "math.sin64" { |
| 110 | const epsilon = 0.000001; | 110 | const epsilon = 0.000001; |
| 111 | 111 | ||
| 112 | expect(math.approxEq(f64, sin_(f64, 0.0), 0.0, epsilon)); | 112 | expect(math.approxEqAbs(f64, sin_(f64, 0.0), 0.0, epsilon)); |
| 113 | expect(math.approxEq(f64, sin_(f64, 0.2), 0.198669, epsilon)); | 113 | expect(math.approxEqAbs(f64, sin_(f64, 0.2), 0.198669, epsilon)); |
| 114 | expect(math.approxEq(f64, sin_(f64, 0.8923), 0.778517, epsilon)); | 114 | expect(math.approxEqAbs(f64, sin_(f64, 0.8923), 0.778517, epsilon)); |
| 115 | expect(math.approxEq(f64, sin_(f64, 1.5), 0.997495, epsilon)); | 115 | expect(math.approxEqAbs(f64, sin_(f64, 1.5), 0.997495, epsilon)); |
| 116 | expect(math.approxEq(f64, sin_(f64, -1.5), -0.997495, epsilon)); | 116 | expect(math.approxEqAbs(f64, sin_(f64, -1.5), -0.997495, epsilon)); |
| 117 | expect(math.approxEq(f64, sin_(f64, 37.45), -0.246543, epsilon)); | 117 | expect(math.approxEqAbs(f64, sin_(f64, 37.45), -0.246543, epsilon)); |
| 118 | expect(math.approxEq(f64, sin_(f64, 89.123), 0.916166, epsilon)); | 118 | expect(math.approxEqAbs(f64, sin_(f64, 89.123), 0.916166, epsilon)); |
| 119 | } | 119 | } |
| 120 | 120 | ||
| 121 | test "math.sin32.special" { | 121 | test "math.sin32.special" { |
lib/std/math/sinh.zig+16-16
| ... | @@ -105,27 +105,27 @@ test "math.sinh" { | ... | @@ -105,27 +105,27 @@ test "math.sinh" { |
| 105 | test "math.sinh32" { | 105 | test "math.sinh32" { |
| 106 | const epsilon = 0.000001; | 106 | const epsilon = 0.000001; |
| 107 | 107 | ||
| 108 | expect(math.approxEq(f32, sinh32(0.0), 0.0, epsilon)); | 108 | expect(math.approxEqAbs(f32, sinh32(0.0), 0.0, epsilon)); |
| 109 | expect(math.approxEq(f32, sinh32(0.2), 0.201336, epsilon)); | 109 | expect(math.approxEqAbs(f32, sinh32(0.2), 0.201336, epsilon)); |
| 110 | expect(math.approxEq(f32, sinh32(0.8923), 1.015512, epsilon)); | 110 | expect(math.approxEqAbs(f32, sinh32(0.8923), 1.015512, epsilon)); |
| 111 | expect(math.approxEq(f32, sinh32(1.5), 2.129279, epsilon)); | 111 | expect(math.approxEqAbs(f32, sinh32(1.5), 2.129279, epsilon)); |
| 112 | expect(math.approxEq(f32, sinh32(-0.0), -0.0, epsilon)); | 112 | expect(math.approxEqAbs(f32, sinh32(-0.0), -0.0, epsilon)); |
| 113 | expect(math.approxEq(f32, sinh32(-0.2), -0.201336, epsilon)); | 113 | expect(math.approxEqAbs(f32, sinh32(-0.2), -0.201336, epsilon)); |
| 114 | expect(math.approxEq(f32, sinh32(-0.8923), -1.015512, epsilon)); | 114 | expect(math.approxEqAbs(f32, sinh32(-0.8923), -1.015512, epsilon)); |
| 115 | expect(math.approxEq(f32, sinh32(-1.5), -2.129279, epsilon)); | 115 | expect(math.approxEqAbs(f32, sinh32(-1.5), -2.129279, epsilon)); |
| 116 | } | 116 | } |
| 117 | 117 | ||
| 118 | test "math.sinh64" { | 118 | test "math.sinh64" { |
| 119 | const epsilon = 0.000001; | 119 | const epsilon = 0.000001; |
| 120 | 120 | ||
| 121 | expect(math.approxEq(f64, sinh64(0.0), 0.0, epsilon)); | 121 | expect(math.approxEqAbs(f64, sinh64(0.0), 0.0, epsilon)); |
| 122 | expect(math.approxEq(f64, sinh64(0.2), 0.201336, epsilon)); | 122 | expect(math.approxEqAbs(f64, sinh64(0.2), 0.201336, epsilon)); |
| 123 | expect(math.approxEq(f64, sinh64(0.8923), 1.015512, epsilon)); | 123 | expect(math.approxEqAbs(f64, sinh64(0.8923), 1.015512, epsilon)); |
| 124 | expect(math.approxEq(f64, sinh64(1.5), 2.129279, epsilon)); | 124 | expect(math.approxEqAbs(f64, sinh64(1.5), 2.129279, epsilon)); |
| 125 | expect(math.approxEq(f64, sinh64(-0.0), -0.0, epsilon)); | 125 | expect(math.approxEqAbs(f64, sinh64(-0.0), -0.0, epsilon)); |
| 126 | expect(math.approxEq(f64, sinh64(-0.2), -0.201336, epsilon)); | 126 | expect(math.approxEqAbs(f64, sinh64(-0.2), -0.201336, epsilon)); |
| 127 | expect(math.approxEq(f64, sinh64(-0.8923), -1.015512, epsilon)); | 127 | expect(math.approxEqAbs(f64, sinh64(-0.8923), -1.015512, epsilon)); |
| 128 | expect(math.approxEq(f64, sinh64(-1.5), -2.129279, epsilon)); | 128 | expect(math.approxEqAbs(f64, sinh64(-1.5), -2.129279, epsilon)); |
| 129 | } | 129 | } |
| 130 | 130 | ||
| 131 | test "math.sinh32.special" { | 131 | test "math.sinh32.special" { |
lib/std/math/tan.zig+12-12
| ... | @@ -87,23 +87,23 @@ test "math.tan" { | ... | @@ -87,23 +87,23 @@ test "math.tan" { |
| 87 | test "math.tan32" { | 87 | test "math.tan32" { |
| 88 | const epsilon = 0.000001; | 88 | const epsilon = 0.000001; |
| 89 | 89 | ||
| 90 | expect(math.approxEq(f32, tan_(f32, 0.0), 0.0, epsilon)); | 90 | expect(math.approxEqAbs(f32, tan_(f32, 0.0), 0.0, epsilon)); |
| 91 | expect(math.approxEq(f32, tan_(f32, 0.2), 0.202710, epsilon)); | 91 | expect(math.approxEqAbs(f32, tan_(f32, 0.2), 0.202710, epsilon)); |
| 92 | expect(math.approxEq(f32, tan_(f32, 0.8923), 1.240422, epsilon)); | 92 | expect(math.approxEqAbs(f32, tan_(f32, 0.8923), 1.240422, epsilon)); |
| 93 | expect(math.approxEq(f32, tan_(f32, 1.5), 14.101420, epsilon)); | 93 | expect(math.approxEqAbs(f32, tan_(f32, 1.5), 14.101420, epsilon)); |
| 94 | expect(math.approxEq(f32, tan_(f32, 37.45), -0.254397, epsilon)); | 94 | expect(math.approxEqAbs(f32, tan_(f32, 37.45), -0.254397, epsilon)); |
| 95 | expect(math.approxEq(f32, tan_(f32, 89.123), 2.285852, epsilon)); | 95 | expect(math.approxEqAbs(f32, tan_(f32, 89.123), 2.285852, epsilon)); |
| 96 | } | 96 | } |
| 97 | 97 | ||
| 98 | test "math.tan64" { | 98 | test "math.tan64" { |
| 99 | const epsilon = 0.000001; | 99 | const epsilon = 0.000001; |
| 100 | 100 | ||
| 101 | expect(math.approxEq(f64, tan_(f64, 0.0), 0.0, epsilon)); | 101 | expect(math.approxEqAbs(f64, tan_(f64, 0.0), 0.0, epsilon)); |
| 102 | expect(math.approxEq(f64, tan_(f64, 0.2), 0.202710, epsilon)); | 102 | expect(math.approxEqAbs(f64, tan_(f64, 0.2), 0.202710, epsilon)); |
| 103 | expect(math.approxEq(f64, tan_(f64, 0.8923), 1.240422, epsilon)); | 103 | expect(math.approxEqAbs(f64, tan_(f64, 0.8923), 1.240422, epsilon)); |
| 104 | expect(math.approxEq(f64, tan_(f64, 1.5), 14.101420, epsilon)); | 104 | expect(math.approxEqAbs(f64, tan_(f64, 1.5), 14.101420, epsilon)); |
| 105 | expect(math.approxEq(f64, tan_(f64, 37.45), -0.254397, epsilon)); | 105 | expect(math.approxEqAbs(f64, tan_(f64, 37.45), -0.254397, epsilon)); |
| 106 | expect(math.approxEq(f64, tan_(f64, 89.123), 2.2858376, epsilon)); | 106 | expect(math.approxEqAbs(f64, tan_(f64, 89.123), 2.2858376, epsilon)); |
| 107 | } | 107 | } |
| 108 | 108 | ||
| 109 | test "math.tan32.special" { | 109 | test "math.tan32.special" { |
lib/std/math/tanh.zig+10-10
| ... | @@ -131,21 +131,21 @@ test "math.tanh" { | ... | @@ -131,21 +131,21 @@ test "math.tanh" { |
| 131 | test "math.tanh32" { | 131 | test "math.tanh32" { |
| 132 | const epsilon = 0.000001; | 132 | const epsilon = 0.000001; |
| 133 | 133 | ||
| 134 | expect(math.approxEq(f32, tanh32(0.0), 0.0, epsilon)); | 134 | expect(math.approxEqAbs(f32, tanh32(0.0), 0.0, epsilon)); |
| 135 | expect(math.approxEq(f32, tanh32(0.2), 0.197375, epsilon)); | 135 | expect(math.approxEqAbs(f32, tanh32(0.2), 0.197375, epsilon)); |
| 136 | expect(math.approxEq(f32, tanh32(0.8923), 0.712528, epsilon)); | 136 | expect(math.approxEqAbs(f32, tanh32(0.8923), 0.712528, epsilon)); |
| 137 | expect(math.approxEq(f32, tanh32(1.5), 0.905148, epsilon)); | 137 | expect(math.approxEqAbs(f32, tanh32(1.5), 0.905148, epsilon)); |
| 138 | expect(math.approxEq(f32, tanh32(37.45), 1.0, epsilon)); | 138 | expect(math.approxEqAbs(f32, tanh32(37.45), 1.0, epsilon)); |
| 139 | } | 139 | } |
| 140 | 140 | ||
| 141 | test "math.tanh64" { | 141 | test "math.tanh64" { |
| 142 | const epsilon = 0.000001; | 142 | const epsilon = 0.000001; |
| 143 | 143 | ||
| 144 | expect(math.approxEq(f64, tanh64(0.0), 0.0, epsilon)); | 144 | expect(math.approxEqAbs(f64, tanh64(0.0), 0.0, epsilon)); |
| 145 | expect(math.approxEq(f64, tanh64(0.2), 0.197375, epsilon)); | 145 | expect(math.approxEqAbs(f64, tanh64(0.2), 0.197375, epsilon)); |
| 146 | expect(math.approxEq(f64, tanh64(0.8923), 0.712528, epsilon)); | 146 | expect(math.approxEqAbs(f64, tanh64(0.8923), 0.712528, epsilon)); |
| 147 | expect(math.approxEq(f64, tanh64(1.5), 0.905148, epsilon)); | 147 | expect(math.approxEqAbs(f64, tanh64(1.5), 0.905148, epsilon)); |
| 148 | expect(math.approxEq(f64, tanh64(37.45), 1.0, epsilon)); | 148 | expect(math.approxEqAbs(f64, tanh64(37.45), 1.0, epsilon)); |
| 149 | } | 149 | } |
| 150 | 150 | ||
| 151 | test "math.tanh32.special" { | 151 | test "math.tanh32.special" { |
lib/std/special/c.zig+12-12
| ... | @@ -912,14 +912,14 @@ test "sqrt" { | ... | @@ -912,14 +912,14 @@ test "sqrt" { |
| 912 | const epsilon = 0.000001; | 912 | const epsilon = 0.000001; |
| 913 | 913 | ||
| 914 | std.testing.expect(sqrt(0.0) == 0.0); | 914 | std.testing.expect(sqrt(0.0) == 0.0); |
| 915 | std.testing.expect(std.math.approxEq(f64, sqrt(2.0), 1.414214, epsilon)); | 915 | std.testing.expect(std.math.approxEqAbs(f64, sqrt(2.0), 1.414214, epsilon)); |
| 916 | std.testing.expect(std.math.approxEq(f64, sqrt(3.6), 1.897367, epsilon)); | 916 | std.testing.expect(std.math.approxEqAbs(f64, sqrt(3.6), 1.897367, epsilon)); |
| 917 | std.testing.expect(sqrt(4.0) == 2.0); | 917 | std.testing.expect(sqrt(4.0) == 2.0); |
| 918 | std.testing.expect(std.math.approxEq(f64, sqrt(7.539840), 2.745877, epsilon)); | 918 | std.testing.expect(std.math.approxEqAbs(f64, sqrt(7.539840), 2.745877, epsilon)); |
| 919 | std.testing.expect(std.math.approxEq(f64, sqrt(19.230934), 4.385309, epsilon)); | 919 | std.testing.expect(std.math.approxEqAbs(f64, sqrt(19.230934), 4.385309, epsilon)); |
| 920 | std.testing.expect(sqrt(64.0) == 8.0); | 920 | std.testing.expect(sqrt(64.0) == 8.0); |
| 921 | std.testing.expect(std.math.approxEq(f64, sqrt(64.1), 8.006248, epsilon)); | 921 | std.testing.expect(std.math.approxEqAbs(f64, sqrt(64.1), 8.006248, epsilon)); |
| 922 | std.testing.expect(std.math.approxEq(f64, sqrt(8942.230469), 94.563367, epsilon)); | 922 | std.testing.expect(std.math.approxEqAbs(f64, sqrt(8942.230469), 94.563367, epsilon)); |
| 923 | } | 923 | } |
| 924 | 924 | ||
| 925 | test "sqrt special" { | 925 | test "sqrt special" { |
| ... | @@ -1010,14 +1010,14 @@ test "sqrtf" { | ... | @@ -1010,14 +1010,14 @@ test "sqrtf" { |
| 1010 | const epsilon = 0.000001; | 1010 | const epsilon = 0.000001; |
| 1011 | 1011 | ||
| 1012 | std.testing.expect(sqrtf(0.0) == 0.0); | 1012 | std.testing.expect(sqrtf(0.0) == 0.0); |
| 1013 | std.testing.expect(std.math.approxEq(f32, sqrtf(2.0), 1.414214, epsilon)); | 1013 | std.testing.expect(std.math.approxEqAbs(f32, sqrtf(2.0), 1.414214, epsilon)); |
| 1014 | std.testing.expect(std.math.approxEq(f32, sqrtf(3.6), 1.897367, epsilon)); | 1014 | std.testing.expect(std.math.approxEqAbs(f32, sqrtf(3.6), 1.897367, epsilon)); |
| 1015 | std.testing.expect(sqrtf(4.0) == 2.0); | 1015 | std.testing.expect(sqrtf(4.0) == 2.0); |
| 1016 | std.testing.expect(std.math.approxEq(f32, sqrtf(7.539840), 2.745877, epsilon)); | 1016 | std.testing.expect(std.math.approxEqAbs(f32, sqrtf(7.539840), 2.745877, epsilon)); |
| 1017 | std.testing.expect(std.math.approxEq(f32, sqrtf(19.230934), 4.385309, epsilon)); | 1017 | std.testing.expect(std.math.approxEqAbs(f32, sqrtf(19.230934), 4.385309, epsilon)); |
| 1018 | std.testing.expect(sqrtf(64.0) == 8.0); | 1018 | std.testing.expect(sqrtf(64.0) == 8.0); |
| 1019 | std.testing.expect(std.math.approxEq(f32, sqrtf(64.1), 8.006248, epsilon)); | 1019 | std.testing.expect(std.math.approxEqAbs(f32, sqrtf(64.1), 8.006248, epsilon)); |
| 1020 | std.testing.expect(std.math.approxEq(f32, sqrtf(8942.230469), 94.563370, epsilon)); | 1020 | std.testing.expect(std.math.approxEqAbs(f32, sqrtf(8942.230469), 94.563370, epsilon)); |
| 1021 | } | 1021 | } |
| 1022 | 1022 | ||
| 1023 | test "sqrtf special" { | 1023 | test "sqrtf special" { |
test/stage1/behavior/floatop.zig+56-56
| ... | @@ -21,7 +21,7 @@ fn testSqrt() void { | ... | @@ -21,7 +21,7 @@ fn testSqrt() void { |
| 21 | var a: f32 = 9; | 21 | var a: f32 = 9; |
| 22 | expect(@sqrt(a) == 3); | 22 | expect(@sqrt(a) == 3); |
| 23 | var b: f32 = 1.1; | 23 | var b: f32 = 1.1; |
| 24 | expect(math.approxEq(f32, @sqrt(b), 1.0488088481701516, epsilon)); | 24 | expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon)); |
| 25 | } | 25 | } |
| 26 | { | 26 | { |
| 27 | var a: f64 = 25; | 27 | var a: f64 = 25; |
| ... | @@ -39,24 +39,24 @@ fn testSqrt() void { | ... | @@ -39,24 +39,24 @@ fn testSqrt() void { |
| 39 | { | 39 | { |
| 40 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; | 40 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; |
| 41 | var result = @sqrt(v); | 41 | var result = @sqrt(v); |
| 42 | expect(math.approxEq(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon)); | 42 | expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon)); |
| 43 | expect(math.approxEq(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon)); | 43 | expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon)); |
| 44 | expect(math.approxEq(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon)); | 44 | expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon)); |
| 45 | expect(math.approxEq(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon)); | 45 | expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon)); |
| 46 | } | 46 | } |
| 47 | } | 47 | } |
| 48 | 48 | ||
| 49 | test "more @sqrt f16 tests" { | 49 | test "more @sqrt f16 tests" { |
| 50 | // TODO these are not all passing at comptime | 50 | // TODO these are not all passing at comptime |
| 51 | expect(@sqrt(@as(f16, 0.0)) == 0.0); | 51 | expect(@sqrt(@as(f16, 0.0)) == 0.0); |
| 52 | expect(math.approxEq(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon)); | 52 | expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon)); |
| 53 | expect(math.approxEq(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon)); | 53 | expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon)); |
| 54 | expect(@sqrt(@as(f16, 4.0)) == 2.0); | 54 | expect(@sqrt(@as(f16, 4.0)) == 2.0); |
| 55 | expect(math.approxEq(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon)); | 55 | expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon)); |
| 56 | expect(math.approxEq(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon)); | 56 | expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon)); |
| 57 | expect(@sqrt(@as(f16, 64.0)) == 8.0); | 57 | expect(@sqrt(@as(f16, 64.0)) == 8.0); |
| 58 | expect(math.approxEq(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon)); | 58 | expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon)); |
| 59 | expect(math.approxEq(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon)); | 59 | expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon)); |
| 60 | 60 | ||
| 61 | // special cases | 61 | // special cases |
| 62 | expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16))))); | 62 | expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16))))); |
| ... | @@ -89,10 +89,10 @@ fn testSin() void { | ... | @@ -89,10 +89,10 @@ fn testSin() void { |
| 89 | { | 89 | { |
| 90 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; | 90 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; |
| 91 | var result = @sin(v); | 91 | var result = @sin(v); |
| 92 | expect(math.approxEq(f32, @sin(@as(f32, 1.1)), result[0], epsilon)); | 92 | expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon)); |
| 93 | expect(math.approxEq(f32, @sin(@as(f32, 2.2)), result[1], epsilon)); | 93 | expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon)); |
| 94 | expect(math.approxEq(f32, @sin(@as(f32, 3.3)), result[2], epsilon)); | 94 | expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon)); |
| 95 | expect(math.approxEq(f32, @sin(@as(f32, 4.4)), result[3], epsilon)); | 95 | expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon)); |
| 96 | } | 96 | } |
| 97 | } | 97 | } |
| 98 | 98 | ||
| ... | @@ -119,10 +119,10 @@ fn testCos() void { | ... | @@ -119,10 +119,10 @@ fn testCos() void { |
| 119 | { | 119 | { |
| 120 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; | 120 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; |
| 121 | var result = @cos(v); | 121 | var result = @cos(v); |
| 122 | expect(math.approxEq(f32, @cos(@as(f32, 1.1)), result[0], epsilon)); | 122 | expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon)); |
| 123 | expect(math.approxEq(f32, @cos(@as(f32, 2.2)), result[1], epsilon)); | 123 | expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon)); |
| 124 | expect(math.approxEq(f32, @cos(@as(f32, 3.3)), result[2], epsilon)); | 124 | expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon)); |
| 125 | expect(math.approxEq(f32, @cos(@as(f32, 4.4)), result[3], epsilon)); | 125 | expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon)); |
| 126 | } | 126 | } |
| 127 | } | 127 | } |
| 128 | 128 | ||
| ... | @@ -149,10 +149,10 @@ fn testExp() void { | ... | @@ -149,10 +149,10 @@ fn testExp() void { |
| 149 | { | 149 | { |
| 150 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; | 150 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; |
| 151 | var result = @exp(v); | 151 | var result = @exp(v); |
| 152 | expect(math.approxEq(f32, @exp(@as(f32, 1.1)), result[0], epsilon)); | 152 | expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon)); |
| 153 | expect(math.approxEq(f32, @exp(@as(f32, 2.2)), result[1], epsilon)); | 153 | expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon)); |
| 154 | expect(math.approxEq(f32, @exp(@as(f32, 0.3)), result[2], epsilon)); | 154 | expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon)); |
| 155 | expect(math.approxEq(f32, @exp(@as(f32, 0.4)), result[3], epsilon)); | 155 | expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon)); |
| 156 | } | 156 | } |
| 157 | } | 157 | } |
| 158 | 158 | ||
| ... | @@ -179,10 +179,10 @@ fn testExp2() void { | ... | @@ -179,10 +179,10 @@ fn testExp2() void { |
| 179 | { | 179 | { |
| 180 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; | 180 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; |
| 181 | var result = @exp2(v); | 181 | var result = @exp2(v); |
| 182 | expect(math.approxEq(f32, @exp2(@as(f32, 1.1)), result[0], epsilon)); | 182 | expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon)); |
| 183 | expect(math.approxEq(f32, @exp2(@as(f32, 2.2)), result[1], epsilon)); | 183 | expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon)); |
| 184 | expect(math.approxEq(f32, @exp2(@as(f32, 0.3)), result[2], epsilon)); | 184 | expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon)); |
| 185 | expect(math.approxEq(f32, @exp2(@as(f32, 0.4)), result[3], epsilon)); | 185 | expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon)); |
| 186 | } | 186 | } |
| 187 | } | 187 | } |
| 188 | 188 | ||
| ... | @@ -198,7 +198,7 @@ fn testLog() void { | ... | @@ -198,7 +198,7 @@ fn testLog() void { |
| 198 | // https://github.com/ziglang/zig/issues/4026 | 198 | // https://github.com/ziglang/zig/issues/4026 |
| 199 | { | 199 | { |
| 200 | var a: f16 = e; | 200 | var a: f16 = e; |
| 201 | expect(math.approxEq(f16, @log(a), 1, epsilon)); | 201 | expect(math.approxEqAbs(f16, @log(a), 1, epsilon)); |
| 202 | } | 202 | } |
| 203 | { | 203 | { |
| 204 | var a: f32 = e; | 204 | var a: f32 = e; |
| ... | @@ -211,10 +211,10 @@ fn testLog() void { | ... | @@ -211,10 +211,10 @@ fn testLog() void { |
| 211 | { | 211 | { |
| 212 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; | 212 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; |
| 213 | var result = @log(v); | 213 | var result = @log(v); |
| 214 | expect(math.approxEq(f32, @log(@as(f32, 1.1)), result[0], epsilon)); | 214 | expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon)); |
| 215 | expect(math.approxEq(f32, @log(@as(f32, 2.2)), result[1], epsilon)); | 215 | expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon)); |
| 216 | expect(math.approxEq(f32, @log(@as(f32, 0.3)), result[2], epsilon)); | 216 | expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon)); |
| 217 | expect(math.approxEq(f32, @log(@as(f32, 0.4)), result[3], epsilon)); | 217 | expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon)); |
| 218 | } | 218 | } |
| 219 | } | 219 | } |
| 220 | 220 | ||
| ... | @@ -241,10 +241,10 @@ fn testLog2() void { | ... | @@ -241,10 +241,10 @@ fn testLog2() void { |
| 241 | { | 241 | { |
| 242 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; | 242 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; |
| 243 | var result = @log2(v); | 243 | var result = @log2(v); |
| 244 | expect(math.approxEq(f32, @log2(@as(f32, 1.1)), result[0], epsilon)); | 244 | expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon)); |
| 245 | expect(math.approxEq(f32, @log2(@as(f32, 2.2)), result[1], epsilon)); | 245 | expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon)); |
| 246 | expect(math.approxEq(f32, @log2(@as(f32, 0.3)), result[2], epsilon)); | 246 | expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon)); |
| 247 | expect(math.approxEq(f32, @log2(@as(f32, 0.4)), result[3], epsilon)); | 247 | expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon)); |
| 248 | } | 248 | } |
| 249 | } | 249 | } |
| 250 | 250 | ||
| ... | @@ -271,10 +271,10 @@ fn testLog10() void { | ... | @@ -271,10 +271,10 @@ fn testLog10() void { |
| 271 | { | 271 | { |
| 272 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; | 272 | var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; |
| 273 | var result = @log10(v); | 273 | var result = @log10(v); |
| 274 | expect(math.approxEq(f32, @log10(@as(f32, 1.1)), result[0], epsilon)); | 274 | expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon)); |
| 275 | expect(math.approxEq(f32, @log10(@as(f32, 2.2)), result[1], epsilon)); | 275 | expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon)); |
| 276 | expect(math.approxEq(f32, @log10(@as(f32, 0.3)), result[2], epsilon)); | 276 | expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon)); |
| 277 | expect(math.approxEq(f32, @log10(@as(f32, 0.4)), result[3], epsilon)); | 277 | expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon)); |
| 278 | } | 278 | } |
| 279 | } | 279 | } |
| 280 | 280 | ||
| ... | @@ -307,10 +307,10 @@ fn testFabs() void { | ... | @@ -307,10 +307,10 @@ fn testFabs() void { |
| 307 | { | 307 | { |
| 308 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; | 308 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; |
| 309 | var result = @fabs(v); | 309 | var result = @fabs(v); |
| 310 | expect(math.approxEq(f32, @fabs(@as(f32, 1.1)), result[0], epsilon)); | 310 | expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon)); |
| 311 | expect(math.approxEq(f32, @fabs(@as(f32, -2.2)), result[1], epsilon)); | 311 | expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon)); |
| 312 | expect(math.approxEq(f32, @fabs(@as(f32, 0.3)), result[2], epsilon)); | 312 | expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon)); |
| 313 | expect(math.approxEq(f32, @fabs(@as(f32, -0.4)), result[3], epsilon)); | 313 | expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon)); |
| 314 | } | 314 | } |
| 315 | } | 315 | } |
| 316 | 316 | ||
| ... | @@ -337,10 +337,10 @@ fn testFloor() void { | ... | @@ -337,10 +337,10 @@ fn testFloor() void { |
| 337 | { | 337 | { |
| 338 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; | 338 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; |
| 339 | var result = @floor(v); | 339 | var result = @floor(v); |
| 340 | expect(math.approxEq(f32, @floor(@as(f32, 1.1)), result[0], epsilon)); | 340 | expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon)); |
| 341 | expect(math.approxEq(f32, @floor(@as(f32, -2.2)), result[1], epsilon)); | 341 | expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon)); |
| 342 | expect(math.approxEq(f32, @floor(@as(f32, 0.3)), result[2], epsilon)); | 342 | expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon)); |
| 343 | expect(math.approxEq(f32, @floor(@as(f32, -0.4)), result[3], epsilon)); | 343 | expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon)); |
| 344 | } | 344 | } |
| 345 | } | 345 | } |
| 346 | 346 | ||
| ... | @@ -367,10 +367,10 @@ fn testCeil() void { | ... | @@ -367,10 +367,10 @@ fn testCeil() void { |
| 367 | { | 367 | { |
| 368 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; | 368 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; |
| 369 | var result = @ceil(v); | 369 | var result = @ceil(v); |
| 370 | expect(math.approxEq(f32, @ceil(@as(f32, 1.1)), result[0], epsilon)); | 370 | expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon)); |
| 371 | expect(math.approxEq(f32, @ceil(@as(f32, -2.2)), result[1], epsilon)); | 371 | expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon)); |
| 372 | expect(math.approxEq(f32, @ceil(@as(f32, 0.3)), result[2], epsilon)); | 372 | expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon)); |
| 373 | expect(math.approxEq(f32, @ceil(@as(f32, -0.4)), result[3], epsilon)); | 373 | expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon)); |
| 374 | } | 374 | } |
| 375 | } | 375 | } |
| 376 | 376 | ||
| ... | @@ -397,10 +397,10 @@ fn testTrunc() void { | ... | @@ -397,10 +397,10 @@ fn testTrunc() void { |
| 397 | { | 397 | { |
| 398 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; | 398 | var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; |
| 399 | var result = @trunc(v); | 399 | var result = @trunc(v); |
| 400 | expect(math.approxEq(f32, @trunc(@as(f32, 1.1)), result[0], epsilon)); | 400 | expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon)); |
| 401 | expect(math.approxEq(f32, @trunc(@as(f32, -2.2)), result[1], epsilon)); | 401 | expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon)); |
| 402 | expect(math.approxEq(f32, @trunc(@as(f32, 0.3)), result[2], epsilon)); | 402 | expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon)); |
| 403 | expect(math.approxEq(f32, @trunc(@as(f32, -0.4)), result[3], epsilon)); | 403 | expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon)); |
| 404 | } | 404 | } |
| 405 | } | 405 | } |
| 406 | 406 |