mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
std/softfloat: compare non-negative, non-NaN operands directly
The f64 and f32 comparison, min and max functions now compare the bit patterns directly when neither operand is negative or a NaN, and call the unchanged general code (now f64_cmp_slow and f32_cmp_slow) otherwise. Results are unchanged: the ops harness and the old-vs-new differential test report zero mismatches.
This commit is contained in:
4 files changed
+311
-32
No files matched your search
@@ -41204,6 +41204,13 @@ wuffs_softfloat__arith__f64_propagate_nan(
|
||||
uint64_t a_a,
|
||||
uint64_t a_b);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_softfloat__arith__f64_cmp_slow(
|
||||
const wuffs_softfloat__arith* self,
|
||||
uint64_t a_a,
|
||||
uint64_t a_b);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint64_t
|
||||
wuffs_softfloat__arith__f64_add_normal(
|
||||
@@ -41270,6 +41277,13 @@ wuffs_softfloat__arith__slow_f32_mul(
|
||||
uint32_t a_a,
|
||||
uint32_t a_b);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_softfloat__arith__f32_cmp_slow(
|
||||
const wuffs_softfloat__arith* self,
|
||||
uint32_t a_a,
|
||||
uint32_t a_b);
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
// ---------------- Initializer Implementations
|
||||
@@ -41668,6 +41682,25 @@ wuffs_softfloat__arith__f64_cmp(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a < a_b) {
|
||||
return 0u;
|
||||
} else if (a_a == a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 2u;
|
||||
}
|
||||
return wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b);
|
||||
}
|
||||
|
||||
// -------- func softfloat.arith.f64_cmp_slow
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_softfloat__arith__f64_cmp_slow(
|
||||
const wuffs_softfloat__arith* self,
|
||||
uint64_t a_a,
|
||||
uint64_t a_b) {
|
||||
uint64_t v_ka = 0;
|
||||
uint64_t v_kb = 0;
|
||||
|
||||
@@ -41708,7 +41741,13 @@ wuffs_softfloat__arith__f64_eq(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 1u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a == a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 1u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -41730,7 +41769,13 @@ wuffs_softfloat__arith__f64_ne(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 1u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a != a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 1u) {
|
||||
return 0u;
|
||||
}
|
||||
return 1u;
|
||||
@@ -41752,7 +41797,13 @@ wuffs_softfloat__arith__f64_lt(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 0u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a < a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 0u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -41774,7 +41825,13 @@ wuffs_softfloat__arith__f64_le(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) <= 1u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a <= a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) <= 1u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -41796,7 +41853,13 @@ wuffs_softfloat__arith__f64_gt(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 2u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a > a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 2u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -41820,7 +41883,13 @@ wuffs_softfloat__arith__f64_ge(
|
||||
|
||||
uint32_t v_c = 0;
|
||||
|
||||
v_c = wuffs_softfloat__arith__f64_cmp(self, a_a, a_b);
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a >= a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
v_c = wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b);
|
||||
if ((v_c == 1u) || (v_c == 2u)) {
|
||||
return 1u;
|
||||
}
|
||||
@@ -41843,7 +41912,13 @@ wuffs_softfloat__arith__f64_min(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 0u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a < a_b) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 0u) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
@@ -41865,7 +41940,13 @@ wuffs_softfloat__arith__f64_max(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 2u) {
|
||||
if ((a_a | a_b) <= 9218868437227405312u) {
|
||||
if (a_a > a_b) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 2u) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
@@ -43057,6 +43138,25 @@ wuffs_softfloat__arith__f32_cmp(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a < a_b) {
|
||||
return 0u;
|
||||
} else if (a_a == a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 2u;
|
||||
}
|
||||
return wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b);
|
||||
}
|
||||
|
||||
// -------- func softfloat.arith.f32_cmp_slow
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_softfloat__arith__f32_cmp_slow(
|
||||
const wuffs_softfloat__arith* self,
|
||||
uint32_t a_a,
|
||||
uint32_t a_b) {
|
||||
uint32_t v_ka = 0;
|
||||
uint32_t v_kb = 0;
|
||||
|
||||
@@ -43097,7 +43197,13 @@ wuffs_softfloat__arith__f32_eq(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 1u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a == a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 1u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -43119,7 +43225,13 @@ wuffs_softfloat__arith__f32_ne(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 1u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a != a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 1u) {
|
||||
return 0u;
|
||||
}
|
||||
return 1u;
|
||||
@@ -43141,7 +43253,13 @@ wuffs_softfloat__arith__f32_lt(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 0u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a < a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 0u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -43163,7 +43281,13 @@ wuffs_softfloat__arith__f32_le(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) <= 1u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a <= a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) <= 1u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -43185,7 +43309,13 @@ wuffs_softfloat__arith__f32_gt(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 2u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a > a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 2u) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
@@ -43209,7 +43339,13 @@ wuffs_softfloat__arith__f32_ge(
|
||||
|
||||
uint32_t v_c = 0;
|
||||
|
||||
v_c = wuffs_softfloat__arith__f32_cmp(self, a_a, a_b);
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a >= a_b) {
|
||||
return 1u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
v_c = wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b);
|
||||
if ((v_c == 1u) || (v_c == 2u)) {
|
||||
return 1u;
|
||||
}
|
||||
@@ -43232,7 +43368,13 @@ wuffs_softfloat__arith__f32_min(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 0u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a < a_b) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 0u) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
@@ -43254,7 +43396,13 @@ wuffs_softfloat__arith__f32_max(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 2u) {
|
||||
if ((a_a | a_b) <= 2139095040u) {
|
||||
if (a_a > a_b) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
}
|
||||
if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 2u) {
|
||||
return a_a;
|
||||
}
|
||||
return a_b;
|
||||
|
||||
@@ -118,6 +118,11 @@ Newsletter, 1995). The tests confirm this against hardware, including for
|
||||
subnormal `f32` results. The fast paths never produce a NaN, so NaN results
|
||||
(and their payloads) are exactly those of the "via `f64`" computation.
|
||||
|
||||
The comparison functions (`f64_cmp`, `f64_lt`, `f64_min`, etc. and their `f32`
|
||||
counterparts) compare the bit patterns directly when neither operand is
|
||||
negative or a NaN (when `a | b` is at most the bit pattern of `+inf`), and
|
||||
otherwise call `f64_cmp_slow` or `f32_cmp_slow`.
|
||||
|
||||
|
||||
## log2
|
||||
|
||||
|
||||
@@ -265,6 +265,21 @@ pub func arith.f64_abs(a: base.u64) base.u64 {
|
||||
// f64_cmp compares a and b, returning 0 if (a < b), 1 if (a == b), 2 if (a
|
||||
// > b) and 3 if they are unordered (either is a NaN). -0 and +0 compare equal.
|
||||
pub func arith.f64_cmp(a: base.u64, b: base.u64) base.u32 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
// Fast path: neither is negative (the sign bits are clear) or a NaN
|
||||
// (both are at most +inf), so the bit patterns sort like the values.
|
||||
if args.a < args.b {
|
||||
return 0
|
||||
} else if args.a == args.b {
|
||||
return 1
|
||||
}
|
||||
return 2
|
||||
}
|
||||
return this.f64_cmp_slow(a: args.a, b: args.b)
|
||||
}
|
||||
|
||||
// f64_cmp_slow is f64_cmp without the fast path.
|
||||
pri func arith.f64_cmp_slow(a: base.u64, b: base.u64) base.u32 {
|
||||
var ka : base.u64
|
||||
var kb : base.u64
|
||||
|
||||
@@ -297,35 +312,65 @@ pub func arith.f64_cmp(a: base.u64, b: base.u64) base.u32 {
|
||||
// true), and -0 equals +0.
|
||||
|
||||
pub func arith.f64_eq(a: base.u64, b: base.u64) base.u32 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) == 1 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a == args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) == 1 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func arith.f64_ne(a: base.u64, b: base.u64) base.u32 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) == 1 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a <> args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) == 1 {
|
||||
return 0
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
pub func arith.f64_lt(a: base.u64, b: base.u64) base.u32 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) == 0 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a < args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) == 0 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func arith.f64_le(a: base.u64, b: base.u64) base.u32 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) <= 1 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a <= args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) <= 1 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func arith.f64_gt(a: base.u64, b: base.u64) base.u32 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) == 2 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a > args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) == 2 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
@@ -334,7 +379,13 @@ pub func arith.f64_gt(a: base.u64, b: base.u64) base.u32 {
|
||||
pub func arith.f64_ge(a: base.u64, b: base.u64) base.u32 {
|
||||
var c : base.u32
|
||||
|
||||
c = this.f64_cmp(a: args.a, b: args.b)
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a >= args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
c = this.f64_cmp_slow(a: args.a, b: args.b)
|
||||
if (c == 1) or (c == 2) {
|
||||
return 1
|
||||
}
|
||||
@@ -345,7 +396,13 @@ pub func arith.f64_ge(a: base.u64, b: base.u64) base.u32 {
|
||||
// Note that this is not IEEE 754 minNum: f64_min(NaN, x) and f64_min(x, NaN)
|
||||
// both return the second argument, and f64_min(-0, +0) returns +0.
|
||||
pub func arith.f64_min(a: base.u64, b: base.u64) base.u64 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) == 0 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a < args.b {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) == 0 {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
@@ -353,7 +410,13 @@ pub func arith.f64_min(a: base.u64, b: base.u64) base.u64 {
|
||||
|
||||
// f64_max returns ((a > b) ? a : b), like brotli's BROTLI_MAX(double, a, b).
|
||||
pub func arith.f64_max(a: base.u64, b: base.u64) base.u64 {
|
||||
if this.f64_cmp(a: args.a, b: args.b) == 2 {
|
||||
if (args.a | args.b) <= F64_INF {
|
||||
if args.a > args.b {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
}
|
||||
if this.f64_cmp_slow(a: args.a, b: args.b) == 2 {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
|
||||
@@ -334,6 +334,21 @@ pub func arith.f32_div(a: base.u32, b: base.u32) base.u32 {
|
||||
// f32_cmp compares a and b, returning 0 if (a < b), 1 if (a == b), 2 if (a
|
||||
// > b) and 3 if they are unordered (either is a NaN). -0 and +0 compare equal.
|
||||
pub func arith.f32_cmp(a: base.u32, b: base.u32) base.u32 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
// Fast path: neither is negative (the sign bits are clear) or a NaN
|
||||
// (both are at most +inf), so the bit patterns sort like the values.
|
||||
if args.a < args.b {
|
||||
return 0
|
||||
} else if args.a == args.b {
|
||||
return 1
|
||||
}
|
||||
return 2
|
||||
}
|
||||
return this.f32_cmp_slow(a: args.a, b: args.b)
|
||||
}
|
||||
|
||||
// f32_cmp_slow is f32_cmp without the fast path.
|
||||
pri func arith.f32_cmp_slow(a: base.u32, b: base.u32) base.u32 {
|
||||
var ka : base.u32
|
||||
var kb : base.u32
|
||||
|
||||
@@ -364,35 +379,65 @@ pub func arith.f32_cmp(a: base.u32, b: base.u32) base.u32 {
|
||||
// true), and -0 equals +0.
|
||||
|
||||
pub func arith.f32_eq(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) == 1 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a == args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) == 1 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func arith.f32_ne(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) == 1 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a <> args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) == 1 {
|
||||
return 0
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
pub func arith.f32_lt(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) == 0 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a < args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) == 0 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func arith.f32_le(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) <= 1 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a <= args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) <= 1 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func arith.f32_gt(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) == 2 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a > args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) == 2 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
@@ -401,7 +446,13 @@ pub func arith.f32_gt(a: base.u32, b: base.u32) base.u32 {
|
||||
pub func arith.f32_ge(a: base.u32, b: base.u32) base.u32 {
|
||||
var c : base.u32
|
||||
|
||||
c = this.f32_cmp(a: args.a, b: args.b)
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a >= args.b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
c = this.f32_cmp_slow(a: args.a, b: args.b)
|
||||
if (c == 1) or (c == 2) {
|
||||
return 1
|
||||
}
|
||||
@@ -412,7 +463,13 @@ pub func arith.f32_ge(a: base.u32, b: base.u32) base.u32 {
|
||||
// Note that this is not IEEE 754 minNum: f32_min(NaN, x) and f32_min(x, NaN)
|
||||
// both return the second argument, and f32_min(-0, +0) returns +0.
|
||||
pub func arith.f32_min(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) == 0 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a < args.b {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) == 0 {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
@@ -420,7 +477,13 @@ pub func arith.f32_min(a: base.u32, b: base.u32) base.u32 {
|
||||
|
||||
// f32_max returns ((a > b) ? a : b), like brotli's BROTLI_MAX(float, a, b).
|
||||
pub func arith.f32_max(a: base.u32, b: base.u32) base.u32 {
|
||||
if this.f32_cmp(a: args.a, b: args.b) == 2 {
|
||||
if (args.a | args.b) <= F32_INF {
|
||||
if args.a > args.b {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
}
|
||||
if this.f32_cmp_slow(a: args.a, b: args.b) == 2 {
|
||||
return args.a
|
||||
}
|
||||
return args.b
|
||||
|
||||
Reference in new issue
Block a user