минимальное двойное значение в C / C ++

Существует ли стандартный и / или переносимый способ представления наименьшего отрицательного значения (например, использование отрицательной бесконечности) в программе на C (++)?

DBL_MIN в float.h - это наименьшее положительное число.

-DBL_MAX в ANSI C , который определен в float.h.

Числа с плавающей запятой (IEEE 754) симметричны, поэтому, если вы можете представить наибольшее значение ( DBL_MAXилиnumeric_limits<double>::max() ), просто добавьте знак минус.

А потом крутой способ:

double f;
(*((long long*)&f))= ~(1LL<<52);

В C используйте

#include <float.h>

const double lowest_double = -DBL_MAX;

В C ++ до 11 используйте

#include <limits>

const double lowest_double = -std::numeric_limits<double>::max();

В C ++ 11 и новее используйте

#include <limits>

constexpr double lowest_double = std::numeric_limits<double>::lowest();

Попробуй это:

-1 * numeric_limits<double>::max()

Справка: numeric_limits

Этот класс специализирован для каждого из основных типов, его члены возвращают или устанавливают различные значения, которые определяют свойства, которые тип имеет на конкретной платформе, на которой он компилируется.

Вы ищете актуальную бесконечность или минимальное конечное значение? Если первое, используйте

-numeric_limits<double>::infinity()

который работает только если

numeric_limits<double>::has_infinity

В противном случае вы должны использовать

numeric_limits<double>::lowest()

который был введен в C ++ 11.

Если lowest()недоступен, вы можете вернуться к

-numeric_limits<double>::max()

которые могут отличаться от них lowest()в принципе, но обычно не работают.

По-настоящему портативное решение на C ++

Начиная с C ++ 11 вы можете использовать numeric_limits<double>::lowest(). Согласно стандарту он возвращает именно то, что вы ищете:

Конечное значение x такое, что не существует другого конечного значения y, где y < x.
Имеет значение для всех специализаций, в которых is_bounded != false.

Онлайн-демонстрация

Здесь много непереносимых ответов на C ++!

Есть много ответов -std::numeric_limits<double>::max().

К счастью, в большинстве случаев они подойдут. В схемах кодирования с плавающей запятой число разлагается на мантиссу и показатель степени, и большинство из них (например, популярный IEEE-754 ) используют отдельный знаковый бит, который не принадлежит мантиссе. Это позволяет преобразовать самый большой положительный результат в самый маленький отрицательный, просто перевернув знак:

Почему они не портативны?

Стандарт не устанавливает никаких стандартов с плавающей запятой.

Я согласен с тем, что мой аргумент является немного теоретическим, но предположим, что какой-нибудь эксцентричный производитель компиляторов будет использовать революционную схему кодирования с мантиссой, закодированной в некоторых вариантах дополнения до двух. . Кодирование с дополнением до двух не является симметричным. например, для 8-битного символа со знаком максимальное положительное значение - 127, а минимальное отрицательное - -128. Таким образом, мы могли представить себе некоторую кодировку с плавающей запятой, показывающую подобное асимметричное поведение.

Я не знаю ни одной такой схемы кодирования, но дело в том, что что стандарт не гарантирует, что смена знака даст желаемый результат . Так что этот популярный ответ (извините, ребята!) Нельзя рассматривать как полностью портативное стандартное решение! / * по крайней мере, если вы не утверждали, что numeric_limits<double>::is_iec559это правда * /

- std::numeric_limits<double>::max()

должно работать нормально

Числовые ограничения

Исходный вопрос касается бесконечности. Итак, почему бы не использовать

#define Infinity  ((double)(42 / 0.0))

согласно определению IEEE? Вы, конечно, можете отрицать это.

Существует ли стандартный и / или переносимый способ представления наименьшего отрицательного значения (например, использование отрицательной бесконечности) в программе на C (++)?

C. подход.

Многие реализации поддерживают +/- бесконечности, поэтому самое отрицательное doubleзначение -INFINITY.

#include <math.h>
double most_negative = -INFINITY;

Есть стандартный и / или портативный способ ....?

Теперь нам нужно рассмотреть и другие случаи:

• Без бесконечностей

Просто -DBL_MAX.

• Только беззнаковая бесконечность.

Я ожидал, что в этом случае OP предпочтет -DBL_MAX.

• Ненормальные значения по величине больше, чем DBL_MAX.

Это необычный случай, вероятно, не имеющий отношения к OP. Когда doubleкодируется как пара с плавающей запятой для достижения желаемого диапазона / прецессии (см. Double-double ), существует максимальное нормальное значение double и, возможно, большее ненормальное . Я видел дебаты, DBL_MAXследует ли ссылаться на величайший нормальный , величайшему из обоих.

К счастью, этот парный подход обычно включает -infinity, поэтому остается наиболее отрицательное значение -INFINITY.

Для большей переносимости код может пойти по пути

// HUGE_VAL is designed to be infinity or DBL_MAX (when infinites are not implemented)
// .. yet is problematic with unsigned infinity.
double most_negative1 = -HUGE_VAL;  

// Fairly portable, unless system does not understand "INF"
double most_negative2 = strtod("-INF", (char **) NULL);

// Pragmatic
double most_negative3 = strtod("-1.0e999999999", (char **) NULL);

// Somewhat time-consuming
double most_negative4 = pow(-DBL_MAX, 0xFFFF /* odd value */);

// My suggestion
double most_negative5 = (-DBL_MAX)*DBL_MAX;

Если у вас не включены исключения с плавающей запятой (чего не следует имхо), вы можете просто сказать:

double neg_inf = -1/0.0;

Это дает отрицательную бесконечность. Если вам нужен float, вы можете преобразовать результат

float neg_inf = (float)-1/0.0;

или используйте арифметику одинарной точности

float neg_inf = -1.0f/0.0f;

Результат всегда один и тот же, существует ровно одно представление отрицательной бесконечности как с одинарной, так и с двойной точностью, и они преобразуются друг в друга, как и следовало ожидать.