mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
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.
532 lines
16 KiB
Plaintext
532 lines
16 KiB
Plaintext
// Copyright 2026 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
// -------- f32 (binary32) operations.
|
|
//
|
|
// When both operands are normal (and, unless it overflows to infinity, the
|
|
// result is normal too), the f32 add, sub and mul functions compute the
|
|
// result directly in binary32 (with 32-bit or 64-bit integer significands).
|
|
// This is the common case. Adding or subtracting a zero and a finite
|
|
// non-zero operand is also handled directly. Otherwise (zeroes, subnormals,
|
|
// infinities, NaNs and subnormal results), they and f32_div convert their
|
|
// (exactly representable) operands to f64, perform the f64 operation and
|
|
// round the result to f32 (the slow_etc functions). Double rounding is
|
|
// innocuous here: binary64 has more than (2 * 24) + 2 bits of precision,
|
|
// which suffices for +, -, * and / (Figueroa, "When is double rounding
|
|
// innocuous?", 1995). This is also exhaustively cross-checked against
|
|
// hardware by the tests. The fast paths never return a NaN, so NaN results
|
|
// (and their payloads) always come from the slow paths.
|
|
|
|
pri const F32_SIGN : base.u32 = 0x8000_0000
|
|
pri const F32_ABS : base.u32 = 0x7FFF_FFFF
|
|
pri const F32_INF : base.u32 = 0x7F80_0000
|
|
|
|
// f32_to_f64 returns the f64 equal to a (C's (double)a). It is exact.
|
|
pub func arith.f32_to_f64(a: base.u32) base.u64 {
|
|
var sign : base.u64
|
|
var exp : base.u32
|
|
var frac : base.u64
|
|
var top : base.u32[..= 63]
|
|
|
|
sign = ((args.a as base.u64) >> 31) << 63
|
|
exp = (args.a >> 23) & 0xFF
|
|
frac = (args.a & 0x7F_FFFF) as base.u64
|
|
|
|
if exp == 0xFF {
|
|
if frac <> 0 {
|
|
return sign | 0x7FF8_0000_0000_0000 | (frac << 29)
|
|
}
|
|
return sign | 0x7FF0_0000_0000_0000
|
|
} else if exp == 0 {
|
|
if frac == 0 {
|
|
return sign
|
|
}
|
|
// Subnormal: the value is (frac * 2**-149) and frac's most
|
|
// significant bit is at bit position top (in 0 ..= 22).
|
|
top = 63 - this.clz64(a: frac)
|
|
if top > 22 {
|
|
return 0
|
|
}
|
|
return sign |
|
|
(((top + 874) as base.u64) << 52) |
|
|
((frac ~mod<< (52 - top)) & 0x000F_FFFF_FFFF_FFFF)
|
|
}
|
|
return sign | (((exp + 896) as base.u64) << 52) | (frac << 29)
|
|
}
|
|
|
|
// f32_is_nan returns 1 if a is a NaN (quiet or signaling) and 0 otherwise.
|
|
pub func arith.f32_is_nan(a: base.u32) base.u32 {
|
|
if (args.a & F32_ABS) > F32_INF {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// f32_neg returns -a (flipping the sign bit, even for NaNs and zeroes).
|
|
pub func arith.f32_neg(a: base.u32) base.u32 {
|
|
return args.a ^ F32_SIGN
|
|
}
|
|
|
|
// f32_abs returns |a| (clearing the sign bit, even for NaNs).
|
|
pub func arith.f32_abs(a: base.u32) base.u32 {
|
|
return args.a & F32_ABS
|
|
}
|
|
|
|
// f32_add returns (a + b).
|
|
pub func arith.f32_add(a: base.u32, b: base.u32) base.u32 {
|
|
var z : base.u32
|
|
|
|
if ((((args.a >> 23) & 0xFF) ~mod- 1) < 0xFE) and ((((args.b >> 23) & 0xFF) ~mod- 1) < 0xFE) {
|
|
if ((args.a ^ args.b) >> 31) == 0 {
|
|
return this.f32_add_mags(a: args.a, b: args.b)
|
|
}
|
|
z = this.f32_sub_mags(a: args.a, b: args.b)
|
|
if z <> 0xFFFF_FFFF {
|
|
return z
|
|
}
|
|
} else if ((args.b & F32_ABS) == 0) and (((args.a & F32_ABS) ~mod- 1) < (F32_INF - 1)) {
|
|
// b is a zero and a is finite and non-zero, so (a + b) is a.
|
|
return args.a
|
|
} else if ((args.a & F32_ABS) == 0) and (((args.b & F32_ABS) ~mod- 1) < (F32_INF - 1)) {
|
|
// a is a zero and b is finite and non-zero, so (a + b) is b.
|
|
return args.b
|
|
}
|
|
return this.slow_f32_add(a: args.a, b: args.b)
|
|
}
|
|
|
|
// f32_sub returns (a - b).
|
|
pub func arith.f32_sub(a: base.u32, b: base.u32) base.u32 {
|
|
var z : base.u32
|
|
|
|
if ((((args.a >> 23) & 0xFF) ~mod- 1) < 0xFE) and ((((args.b >> 23) & 0xFF) ~mod- 1) < 0xFE) {
|
|
if ((args.a ^ args.b) >> 31) <> 0 {
|
|
return this.f32_add_mags(a: args.a, b: args.b)
|
|
}
|
|
z = this.f32_sub_mags(a: args.a, b: args.b)
|
|
if z <> 0xFFFF_FFFF {
|
|
return z
|
|
}
|
|
} else if ((args.b & F32_ABS) == 0) and (((args.a & F32_ABS) ~mod- 1) < (F32_INF - 1)) {
|
|
// b is a zero and a is finite and non-zero, so (a - b) is a.
|
|
return args.a
|
|
} else if ((args.a & F32_ABS) == 0) and (((args.b & F32_ABS) ~mod- 1) < (F32_INF - 1)) {
|
|
// a is a zero and b is finite and non-zero, so (a - b) is -b.
|
|
return args.b ^ F32_SIGN
|
|
}
|
|
return this.slow_f32_sub(a: args.a, b: args.b)
|
|
}
|
|
|
|
// f32_mul returns (a * b).
|
|
pub func arith.f32_mul(a: base.u32, b: base.u32) base.u32 {
|
|
var ea : base.u32[..= 0xFF]
|
|
var eb : base.u32[..= 0xFF]
|
|
var e : base.u32[..= 0x1FF]
|
|
var p : base.u64
|
|
var m : base.u32
|
|
var r : base.u32
|
|
var z : base.u32
|
|
|
|
ea = (args.a >> 23) & 0xFF
|
|
eb = (args.b >> 23) & 0xFF
|
|
if ((ea ~mod- 1) < 0xFE) and ((eb ~mod- 1) < 0xFE) {
|
|
// Both operands are normal. The exact product of the two 24-bit
|
|
// significands, p, is in [1 << 46, 1 << 48). The biased exponent of
|
|
// the result, e, is (ea + eb - 127) (plus 1 if p >= (1 << 47)).
|
|
p = (((args.a & 0x7F_FFFF) | 0x80_0000) as base.u64) *
|
|
(((args.b & 0x7F_FFFF) | 0x80_0000) as base.u64)
|
|
e = ea + eb
|
|
if p >= 0x8000_0000_0000 {
|
|
e += 1
|
|
m = ((p >> 24) & 0xFF_FFFF) as base.u32
|
|
r = ((p & 0xFF_FFFF) as base.u32) ~mod- 0x80_0000
|
|
} else {
|
|
m = ((p >> 23) & 0xFF_FFFF) as base.u32
|
|
r = ((p & 0x7F_FFFF) as base.u32) ~mod- 0x40_0000
|
|
}
|
|
// r is the remainder minus half an ULP, as a two's complement
|
|
// integer. Round to nearest, ties to even.
|
|
if (r <> 0) and (r < 0x8000_0000) {
|
|
m ~mod+= 1
|
|
} else if r == 0 {
|
|
m ~mod+= m & 1
|
|
}
|
|
if (e >= 128) and (e <= 381) {
|
|
// Adding m (whose bit 23 is the implicit bit) carries any
|
|
// rounding overflow into the exponent field.
|
|
z = ((e - 128) << 23) ~mod+ m
|
|
if z >= F32_INF {
|
|
z = F32_INF
|
|
}
|
|
return ((args.a ^ args.b) & F32_SIGN) | z
|
|
}
|
|
}
|
|
return this.slow_f32_mul(a: args.a, b: args.b)
|
|
}
|
|
|
|
// f32_add_mags returns (sign(a) * (|a| + |b|)), for normal a and b.
|
|
pri func arith.f32_add_mags(a: base.u32, b: base.u32) base.u32 {
|
|
var ea : base.u32[..= 0x100]
|
|
var eb : base.u32[..= 0xFF]
|
|
var ma : base.u32[..= 0x3FFF_FFC0]
|
|
var mb : base.u32[..= 0x3FFF_FFC0]
|
|
var d : base.u32[..= 0xFF]
|
|
var z : base.u32
|
|
var rb : base.u32
|
|
|
|
ea = (args.a >> 23) & 0xFF
|
|
eb = (args.b >> 23) & 0xFF
|
|
// The significands, with their implicit bit at bit 29 and 6 extra bits
|
|
// of precision at the bottom.
|
|
ma = ((args.a & 0x7F_FFFF) | 0x80_0000) << 6
|
|
mb = ((args.b & 0x7F_FFFF) | 0x80_0000) << 6
|
|
if ea < eb {
|
|
d = (eb ~mod- ea) & 0xFF
|
|
ea = eb
|
|
z = ma
|
|
ma = mb
|
|
mb = z
|
|
} else {
|
|
d = (ea ~mod- eb) & 0xFF
|
|
}
|
|
if d >= 31 {
|
|
mb = 1
|
|
} else if d > 0 {
|
|
if (mb ~mod<< (32 - d)) <> 0 {
|
|
mb = (mb >> d) | 1
|
|
} else {
|
|
mb = mb >> d
|
|
}
|
|
}
|
|
z = (ma & 0x3FFF_FFFF) + (mb & 0x3FFF_FFFF)
|
|
if z >= 0x4000_0000 {
|
|
ea += 1
|
|
z = (z >> 1) | (z & 1)
|
|
}
|
|
rb = z & 0x3F
|
|
z = (z ~mod+ 0x20) >> 6
|
|
if rb == 0x20 {
|
|
z &= 0xFFFF_FFFE
|
|
}
|
|
// ea is in [1 ..= 255] and z is in [1 << 23 ..= 1 << 24].
|
|
z = ((ea ~mod- 1) ~mod<< 23) ~mod+ z
|
|
if z >= F32_INF {
|
|
z = F32_INF
|
|
}
|
|
return (args.a & F32_SIGN) | z
|
|
}
|
|
|
|
// f32_sub_mags returns (sign(a) * (|a| - |b|)), for normal a and b, unless
|
|
// the result is subnormal, in which case it returns 0xFFFF_FFFF (a NaN, which
|
|
// it never otherwise returns) and the caller must take its slow path.
|
|
pri func arith.f32_sub_mags(a: base.u32, b: base.u32) base.u32 {
|
|
var sign : base.u32
|
|
var ea : base.u32[..= 0xFF]
|
|
var eb : base.u32[..= 0xFF]
|
|
var fa : base.u32[..= 0x7F_FFFF]
|
|
var fb : base.u32[..= 0x7F_FFFF]
|
|
var ma : base.u32
|
|
var mb : base.u32
|
|
var d : base.u32[..= 0xFF]
|
|
var s : base.u32[..= 31]
|
|
var z : base.u32
|
|
var rb : base.u32
|
|
|
|
sign = args.a & F32_SIGN
|
|
ea = (args.a >> 23) & 0xFF
|
|
eb = (args.b >> 23) & 0xFF
|
|
fa = args.a & 0x7F_FFFF
|
|
fb = args.b & 0x7F_FFFF
|
|
|
|
if ea == eb {
|
|
// The difference is exact.
|
|
if fa == fb {
|
|
// Exact cancellation gives +0 when rounding to nearest.
|
|
return 0
|
|
} else if fa < fb {
|
|
sign ^= F32_SIGN
|
|
z = fb ~mod- fa
|
|
} else {
|
|
z = fa ~mod- fb
|
|
}
|
|
// z is in [1 ..= 0x7F_FFFF]. Shift its top bit to bit 23.
|
|
s = (this.clz32(a: z) ~mod- 8) & 31
|
|
if s >= ea {
|
|
return 0xFFFF_FFFF
|
|
}
|
|
return sign | ((((ea ~mod- s) ~mod- 1) ~mod<< 23) ~mod+ (z ~mod<< s))
|
|
}
|
|
|
|
// The significands, with their implicit bit at bit 30 and 7 extra bits
|
|
// of precision at the bottom.
|
|
ma = (fa | 0x80_0000) << 7
|
|
mb = (fb | 0x80_0000) << 7
|
|
if ea < eb {
|
|
sign ^= F32_SIGN
|
|
d = (eb ~mod- ea) & 0xFF
|
|
ea = eb
|
|
z = ma
|
|
ma = mb
|
|
mb = z
|
|
} else {
|
|
d = (ea ~mod- eb) & 0xFF
|
|
}
|
|
if d >= 31 {
|
|
mb = 1
|
|
} else if (mb ~mod<< ((32 - d) & 31)) <> 0 {
|
|
mb = (mb >> d) | 1
|
|
} else {
|
|
mb = mb >> d
|
|
}
|
|
// ma > mb, so z is non-zero. If (d >= 2) then z >= (1 << 29) and the
|
|
// normalization shift is at most 1. Otherwise, no bits were shifted out.
|
|
z = ma ~mod- mb
|
|
s = (this.clz32(a: z) ~mod- 1) & 31
|
|
if s >= ea {
|
|
return 0xFFFF_FFFF
|
|
}
|
|
ea = (ea ~mod- s) & 0xFF
|
|
z = z ~mod<< s
|
|
rb = z & 0x7F
|
|
z = (z ~mod+ 0x40) >> 7
|
|
if rb == 0x40 {
|
|
z &= 0xFFFF_FFFE
|
|
}
|
|
// ea is in [1 ..= 254] and z is in [1 << 23 ..= 1 << 24], so this does
|
|
// not overflow.
|
|
return sign | (((ea ~mod- 1) ~mod<< 23) ~mod+ z)
|
|
}
|
|
|
|
// slow_f32_add returns (a + b), computed via f64.
|
|
pri func arith.slow_f32_add(a: base.u32, b: base.u32) base.u32 {
|
|
return this.f64_to_f32(a: this.f64_add(
|
|
a: this.f32_to_f64(a: args.a),
|
|
b: this.f32_to_f64(a: args.b)))
|
|
}
|
|
|
|
// slow_f32_sub returns (a - b), computed via f64.
|
|
pri func arith.slow_f32_sub(a: base.u32, b: base.u32) base.u32 {
|
|
return this.f64_to_f32(a: this.f64_sub(
|
|
a: this.f32_to_f64(a: args.a),
|
|
b: this.f32_to_f64(a: args.b)))
|
|
}
|
|
|
|
// slow_f32_mul returns (a * b), computed via f64.
|
|
pri func arith.slow_f32_mul(a: base.u32, b: base.u32) base.u32 {
|
|
return this.f64_to_f32(a: this.f64_mul(
|
|
a: this.f32_to_f64(a: args.a),
|
|
b: this.f32_to_f64(a: args.b)))
|
|
}
|
|
|
|
// f32_div returns (a / b).
|
|
pub func arith.f32_div(a: base.u32, b: base.u32) base.u32 {
|
|
return this.f64_to_f32(a: this.f64_div(
|
|
a: this.f32_to_f64(a: args.a),
|
|
b: this.f32_to_f64(a: args.b)))
|
|
}
|
|
|
|
// 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
|
|
|
|
if ((args.a & F32_ABS) > F32_INF) or ((args.b & F32_ABS) > F32_INF) {
|
|
return 3
|
|
} else if ((args.a | args.b) & F32_ABS) == 0 {
|
|
return 1
|
|
}
|
|
ka = args.a | F32_SIGN
|
|
if (args.a >> 31) <> 0 {
|
|
ka = 0xFFFF_FFFF ^ args.a
|
|
}
|
|
kb = args.b | F32_SIGN
|
|
if (args.b >> 31) <> 0 {
|
|
kb = 0xFFFF_FFFF ^ args.b
|
|
}
|
|
if ka < kb {
|
|
return 0
|
|
} else if ka == kb {
|
|
return 1
|
|
}
|
|
return 2
|
|
}
|
|
|
|
// The f32_eq, f32_ne, f32_lt, f32_le, f32_gt and f32_ge functions implement
|
|
// C's ==, !=, <, <=, > and >= operators. They return 1 for true and 0 for
|
|
// false. Any comparison involving a NaN is false (except for !=, which is
|
|
// true), and -0 equals +0.
|
|
|
|
pub func arith.f32_eq(a: base.u32, b: base.u32) base.u32 {
|
|
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 (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 (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 (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 (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
|
|
}
|
|
|
|
pub func arith.f32_ge(a: base.u32, b: base.u32) base.u32 {
|
|
var c : base.u32
|
|
|
|
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
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// f32_min returns ((a < b) ? a : b), like brotli's BROTLI_MIN(float, a, b).
|
|
// 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 (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
|
|
}
|
|
|
|
// 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 (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
|
|
}
|
|
|
|
// f32_from_u32 returns the f32 nearest to the integer a (C's (float)a).
|
|
pub func arith.f32_from_u32(a: base.u32) base.u32 {
|
|
var c : base.u32[..= 31]
|
|
|
|
if args.a == 0 {
|
|
return 0
|
|
} else if args.a < 0x100_0000 {
|
|
// a is exactly representable. Shift its top bit to bit 23 (the
|
|
// implicit bit, which is then added to the exponent field).
|
|
c = this.clz32(a: args.a)
|
|
if c >= 8 {
|
|
return ((157 ~mod- c) ~mod<< 23) ~mod+ (args.a ~mod<< (c - 8))
|
|
}
|
|
}
|
|
// The u32 to f64 conversion is exact, so there is only one rounding.
|
|
return this.f64_to_f32(a: this.f64_from_u32(a: args.a))
|
|
}
|
|
|
|
// f32_from_i32 returns the f32 nearest to the integer a (C's (float)a).
|
|
pub func arith.f32_from_i32(a: base.i32) base.u32 {
|
|
return this.f64_to_f32(a: this.f64_from_i64(a: args.a as base.i64))
|
|
}
|
|
|
|
// f32_from_u64 returns the f32 nearest to the integer a (C's (float)a).
|
|
pub func arith.f32_from_u64(a: base.u64) base.u32 {
|
|
var top : base.u32[..= 63]
|
|
var x : base.u64
|
|
|
|
// Converting via f64 could double-round, so first reduce a to at most
|
|
// 53 significant bits, the last of which is a sticky bit. The f64
|
|
// conversion of that is exact.
|
|
x = args.a
|
|
if x >= 0x0020_0000_0000_0000 {
|
|
top = 63 - this.clz64(a: x)
|
|
if top >= 53 {
|
|
x = this.shift_right_jam64(a: x, dist: top - 52) ~mod<< (top - 52)
|
|
}
|
|
}
|
|
return this.f64_to_f32(a: this.f64_from_u64(a: x))
|
|
}
|