machina-softfloat 0.1.2

Pure software IEEE 754 floating-point library
Documentation 
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// SPDX-License-Identifier: MIT
// IEEE 754 round-to-integer (in floating-point format).

use crate::env::{ExcFlags, FloatEnv, RoundMode};
use crate::parts::{
    nan_propagate_one, round_pack, unpack, FloatClass, FloatParts,
};
use crate::types::{
    BFloat16, Float128, Float16, Float32, Float64, FloatFormat, FloatX80,
};

const INT_BIT: u32 = 126;

/// Round a floating-point number to an integer value,
/// returning the result in the same float format.
pub fn round_to_int<F: FloatFormat>(a: F, env: &mut FloatEnv) -> F {
    let pa = unpack::<F>(a);

    if pa.is_nan() {
        let mut r = nan_propagate_one(&pa, env);
        return round_pack::<F>(&mut r, env);
    }

    if pa.cls == FloatClass::Inf || pa.cls == FloatClass::Zero {
        let mut r = pa;
        return round_pack::<F>(&mut r, env);
    }

    // If exponent is large enough that all fraction bits
    // are integer bits, the number is already integral.
    if pa.exp >= F::FRAC_BITS as i32 {
        let mut r = pa;
        return round_pack::<F>(&mut r, env);
    }

    // If exponent is very negative, the magnitude is < 1.
    if pa.exp < 0 {
        let rm = env.round_mode();
        let inexact = pa.frac != 0;
        if inexact {
            env.raise(ExcFlags::INEXACT);
        }

        let round_up = match rm {
            RoundMode::NearEven => {
                // Round to even: 0.5 exactly rounds to 0
                // (even), anything above 0.5 rounds to 1.
                pa.exp == -1 && pa.frac > (1u128 << INT_BIT)
            }
            RoundMode::NearMaxMag => pa.exp == -1,
            RoundMode::ToZero => false,
            RoundMode::Up => !pa.sign && inexact,
            RoundMode::Down => pa.sign && inexact,
            RoundMode::Odd => true,
        };

        if round_up {
            // Return +-1.0
            let mut r = FloatParts {
                sign: pa.sign,
                exp: 0,
                frac: 1u128 << INT_BIT,
                cls: FloatClass::Normal,
            };
            return round_pack::<F>(&mut r, env);
        }

        // Return +-0
        let mut r = FloatParts {
            sign: pa.sign,
            exp: 0,
            frac: 0,
            cls: FloatClass::Zero,
        };
        return round_pack::<F>(&mut r, env);
    }

    // 0 <= exp < FRAC_BITS: some fractional bits exist.
    // Mask off the fractional bits and round.
    let frac_shift = INT_BIT - pa.exp as u32;
    let frac_mask = (1u128 << frac_shift) - 1;
    let remainder = pa.frac & frac_mask;

    if remainder == 0 {
        // Already an integer.
        let mut r = pa;
        return round_pack::<F>(&mut r, env);
    }

    env.raise(ExcFlags::INEXACT);

    let rm = env.round_mode();
    let half = 1u128 << (frac_shift - 1);
    let truncated = pa.frac & !frac_mask;
    let lsb_set = (pa.frac >> frac_shift) & 1 != 0;
    let increment = 1u128 << frac_shift;

    let round_up = match rm {
        RoundMode::NearEven => {
            if remainder > half {
                true
            } else if remainder == half {
                lsb_set
            } else {
                false
            }
        }
        RoundMode::NearMaxMag => remainder >= half,
        RoundMode::ToZero => false,
        RoundMode::Up => !pa.sign,
        RoundMode::Down => pa.sign,
        RoundMode::Odd => {
            // Set LSB to 1 if inexact.
            !lsb_set
        }
    };

    let frac = if round_up {
        truncated.wrapping_add(increment)
    } else {
        truncated
    };

    let mut r = FloatParts {
        sign: pa.sign,
        exp: pa.exp,
        frac,
        cls: FloatClass::Normal,
    };
    round_pack::<F>(&mut r, env)
}

// ---------------------------------------------------------------
// Convenience methods
// ---------------------------------------------------------------

macro_rules! impl_round {
    ($ty:ty) => {
        impl $ty {
            pub fn round_to_int(self, env: &mut FloatEnv) -> Self {
                round_to_int::<Self>(self, env)
            }
        }
    };
}

impl_round!(Float16);
impl_round!(BFloat16);
impl_round!(Float32);
impl_round!(Float64);
impl_round!(Float128);
impl_round!(FloatX80);