Сравнивайте с английским: нажмите на абзац — оригинал откроется в окне. Кнопка EN под абзацем показывает его прямо в тексте.
Содержание
Введение
Тип данных с плавающей точкой в языках семейства C
Floating point data type in C family languages
В языках C и связанных с ними языках программирования, `long double` обозначает тип данных с плавающей точкой, который часто обладает большей точностью, чем тип `double`, хотя стандарт языка лишь требует, чтобы он был как минимум столь же точен, как `double`. Как и другие типы данных с плавающей точкой в C, он не обязательно соответствует формату IEEE.
In C and related programming languages, long double refers to a floating point data type that is often more precise than double precision though the language standard only requires it to be at least as precise as double. As with C's other floating point types, it may not necessarily map to an IEEE format.
История
Тип long double присутствовал в оригинальном стандарте C 1989 года, но поддержка была улучшена в пересмотре стандарта C 1999 года, или C99, который расширил стандартную библиотеку, включив в нее функции, работающие с long double, такие как sinl и strtold. Константы long double – это константы с плавающей точкой, к которым добавлен суффикс "L" или "l" (строчная L), например, 0.3333333333333333333333333333333333L или 3.1415926535897932384626433832795029L для четверной точности. Без суффикса вычисление зависит от FLT_EVAL_METHOD.
The long double type was present in the original 1989 C standard, but support was improved by the 1999 revision of the C standard, or C99, which extended the standard library to include functions operating on long double such as sinl and strtold
Long double constants are floating point constants suffixed with "L" or "l" (lower case L), e. g., 0.3333333333333333333333333333333333L or 3.1415926535897932384626433832795029L for quadruple precision. Without a suffix, the evaluation depends on FLT EVAL METHOD.
Реализация
На архитектуре x86 большинство компиляторов C реализуют `long double` как 80-битный тип расширенной точности, поддерживаемый аппаратным обеспечением x86 (обычно хранится в виде 12 или 16 байт для обеспечения выравнивания структуры данных), как это определено в стандартах C99 / C11 (арифметика чисел с плавающей запятой IEC 60559, Приложение F). Исключением является Microsoft Visual C++ для x86, который делает `long double` синонимом `double`. Компилятор Intel C++ в Microsoft Windows поддерживает расширенную точность, но требует переключателя `/Qlong-double`, чтобы `long double` соответствовал расширенному формату точности, обеспечиваемому аппаратным обеспечением. Компиляторы также могут использовать `long double` для представления формата чисел с плавающей запятой двойной точности IEEE 754 (binary128). Это справедливо для HP-UX, Solaris/SPARC, MIPS с 64-битным или n32 ABI, 64-битных ARM (AArch64) (на операционных системах, использующих стандартные соглашения о вызовах AAPCS, такие как Linux), и z/OS с FLOAT(IEEE). Большинство реализаций выполняются программно, но некоторые процессоры имеют аппаратную поддержку. На некоторых системах PowerPC `long double` реализован как арифметика двойной двойной точности, где значение `long double` рассматривается как точная сумма двух значений двойной точности, обеспечивая точность не менее 106 бит; в этом формате тип `long double` не соответствует стандарту IEEE 754. В противном случае `long double` является просто синонимом `double` (двойной точности), например, на 32-битных ARM, 64-битных ARM (AArch64) (на Windows и macOS) и на 32-битных MIPS (старый ABI, также известный как o32). При использовании компилятора GNU C, `long double` имеет расширенную точность 80 бит на процессорах x86, независимо от физического хранилища, используемого для этого типа (которое может быть 96 или 128 бит). На некоторых других архитектурах `long double` может быть представлен как двойная двойная точность (например, на PowerPC) или как 128-битная четверная точность (например, на SPARC). Начиная с версии gcc 4.3, четверная точность также поддерживается на x86, но как нестандартный тип `float128`, а не `long double`. Хотя архитектура x86, и в частности инструкции x87 с плавающей запятой на x86, поддерживают 80-битные операции расширенной точности, можно настроить процессор для автоматического округления операций до двойной (или даже одинарной) точности. И наоборот, в режиме расширенной точности расширенная точность может использоваться для промежуточных вычислений, генерируемых компилятором, даже если конечные результаты хранятся с меньшей точностью (то есть, FLT EVAL METHOD == 2). При использовании gcc на Linux расширенная точность 80 бит является значением по умолчанию; на нескольких операционных системах BSD (FreeBSD и OpenBSD) режим двойной точности является значением по умолчанию, и операции с `long double` фактически приводятся к двойной точности. (Однако, начиная с NetBSD 7.0, по умолчанию используется расширенная точность 80 бит). Тем не менее, это можно переопределить в отдельной программе с помощью инструкции FLDCW ("floating point load control word"). С другой стороны, компилятор Intel C++ для x86 включает режим расширенной точности по умолчанию. На IA 32 OS X `long double` имеет расширенную точность 80 бит.
On the x86 architecture, most C compilers implement long double as the 80 bit extended precision type supported by x86 hardware (generally stored as 12 or 16 bytes to maintain data structure alignment), as specified in the C99 / C11 standards (IEC 60559 floating point arithmetic (Annex F)). An exception is Microsoft Visual C++ for x86, which makes long double a synonym for double. The Intel C++ compiler on Microsoft Windows supports extended precision, but requires the /Qlong‑double switch for long double to correspond to the hardware's extended precision format. Compilers may also use long double for the IEEE 754 quadruple precision binary floating point format (binary128). This is the case on HP UX, Solaris/SPARC, MIPS with the 64 bit or n32 ABI, 64 bit ARM (AArch64) (on operating systems using the standard AAPCS calling conventions, such as Linux), and z/OS with FLOAT(IEEE). Most implementations are in software, but some processors have hardware support. On some PowerPC systems, long double is implemented as a double double arithmetic, where a long double value is regarded as the exact sum of two double precision values, giving at least a 106 bit precision; with such a format, the long double type does not conform to the IEEE floating point standard. Otherwise, long double is simply a synonym for double (double precision), e. g. on 32 bit ARM, 64 bit ARM (AArch64) (on Windows and macOS) and on 32 bit MIPS (old ABI, a. k. a. o32). With the GNU C Compiler, long double is 80 bit extended precision on x86 processors regardless of the physical storage used for the type (which can be either 96 or 128 bits), On some other architectures, long double can be double double (e. g. on PowerPC) or 128 bit quadruple precision (e. g. on SPARC). As of gcc 4.3, a quadruple precision is also supported on x86, but as the nonstandard type float128 rather than long double. Although the x86 architecture, and specifically the x87 floating point instructions on x86, supports 80 bit extended precision operations, it is possible to configure the processor to automatically round operations to double (or even single) precision. Conversely, in extended precision mode, extended precision may be used for intermediate compiler generated calculations even when the final results are stored at a lower precision (i. e. FLT EVAL METHOD == 2). With gcc on Linux, 80 bit extended precision is the default; on several BSD operating systems (FreeBSD and OpenBSD), double precision mode is the default, and long double operations are effectively reduced to double precision. (NetBSD 7.0 and later, however, defaults to 80 bit extended precision ). However, it is possible to override this within an individual program via the FLDCW "floating point load control word" instruction.). The Intel C++ Compiler for x86, on the other hand, enables extended precision mode by default. On IA 32 OS X, long double is 80 bit extended precision.
Другие спецификации
В CORBA (согласно спецификации 3.0, использующей "ANSI/IEEE Standard 754 1985" в качестве эталона), "тип данных `long double` представляет собой число двойной расширенной точности формата IEEE, имеющее экспоненту длиной не менее 15 бит и знакомую мантиссу длиной не менее 64 бит". При использовании GIOP/IIOP CDR, типы данных с плавающей точкой "строго соответствуют стандартным форматам IEEE для чисел с плавающей точкой", и при этом сериализуются как формат IEEE 754 2008 binary128, также известный как четырехкратная точность, но без использования этого наименования.
In CORBA (from specification of 3.0, which uses "ANSI/IEEE Standard 754 1985" as its reference), "the long double data type represents an IEEE double extended floating point number, which has an exponent of at least 15 bits in length and a signed fraction of at least 64 bits", with GIOP/IIOP CDR, whose floating point types "exactly follow the IEEE standard formats for floating point numbers", marshalling this as what seems to be IEEE 754 2008 binary128 a. k. a. quadruple precision without using that name.