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
92 .select(rounded - ctx.make(1.to()), rounded)
94 big.select(v, in_range_value)
99 VecF: Float<PrimFloat = PrimF, BitsType = VecU> + Make<Context = Ctx>,
100 VecU: UInt<PrimUInt = PrimU> + Make<Context = Ctx>,
101 PrimF: PrimFloat<BitsType = PrimU>,
107 let big_limit: VecF = ctx.make(PrimF::IMPLICIT_MANTISSA_BIT.to());
108 let big = !v.abs().lt(big_limit); // use `lt` so nans are counted as big
109 let offset = ctx.make((PrimU::cvt_from(1) << PrimF::MANTISSA_FIELD_WIDTH).to());
110 let offset_value: VecF = v.abs() + offset;
111 let rounded = (offset_value - offset).copy_sign(v);
112 let need_round_up = v.gt(rounded);
113 let in_range_value = need_round_up
114 .select(rounded + ctx.make(1.to()), rounded)
116 big.select(v, in_range_value)
125 scalar::{Scalar, Value},
131 not(feature = "f16"),
132 should_panic(expected = "f16 feature is not enabled")
135 for bits in 0..=u16::MAX {
136 let v = F16::from_bits(bits);
137 let expected = v.abs();
138 let result = abs(Scalar, Value(v)).0;
139 assert_eq!(expected.to_bits(), result.to_bits());
145 for bits in (0..=u32::MAX).step_by(10001) {
146 let v = f32::from_bits(bits);
147 let expected = v.abs();
148 let result = abs(Scalar, Value(v)).0;
149 assert_eq!(expected.to_bits(), result.to_bits());
155 for bits in (0..=u64::MAX).step_by(100_000_000_000_001) {
156 let v = f64::from_bits(bits);
157 let expected = v.abs();
158 let result = abs(Scalar, Value(v)).0;
159 assert_eq!(expected.to_bits(), result.to_bits());
165 not(feature = "f16"),
166 should_panic(expected = "f16 feature is not enabled")
168 fn test_copy_sign_f16() {
170 fn check(mag_bits: u16, sign_bits: u16) {
171 let mag = F16::from_bits(mag_bits);
172 let sign = F16::from_bits(sign_bits);
173 let expected = mag.copysign(sign);
174 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
175 assert_eq!(expected.to_bits(), result.to_bits());
177 for mag_low_bits in 0..16 {
178 for mag_high_bits in 0..16 {
179 for sign_low_bits in 0..16 {
180 for sign_high_bits in 0..16 {
182 mag_low_bits | (mag_high_bits << (16 - 4)),
183 sign_low_bits | (sign_high_bits << (16 - 4)),
192 fn test_copy_sign_f32() {
194 fn check(mag_bits: u32, sign_bits: u32) {
195 let mag = f32::from_bits(mag_bits);
196 let sign = f32::from_bits(sign_bits);
197 let expected = mag.copysign(sign);
198 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
199 assert_eq!(expected.to_bits(), result.to_bits());
201 for mag_low_bits in 0..16 {
202 for mag_high_bits in 0..16 {
203 for sign_low_bits in 0..16 {
204 for sign_high_bits in 0..16 {
206 mag_low_bits | (mag_high_bits << (32 - 4)),
207 sign_low_bits | (sign_high_bits << (32 - 4)),
216 fn test_copy_sign_f64() {
218 fn check(mag_bits: u64, sign_bits: u64) {
219 let mag = f64::from_bits(mag_bits);
220 let sign = f64::from_bits(sign_bits);
221 let expected = mag.copysign(sign);
222 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
223 assert_eq!(expected.to_bits(), result.to_bits());
225 for mag_low_bits in 0..16 {
226 for mag_high_bits in 0..16 {
227 for sign_low_bits in 0..16 {
228 for sign_high_bits in 0..16 {
230 mag_low_bits | (mag_high_bits << (64 - 4)),
231 sign_low_bits | (sign_high_bits << (64 - 4)),
239 fn same<F: PrimFloat>(a: F, b: F) -> bool {
240 if a.is_finite() && b.is_finite() {
241 a.to_bits() == b.to_bits()
243 a == b || (a.is_nan() && b.is_nan())
249 not(feature = "f16"),
250 should_panic(expected = "f16 feature is not enabled")
252 fn test_trunc_f16() {
253 for bits in 0..=u16::MAX {
254 let v = F16::from_bits(bits);
255 let expected = v.trunc();
256 let result = trunc(Scalar, Value(v)).0;
258 same(expected, result),
259 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
263 expected_bits=expected.to_bits(),
265 result_bits=result.to_bits(),
271 fn test_trunc_f32() {
272 for bits in (0..=u32::MAX).step_by(0x10000) {
273 let v = f32::from_bits(bits);
274 let expected = v.trunc();
275 let result = trunc(Scalar, Value(v)).0;
277 same(expected, result),
278 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
282 expected_bits=expected.to_bits(),
284 result_bits=result.to_bits(),
290 fn test_trunc_f64() {
291 for bits in (0..=u64::MAX).step_by(1 << 48) {
292 let v = f64::from_bits(bits);
293 let expected = v.trunc();
294 let result = trunc(Scalar, Value(v)).0;
296 same(expected, result),
297 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
301 expected_bits=expected.to_bits(),
303 result_bits=result.to_bits(),
308 fn reference_round_to_nearest_ties_to_even<
309 F: PrimFloat<BitsType = U, SignedBitsType = S>,
311 S: PrimSInt + ConvertFrom<F>,
315 if v.abs() < F::cvt_from(S::MAX) {
316 let int_value: S = v.to();
317 let int_value_f: F = int_value.to();
318 let remainder: F = v - int_value_f;
319 if remainder.abs() < 0.5.to()
320 || (int_value % 2.to() == 0.to() && remainder.abs() == 0.5.to())
322 int_value_f.copy_sign(v)
323 } else if remainder < 0.0.to() {
324 int_value_f - 1.0.to()
326 int_value_f + 1.0.to()
334 fn test_reference_round_to_nearest_ties_to_even() {
336 fn case(v: f32, expected: f32) {
337 let result = reference_round_to_nearest_ties_to_even(v);
339 same(result, expected),
340 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
344 expected_bits=expected.to_bits(),
346 result_bits=result.to_bits(),
373 case(f32::INFINITY, f32::INFINITY);
374 case(-f32::INFINITY, -f32::INFINITY);
375 case(f32::NAN, f32::NAN);
378 let i32_max = i32::MAX as f32;
379 let i32_max_prev = f32::from_bits(i32_max.to_bits() - 1);
380 let i32_max_next = f32::from_bits(i32_max.to_bits() + 1);
381 case(i32_max, i32_max);
382 case(-i32_max, -i32_max);
383 case(i32_max_prev, i32_max_prev);
384 case(-i32_max_prev, -i32_max_prev);
385 case(i32_max_next, i32_max_next);
386 case(-i32_max_next, -i32_max_next);
391 not(feature = "f16"),
392 should_panic(expected = "f16 feature is not enabled")
394 fn test_round_to_nearest_ties_to_even_f16() {
395 for bits in 0..=u16::MAX {
396 let v = F16::from_bits(bits);
397 let expected = reference_round_to_nearest_ties_to_even(v);
398 let result = round_to_nearest_ties_to_even(Scalar, Value(v)).0;
400 same(result, expected),
401 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
405 expected_bits=expected.to_bits(),
407 result_bits=result.to_bits(),
413 fn test_round_to_nearest_ties_to_even_f32() {
414 for bits in (0..=u32::MAX).step_by(0x10000) {
415 let v = f32::from_bits(bits);
416 let expected = reference_round_to_nearest_ties_to_even(v);
417 let result = round_to_nearest_ties_to_even(Scalar, Value(v)).0;
419 same(result, expected),
420 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
424 expected_bits=expected.to_bits(),
426 result_bits=result.to_bits(),
432 fn test_round_to_nearest_ties_to_even_f64() {
433 for bits in (0..=u64::MAX).step_by(1 << 48) {
434 let v = f64::from_bits(bits);
435 let expected = reference_round_to_nearest_ties_to_even(v);
436 let result = round_to_nearest_ties_to_even(Scalar, Value(v)).0;
438 same(result, expected),
439 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
443 expected_bits=expected.to_bits(),
445 result_bits=result.to_bits(),
452 not(feature = "f16"),
453 should_panic(expected = "f16 feature is not enabled")
455 fn test_floor_f16() {
456 for bits in 0..=u16::MAX {
457 let v = F16::from_bits(bits);
458 let expected = v.floor();
459 let result = floor(Scalar, Value(v)).0;
461 same(expected, result),
462 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
466 expected_bits=expected.to_bits(),
468 result_bits=result.to_bits(),
474 fn test_floor_f32() {
475 for bits in (0..=u32::MAX).step_by(0x10000) {
476 let v = f32::from_bits(bits);
477 let expected = v.floor();
478 let result = floor(Scalar, Value(v)).0;
480 same(expected, result),
481 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
485 expected_bits=expected.to_bits(),
487 result_bits=result.to_bits(),
493 fn test_floor_f64() {
494 for bits in (0..=u64::MAX).step_by(1 << 48) {
495 let v = f64::from_bits(bits);
496 let expected = v.floor();
497 let result = floor(Scalar, Value(v)).0;
499 same(expected, result),
500 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
504 expected_bits=expected.to_bits(),
506 result_bits=result.to_bits(),
513 not(feature = "f16"),
514 should_panic(expected = "f16 feature is not enabled")
517 for bits in 0..=u16::MAX {
518 let v = F16::from_bits(bits);
519 let expected = v.ceil();
520 let result = ceil(Scalar, Value(v)).0;
522 same(expected, result),
523 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
527 expected_bits=expected.to_bits(),
529 result_bits=result.to_bits(),
536 for bits in (0..=u32::MAX).step_by(0x10000) {
537 let v = f32::from_bits(bits);
538 let expected = v.ceil();
539 let result = ceil(Scalar, Value(v)).0;
541 same(expected, result),
542 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
546 expected_bits=expected.to_bits(),
548 result_bits=result.to_bits(),
555 for bits in (0..=u64::MAX).step_by(1 << 48) {
556 let v = f64::from_bits(bits);
557 let expected = v.ceil();
558 let result = ceil(Scalar, Value(v)).0;
560 same(expected, result),
561 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
565 expected_bits=expected.to_bits(),
567 result_bits=result.to_bits(),