Как вы находите ближайшую не равную ценность поплавка?

Ответ 1

Стандартным способом поиска соседей с плавающей запятой является функция nextafter для double и nextafterf для float. Второй аргумент дает направление. Помните, что бесконечности являются юридическими значениями в плавающей запятой IEEE 754, поэтому вы можете очень хорошо позвонить nextafter(x, +1.0/0.0), чтобы получить значение сразу над x, и это будет работать даже для DBL_MAX (тогда как если бы вы написали nextafter(x, DBL_MAX), он будет возвращать DBL_MAX при применении для x == DBL_MAX).

Иногда могут использоваться нестандартные способы:

• получить доступ к представлению float/double как целое без знака того же размера и прирастить или уменьшить это целое число. Формат с плавающей запятой был тщательно разработан так, чтобы для положительных поплавков и, соответственно, для отрицательных поплавков, биты представления, рассматриваемые как целое число, эволюционировали монотонно с представленным поплавком.

• измените режим округления вверх и добавьте наименьшее положительное число с плавающей запятой. Наименьшее положительное число с плавающей запятой также является наименьшим приращением, которое может быть между двумя поплавками, поэтому это никогда не пропустит никакого поплавка. Наименьшее положительное число с плавающей запятой FLT_MIN * FLT_EPSILON.

Для полноты я добавлю, что даже без изменения режима округления с его "до ближайшего" значения по умолчанию, умножение поплавка на (1.0f + FLT_EPSILON) вызывает число, которое является либо ближайшим соседом от нуля, либо соседним после этого. Это, вероятно, самый дешевый, если вы уже знаете знак плавающего, который хотите увеличить/уменьшить, и вы не возражаете, что он иногда не создает ближайшего соседа. Функции nextafter и nextafterf задаются таким образом, что правильная реализация на x86 должна проверяться на наличие ряда специальных значений и FPU и, следовательно, является дорогостоящим для того, что он делает.

Чтобы перейти к нулю, умножьте на 1.0f - FLT_EPSILON.

Это не работает для 0.0f, очевидно, и вообще для меньших денормализованных чисел.

Значения, для которых умножение на 1.0f + FLT_EPSILON продвигается на 2 ULPS, находятся чуть ниже двух, особенно в интервале [0.75 * 2 ^p... 2 ^p). Если вы не возражаете делать умножение и добавление, x + (x * (FLT_EPSILON * 0.74)) должен работать для всех нормальных чисел (но все же не для нуля или для всех маленьких денормальных чисел).

Ответ 2

Посмотрите на функцию "nextafter", которая является частью Standard C (и, вероятно, С++, но я не проверял).

Ответ 3

Я попробовал это на своей машине. И все три подхода:
1. добавление с 1 и memcopying
2. добавление FLT_EPSILON
3. умножение на (1.0f + FLT_EPSILON)
похоже, дает тот же ответ.

#include <float.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>

int main(int argc, char *argv[])
{

    if(argc != 3) {
        printf("Usage: <binary> <floating_pt_num> <num_iter>\n");
        exit(0);
    }

    float f = atof(argv[1]);
    int count = atoi(argv[2]);

    assert(count > 0);

    int i;
    int num;
    float num_float;

    printf("Original num: %f\n", f);
    for(i=1; i<=count; i++) {
        memcpy(&num, &f, 4);
        num += i;
        memcpy(&num_float, &num, 4);
        printf("int added = %f \t%02d-eps added = %f \tmult by %2d*(eps+1) = %f\n", num_float, i, f + i*FLT_EPSILON, i, f*(1.0f + i*FLT_EPSILON));
    }

    return 0;
}