Добавление наименьшего поплавка в поплавок

Question

Я хочу добавить наименьшее возможное значение поплавка в поплавок. Так, к примеру, я попытался сделать это, чтобы получить 1,0 + наименьшее возможное поплавок:

float result = 1.0f + std::numeric_limits<float>::min(); 

Но после того, как сделать это, я получаю следующие результаты:

(result > 1.0f) == false 
(result == 1.0f) == true 

Я использую Visual Studio 2015 Почему это происходит? Что я могу сделать, чтобы обойти это?

Answer 1

Если вы хотите следующее представимое значение после 1, для заголовка std::nextafter есть функция из заголовка <cmath>.

float result = std::nextafter(1.0f, 2.0f); 

Он возвращает следующее представимое значение, начиная с первого аргумента в направлении второго аргумента. Так что если вы хотите, чтобы найти следующее значение ниже 1, вы можете сделать это:

float result = std::nextafter(1.0f, 0.0f); 

Добавление наименьшее положительное представимое значение 1 не работает, потому что разница между 1 и следующей представимому значение больше, чем разница между 0 и следующим представляемым значением.

Answer 2

min является наименьшим ненулевое значение, что (нормированная-форма) с плавающей точкой можно предположить, то есть что-то около 2 ^-126 (-126 это минимально допустимый показатель для поплавка); теперь, если вы суммируете его на 1, вы все равно получите 1, так как float имеет всего 23 бита мантиссы, поэтому такое небольшое изменение не может быть представлено в таком «большом» номере (вам понадобится 126-битная мантисса, чтобы увидеть изменение суммирования 2 ^-126 до 1).

минимально возможное изменение 1, вместо этого, является epsilon (так называемый машинный ноль), который фактически 2 ^-23 - как это влияет на последний бит мантиссы.

Answer 3

«Проблема», которую вы наблюдаете, вызвана самой природой с арифметикой с плавающей запятой.

В FP точность зависит от масштаба; вокруг значения 1.0 точность не позволяет различать 1.0 и 1.0+min_representable, где min_representable - наименьшее возможное значение, большее нуля (даже если мы рассматриваем только наименьшее нормализованное число, std::numeric_limits<float>::min(). Наименьшая денормальность - это еще несколько порядков величины меньше).

Например, с числами с плавающей точкой двойной точности 64-разрядные IEEE754, по шкале x=10000000000000000 (10), что невозможно провести различие между x и x+1.

---

Тот факт, что изменения разрешения с масштабом является причиной для названия «плавающей точкой», потому что десятичная точка «плавает». Вместо этого фиксированное представление точки будет иметь фиксированное разрешение (например, с 16 двоичными цифрами ниже единиц у вас есть точность 1/65536 ~ 0,00001).

Например, в 32-битном формате с плавающей запятой IEEE754 есть один бит для знака, 8 бит для экспоненты и 31 бита для мантиссы:

---

Наименьшее значение eps, так что 1.0f + eps != 1.0f доступен в виде предопределенной константы как FLT_EPSILON, или std::numeric_limits<float>::epsilon. См. Также machine epsilon on Wikipedia, в котором обсуждается, как epsilon относится к ошибкам округления.

I.e. epsilon - это наименьшее значение, которое делает то, что вы ожидаете здесь, делая разницу при добавлении к 1.0.

Более общая версия этого (для чисел, отличных от 1.0) называется 1 единицей на последнем месте (мантиссы). См. Статью ULP article Википедии.

Answer 4

Чтобы увеличить/уменьшить значение с плавающей запятой на минимально возможную сумму, используйте nextafter в направлении +/- infinity().

Если вы используете next_after(x,std::numeric_limits::max()), результат будет неправильным в случае, если x - бесконечность.

#include <iostream> 
#include <limits> 
#include <cmath> 

template<typename T> 
T next_above(const T& v){ 
    return std::nextafter(1.0,std::numeric_limits<T>::infinity()) ; 
} 
template<typename T> 
T next_below(const T& v){ 
    return std::nextafter(1.0,-std::numeric_limits<T>::infinity()) ; 
} 

int main(){ 
    std::cout << next_below(1.0) - 1.0<< std::endl; // gives eps 
    std::cout << next_above(1.0) - 1.0<< std::endl; // gives ~ -eps/2 

    // Note: 
    std::cout << std::nextafter(std::numeric_limits<double>::infinity(), 
    std::numeric_limits<double>::infinity()) << std::endl; // gives inf 
    std::cout << std::nextafter(std::numeric_limits<double>::infinity(), 
    std::numeric_limits<double>::max()) << std::endl; // gives 1.79769e+308 

}