Float.h – описывает характеристики типа данных × C++ Builder программирование

23 июня 2021

  • #библиотеки
  • #программирование
  • #cbuilder

Заголовочный файл Float.h описывает характеристики типа данных с плавающей точкой для конкретной системы и компилятора. Значение с плавающей точкой (вещественное число) состоит из четырех элементов:

  • знак: либо отрицательный, либо положительный
  • основание: выражает количество значений, для кодирования чисел, которые могут быть представлены одной цифрой (2 для двоичной, 10 для десятичной, 16 для шестнадцатеричной, и т. д.)
  • мантисса: значение, стоящее перед основанием. Количество цифр в этом значении определяет точность
  • степень: значение в которое возводится основание следующим образом:
    вещественное значение = мантисса * основаниестепень, с соответствующим знаком

В таблице ниже показаны названия различных макросов, определенных в этом заголовочном файле, и их минимальные величины. Любая конкретная реализация может иметь значения характеристик больших, чем показано, за исключением FLT_RADIX, имена которых начинаются с FLT относятся к типу данных с плавающей точкой, DBL — double и LDBL — long double.

ИмяЗначениеОписание
FLT_RADIX2Основание для всех типов данных с плавающей точкой (long double, double, float).
FLT_MANT_DIG (float)
DBL_MANT_DIG (double)
LDBL_MANT_DIG (long double)		24
53
64		Количество цифр мантиссы, соответственно для указанных типов данных.
FLT_DIG (float)
DBL_DIG (double)
LDBL_DIG (long double)		6
15
18		Количество десятичных цифр, которые могут быть округлены в число с плавающей точкой и обратно, без потери данных.
FLT_MIN_EXP (float)
DBL_MIN_EXP (double)
LDBL_MIN_EXP (long double)		-125
-1021
-16381		Минимальное отрицательное целое значение для степени, которое генерирует нормализованное число с плавающей точкой (запятой).
FLT_MIN_10_EXP (float)
DBL_MIN_10_EXP (double)
LDBL_MIN_10_EXP (long double)		-37
-307
-4931		Минимальное отрицательное целое значение степени основания 10 выражение, которое будет генерировать нормализованное число с плавающей точкой (запятой).
FLT_MAX_EXP (float)
DBL_MAX_EXP (double)
LDBL_MAX_EXP (long double)		128
1024
16384		Максимальное целое значение для степени в нормализованной форме представления числа с плавающей точкой (запятой).
FLT_MAX_10_EXP (float)
DBL_MAX_10_EXP (double)
LDBL_MAX_10_EXP (long double)		383084932Максимальное целое значение для степени с основанием 10 в нормализованной форме представления числа с плавающей точкой (запятой).
FLT_MAX (float)
DBL_MAX (double)
LDBL_MAX (long double)		3.40282e+38
1.79769e+308
1.18973e+4932		Максимальные значения чисел с плавающей точкой (запятой).
FLT_EPSILON (float)
DBL_EPSILON (double)
LDBL_EPSILON (long double)		1.19209e-07
2.22045e-16
1.0842e-19		Разница между 1 и минимальным значением, большим единицы, которое может быть представлено указанными типами данных.
FLT_MIN (float)
DBL_MIN (double)
LDBL_MIN (long double)		1.17549e-38
2.22507e-308
3.3621e-4932		Минимальные значения чисел с плавающей точкой (запятой).

Поделиться


Шкаф Float с двумя дверцами и тремя ящиками

  • Главная
  • Шкафы
  • Шкаф Float с двумя дверцами и тремя ящиками

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Sphere

190 600 ₽ 171 540 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Без фрезеровки

175 200 ₽ 157 680 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Bottle

190 600 ₽ 171 540 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Month

190 600 ₽ 171 540 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Rainbow

190 600 ₽ 171 540 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Arch

190 600 ₽ 171 540 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Arch 2

190 600 ₽ 171 540 ₽

В наличии

Предзаказ

Шкаф Float с двумя дверцами и тремя ящиками Tier

190 600 ₽ 171 540 ₽

Обратный звонок

Запрос успешно отправлен!

Телефон *

