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)
62 scalar::{Scalar, Value},
68 should_panic(expected = "f16 feature is not enabled")
71 for bits in 0..=u16::MAX {
72 let v = F16::from_bits(bits);
73 let expected = v.abs();
74 let result = abs(Scalar, Value(v)).0;
75 assert_eq!(expected.to_bits(), result.to_bits());
81 for bits in (0..=u32::MAX).step_by(10001) {
82 let v = f32::from_bits(bits);
83 let expected = v.abs();
84 let result = abs(Scalar, Value(v)).0;
85 assert_eq!(expected.to_bits(), result.to_bits());
91 for bits in (0..=u64::MAX).step_by(100_000_000_000_001) {
92 let v = f64::from_bits(bits);
93 let expected = v.abs();
94 let result = abs(Scalar, Value(v)).0;
95 assert_eq!(expected.to_bits(), result.to_bits());
101 not(feature = "f16"),
102 should_panic(expected = "f16 feature is not enabled")
104 fn test_copy_sign_f16() {
106 fn check(mag_bits: u16, sign_bits: u16) {
107 let mag = F16::from_bits(mag_bits);
108 let sign = F16::from_bits(sign_bits);
109 let expected = mag.copysign(sign);
110 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
111 assert_eq!(expected.to_bits(), result.to_bits());
113 for mag_low_bits in 0..16 {
114 for mag_high_bits in 0..16 {
115 for sign_low_bits in 0..16 {
116 for sign_high_bits in 0..16 {
118 mag_low_bits | (mag_high_bits << (16 - 4)),
119 sign_low_bits | (sign_high_bits << (16 - 4)),
128 fn test_copy_sign_f32() {
130 fn check(mag_bits: u32, sign_bits: u32) {
131 let mag = f32::from_bits(mag_bits);
132 let sign = f32::from_bits(sign_bits);
133 let expected = mag.copysign(sign);
134 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
135 assert_eq!(expected.to_bits(), result.to_bits());
137 for mag_low_bits in 0..16 {
138 for mag_high_bits in 0..16 {
139 for sign_low_bits in 0..16 {
140 for sign_high_bits in 0..16 {
142 mag_low_bits | (mag_high_bits << (32 - 4)),
143 sign_low_bits | (sign_high_bits << (32 - 4)),
152 fn test_copy_sign_f64() {
154 fn check(mag_bits: u64, sign_bits: u64) {
155 let mag = f64::from_bits(mag_bits);
156 let sign = f64::from_bits(sign_bits);
157 let expected = mag.copysign(sign);
158 let result = copy_sign(Scalar, Value(mag), Value(sign)).0;
159 assert_eq!(expected.to_bits(), result.to_bits());
161 for mag_low_bits in 0..16 {
162 for mag_high_bits in 0..16 {
163 for sign_low_bits in 0..16 {
164 for sign_high_bits in 0..16 {
166 mag_low_bits | (mag_high_bits << (64 - 4)),
167 sign_low_bits | (sign_high_bits << (64 - 4)),
175 fn same<F: PrimFloat>(a: F, b: F) -> bool {
176 if a.is_finite() && b.is_finite() {
179 a == b || (a.is_nan() && b.is_nan())
185 not(feature = "f16"),
186 should_panic(expected = "f16 feature is not enabled")
188 fn test_trunc_f16() {
189 for bits in 0..=u16::MAX {
190 let v = F16::from_bits(bits);
191 let expected = v.trunc();
192 let result = trunc(Scalar, Value(v)).0;
194 same(expected, result),
195 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
199 expected_bits=expected.to_bits(),
201 result_bits=result.to_bits(),
207 fn test_trunc_f32() {
208 for bits in (0..=u32::MAX).step_by(0x10000) {
209 let v = f32::from_bits(bits);
210 let expected = v.trunc();
211 let result = trunc(Scalar, Value(v)).0;
213 same(expected, result),
214 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
218 expected_bits=expected.to_bits(),
220 result_bits=result.to_bits(),
226 fn test_trunc_f64() {
227 for bits in (0..=u64::MAX).step_by(1 << 48) {
228 let v = f64::from_bits(bits);
229 let expected = v.trunc();
230 let result = trunc(Scalar, Value(v)).0;
232 same(expected, result),
233 "case failed: v={v}, v_bits={v_bits:#X}, expected={expected}, expected_bits={expected_bits:#X}, result={result}, result_bits={result_bits:#X}",
237 expected_bits=expected.to_bits(),
239 result_bits=result.to_bits(),