==================================================================

======= Intel(R) Decimal Floating-Point Math Library v2.4 ========

==================================================================

December 2, 2025

******************************************************************

*** To report issues, please send email to [email protected] ***

******************************************************************

Release History:

================

Jul 2009 - Version 1.0 - implemented all the mandatory functions

from the IEEE Standard 754-2019

Jun 2011 - Version 2.0 - implemented also the functions

recommended in the ISO/IEC Technical Report 24732,

'Extension for the programming language C to support

decimal floating-point arithmetic'

Aug 2011 - Version 2.0 Update 1 - fixed a small issue in fma128

Jun 2018 - Version 2.0 Update 2 - fixed issues in powd64,

acos64, and acos128. Added the llround, llquantexp,

and quantum functions, as well as corresponding new tests.

This version has been tested in Linux, Windows, OSX, and

Solaris.

Apr 2024 - 1. Version 2.0 Update 3 - Clang and the latest Intel Compiler

builds were added.

2. The return type of bid{128,64,32}_class functions was

updated and 'enum class_types' moved from bid_internal.h to

bid_functions.h.

3. The payload mask constant was updated (0x0000cfffffffffff

--> 0x00003fffffffffff)

for the bid128_nan function in bid128_noncomp.c.

4. A few unused variables were removed in order to eliminate

potential build warnings.

5. The __NO_BINARY80__ macro was added to LIBRARY/src/bid_functions.h

to address a decimal library build fail on ARM32.

6. The bid{64,32}_pow functions were updated so that powers

of 10 are now rounded correctly. For example, bid64_pow(10,-398)

returns +1E-398 (and it returned zero before).

7. The bid128_pow function was updated to use volatile for a certain

variable, in order to work correctly with Intel Compiler optimizations.

8. The bid128_hypot function was updated for the case when the

exponent of one input value is much smaller than the exponent of