Настоящим подтверждаю, что я ознакомлен и согласен с условиями оферты и политики конфиденциальности *

Предзаказ

Предзаказ успешно отправлен!

Телефон *

Настоящим подтверждаю, что я ознакомлен и согласен с условиями оферты и политики конфиденциальности *

Добавить в корзину

Перейти в корзину

Заказ в один клик

Контактное лицо (ФИО):

Контактный телефон:

Согласие на обработку персональных данных

Я ознакомлен и согласен с условиями оферты и политики конфиденциальности.

Комментарий:

Объекты с плавающей запятой — Документация по Python 3.11.4

тип PyFloatObject

Этот подтип PyObject представляет объект Python с плавающей запятой.

PyTypeObject PyFloat_Type
Часть стабильного ABI.

Этот экземпляр PyTypeObject представляет плавающую точку Python тип. Это тот же объект, что и

с плавающей запятой в слое Python.

интервал PyFloat_Check (PyObject * p)

Вернуть true, если его аргументом является PyFloatObject или подтип PyFloatObject . Эта функция всегда выполняется успешно.

интервал PyFloat_CheckExact (PyObject * p)

Вернуть true, если его аргумент PyFloatObject , но не подтип PyFloatObject . Эта функция всегда выполняется успешно.

PyObject *PyFloat_FromString(PyObject *str)
Возвращаемое значение: Новая ссылка.
 Часть стабильного ABI.

Создайте объект PyFloatObject на основе строкового значения в str или NULL при ошибке.

PyObject *PyFloat_FromDouble(двойной v)
Возвращаемое значение: Новая ссылка. Часть стабильного ABI.

Создайте объект PyFloatObject из v или NULL при неудаче.

двойной PyFloat_AsDouble (PyObject *pyfloat)
Часть стабильного ABI.

Вернуть двойное представление C содержимого pyfloat

. Если pyfloat не является объектом Python с плавающей запятой, но имеет __float__() метод, этот метод сначала будет вызываться для преобразования pyfloat в число с плавающей запятой. Если __float__() не определено, то возвращается к __index__() . Этот метод возвращает -1.0 в случае ошибки, поэтому следует вызвать PyErr_Occurred() для проверки ошибок.

Изменено в версии 3.8: используйте __index__() , если доступно.

двойной PyFloat_AS_DOUBLE (PyObject *pyfloat)

Вернуть двойное представление C содержимого pyfloat , но без проверки ошибок.

PyObject *PyFloat_GetInfo(void)
Возвращаемое значение: Новая ссылка. Часть стабильного ABI.

Вернуть экземпляр structseq, содержащий информацию о точность, минимальное и максимальное значения числа с плавающей запятой. это тонкая обертка вокруг файла заголовка float.h .

двойной PyFloat_GetMax()
Часть стабильного ABI.

Вернуть максимальное представимое конечное число с плавающей запятой DBL_MAX

как C double.

двойной PyFloat_GetMin()
Часть стабильного ABI.

Вернуть минимальное нормализованное положительное число с плавающей запятой DBL_MIN как C double.

Функции упаковки и распаковки обеспечивают эффективный, независимый от платформы способ хранить значения с плавающей запятой в виде строк байтов. Подпрограммы Pack производят байты строка из двойного C, а подпрограммы Unpack производят C double из такой строки байтов. Суффикс (2, 4 или 8) указывает количество байтов в строке байтов.

На платформах, использующих форматы IEEE 754, эти функции работают копирование битов. На других платформах 2-байтовый формат идентичен IEEE. 754 binary16 с половинной точностью, 4-байтовый формат (32-битный) идентичен формат одинарной точности IEEE 754 binary32 и 8-байтовый формат для Формат двойной точности IEEE 754 binary64, хотя упаковка INF и NaN (если такие вещи существуют на платформе) не обрабатываются правильно, и попытка распаковать строку байтов, содержащую IEEE INF или NaN, вызовет ошибку исключение.

На платформах, отличных от IEEE, с большей точностью или большим динамическим диапазоном, чем IEEE 754 поддерживает, не все значения могут быть упакованы; на платформах, отличных от IEEE, с меньшим точность или меньший динамический диапазон, не все значения могут быть распакованы.

