2 prim::{PrimFloat, PrimUInt},
3 traits::{Context, ConvertTo, Float, Make, Select, UInt},
8 VecF: Float<PrimFloat = PrimF> + Make<Context = Ctx>,
9 PrimF: PrimFloat<BitsType = PrimU>,
15 VecF::from_bits(x.to_bits() & ctx.make(!PrimF::SIGN_FIELD_MASK))
20 VecF: Float<PrimFloat = PrimF> + Make<Context = Ctx>,
21 PrimF: PrimFloat<BitsType = PrimU>,
28 let mag_bits = mag.to_bits() & ctx.make(!PrimF::SIGN_FIELD_MASK);
29 let sign_bit = sign.to_bits() & ctx.make(PrimF::SIGN_FIELD_MASK);
30 VecF::from_bits(mag_bits | sign_bit)
35 VecF: Float<PrimFloat = PrimF, BitsType = VecU> + Make<Context = Ctx>,
36 VecU: UInt<PrimUInt = PrimU> + Make<Context = Ctx>,
37 PrimF: PrimFloat<BitsType = PrimU>,
43 let big_limit: VecF = ctx.make(PrimF::IMPLICIT_MANTISSA_BIT.to());
44 let big = !v.abs().lt(big_limit); // use `lt` so nans are counted as big
45 let small = v.abs().lt(ctx.make(PrimF::cvt_from(1)));
46 let out_of_range = big | small;
47 let small_value = ctx.make::<VecF>(0.to()).copy_sign(v);
48 let out_of_range_value = small.select(small_value, v);
49 let exponent_field = v.extract_exponent_field();
50 let right_shift_amount: VecU = exponent_field - ctx.make(PrimF::EXPONENT_BIAS_UNSIGNED);
51 let mut mask: VecU = ctx.make(PrimF::MANTISSA_FIELD_MASK);
52 mask >>= right_shift_amount;
53 let in_range_value = VecF::from_bits(v.to_bits() & !mask);
54 out_of_range.select(out_of_range_value, in_range_value)
57 pub fn round_to_nearest_ties_to_even<
59 VecF: Float<PrimFloat = PrimF, BitsType = VecU> + Make<Context = Ctx>,
60 VecU: UInt<PrimUInt = PrimU> + Make<Context = Ctx>,
61 PrimF: PrimFloat<BitsType = PrimU>,
67 let big_limit: VecF = ctx.make(PrimF::IMPLICIT_MANTISSA_BIT.to());
68 let big = !v.abs().lt(big_limit); // use `lt` so nans are counted as big
69 let offset = ctx.make((PrimU::cvt_from(1) << PrimF::MANTISSA_FIELD_WIDTH).to());
70 let offset_value: VecF = v.abs() + offset;
71 let in_range_value = (offset_value - offset).copy_sign(v);
72 big.select(v, in_range_value)
77 VecF: Float<PrimFloat = PrimF, BitsType = VecU> + Make<Context = Ctx>,
78 VecU: UInt<PrimUInt = PrimU> + Make<Context = Ctx>,
79 PrimF: PrimFloat<BitsType = PrimU>,
85 let big_limit: VecF = ctx.make(PrimF::IMPLICIT_MANTISSA_BIT.to());
86 let big = !v.abs().lt(big_limit); // use `lt` so nans are counted as big
87 let offset = ctx.make((PrimU::cvt_from(1) << PrimF::MANTISSA_FIELD_WIDTH).to());
88 let offset_value: VecF = v.abs() + offset;
89 let rounded = (offset_value - offset).copy_sign(v);
90 let need_round_down = v.lt(rounded);
91 let in_range_value = need_round_down.select(rounded - ctx.make(1.to()), rounded).copy_sign(v);
92 big.select(v, in_range_value)
97 VecF: Float<PrimFloat = PrimF, BitsType = VecU> + Make<Context = Ctx>,
98 VecU: UInt<PrimUInt = PrimU> + Make<Context = Ctx>,
99 PrimF: PrimFloat<BitsType = PrimU>,
105 let big_limit: VecF = ctx.make(PrimF::IMPLICIT_MANTISSA_BIT.to());
106 let big = !v.abs().lt(big_limit); // use `lt` so nans are counted as big
107 let offset = ctx.make((PrimU::cvt_from(1) << PrimF::MANTISSA_FIELD_WIDTH).to());
108 let offset_value: VecF = v.abs() + offset;
109 let rounded = (offset_value - offset).copy_sign(v);
110 let need_round_up = v.gt(rounded);
111 let in_range_value = need_round_up.select(rounded + ctx.make(1.to()), rounded).copy_sign(v);
112 big.select(v, in_range_value)
121 scalar::{Scalar, Value},
127 not(feature = "f16"),
128 should_panic(expected = "f16 feature is not enabled")
131 for bits in 0..=u16::MAX {
132 let v = F16::from_bits(bits);
133 let expected = v.abs();
134 let result = abs(Scalar, Value(v)).0;
135 assert_eq!(expected.to_bits(), result.to_bits());
141 for bits in (0..=u32::MAX).step_by(10001) {
142 let v = f32::from_bits(bits);
143 let expected = v.abs();
144 let result = abs(Scalar, Value(v)).0;
145 assert_eq!(expected.to_bits(), result.to_bits());
151 for bits in (0..=u64::MAX).step_by(100_000_000_000_001) {
152 let v = f64::from_bits(bits);
153 let expected = v.abs();
154 let result = abs(Scalar, Value(v)).0;
155 assert_eq!(expected.to_bits(), result.to_bits());
161 not(feature = "f16"),
162 should_panic(expected = "f16 feature is not enabled")
164 fn test_copy_sign_f16() {
166 fn check(mag_bits: u16, sign_bits: u16) {
167 let mag = F16::from_bits(mag_bits);
168 let sign = F16::from_bits(sign_bits);
169 let expected = mag.copysign(sign);
170 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
171 assert_eq!(expected.to_bits(), result.to_bits());
173 for mag_low_bits in 0..16 {
174 for mag_high_bits in 0..16 {
175 for sign_low_bits in 0..16 {
176 for sign_high_bits in 0..16 {
178 mag_low_bits | (mag_high_bits << (16 - 4)),
179 sign_low_bits | (sign_high_bits << (16 - 4)),
188 fn test_copy_sign_f32() {
190 fn check(mag_bits: u32, sign_bits: u32) {
191 let mag = f32::from_bits(mag_bits);
192 let sign = f32::from_bits(sign_bits);
193 let expected = mag.copysign(sign);
194 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
195 assert_eq!(expected.to_bits(), result.to_bits());
197 for mag_low_bits in 0..16 {
198 for mag_high_bits in 0..16 {
199 for sign_low_bits in 0..16 {
200 for sign_high_bits in 0..16 {
202 mag_low_bits | (mag_high_bits << (32 - 4)),
203 sign_low_bits | (sign_high_bits << (32 - 4)),
212 fn test_copy_sign_f64() {
214 fn check(mag_bits: u64, sign_bits: u64) {
215 let mag = f64::from_bits(mag_bits);
216 let sign = f64::from_bits(sign_bits);
217 let expected = mag.copysign(sign);
218 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
219 assert_eq!(expected.to_bits(), result.to_bits());
221 for mag_low_bits in 0..16 {
222 for mag_high_bits in 0..16 {
223 for sign_low_bits in 0..16 {
224 for sign_high_bits in 0..16 {
226 mag_low_bits | (mag_high_bits << (64 - 4)),
227 sign_low_bits | (sign_high_bits << (64 - 4)),
235 fn same<F: PrimFloat>(a: F, b: F) -> bool {
236 if a.is_finite() && b.is_finite() {
237 a.to_bits() == b.to_bits()
239 a == b || (a.is_nan() && b.is_nan())
245 not(feature = "f16"),
246 should_panic(expected = "f16 feature is not enabled")
248 fn test_trunc_f16() {
249 for bits in 0..=u16::MAX {
250 let v = F16::from_bits(bits);
251 let expected = v.trunc();
252 let result = trunc(Scalar, Value(v)).0;
254 same(expected, result),
255 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
259 expected_bits=expected.to_bits(),
261 result_bits=result.to_bits(),
267 fn test_trunc_f32() {
268 for bits in (0..=u32::MAX).step_by(0x10000) {
269 let v = f32::from_bits(bits);
270 let expected = v.trunc();
271 let result = trunc(Scalar, Value(v)).0;
273 same(expected, result),
274 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
278 expected_bits=expected.to_bits(),
280 result_bits=result.to_bits(),
286 fn test_trunc_f64() {
287 for bits in (0..=u64::MAX).step_by(1 << 48) {
288 let v = f64::from_bits(bits);
289 let expected = v.trunc();
290 let result = trunc(Scalar, Value(v)).0;
292 same(expected, result),
293 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
297 expected_bits=expected.to_bits(),
299 result_bits=result.to_bits(),
304 fn reference_round_to_nearest_ties_to_even<
305 F: PrimFloat<BitsType = U, SignedBitsType = S>,
307 S: PrimSInt + ConvertFrom<F>,
311 if v.abs() < F::cvt_from(S::MAX) {
312 let int_value: S = v.to();
313 let int_value_f: F = int_value.to();
314 let remainder: F = v - int_value_f;
315 if remainder.abs() < 0.5.to()
316 || (int_value % 2.to() == 0.to() && remainder.abs() == 0.5.to())
318 int_value_f.copy_sign(v)
319 } else if remainder < 0.0.to() {
320 int_value_f - 1.0.to()
322 int_value_f + 1.0.to()
330 fn test_reference_round_to_nearest_ties_to_even() {
332 fn case(v: f32, expected: f32) {
333 let result = reference_round_to_nearest_ties_to_even(v);
335 same(result, expected),
336 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
340 expected_bits=expected.to_bits(),
342 result_bits=result.to_bits(),
369 case(f32::INFINITY, f32::INFINITY);
370 case(-f32::INFINITY, -f32::INFINITY);
371 case(f32::NAN, f32::NAN);
374 let i32_max = i32::MAX as f32;
375 let i32_max_prev = f32::from_bits(i32_max.to_bits() - 1);
376 let i32_max_next = f32::from_bits(i32_max.to_bits() + 1);
377 case(i32_max, i32_max);
378 case(-i32_max, -i32_max);
379 case(i32_max_prev, i32_max_prev);
380 case(-i32_max_prev, -i32_max_prev);
381 case(i32_max_next, i32_max_next);
382 case(-i32_max_next, -i32_max_next);
387 not(feature = "f16"),
388 should_panic(expected = "f16 feature is not enabled")
390 fn test_round_to_nearest_ties_to_even_f16() {
391 for bits in 0..=u16::MAX {
392 let v = F16::from_bits(bits);
393 let expected = reference_round_to_nearest_ties_to_even(v);
394 let result = round_to_nearest_ties_to_even(Scalar, Value(v)).0;
396 same(result, expected),
397 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
401 expected_bits=expected.to_bits(),
403 result_bits=result.to_bits(),
409 fn test_round_to_nearest_ties_to_even_f32() {
410 for bits in (0..=u32::MAX).step_by(0x10000) {
411 let v = f32::from_bits(bits);
412 let expected = reference_round_to_nearest_ties_to_even(v);
413 let result = round_to_nearest_ties_to_even(Scalar, Value(v)).0;
415 same(result, expected),
416 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
420 expected_bits=expected.to_bits(),
422 result_bits=result.to_bits(),
428 fn test_round_to_nearest_ties_to_even_f64() {
429 for bits in (0..=u64::MAX).step_by(1 << 48) {
430 let v = f64::from_bits(bits);
431 let expected = reference_round_to_nearest_ties_to_even(v);
432 let result = round_to_nearest_ties_to_even(Scalar, Value(v)).0;
434 same(result, expected),
435 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
439 expected_bits=expected.to_bits(),
441 result_bits=result.to_bits(),
448 not(feature = "f16"),
449 should_panic(expected = "f16 feature is not enabled")
451 fn test_floor_f16() {
452 for bits in 0..=u16::MAX {
453 let v = F16::from_bits(bits);
454 let expected = v.floor();
455 let result = floor(Scalar, Value(v)).0;
457 same(expected, result),
458 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
462 expected_bits=expected.to_bits(),
464 result_bits=result.to_bits(),
470 fn test_floor_f32() {
471 for bits in (0..=u32::MAX).step_by(0x10000) {
472 let v = f32::from_bits(bits);
473 let expected = v.floor();
474 let result = floor(Scalar, Value(v)).0;
476 same(expected, result),
477 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
481 expected_bits=expected.to_bits(),
483 result_bits=result.to_bits(),
489 fn test_floor_f64() {
490 for bits in (0..=u64::MAX).step_by(1 << 48) {
491 let v = f64::from_bits(bits);
492 let expected = v.floor();
493 let result = floor(Scalar, Value(v)).0;
495 same(expected, result),
496 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
500 expected_bits=expected.to_bits(),
502 result_bits=result.to_bits(),
509 not(feature = "f16"),
510 should_panic(expected = "f16 feature is not enabled")
513 for bits in 0..=u16::MAX {
514 let v = F16::from_bits(bits);
515 let expected = v.ceil();
516 let result = ceil(Scalar, Value(v)).0;
518 same(expected, result),
519 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
523 expected_bits=expected.to_bits(),
525 result_bits=result.to_bits(),
532 for bits in (0..=u32::MAX).step_by(0x10000) {
533 let v = f32::from_bits(bits);
534 let expected = v.ceil();
535 let result = ceil(Scalar, Value(v)).0;
537 same(expected, result),
538 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
542 expected_bits=expected.to_bits(),
544 result_bits=result.to_bits(),
551 for bits in (0..=u64::MAX).step_by(1 << 48) {
552 let v = f64::from_bits(bits);
553 let expected = v.ceil();
554 let result = ceil(Scalar, Value(v)).0;
556 same(expected, result),
557 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
561 expected_bits=expected.to_bits(),
563 result_bits=result.to_bits(),