Files
wuffs/std/softfloat/softfloat_f32.wuffs
Claude 44a9ca086c 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.
2026-10-27 10:30:04 +00:00

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))
}