Что бывает в таких случаях отчасти случайно (увы).

Новое в версии 3.11.

Пакет функций

Подпрограммы пакета записывают 2, 4 или 8 байтов, начиная с p . ле является Аргумент int, ненулевой, если вы хотите, чтобы строка байтов была с прямым порядком байтов формат (экспонента последняя, ​​в p+1 , p+3 или p+6 p+7 ), ноль, если вы нужен формат с обратным порядком байтов (сначала экспонента, p ). PY_BIG_ENDIAN константа может использоваться для использования родного порядка байтов: она равна

1 для больших процессор с прямым порядком байтов или 0 на процессоре с прямым порядком байтов.

Возвращаемое значение: 0 , если все в порядке, -1 , если ошибка (и установлено исключение, скорее всего OverflowError ).

На платформах, отличных от IEEE, две проблемы:

int PyFloat_Pack2 (двойной x, беззнаковый символ * p, int le)

Упакуйте C в два раза больше, чем формат половинной точности IEEE 754 binary16.

int PyFloat_Pack4 (двойной x, беззнаковый символ * p, int le)

Pack a C double как формат одинарной точности IEEE 754 binary32.

int PyFloat_Pack8 (двойной x, беззнаковый символ * p, int le)

Pack a C double как формат двойной точности IEEE 754 binary64.

Функции распаковки

Процедуры распаковки считывают 2, 4 или 8 байтов, начиная с p . ле является Аргумент int, отличный от нуля, если строка байтов находится в формате с прямым порядком байтов. (последняя экспонента, p+1 , p+3 или p+6 и p+7 ), ноль при обратном порядке байтов (первая экспонента, p ). Константа PY_BIG_ENDIAN может использоваться для используйте собственный порядок байтов: он равен 1 на процессоре с прямым порядком байтов или 0 на процессоре с прямым порядком байтов.

Возвращаемое значение: Распакованный двойник. При ошибке это -1.0 и PyErr_Occurred() верно (и установлено исключение, скорее всего Ошибка переполнения ).

Обратите внимание, что на платформе, отличной от IEEE, будет отказано в распаковке строки байтов, которая представляет NaN или бесконечность.

double PyFloat_Unpack2 (const unsigned char *p, int le)

Распакуйте формат половинной точности IEEE 754 binary16 как двойной C.

double PyFloat_Unpack4 (const unsigned char *p, int le)

Распакуйте формат одинарной точности IEEE 754 binary32 как C double.

double PyFloat_Unpack8 (const unsigned char *p, int le)

Распакуйте формат двойной точности IEEE 754 binary64 как C double.

Типы данных — NumPy v1.25 Manual

См. также

Объекты типа данных

Типы массивов и преобразования между типами

NumPy поддерживает гораздо большее разнообразие числовых типов, чем Python. В этом разделе показано, какие из них доступны, и как изменить тип данных массива.

Поддерживаемые типы примитивов тесно связаны с типами в C:

Тип Numpy

Тип С

Описание

numpy.bool_

логическое значение

Логическое значение (Истина или Ложь), сохраненное в виде байта

numpy.byte

знаковый символ

Определяется платформой

numpy.ubyte

беззнаковый символ

Определяется платформой

numpy.short

короткий

Определяется платформой

numpy.ushort

короткий без знака

Определяется платформой

numpy. intc

внутр.

Определяется платформой

numpy.uintc

целое число без знака

Определяется платформой

numpy.int_

длинный

Определяется платформой

numpy.uint

длинный без знака

Определяется платформой

numpy.longlong

длинный длинный

Определяется платформой

numpy.ulonglong

без знака длинный длинный

Определяется платформой

numpy.half / numpy.float16

Поплавок половинной точности: знаковый бит, 5-битная экспонента, 10-битная мантисса

numpy. single

плавающий

Определяемое платформой число с плавающей запятой одинарной точности: обычно знаковый бит, 8-битная экспонента, 23-битная мантисса

numpy.double

двойной

Определяемое платформой число с плавающей запятой двойной точности: обычно знаковый бит, 11-битная экспонента, 52-битная мантисса.

