Как изменить значение числа с плавающей запятой на наименьшее значение (или близкое к нему)?

Проверьте свой файл math.h. Если вам повезло, у вас есть определенные функции nextafter и nextafterf. Они делают именно то, что вы хотите, портативно и независимо от платформы и являются частью стандарта C99.

Другой способ сделать это (может быть запасным решением) - разложить поплавок на мантиссу и экспоненту. Увеличить легко: просто добавьте единицу к мантиссе. Если вы получаете переполнение, вы должны справиться с этим, увеличивая показатель степени. Декремент работает точно так же.

РЕДАКТИРОВАТЬ: Как указано в комментариях, достаточно просто увеличить число с плавающей запятой в его двоичном представлении. Переполнение мантиссы увеличит показатель степени, и это именно то, что мы хотим.

В двух словах, это то же самое, что и nextafter.

Однако это не будет полностью переносимым. Вам придется иметь дело с порядком байтов и тем фактом, что не все машины имеют IEEE float (хорошо - последняя причина более академическая).

Также обработка NAN и бесконечных чисел может быть немного сложной. Вы не можете просто увеличить их, поскольку они по определению не являются числами.

u64 &x = *(u64*)(&f);
x++;

Да серьезно.

Редактировать: Как кто-то заметил, это не имеет отношения к числам -ve, Inf, Nan или переполнению. Более безопасная версия вышеизложенного -

u64 &x = *(u64*)(&f);
if ( ((x>>52) & 2047) != 2047 )    //if exponent is all 1's then f is a nan or inf.
{
    x += f>0 ? 1 : -1;
}

В абсолютном выражении наименьшая сумма, которую вы можете добавить к значению с плавающей запятой, чтобы сделать новое уникальное значение, будет зависеть от текущей величины значения; это будет машина эпсилон типа, умноженное на текущий показатель степени.

Проверьте Спецификация IEEE для представления с плавающей запятой. Самый простой способ - переинтерпретировать значение как целочисленный тип, добавить 1, а затем проверить (если вам интересно), что вы не перевернули знак или не сгенерировали NaN, исследуя биты знака и экспоненты.

В качестве альтернативы вы можете использовать frexp для получения текущей мантиссы и экспоненты и, следовательно, для вычисления добавляемого значения.

Я нашел этот код некоторое время назад, возможно, он поможет вам определить наименьшее значение, которое вы можете увеличить, а затем просто увеличьте его на это значение. К сожалению, я не могу вспомнить ссылку на этот код:

#include <stdio.h>

int main()
{
    /* two numbers to work with */
    double number1, number2;    // result of calculation
    double result;
    int counter;        // loop counter and accuracy check

    number1 = 1.0;
    number2 = 1.0;
    counter = 0;

    while (number1 + number2 != number1) {
        ++counter;
        number2 = number2 / 10;
    }
    printf("%2d digits accuracy in calculations\n", counter);

    number2 = 1.0;
    counter = 0;

    while (1) {
        result = number1 + number2;
        if (result == number1)
            break;
        ++counter;
        number2 = number2 / 10.0;
    }

    printf("%2d digits accuracy in storage\n", counter );

    return (0);
}

Мне нужно было сделать то же самое, и я придумал такой код:

double DoubleIncrement(double value)
{
  int exponent;
  double mantissa = frexp(value, &exponent);
  if (mantissa == 0)
    return DBL_MIN;

  mantissa += DBL_EPSILON/2.0f;
  value = ldexp(mantissa, exponent);
  return value;
}

Как бы то ни было, значение, при котором стандартное приращение ++ перестает работать, составляет 9 007 199 254 740 992.

Возможно, это не совсем то, что вам нужно, но вы все равно можете найти numeric_limits в использовании. В частности, члены min () и epsilon ().

Я не верю, что что-то вроде mydouble + numeric_limits :: epsilon () будет делать то, что вы хотите, если mydouble уже близко к epsilon. Если да, то вам повезло.