blob: d73713084d6c612473b9459aeab01fa7ec3f909e (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
use float::Float;
use int::{CastInto, Int};
fn trunc<F: Float, R: Float>(a: F) -> R
where
F::Int: CastInto<u64>,
F::Int: CastInto<u32>,
u64: CastInto<F::Int>,
u32: CastInto<F::Int>,
R::Int: CastInto<u32>,
u32: CastInto<R::Int>,
F::Int: CastInto<R::Int>,
{
let src_zero = F::Int::ZERO;
let src_one = F::Int::ONE;
let src_bits = F::BITS;
let src_exp_bias = F::EXPONENT_BIAS;
let src_min_normal = F::IMPLICIT_BIT;
let src_significand_mask = F::SIGNIFICAND_MASK;
let src_infinity = F::EXPONENT_MASK;
let src_sign_mask = F::SIGN_MASK;
let src_abs_mask = src_sign_mask - src_one;
let round_mask = (src_one << (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS)) - src_one;
let halfway = src_one << (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS - 1);
let src_qnan = src_one << (F::SIGNIFICAND_BITS - 1);
let src_nan_code = src_qnan - src_one;
let dst_zero = R::Int::ZERO;
let dst_one = R::Int::ONE;
let dst_bits = R::BITS;
let dst_inf_exp = R::EXPONENT_MAX;
let dst_exp_bias = R::EXPONENT_BIAS;
let underflow_exponent: F::Int = (src_exp_bias + 1 - dst_exp_bias).cast();
let overflow_exponent: F::Int = (src_exp_bias + dst_inf_exp - dst_exp_bias).cast();
let underflow: F::Int = underflow_exponent << F::SIGNIFICAND_BITS;
let overflow: F::Int = overflow_exponent << F::SIGNIFICAND_BITS;
let dst_qnan = R::Int::ONE << (R::SIGNIFICAND_BITS - 1);
let dst_nan_code = dst_qnan - dst_one;
let sign_bits_delta = F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS;
// Break a into a sign and representation of the absolute value.
let a_abs = a.repr() & src_abs_mask;
let sign = a.repr() & src_sign_mask;
let mut abs_result: R::Int;
if a_abs.wrapping_sub(underflow) < a_abs.wrapping_sub(overflow) {
// The exponent of a is within the range of normal numbers in the
// destination format. We can convert by simply right-shifting with
// rounding and adjusting the exponent.
abs_result = (a_abs >> sign_bits_delta).cast();
let tmp = src_exp_bias.wrapping_sub(dst_exp_bias) << R::SIGNIFICAND_BITS;
abs_result = abs_result.wrapping_sub(tmp.cast());
let round_bits = a_abs & round_mask;
if round_bits > halfway {
// Round to nearest.
abs_result += dst_one;
} else if round_bits == halfway {
// Tie to even.
abs_result += abs_result & dst_one;
};
} else if a_abs > src_infinity {
// a is NaN.
// Conjure the result by beginning with infinity, setting the qNaN
// bit and inserting the (truncated) trailing NaN field.
abs_result = (dst_inf_exp << R::SIGNIFICAND_BITS).cast();
abs_result |= dst_qnan;
abs_result |= dst_nan_code
& ((a_abs & src_nan_code) >> (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS)).cast();
} else if a_abs >= overflow {
// a overflows to infinity.
abs_result = (dst_inf_exp << R::SIGNIFICAND_BITS).cast();
} else {
// a underflows on conversion to the destination type or is an exact
// zero. The result may be a denormal or zero. Extract the exponent
// to get the shift amount for the denormalization.
let a_exp: u32 = (a_abs >> F::SIGNIFICAND_BITS).cast();
let shift = src_exp_bias - dst_exp_bias - a_exp + 1;
let significand = (a.repr() & src_significand_mask) | src_min_normal;
// Right shift by the denormalization amount with sticky.
if shift > F::SIGNIFICAND_BITS {
abs_result = dst_zero;
} else {
let sticky = if (significand << (src_bits - shift)) != src_zero {
src_one
} else {
src_zero
};
let denormalized_significand: F::Int = significand >> shift | sticky;
abs_result =
(denormalized_significand >> (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS)).cast();
let round_bits = denormalized_significand & round_mask;
// Round to nearest
if round_bits > halfway {
abs_result += dst_one;
}
// Ties to even
else if round_bits == halfway {
abs_result += abs_result & dst_one;
};
}
}
// Apply the signbit to the absolute value.
R::from_repr(abs_result | sign.wrapping_shr(src_bits - dst_bits).cast())
}
intrinsics! {
#[aapcs_on_arm]
#[arm_aeabi_alias = __aeabi_d2f]
pub extern "C" fn __truncdfsf2(a: f64) -> f32 {
trunc(a)
}
#[cfg(target_arch = "arm")]
pub extern "C" fn __truncdfsf2vfp(a: f64) -> f32 {
a as f32
}
}
|