numpy.longdouble

длинный двойной

Поплавок повышенной точности, определяемый платформой

numpy.csingle

поплавковый комплекс

Комплексное число, представленное двумя вещественными числами одинарной точности (действительная и мнимая составляющие)

numpy.cdouble

двойной комплекс

Комплексное число, представленное двумя числами с двойной точностью (действительная и мнимая составляющие).

numpy.clongdouble

длинный двойной комплекс

Комплексное число, представленное двумя вещественными числами повышенной точности (действительная и мнимая составляющие).

Поскольку многие из них имеют определения, зависящие от платформы, набор фиксированных размеров предоставляются псевдонимы (см. Размерные псевдонимы).

Числовые типы NumPy являются экземплярами объектов dtype (тип данных), каждый обладающие уникальными характеристиками. После того, как вы импортировали NumPy с помощью >>> импортировать numpy как np dtypes доступны как np.bool_ , np.float32 и т. д.

Расширенные типы, не перечисленные выше, изучаются в раздел Структурированные массивы.

Существует 5 основных числовых типов, представляющих логические значения (bool), целые числа (int), целые числа без знака (uint), числа с плавающей запятой (float) и комплексные числа. Те, что с цифрами в их названии указывают разрядность типа (т.е. сколько бит необходимо для представления одного значения в памяти). Некоторые типы, такие как в и intp , имеют разные размеры битов в зависимости от платформы (например, 32-разрядная по сравнению с 64-битными машинами). Это следует учитывать при сопряжении с низкоуровневым кодом (таким как C или Fortran), где адресована необработанная память.

Типы данных могут использоваться как функции для преобразования чисел Python в скаляры массивов. (объяснение см. в разделе скалярных массивов), последовательности чисел Python для массивов этого типа или в качестве аргументов для ключевого слова dtype, что многие numpy функции или методы принимают. Некоторые примеры:

 >>> х = np.float32 (1.0)
>>> х
1,0
>>> у = np.int_([1,2,4])
>>> г
массив([1, 2, 4])
>>> z = np.arange(3, dtype=np.uint8)
>>> г
массив ([0, 1, 2], dtype = uint8)

Типы массивов также могут обозначаться кодами символов, в основном для сохранения обратная совместимость со старыми пакетами, такими как Numeric. Некоторый документация может по-прежнему ссылаться на них, например:

 >>> np.array([1, 2, 3], dtype='f')
массив([1., 2., 3.], dtype=float32)

Вместо этого мы рекомендуем использовать объекты dtype.

Чтобы преобразовать тип массива, используйте метод .astype() (предпочтительно) или сам тип как функция. Например:

 >>> z.astype(с плавающей запятой)
массив([0., 1., 2.])
>>> np.int8(z)
массив ([0, 1, 2], dtype = int8)

Обратите внимание, что выше мы используем объект Python с плавающей запятой в качестве dtype. NumPy знает что int относится к np.int_ , bool означает нп.bool_ , что float — это np.float_ , а комплекс — это np.complex_ . Другие типы данных не имеют эквивалентов Python.

Чтобы определить тип массива, посмотрите на атрибут dtype:

 >>> z.dtype
dtype('uint8')

Объекты dtype также содержат информацию о типе, например, его разрядность. и его порядок байтов. Тип данных также может косвенно использоваться для запроса свойства типа, например, является ли он целым числом:

 >>> d = np.dtype(int)
>>> д
dtype('int32')
>>> np.issubdtype(d, np.integer)
Истинный
>>> np.issubdtype(d, np.плавающий)
ЛОЖЬ

Массив скаляров

NumPy обычно возвращает элементы массивов как скаляры массива (скаляр со связанным dtype). Скаляры массива отличаются от скаляров Python, но по большей части они могут использоваться взаимозаменяемо (основной исключение составляют версии Python старше v2.x, где целочисленный массив скаляры не могут выступать в качестве индексов для списков и кортежей). Есть некоторые исключения, например, когда код требует очень специфических атрибутов скаляра или когда он специально проверяет, является ли значение скаляром Python. В целом, проблемы легко устраняются явным преобразованием скаляров массивов в скаляры Python, используя соответствующую функцию типа Python (например, int , float , complex , str , unicode ).

