float.hpp

Go to the documentation of this file.

#ifndef SANISIZER_FLOAT_HPP
#define SANISIZER_FLOAT_HPP
 
#include <limits>
#include <cmath>
#include <stdexcept>
#include <type_traits>
#include <cassert>
 
#include "utils.hpp"
#include "attest.hpp"
 
namespace sanisizer {
 
template<typename Float_>
int required_bits_for_float(Float_ x) {
    static_assert(std::is_floating_point<Float_>::value);
    assert(x >= 0);
    assert(std::isfinite(x));
    assert(std::trunc(x) == x);
 
#ifndef SANISIZER_FLOAT_FORCE_FREXP
    if constexpr(std::numeric_limits<Float_>::radix == 2) {
        if (x == 0) {
            return 0;
        } else {
            // ilogb returns an 'exp' such that 2^exp <= x < 2^(exp + 1).
            return std::ilogb(x) + 1;
        }
    } else {
#endif
        // Ensure we're covered for weird float types where the radix is not 2.
        int exp;
        std::frexp(x, &exp); 
        // frexp guarantees that 2^(exp - 1) <= x < 2^exp.
        return exp;
#ifndef SANISIZER_FLOAT_FORCE_FREXP
    }
#endif
}
 
template<typename Integer_, typename Float_>
Integer_ from_float(Float_ x) {
    static_assert(std::is_floating_point<Float_>::value);
    static_assert(std::is_integral<Integer_>::value);
 
    if (!std::isfinite(x)) {
        throw std::range_error("invalid conversion of non-finite value in sanisizer::from_float");
    }
    if (x < 0) {
        throw std::out_of_range("negative input value in sanisizer::from_float");
    }
    x = std::trunc(x);
 
    constexpr auto output_precision = std::numeric_limits<Integer_>::digits;
    if (required_bits_for_float(x) > output_precision) {
        throw std::overflow_error("overflow detected in sanisizer::from_float");
    }
 
    return x;
}
 
template<typename Float_, typename Integer_>
Float_ to_float(Integer_ x) {
    const auto val = get_value(x);
 
    // protect against the various -1 operations.
    constexpr auto xmax = get_max<I<decltype(x)> >();
    if constexpr(xmax == 0) {
        return 0;
    } else if (val == 0) {
        return 0;
    }
 
    constexpr auto frad = std::numeric_limits<Float_>::radix;
    constexpr auto fdig = std::numeric_limits<Float_>::digits;
 
    // Only considering IEEE-754 binary formats, to keep things simple.
    // Also I don't even have the hardware to test the other formats.
    static_assert(frad == 2);
    static_assert(std::numeric_limits<Float_>::is_iec559);
 
    // Checking digits first, because attempting to right-shift an integer by a number equal to or more than its bits is UB.
    if constexpr(std::numeric_limits<I<decltype(val)> >::digits > fdig) {
        // We can represent '2^fdig' itself due to the implicit leading bit on the mantissa in a (normal) IEEE binary float.
        // Thus, we subtract 1 to avoid throwing an error when 'x == 2^fdig'.
        if constexpr((xmax - 1) >> fdig) {
            const auto y = (val - 1) >> fdig;
            if (y) {
                throw std::overflow_error("overflow detected in sanisizer::to_float");
            }
        }
    }
 
    return val;
}
 
}
 
#endif