the other one (it was being done without checking the mantissas.

For example, hypot(+1E+0, +3333333333333333333333333333333333E-35)

was returning +1E+0, instead

of +1000555401320242292114995032370049E-33.

9. Sixteen files were updated by adding a 'default: break;' in

switch statements, to avoid compiler warnings.

10. The ASCII value of 0x30 for zero was replaced with '0' in

bid128_to_string function.

11. The bid{32,64}_from_string functions were updated, as the result

was not correct for certain inputs when the rounding mode was set to

'rounding up'. For example, the bid32_from_string function with input

value "10000000" returns +1000000E+1 now, instead of +1000001E+1.

The updated library was tested in Linux and in Windows, compiled with

the Intel ICX (new) and ICC/ICL (classic) compilers, and also with

the GCC 13.1 and Clang 17.0 compilers.

Testing was also performed with the Apple Clang compiler 14.0.0 on Mac.

Dec 2025 - Version 2.0 Update 4 - Three issues and one warning were fixed. An outdated

command file was also removed.

1. The bid128_from_string function was updated to handle very long input

strings correctly, and new tests were added for that. Errors could have

occurred only for input strings longer than 100 digits. As an example,

the result for the input +1.000000000000000000000000000000000000000000000 \

00000000000000000000000000000000000000000000000000000000000000000000000000

(119 zeros in this example) was incorrect as

+1000000000000000000000000000000001E-33 (34 digits in the coefficient) with

rounding-up rounding mode, and after the fix we get the correct result of

+1000000000000000000000000000000000E-33.

2. The bid64_from_string function was updated to fix incorrect handling of

the exponent. The issue occurred only in rounding-down or rounding-up rounding

modes, and for input strings with more than 17 coefficient digits. For example,

for input +9.99999999999999900000000005 (27 digits), the result was incorrect

as +1000000000000000E-25 with rounding-up rounding mode before the fix, and

the correct result of 1000000000000000E-14 is computed after the fix.

3. The wcstod_conversion function was updated for possible buffer overrun.

A buffer overrun of one byte could occur before this update in some cases,

caused by incorrect accounting of the sign character.

4. Several division, sqrt, fmod, and remainder functions that rely on binary

floating-point computation were updated to ensure the computation is performed

in round-to-nearest mode. Inaccurate results could potentially occur prior to

this update if the user changed the rounding mode to something other than

the assumed default (round-to-nearest-even rounding mode).

5. Warnings for printf when building EXAMPLES in MacOS were eliminated.

6. RUNOSXINTEL64 was removed.

The library was tested in Linux, Windows, and MacOS.

1. INTRODUCTION

===============

This package contains the release 2.0 Update 4 (or V2.4) of the Intel(R) Decimal

Floating-Point Math Library, conforming to the IEEE Standard 754-2019 for Floating-

Point Arithmetic. This is an update of Release 2.0 Update 3 (or V2.3) of 2024.

The library implements the functions defined for decimal floating-point

arithmetic operations in the IEEE Standard 754-2019 for Floating-Point

Arithmetic, which is a revision of the IEEE Standard 754-2008 for Floating-Point Arithmetic.

However, there were no changes in what is mandated for decimal floating-point arithmetic

in the IEEE Standard 754-2019, compared to the IEEE Standard 754-2008.

The IEEE Standard 754-2019 for Floating-Point Arithmetic supports two

encoding formats: the decimal encoding format, and the binary encoding format.

The Intel(R) Decimal Floating-Point Math Library supports primarily the binary

encoding format for decimal floating-point values, but the decimal encoding

format is supported too in the library, by means of conversion functions

between the two encoding formats.

Release 2.4 of the library contained in this package implements all

the operations mandated by the IEEE Standard 754-2019. Alternate exception

handling (not a mandatory feature) is not supported currently in the library,

but the design facilitates adding it if necessary. It is worth noting that

several useful functions (not part of the IEEE 754-2019 definition) are

provided in LIBRARY/src/bid_round.c. They can be used to round a q-digit decimal

integer number represented in binary to q - x digits (1 <= x <= q - 1).

For operations involving integer operands or results, the library supports

signed and unsigned 8-, 16-, 32-, and 64-bit integers.

Note: Release 2.0 added transcendental functions (supported in 128-bit, 64-bit,

and 32-bit decimal formats), including the ones specified in the technical

report on decimal arithmetic ISO/IEC TR 24732 (available from www.iso.org).

These functions are not correctly rounded, a fact that should be considered

when using them (similary, binary floating-point mathematical functions

implemented for example in C or other compiler math libraries are in general

not correctly rounded either).

2. PACKAGE CONTENTS

===================

This package contains:

- eula.txt, a copy of the end user license agreement that applies to

everything in this package

- this README FILE

- the LIBRARY subdirectory with all the source files necessary to build the

library, and a README file which specifies how to build the library

in Linux**, Windows***, or MacOS**; a small set

of command files (RUNLINUX*, RUNWINDOWS*) can be used to build the

library with different options

- the TESTS subdirectory with source and input files necessary to build and

run a reduced set of tests for the library, and a README

file which specifies how to build and run these tests;

the test program will print the number of errors detected;

note that tests involving 80-bit binary floating-point values (these are

only conversions to and from decimal floating-point formats) are skipped

if the 80-bit floating-point data type is not supported; a small set

of command files (RUNLINUX*, RUNWINDOW*) can be used to build and

run the tests with different options

- the EXAMPLES subdirectory containing eight examples of calls to library

functions with various combinations of build options (see Section 8

below); a README file is included; a small set of command files (RUNLINUX*,

RUNWINDOWS*) can be used to build and run the examples with different

options

3. FUNCTION NAMES

=================

The function names used in the library are not identical to the names from

the IEEE Standard 754-2019 for Floating-Point Arithmetic. The mapping between

the two sets is given in Section 10 below. The function names can be changed

by editing the #define statements at the beginning of bid_conf.h.

4. LIBRARY BUILD OPTIONS

========================

The API for the library functions is intended to support constant modes,

global dynamic modes, and scoped dynamic modes. It should be convenient for

compilers with various requirements, even where default modes and no flag

tests can be assumed, as in C99 FENV_ACCESS OFF.

Three build options are provided, that can be set by editing

LIBRARY/src/bid_conf.h, or (more conveniently) can be set on the compile

command line.

(a) Function arguments and return values can be passed by reference if

DECIMAL_CALL_BY_REFERENCE is set to 1, or by value otherwise. However, the

floating-point status flags argument is passed by reference even when

DECIMAL_CALL_BY_REFERENCE is 0, unless it is stored in a global variable

(see (c) below).

(b) The value of the rounding mode can be passed by reference or by value,

or it can be stored in a global variable if DECIMAL_GLOBAL_ROUNDING is

set to 1.

If DECIMAL_GLOBAL_ROUNDING is set to 1 then the rounding mode is stored

in a global variable that must be declared as

_IDEC_round __bid_IDEC_glbround;

In this case __bid_IDEC_glbround is a fixed name that *must* be used (but

it can be changed by editing the corresponding #define in bid_conf.h). Its

initial value should be ROUNDING_TO_NEAREST (or an equivalent value with a name

chosen by the user, as shown in code samples from EXAMPLES where

_IDEC_nearesteven is used). The _IDEC_round type name can be different

(but equivalent), chosen by the user.

(c) The value of the exception status flags is passed by reference if

they are not represented by a global variable, or it can be stored in a

global variable if DECIMAL_GLOBAL_EXCEPTION_FLAGS is set to 1.

If DECIMAL_GLOBAL_EXCEPTION_FLAGS is set to 1 then the exception status

flags are stored in a global variable that must be declared as

_IDEC_flags __bid_IDEC_glbflags;

In this case __bid_IDEC_glbflags is a fixed name that *must* be used but

it can be changed by editing the corresponding #define in bid_conf.h). Its

initial value should be EXACT_STATUS (or an equivalent value with a name chosen

by the user, as shown in code samples from EXAMPLES where _IDEC_allflagsclear

is used). The _IDEC_flags type name can be different (but equivalent),

chosen by the user.

The three build options supported in this release are selected on the

'make' command line when building the library in LIBRARY and the tests in

TESTS using the makefile-s provided here (so editing bid_conf.h is not

necessary). For example when using the Intel(R) C++ Compiler in Linux**:

make CC=icc CALL_BY_REF=0 GLOBAL_RND=0 GLOBAL_FLAGS=0 UNCHANGED_BINARY_FLAGS=0

selects parameter passing by value; the rounding mode is a parameter

passed to each function that requires it; the status flags are passed

as a parameter to functions that may modify them (note however that the

status flags represent an exception in that the CALL_BY_REF setting

is ignored - if not global, they are always passed by reference); the

decimal operations may change the inexact binary status flag.

Another example, when using the Intel(R) C++ Compiler in Windows*** is:

nmake -fmakefile.mak CC=icl CALL_BY_REF=1 GLOBAL_RND=1 GLOBAL_FLAGS=1 UNCHANGED_BINARY_FLAGS=1

where parameters are passed by reference; the rounding mode is a global

variable; the status flags are stored in a global variable; the

decimal operations will not change the inexact binary status flag.

If 80-bit long double precision is not supported then you can simply set

NO_BINARY80 macro to '1' in the LIBRARY/makefile and TESTS/makefile.

5. FUNCTION PROTOTYPES

======================

Function prototypes are provided in LIBRARY/src/bid_functions.h (starting at

line 417 if parameters are passed by reference, and at line 3015 if they

are passed by value).

6. TESTING

==========

The library was tested on several different platforms (Intel(R)64 Architecture

running Linux**, Windows*** and MacOS**). For example in Linux** the

oneAPI DPC++/C++ Compiler 2025.0, Clang**, and gcc** were used. In Windows***,

the oneAPI DPC++/C++ Compiler 2025.0 and the Microsoft*** Visual C++ Compiler

were used. For each of these combinations, eight combinations of parameter passing

method and global or local rounding mode and status flags were tested.

7. USAGE EXAMPLES

=================

Eight usage examples are given in the EXAMPLES subdirectory, which illustrate

calls to library functions with various combinations of build options (see

Section 4 above). A README file is included. Note that these examples do not

use any include files from the library: the necessary data types are defined

instead directly in the user-defined decimal.h. However, if the rounding mode

or exception status flags are stored in global variables, then these must have

the fixed names of _IDEC_glbround and _IDEC_glbflags.

Alternatively - and this is the preferred method, one could use the data

types defined in the library by including two header files (and in this case

DECIMAL_CALL_BY_REFERENCE, DECIMAL_GLOBAL_ROUNDING, and

DECIMAL_GLOBAL_EXCEPTION_FLAGS would have to be properly defined not only when

building the library, but also for the application calling the library

functions):

#include "../LIBRARY/src/bid_conf.h"

#include "../LIBRARY/src/bid_functions.h"

Such an example is represented by the readtest program in TESTS/readtest.c.

8. DECIMAL AND BINARY STATUS FLAGS

==================================

The IEEE Standard 754-2019 specifies distinct rounding modes for binary

and for decimal floating-point operations. However, the floating-point status

flags may be identical for decimal and binary computations. In this

implementation of the decimal arithmetic, the decimal floating-point status

flags are kept separate from the binary flags. Still, it is possible to merge

the two sets (outside the library).

One issue that needs to be pointed out is that the current implementation of

the decimal floating-point library may set the binary inexact status flag for

certain operations: division, square root, and several other operations where

integers are converted to floating-point values, and the conversion

is inexact. In order to avoid setting the binary inexact flag by decimal

functions, uncomment the following line in bid_conf.h

prior to building the library:

// #define UNCHANGED_BINARY_STATUS_FLAGS

9. MAPPING OF IEEE 754-2019 NAMES TO INTEL (R) DECIMAL FLOATING-POINT MATH

LIBRARY FUNCTION NAMES

=========================================================================

Operand and result types are included, where:

BID64 = the 64-bit decimal floating-point format using the binary

encoding; this becomes BID_UINT64 in the library

BID128 = the 128-bit decimal floating-point format using the binary

encoding ; this becomes BID_UINT128 in the library

binary32 = 32-bit binary floating-point data format

binary64 = 64-bit binary floating-point data format

binary80 = 80-bit binary floating-point data format

binary128 = 128-bit binary floating-point data format

string = char *

boolean = int

enum = int

_IDEC_flags = int

_IDEC_round = int

The library function names shown here can be changed by editing #define

statements in bid_conf.h.

================================================================================

IEEE 754-2019 Name Opd1 Opd2 Opd3 Result

Intel(R) DFP Math Library Name

================================================================================

roundToIntegralTiesToEven BID64 BID64

__bid64_round_integral_nearest_even

BID128 BID128

__bid128_round_integral_nearest_even

roundToIntegralTiesToAway BID64 BID64

__bid64_round_integral_nearest_away

BID128 BID128

__bid128_round_integral_nearest_away

roundToIntegralTiesTowardZero BID64 BID64

__bid64_round_integral_zero

BID128 BID128

__bid128_round_integral_zero

roundToIntegralTiesTowardPositive BID64 BID64

__bid64_round_integral_positive

BID128 BID128

__bid128_round_integral_positive

roundToIntegralTiesTowardNegative BID64 BID64

__bid64_round_integral_negative

BID128 BID128

__bid128_round_integral_negative

roundToIntegralExact BID64 BID64

__bid64_round_integral_exact

BID128 BID128

__bid128_round_integral_exact

nextUp BID64 BID64

__bid64_nextup

BID128 BID128

__bid128_nextup

nextDown BID64 BID64

__bid64_nextdown

BID128 BID128

__bid128_nextdown

N/A BID64 BID64 BID64

__bid64_nextafter

BID128 BID128 BID128

__bid128_nextafter

remainder BID64 BID64 BID64

__bid64_rem

BID128 BID128 BID128

__bid128_rem

minNum BID64 BID64 BID64

__bid64_minnum

BID128 BID128 BID128

__bid128_minnum

maxNum BID64 BID64 BID64

__bid64_maxnum

BID128 BID128 BID128

__bid128_maxnum

minNumMag BID64 BID64 BID64

__bid64_minnum_mag

BID128 BID128 BID128

__bid128_minnum_mag

maxNumMag BID64 BID64 BID64

__bid64_maxnum_mag

BID128 BID128 BID128

__bid128_maxnum_mag

quantize BID64 BID64 BID64

__bid64_quantize

BID128 BID128 BID128

__bid128_quantize

logB BID64 BID64

__bid64_ilogb

BID128 BID128

__bid128_ilogb

scaleB BID64 BID64 BID64

__bid64_scalbn

BID128 BID128 BID128

__bid128_scalbn

addition BID64 BID64 BID64

__bid64_add

BID128 BID128 BID128

__bid128_add

subtraction BID64 BID64 BID64

__bid64_sub

BID128 BID128 BID128

__bid128_sub

multiplication BID64 BID64 BID64

__bid64_mul

BID128 BID128 BID128

__bid128_mul

division BID64 BID64 BID64

__bid64_div

BID128 BID128 BID128

__bid128_div

squareRoot BID64 BID64

__bid64_sqrt

BID128 BID128

__bid128_sqrt

fusedMultiplyAdd BID64 BID64 BID64 BID64

__bid64_fma

BID128 BID128 BID128 BID128

__bid128_fma

convertFromInt int32 BID64

__bid64_from_int32

uint32 BID64

__bid64_from_uint32

int64 BID64

__bid64_from_int64

uint64 BID64

__bid64_from_uint64

int32 BID128

__bid128_from_int32

uint32 BID128

__bid128_from_uint32

int64 BID128

__bid128_from_int64

uint64 BID128

__bid128_from_uint64

convertToIntegerTiesToEven BID64 int32

__bid64_to_int32_rnint

BID64 uint32

__bid64_to_uint32_rnint

BID64 int64

__bid64_to_int64_rnint

BID64 uint64

__bid64_to_uint64_rnint

BID128 int32

__bid128_to_int32_rnint

BID128 uint32

__bid128_to_uint32_rnint

BID128 int64

__bid128_to_int64_rnint

BID128 uint64

__bid128_to_uint64_rnint

convertToIntegerTowardZero BID64 int32

__bid64_to_int32_int

BID64 uint32

__bid64_to_uint32_int

BID64 int64

__bid64_to_int64_int

BID64 uint64

__bid64_to_uint64_int

BID128 int32

__bid128_to_int32_int

BID128 uint32

__bid128_to_uint32_int

BID128 int64

__bid128_to_int64_int

BID128 uint64

__bid128_to_uint64_int

convertToIntegerTowardPositive BID64 int32

__bid64_to_int32_ceil

BID64 uint32

__bid64_to_uint32_ceil

BID64 int64

__bid64_to_int64_ceil

BID64 uint64

__bid64_to_uint64_ceil

BID128 int32

__bid128_to_int32_ceil

BID128 uint32

__bid128_to_uint32_ceil

BID128 int64

__bid128_to_int64_ceil

BID128 uint64

__bid128_to_uint64_ceil

convertToIntegerTowardNegative BID64 int32

__bid64_to_int32_floor

BID64 int32

__bid64_to_uint32_floor

BID64 int64

__bid64_to_int64_floor

BID64 uint64

__bid64_to_uint64_floor

BID128 int32

__bid128_to_int32_floor

BID128 uint32

__bid128_to_uint32_floor

BID128 int64

__bid128_to_int64_floor

BID128 uint64

__bid128_to_uint64_floor

convertToIntegerTiesToAway BID64 int32

__bid64_to_int32_rninta

BID64 uint32

__bid64_to_uint32_rninta

BID64 int64

__bid64_to_int64_rninta

BID64 uint64

__bid64_to_uint64_rninta

BID128 int32

__bid128_to_int32_rninta

BID128 uint32

__bid128_to_uint32_rninta

BID128 int64

__bid128_to_int64_rninta

BID128 uint64

__bid128_to_uint64_rninta

convertToIntegerExactTiesToEven BID64 int32

__bid64_to_int32_xrnint

BID64 uint32

__bid64_to_uint32_xrnint

BID64 int64

__bid64_to_int64_xrnint

BID64 uint64

__bid64_to_uint64_xrnint

BID128 int32

__bid128_to_int32_xrnint

BID128 uint32

__bid128_to_uint32_xrnint

BID128 int64

__bid128_to_int64_xrnint

BID128 uint64

__bid128_to_uint64_xrnint

convertToIntegerExactTowardZero BID64 int32

__bid64_to_int32_xint

BID64 uint32

__bid64_to_uint32_xint

BID64 int64

__bid64_to_int64_xint

BID64 uint64

__bid64_to_uint64_xint

BID128 int32

__bid128_to_int32_xint

BID128 uint32

__bid128_to_uint32_xint

BID128 int64

__bid128_to_int64_xint

BID128 uint64

__bid128_to_uint64_xint

convertToIntegerExactTowardPositive BID64 int32

__bid64_to_int32_xceil

BID64 uint32

__bid64_to_uint32_xceil

BID64 int64

__bid64_to_int64_xceil

BID64 uint64

__bid64_to_uint64_xceil

BID128 int32

__bid128_to_int32_xceil

BID128 uint32

__bid128_to_uint32_xceil

BID128 int64

__bid128_to_int64_xceil

BID128 uint64

__bid128_to_uint64_xceil

convertToIntegerExactTowardNegative BID64 int32

__bid64_to_int32_xfloor

BID64 uint32

__bid64_to_uint32_xfloor

BID64 int64

__bid64_to_int64_xfloor

BID64 uint64

__bid64_to_uint64_xfloor

BID128 int32

__bid128_to_int32_xfloor

BID128 uint32

__bid128_to_uint32_xfloor

BID128 int64

__bid128_to_int64_xfloor

BID128 uint64

__bid128_to_uint64_xfloor

convertToIntegerExactTiesToAway BID64 int32

__bid64_to_int32_xrninta

BID64 uint32

__bid64_to_uint32_xrninta

BID64 int64

__bid64_to_int64_rninta

BID64 uint64

__bid64_to_uint64_xrninta

BID128 int32

__bid128_to_int32_xrninta

BID128 uint32

__bid128_to_uint32_xrninta

BID128 int64

__bid128_to_int64_xrninta

BID128 uint64

__bid128_to_uint64_xrninta

convert BID32 BID64

__bid32_to_bid64

BID32 BID128

__bid32_to_bid128

BID32 bin32

__bid32_to_binary32

BID32 bin64

__bid32_to_binary64

BID32 bin80

__bid32_to_binary80

BID32 bin128

__bid32_to_binary128

BID64 BID32

__bid64_to_bid32

BID64 BID128

__bid64_to_bid128

BID64 bin32

__bid64_to_binary32

BID64 bin64

__bid64_to_binary64

BID64 bin80

__bid64_to_binary80

BID64 bin128

__bid64_to_binary128

BID128 BID32

__bid128_to_bid32

BID128 BID64

__bid128_to_bid64

BID128 bin32

__bid128_to_binary32

BID128 bin64

__bid128_to_binary64

BID128 bin80

__bid128_to_binary80

BID128 bin128

__bid128_to_binary128

bin32 BID32

__binary32_to_bid32

bin32 BID64

__binary32_to_bid64

bin32 BID128

__binary32_to_bid128

bin64 BID32

__binary64_to_bid32

bin64 BID64

__binary64_to_bid64

bin64 BID128

__binary64_to_bid128

bin80 BID32

__binary80_to_bid32

bin80 BID64

__binary80_to_bid64

bin80 BID128

__binary80_to_bid128

bin128 BID32

__binary128_to_bid32

bin128 BID64

__binary128_to_bid64

bin128 BID128

__binary128_to_bid128

convertFromDecimalCharacter string BID64

__bid64_from_string

string BID128

__bid128_from_string

convertToDecimalCharacter BID64 string

__bid64_to_string

BID128 string

__bid128_to_string

copy BID64 BID64

__bid64_copy

BID128 BID128

__bid128_copy

negate BID64 BID64

__bid64_negate

BID128 BID128

__bid128_negate

abs BID64 BID64

__bid64_abs

BID128 BID128

__bid128_abs

copySign BID64 BID64 BID64

__bid64_copySign

BID128 BID128 BID128

__bid128_copySign

encodeDecimal BID32 DPD32

__bid_to_dpd32

BID64 DPD64

__bid_to_dpd64

BID128 DPD128

__bid_to_dpd128

decodeDecimal DPD32 BID32

__bid_dpd_to_bid32

DPD64 BID64

__bid_dpd_to_bid64

DPD128 BID128

__bid_dpd_to_bid128

compareQuietEqual BID64 BID64 boolean

__bid64_quiet_equal

BID128 BID128 boolean

__bid128_quiet_equal

compareQuietGreater BID64 BID64 boolean

__bid64_quiet_greater

BID128 BID128 boolean

__bid128_quiet_greater

compareQuietGreaterEqual BID64 BID64 boolean

__bid64_quiet_greater_equal

BID128 BID128 boolean

__bid128_quiet_greater_equal

compareQuietGreaterUnordered BID64 BID64 boolean

__bid64_quiet_greater_unordered

BID128 BID128 boolean

__bid128_quiet_greater_unordered

compareQuietLess BID64 BID64 boolean

__bid64_quiet_less

BID128 BID128 boolean

__bid128_quiet_less

compareQuietLessEqual BID64 BID64 boolean

__bid64_quiet_less_equal

BID128 BID128 boolean

__bid128_quiet_less_equal

compareQuietLessUnordered BID64 BID64 boolean

__bid64_quiet_less_unordered

BID128 BID128 boolean

__bid128_quiet_less_unordered

compareQuietNotEqual BID64 BID64 boolean

__bid64_quiet_not_equal

BID128 BID128 boolean

__bid128_quiet_not_equal

compareQuietNotGreater BID64 BID64 boolean

__bid64_quiet_not_greater

BID128 BID128 boolean

__bid128_quiet_not_greater

compareQuietNotLess BID64 BID64 boolean

__bid64_quiet_not_less

BID128 BID128 boolean

__bid128_quiet_not_less

compareQuietOrdered BID64 BID64 boolean

__bid64_quiet_ordered

BID128 BID128 boolean

__bid128_quiet_ordered

compareQuietUnordered BID64 BID64 boolean

__bid64_quiet_unordered

BID128 BID128 boolean

__bid128_quiet_unordered

compareSignalingEqual BID64 BID64 boolean

__bid64_signaling_equal (not currently implemented)

BID128 BID128 boolean

__bid128_signaling_equal (not currently implemented)

compareSignalingGreater BID64 BID64 boolean

__bid64_signaling_greater

BID128 BID128 boolean

__bid128_signaling_greater

compareSignalingGreaterEqual BID64 BID64 boolean

__bid64_signaling_greater_equal

BID128 BID128 boolean

__bid128_signaling_greater_equal

compareSignalingGreaterUnordered BID64 BID64 boolean

__bid64_signaling_greater_unordered

BID128 BID128 boolean

__bid128_signaling_greater_unordered

compareSignalingLess BID64 BID64 boolean

__bid64_signaling_less

BID128 BID128 boolean

__bid128_signaling_less

compareSignalingLessEqual BID64 BID64 boolean

__bid64_signaling_less_equal

BID128 BID128 boolean

__bid128_signaling_less_equal

compareSignalingLessUnordered BID64 BID64 boolean

__bid64_signaling_less_unordered

BID128 BID128 boolean

__bid128_signaling_less_unordered

compareSignalingNotEqual BID64 BID64 boolean

__bid64_signaling_not_equal (not currently implemented)

BID128 BID128 boolean

__bid128_signaling_not_equal (not currently implemented)

compareSignalingNotGreater BID64 BID64 boolean

__bid64_signaling_not_greater

BID128 BID128 boolean

__bid128_signaling_not_greater

compareSignalingNotLess BID64 BID64 boolean

__bid64_signaling_not_less

BID128 BID128 boolean

__bid128_signaling_not_less

N/A IDEC_flags *IDEC_flags

__bid_signalException

isSignMinus BID64 boolean

__bid64_isSigned

BID128 boolean

__bid128_isSigned

isNormal BID64 boolean

__bid64_isNormal

BID128 boolean

__bid128_isNormal

isFinite BID64 boolean

__bid64_isFinite

BID128 boolean

__bid128_isFinite

isZero BID64 boolean

__bid64_isZero

BID128 boolean

__bid128_isZero

isSubnormal BID64 boolean

__bid64_isSubnormal

BID128 boolean

__bid128_isSubnormal

isInfinite BID64 boolean

__bid64_isInf

BID128 boolean

__bid128_isInf

isNaN BID64 boolean

__bid64_isNaN

BID128 boolean

__bid128_isNaN

isSignaling BID64 boolean

__bid64_isSignaling

BID128 boolean

__bid128_isSignaling

isCanonical BID64 boolean

__bid64_isCanonical

BID128 boolean

__bid128_isCanonical

radix BID64 boolean

__bid64_radix

BID128 boolean

__bid128_radix

class BID64 enum

__bid64_class

BID128 enum

__bid128_class

totalOrder BID64 BID64 boolean

__bid64_totalOrder

BID128 BID128 boolean

__bid128_totalOrder

totalOrderMag BID64 BID64 boolean

__bid64_totalOrderMag

BID128 BID128 boolean

__bid128_totalOrderMag

lowerFlags _IDEC_flags

__bid_lowerFlags

testFlags _IDEC_flags boolean

__bid_testFlags

testSavedFlags _IDEC_flags _IDEC_flags boolean

__bid_testSavedFlags

restoreFlags _IDEC_flags _IDEC_flags

__bid_restoreFlags

saveAllFlags _IDEC_flags IDEC_flags

__bid_saveFlags

getDecimalRoundingDirection _IDEC_round

__bid_getDecimalRoundingDirection

setDecimalRoundingDirection _IDEC_round

__bid_setDecimalRoundingDirection

10. DESCRIPTION OF THE INTEL(R) DECIMAL FP MATH LIBRARY FUNCTIONS

This section gives brief descriptions of the functions available in the

Intel(R) Decimal Floating-Point Math Library v2.4. The prototypes are

shown assuming all arguments are passed by value; the rounding mode variable is

passed as an argument to each function that requires it; a pointer to a

variable containing the status flags is passed to each function that requires

it; alternate exception handling is not supported. The function prototypes

for other variants allowed for building the library can be determined from

header files bid_functions.h and bid_conf.h, which contain also all the type

definitions used in the following description, as well as the possible values of

the rounding mode variable rnd_mode and the positions of the individual status

flags in the status word *pfpsf.

Notes:

1. Three decimal floating-point formats are supported, as defined in

IEEE Standard 754-2019: 32-bit, 64-bit, and 128-bit.

The data types used in the library for entities in the three formats are

UINT32, UINT64, and UINT128 which can be mapped externally to types of

appropriate sizes and alignments but having different names, for example

_Decimal32, _Decimal64, and _Decimal128.

The maximum number of decimal digits in the significand of numerical

values represented in these three formats are:

P = 7 decimal digits for the 32-bit decimal floating-point format

P = 16 decimal digits for the 64-bit decimal floating-point format

P = 34 decimal digits for the 128-bit decimal floating-point format

The ranges for normal decimal floating-point numbers are (in magnitude):

1.000000 * 10^(-95) <= x <= 9.999999 * 10^96 for 32-bit format

1.0...0 * 10^(-383) <= x <= 9.9...9 * 10^384 for 64-bit format

(15 decimal digits in the fractional part of the significand)

1.0...0 * 10^(-6143) <= x <= 9.9...9 * 10^6144 for 128-bit format

(33 decimal digits in the fractional part of the significand)

The ranges for subnormal decimal floating-point numbers are (in magnitude):

0.000001 * 10^(-95) <= x <= 0.999999 * 10^(-95) for 32-bit format

0.0...01 * 10^(-383) <= x <= 0.9...9 * 10^(-383) for 64-bit format

(15 decimal digits in the fractional part of the significand)

0.0...01 * 10^(-6144) <= x <= 0.9...9 * 10^(-6144) for 128-bit format

(33 decimal digits in the fractional part of the significand)

Operations with decimal floating-point results usually choose one

representation of the result from among several possible that have the

same numerical value (constituting a 'cohort'). The chosen representation

must have the 'preferred exponent' specified in the IEEE Standard 754-2019.

(For example 1.0 * 10^(-2) + 10.0 * 10^(-3) = 20.0 * 10^(-3), and not

2.0 * 10^(-2).)

The encoding methods for decimal floating-point values are not explained

here. Decimal floating-point values can be encoded using the

string-to-decimal conversion functions (__bid64_from_string and

__bid128_from_string), or decoded using the decimal-to-string conversion

functions (__bid64_to_string and __bid128_to_string).

2. The acronym 'dpd' or 'DPD' is used to identify the decimal encoding method

for decimal floating-point values, defined in the IEEE Standard 754-2019.

The acronym 'bid' or 'BID' is used to identify the binary encoding method

for decimal floating-point values, defined in the IEEE Standard 754-2019.

3. The library functions that operate on decimal floating-point values do so on

values encoded in BID format.

4. The floating-point status flags for inexact result, underflow, overflow,

division by zero and invalid operation are denoted by P, U, O, Z, I

respectively

Note that the function names can be changed by editing #define statements in

bid_conf.h.

===============================================================================

FUNCTION: Convert a 32-bit decimal floating-point value encoded in BID format to

the same value encoded in DPD format

PROTOTYPE:

UINT32 __bid_to_dpd32 (

UINT32 px);

FLOATING-POINT EXCEPTIONS: none

FUNCTION: Convert a 64-bit decimal floating-point value encoded in BID format to

the same value encoded in DPD format

PROTOTYPE:

UINT64 __bid_to_dpd64 (

UINT64 px);

FLOATING-POINT EXCEPTIONS: none

FUNCTION: Convert a 128-bit decimal floating-point value encoded in BID format

to the same value encoded in DPD format

PROTOTYPE:

UINT128 __bid_to_dpd128 (

UINT128 px);

FLOATING-POINT EXCEPTIONS: none

FUNCTION: Convert a 32-bit decimal floating-point value encoded in DPD format

to the same value encoded in BID format

PROTOTYPE:

UINT32 __bid_dpd_to_bid32 (

UINT32 px);

FLOATING-POINT EXCEPTIONS: none

FUNCTION: Convert a 64-bit decimal floating-point value encoded in DPD format

to the same value encoded in BID format

PROTOTYPE:

UINT64 __bid_dpd_to_bid64 (

UINT64 px);

FLOATING-POINT EXCEPTIONS: none

FUNCTION: Convert a 128-bit decimal floating-point value encoded in DPD format

to the same value encoded in BID format

PROTOTYPE:

UINT128 __bid_dpd_to_bid128 (

UINT128 px);

FLOATING-POINT EXCEPTIONS: none

FUNCTION: Decimal floating-point addition, UINT64 + UINT64 -> UINT128

PROTOTYPE:

UINT128 __bid128dd_add (

UINT64 x, UINT64 y, _IDEC_round rnd_mode, _IDEC_flags *pfpsf);

FLOATING-POINT EXCEPTIONS: P, U, O, I

FUNCTION: Decimal floating-point addition, UINT64 + UINT128 -> UINT128

PROTOTYPE:

UINT128 __bid128dq_add (

UINT64 x, UINT128 y, _IDEC_round rnd_mode, _IDEC_flags *pfpsf);

FLOATING-POINT EXCEPTIONS: P, U, O, I

FUNCTION: Decimal floating-point addition, UINT128 + UINT64 -> UINT128

PROTOTYPE:

UINT128 __bid128qd_add (

UINT128 x, UINT64 y, _IDEC_round rnd_mode, _IDEC_flags *pfpsf);

FLOATING-POINT EXCEPTIONS: P, U, O, I

FUNCTION: Decimal floating-point addition, UINT128 + UINT128 -> UINT128

PROTOTYPE:

UINT128 __bid128_add (

UINT128 x, UINT128 y, _IDEC_round rnd_mode, _IDEC_flags *pfpsf);

FLOATING-POINT EXCEPTIONS: P, U, O, I

FUNCTION: Decimal floating-point subtraction, UINT64 - UINT64 -> UINT128

PROTOTYPE:

UINT128 __bid128dd_sub (

UINT64 x, UINT64 y, _IDEC_round rnd_mode, _IDEC_flags *pfpsf);

FLOATING-POINT EXCEPTIONS: P, U, O, I

FUNCTION: Decimal floating-point subtraction, UINT64 - UINT128 -> UINT128

PROTOTYPE:

UINT128 __bid128dq_sub (