Основное преимущество использования скаляров-массивов состоит в том, что они сохраняют тип массива (Python может не иметь соответствующего скалярного типа доступный, напр. int16 ). Таким образом, использование скаляров массивов обеспечивает одинаковое поведение между массивами и скалярами, независимо от того, значение находится внутри массива или нет. Скаляры NumPy также имеют много одинаковых массивы методов.

Ошибки переполнения

Фиксированный размер числовых типов NumPy может вызвать ошибки переполнения, когда значение требует больше памяти, чем доступно в типе данных. Например, numpy.power правильно оценивает 100 ** 8 для 64-битных целых чисел, но дает 1874919424 (неверно) для 32-битного целого числа.

 >>> np.power(100, 8, dtype=np.int64)
10000000000000000
>>> np.power(100, 8, dtype=np.int32)
1874919424

Поведение целочисленных типов NumPy и Python значительно различается для целые переполнения и могут сбить с толку пользователей, ожидающих, что целые числа NumPy будут вести себя похоже на Python интервал . В отличие от NumPy, размер int в Python равен гибкий. Это означает, что целые числа Python могут расширяться для размещения любых целых и не будет переливаться.

NumPy предоставляет numpy.iinfo и numpy.finfo для проверки минимальные или максимальные значения целых чисел NumPy и значений с плавающей запятой соответственно

 >>> np.iinfo(int) # Границы целого числа по умолчанию в этой системе.
iinfo(мин=-9223372036854775808, макс=9223372036854775807, dtype=int64)
>>> np.iinfo(np.int32) # Границы 32-битного целого числа
iinfo(мин=-2147483648, макс=2147483647, dtype=int32)
>>> np.iinfo(np.int64) # Границы 64-битного целого числа
инфо(мин=-9223372036854775808, макс=9223372036854775807, dtype=int64)

Если 64-битные целые числа все еще слишком малы, результат может быть приведен к число с плавающей запятой. Числа с плавающей запятой предлагают большее, но неточное, диапазон возможных значений.

 >>> np.power(100, 100, dtype=np. int64) # Неверно даже с 64-битным целым числом
0
>>> np.power(100, 100, dtype=np.float64)
1e+200

Повышенная точность

Числа с плавающей запятой в Python обычно представляют собой 64-битные числа с плавающей запятой. почти эквивалентно np.float64 . В некоторых нестандартных ситуациях может быть полезно использовать числа с плавающей запятой с большей точностью. Будь то возможно в numpy зависит от оборудования и от разработки среда: в частности, машины x86 обеспечивают аппаратные операции с плавающей запятой. с 80-битной точностью, и хотя большинство компиляторов C предоставляют это как long double Тип , MSVC (стандарт для сборок Windows) делает long double идентичен double (64 бита). NumPy делает компилятор long double доступен как np.longdouble (и np.clongdouble для комплексных чисел). Вы можете узнать, какой у вас numpy предоставляет np.finfo(np.longdouble) .

NumPy не предоставляет dtype с большей точностью, чем C длинный двойной ; в частности, 128-битная четырехкратная точность IEEE. тип данных (FORTRAN’s REAL*16 ) недоступен.

Для эффективного выравнивания памяти обычно сохраняется np.longdouble дополняется нулевыми битами, либо до 96 или 128 бит. Что эффективнее зависит от оборудования и среды разработки; обычно на 32-битной системах они дополняются до 96 бит, а в 64-битных системах они обычно дополняется до 128 бит. np.longdouble дополняется системой по умолчанию; np.float96 и np.float128 предназначены для пользователей, которые хотите конкретное дополнение. Несмотря на имена, np.float96 и np.float128 обеспечивают такую ​​же точность, как np.longdouble , то есть 80 бит на большинстве машин x86 и 64 бита в стандартной Сборки Windows.

Имейте в виду, что даже если np.longdouble обеспечивает большую точность, чем python float легко потерять эту дополнительную точность, поскольку python часто заставляет значения проходить через float .

No related posts.