Найти максимальный целочисленный размер, который может обрабатывать тип с плавающей запятой без потери точности - PullRequest
Новая
       57

Найти максимальный целочисленный размер, который может обрабатывать тип с плавающей запятой без потери точности

6 голосов
/ 06 апреля 2010

Double имеет диапазон больше, чем 64-битное целое число, но его точность меньше зависит от его представления (поскольку double также 64-битное, он не может соответствовать более фактическим значениям). Поэтому, когда вы представляете большие целые числа, вы начинаете терять точность в целочисленной части. 

#include <boost/cstdint.hpp>
#include <limits>

template<typename T, typename TFloat>
void
maxint_to_double()
{
    T i = std::numeric_limits<T>::max();
    TFloat d = i;
    std::cout
        << std::fixed
        << i << std::endl
        << d << std::endl;
}

int
main()
{
    maxint_to_double<int, double>();
    maxint_to_double<boost::intmax_t, double>();
    maxint_to_double<int, float>();
    return 0;
}

Это печатает: 

2147483647
2147483647.000000
9223372036854775807
9223372036854775800.000000
2147483647
2147483648.000000

Обратите внимание, как max int может вписаться в double без потери точности, а boost::intmax_t (в данном случае 64-разрядное) - нет. float не может даже держать int.

Теперь вопрос: есть ли способ в C ++ проверить, может ли весь диапазон заданного целочисленного типа вписаться в тип точки с плавающей точкой без потери точности? Предпочтительно

  • это будет проверка во время компиляции, которая может использоваться в статическом утверждении,
  • и не потребует перечисления констант, которые компилятор должен знать или может вычислять.

Ответы [ 2 ]

6 голосов
/ 06 апреля 2010

Просто маленький предикат: 

#include <limits>

template <typename T, typename U>
struct can_fit
{
    static const bool value = std::numeric_limits<T>::digits
                            <= std::numeric_limits<U>::digits;
};

#include <iostream>

int main(void)
{
    std::cout << std::boolalpha;

    std::cout << can_fit<short, float>::value << std::endl;
    std::cout << can_fit<int, float>::value << std::endl;

    std::cout << can_fit<int, double>::value << std::endl;
    std::cout << can_fit<long long, double>::value << std::endl;

    std::cout << can_fit<short, int>::value << std::endl;
    std::cout << can_fit<int, short>::value << std::endl;
}

Проверяет, существует ли двоичная точность, доступная в T, в U. Работает на всех типах.

"Boostified": 

// this is just stuff I use
#include <boost/type_traits/integral_constant.hpp>

template <bool B>
struct bool_type : boost::integral_constant<bool, B>
{
    static const bool value = B;
};

typedef const boost::true_type& true_tag;
typedef const boost::false_type& false_tag;

// can_fit type traits
#include <limits>

namespace detail
{
    template <typename T, typename U>
    struct can_fit
    {
        static const bool value = std::numeric_limits<T>::digits
                                <= std::numeric_limits<U>::digits;
    };
}

template <typename T, typename U>
struct can_fit : bool_type<detail::can_fit<T, U>::value>
{
    typedef T type1;
    typedef U type2;

    static const bool value = detail::can_fit<T, U>::value;
};

// test
#include <iostream>

namespace detail
{
    void foo(true_tag)
    {
        std::cout << "T fits in U" << std::endl;
    }

    void foo(false_tag)
    {
        std::cout << "T does not fit in U" << std::endl;
    }
}

// just an example
template <typename T, typename U>
void foo(void)
{
    detail::foo(can_fit<T, U>());
}

int main(void)
{
    foo<int, double>();
}
5 голосов
/ 06 апреля 2010

Вы можете использовать std::numeric_limits<T>::digits, чтобы узнать, какая у вас двоичная точность. например: 

int binary_digits_double = numeric_limits<double>::digits;       // 53
int binary_digits_long_long = numeric_limits<long long>::digits; // 63
int binary_digits_uint = numeric_limits<unsigned int>::digits;   // 32
...