Lines Matching +full:high +full:- +full:z
4 * This version hacked for use with gcc -msoft-float by bjh21.
12 * SOFTFLOAT_FOR_GCC - build only those functions necessary for GCC (with
13 * -msoft-float) to work. Include "softfloat-for-gcc.h" to get them
19 * is defined to be a 64-bit integer rather than a structure. The
27 This C source file is part of the SoftFloat IEC/IEEE Floating-Point
33 National Science Foundation under grant MIP-9311980. The original version
34 of this code was written as part of a project to build a fixed-point vector
55 #include "softfloat-for-gcc.h"
73 -------------------------------------------------------------------------------
74 Floating-point rounding mode and exception flags.
75 -------------------------------------------------------------------------------
81 -------------------------------------------------------------------------------
82 Primitive arithmetic functions, including multi-word arithmetic, and
85 -------------------------------------------------------------------------------
87 #include "softfloat-macros"
90 -------------------------------------------------------------------------------
95 are propagated from function inputs to output. These details are target-
97 -------------------------------------------------------------------------------
99 #include "softfloat-specialize"
102 -------------------------------------------------------------------------------
103 Returns the fraction bits of the single-precision floating-point value `a'.
104 -------------------------------------------------------------------------------
114 -------------------------------------------------------------------------------
115 Returns the exponent bits of the single-precision floating-point value `a'.
116 -------------------------------------------------------------------------------
126 -------------------------------------------------------------------------------
127 Returns the sign bit of the single-precision floating-point value `a'.
128 -------------------------------------------------------------------------------
138 -------------------------------------------------------------------------------
139 Normalizes the subnormal single-precision floating-point value represented
143 -------------------------------------------------------------------------------
150 shiftCount = countLeadingZeros32( aSig ) - 8; in normalizeFloat32Subnormal()
152 *zExpPtr = 1 - shiftCount; in normalizeFloat32Subnormal()
157 -------------------------------------------------------------------------------
159 single-precision floating-point value, returning the result. After being
166 -------------------------------------------------------------------------------
176 -------------------------------------------------------------------------------
177 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
178 and significand `zSig', and returns the proper single-precision floating-
180 value is simply rounded and packed into the single-precision format, with
186 the abstract input cannot be represented exactly as a subnormal single-
187 precision floating-point number.
193 normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.
195 Binary Floating-Point Arithmetic.
196 -------------------------------------------------------------------------------
229 return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 ); in roundAndPackFloat32()
234 || ( zExp < -1 ) in roundAndPackFloat32()
236 shift32RightJamming( zSig, - zExp, &zSig ); in roundAndPackFloat32()
251 -------------------------------------------------------------------------------
252 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
253 and significand `zSig', and returns the proper single-precision floating-
257 floating-point exponent.
258 -------------------------------------------------------------------------------
265 shiftCount = countLeadingZeros32( zSig ) - 1; in normalizeRoundAndPackFloat32()
266 return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount ); in normalizeRoundAndPackFloat32()
271 -------------------------------------------------------------------------------
272 Returns the least-significant 32 fraction bits of the double-precision
273 floating-point value `a'.
274 -------------------------------------------------------------------------------
284 -------------------------------------------------------------------------------
285 Returns the most-significant 20 fraction bits of the double-precision
286 floating-point value `a'.
287 -------------------------------------------------------------------------------
297 -------------------------------------------------------------------------------
298 Returns the exponent bits of the double-precision floating-point value `a'.
299 -------------------------------------------------------------------------------
309 -------------------------------------------------------------------------------
310 Returns the sign bit of the double-precision floating-point value `a'.
311 -------------------------------------------------------------------------------
321 -------------------------------------------------------------------------------
322 Normalizes the subnormal double-precision floating-point value represented
329 -------------------------------------------------------------------------------
343 shiftCount = countLeadingZeros32( aSig1 ) - 11; in normalizeFloat64Subnormal()
345 *zSig0Ptr = aSig1>>( - shiftCount ); in normalizeFloat64Subnormal()
352 *zExpPtr = - shiftCount - 31; in normalizeFloat64Subnormal()
355 shiftCount = countLeadingZeros32( aSig0 ) - 11; in normalizeFloat64Subnormal()
357 *zExpPtr = 1 - shiftCount; in normalizeFloat64Subnormal()
363 -------------------------------------------------------------------------------
365 the concatenation of `zSig0' and `zSig1' into a double-precision floating-
373 -------------------------------------------------------------------------------
387 -------------------------------------------------------------------------------
388 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
390 and `zSig2', and returns the proper double-precision floating-point value
392 simply rounded and packed into the double-precision format, with the inexact
398 abstract input cannot be represented exactly as a subnormal double-precision
399 floating-point number.
404 than the ``true'' floating-point exponent. The handling of underflow and
405 overflow follows the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
406 -------------------------------------------------------------------------------
450 || ( zExp < -1 ) in roundAndPackFloat64()
454 zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 ); in roundAndPackFloat64()
483 -------------------------------------------------------------------------------
484 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
486 returns the proper double-precision floating-point value corresponding
489 normalized. In all cases, `zExp' must be 1 less than the ``true'' floating-
491 -------------------------------------------------------------------------------
503 zExp -= 32; in normalizeRoundAndPackFloat64()
505 shiftCount = countLeadingZeros32( zSig0 ) - 11; in normalizeRoundAndPackFloat64()
512 zSig0, zSig1, 0, - shiftCount, &zSig0, &zSig1, &zSig2 ); in normalizeRoundAndPackFloat64()
514 zExp -= shiftCount; in normalizeRoundAndPackFloat64()
520 -------------------------------------------------------------------------------
521 Returns the result of converting the 32-bit two's complement integer `a' to
522 the single-precision floating-point format. The conversion is performed
523 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
524 -------------------------------------------------------------------------------
533 return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a ); in int32_to_float32()
538 -------------------------------------------------------------------------------
539 Returns the result of converting the 32-bit two's complement integer `a' to
540 the double-precision floating-point format. The conversion is performed
541 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
542 -------------------------------------------------------------------------------
553 absA = zSign ? - a : a; in int32_to_float64()
554 shiftCount = countLeadingZeros32( absA ) - 11; in int32_to_float64()
560 shift64Right( absA, 0, - shiftCount, &zSig0, &zSig1 ); in int32_to_float64()
562 return packFloat64( zSign, 0x412 - shiftCount, zSig0, zSig1 ); in int32_to_float64()
568 -------------------------------------------------------------------------------
569 Returns the result of converting the single-precision floating-point value
570 `a' to the 32-bit two's complement integer format. The conversion is
571 performed according to the IEC/IEEE Standard for Binary Floating-Point
572 Arithmetic---which means in particular that the conversion is rounded
576 -------------------------------------------------------------------------------
583 int32 z; in float32_to_int32() local
589 shiftCount = aExp - 0x96; in float32_to_int32()
600 z = ( aSig | 0x00800000 )<<shiftCount; in float32_to_int32()
601 if ( aSign ) z = - z; in float32_to_int32()
606 z = 0; in float32_to_int32()
611 z = aSig>>( - shiftCount ); in float32_to_int32()
617 ++z; in float32_to_int32()
618 if ( (bits32) ( aSigExtra<<1 ) == 0 ) z &= ~1; in float32_to_int32()
620 if ( aSign ) z = - z; in float32_to_int32()
625 z += ( roundingMode == float_round_down ) & aSigExtra; in float32_to_int32()
626 z = - z; in float32_to_int32()
629 z += ( roundingMode == float_round_up ) & aSigExtra; in float32_to_int32()
633 return z; in float32_to_int32()
639 -------------------------------------------------------------------------------
640 Returns the result of converting the single-precision floating-point value
641 `a' to the 32-bit two's complement integer format. The conversion is
642 performed according to the IEC/IEEE Standard for Binary Floating-Point
647 -------------------------------------------------------------------------------
654 int32 z; in float32_to_int32_round_to_zero() local
659 shiftCount = aExp - 0x9E; in float32_to_int32_round_to_zero()
672 z = aSig>>( - shiftCount ); in float32_to_int32_round_to_zero()
676 if ( aSign ) z = - z; in float32_to_int32_round_to_zero()
677 return z; in float32_to_int32_round_to_zero()
682 -------------------------------------------------------------------------------
683 Returns the result of converting the single-precision floating-point value
684 `a' to the double-precision floating-point format. The conversion is
685 performed according to the IEC/IEEE Standard for Binary Floating-Point
687 -------------------------------------------------------------------------------
705 --aExp; in float32_to_float64()
714 -------------------------------------------------------------------------------
715 Rounds the single-precision floating-point value `a' to an integer,
716 and returns the result as a single-precision floating-point value. The
718 Floating-Point Arithmetic.
719 -------------------------------------------------------------------------------
727 float32 z; in float32_round_to_int() local
756 lastBitMask <<= 0x96 - aExp; in float32_round_to_int()
757 roundBitsMask = lastBitMask - 1; in float32_round_to_int()
758 z = a; in float32_round_to_int()
761 z += lastBitMask>>1; in float32_round_to_int()
762 if ( ( z & roundBitsMask ) == 0 ) z &= ~ lastBitMask; in float32_round_to_int()
765 if ( extractFloat32Sign( z ) ^ ( roundingMode == float_round_up ) ) { in float32_round_to_int()
766 z += roundBitsMask; in float32_round_to_int()
769 z &= ~ roundBitsMask; in float32_round_to_int()
770 if ( z != a ) float_exception_flags |= float_flag_inexact; in float32_round_to_int()
771 return z; in float32_round_to_int()
777 -------------------------------------------------------------------------------
778 Returns the result of adding the absolute values of the single-precision
779 floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
782 Floating-Point Arithmetic.
783 -------------------------------------------------------------------------------
795 expDiff = aExp - bExp; in addFloat32Sigs()
804 --expDiff; in addFloat32Sigs()
823 shift32RightJamming( aSig, - expDiff, &aSig ); in addFloat32Sigs()
838 --zExp; in addFloat32Sigs()
849 -------------------------------------------------------------------------------
850 Returns the result of subtracting the absolute values of the single-
851 precision floating-point values `a' and `b'. If `zSign' is 1, the
854 Standard for Binary Floating-Point Arithmetic.
855 -------------------------------------------------------------------------------
867 expDiff = aExp - bExp; in subFloat32Sigs()
895 shift32RightJamming( aSig, - expDiff, &aSig ); in subFloat32Sigs()
898 zSig = bSig - aSig; in subFloat32Sigs()
908 --expDiff; in subFloat32Sigs()
916 zSig = aSig - bSig; in subFloat32Sigs()
919 --zExp; in subFloat32Sigs()
925 -------------------------------------------------------------------------------
926 Returns the result of adding the single-precision floating-point values `a'
928 Binary Floating-Point Arithmetic.
929 -------------------------------------------------------------------------------
947 -------------------------------------------------------------------------------
948 Returns the result of subtracting the single-precision floating-point values
950 for Binary Floating-Point Arithmetic.
951 -------------------------------------------------------------------------------
969 -------------------------------------------------------------------------------
970 Returns the result of multiplying the single-precision floating-point values
972 for Binary Floating-Point Arithmetic.
973 -------------------------------------------------------------------------------
1014 zExp = aExp + bExp - 0x7F; in float32_mul()
1021 --zExp; in float32_mul()
1028 -------------------------------------------------------------------------------
1029 Returns the result of dividing the single-precision floating-point value `a'
1031 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1032 -------------------------------------------------------------------------------
1075 zExp = aExp - bExp + 0x7D; in float32_div()
1087 --zSig; in float32_div()
1098 -------------------------------------------------------------------------------
1099 Returns the remainder of the single-precision floating-point value `a'
1101 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1102 -------------------------------------------------------------------------------
1139 expDiff = aExp - bExp; in float32_rem()
1143 if ( expDiff < -1 ) return a; in float32_rem()
1147 if ( q ) aSig -= bSig; in float32_rem()
1148 expDiff -= 32; in float32_rem()
1151 q = ( 2 < q ) ? q - 2 : 0; in float32_rem()
1152 aSig = - ( ( bSig>>2 ) * q ); in float32_rem()
1153 expDiff -= 30; in float32_rem()
1158 q = ( 2 < q ) ? q - 2 : 0; in float32_rem()
1159 q >>= 32 - expDiff; in float32_rem()
1161 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q; in float32_rem()
1170 aSig -= bSig; in float32_rem()
1177 if ( zSign ) aSig = - aSig; in float32_rem()
1185 -------------------------------------------------------------------------------
1186 Returns the square root of the single-precision floating-point value `a'.
1188 Floating-Point Arithmetic.
1189 -------------------------------------------------------------------------------
1215 zExp = ( ( aExp - 0x7F )>>1 ) + 0x7E; in float32_sqrt()
1228 --zSig; in float32_sqrt()
1244 -------------------------------------------------------------------------------
1245 Returns 1 if the single-precision floating-point value `a' is equal to
1247 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1248 -------------------------------------------------------------------------------
1266 -------------------------------------------------------------------------------
1267 Returns 1 if the single-precision floating-point value `a' is less than
1269 is performed according to the IEC/IEEE Standard for Binary Floating-Point
1271 -------------------------------------------------------------------------------
1291 -------------------------------------------------------------------------------
1292 Returns 1 if the single-precision floating-point value `a' is less than
1294 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1295 -------------------------------------------------------------------------------
1316 -------------------------------------------------------------------------------
1317 Returns 1 if the single-precision floating-point value `a' is equal to
1320 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1321 -------------------------------------------------------------------------------
1337 -------------------------------------------------------------------------------
1338 Returns 1 if the single-precision floating-point value `a' is less than or
1341 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1342 -------------------------------------------------------------------------------
1365 -------------------------------------------------------------------------------
1366 Returns 1 if the single-precision floating-point value `a' is less than
1369 Standard for Binary Floating-Point Arithmetic.
1370 -------------------------------------------------------------------------------
1394 -------------------------------------------------------------------------------
1395 Returns the result of converting the double-precision floating-point value
1396 `a' to the 32-bit two's complement integer format. The conversion is
1397 performed according to the IEC/IEEE Standard for Binary Floating-Point
1398 Arithmetic---which means in particular that the conversion is rounded
1402 -------------------------------------------------------------------------------
1409 int32 z; in float64_to_int32() local
1416 shiftCount = aExp - 0x413; in float64_to_int32()
1435 absZ = aSig0>>( - shiftCount ); in float64_to_int32()
1444 z = aSign ? - absZ : absZ; in float64_to_int32()
1449 z = - ( absZ in float64_to_int32()
1453 z = absZ + ( ( roundingMode == float_round_up ) & aSigExtra ); in float64_to_int32()
1456 if ( ( aSign ^ ( z < 0 ) ) && z ) { in float64_to_int32()
1462 return z; in float64_to_int32()
1468 -------------------------------------------------------------------------------
1469 Returns the result of converting the double-precision floating-point value
1470 `a' to the 32-bit two's complement integer format. The conversion is
1471 performed according to the IEC/IEEE Standard for Binary Floating-Point
1476 -------------------------------------------------------------------------------
1483 int32 z; in float64_to_int32_round_to_zero() local
1489 shiftCount = aExp - 0x413; in float64_to_int32_round_to_zero()
1507 absZ = aSig0>>( - shiftCount ); in float64_to_int32_round_to_zero()
1509 z = aSign ? - absZ : absZ; in float64_to_int32_round_to_zero()
1510 if ( ( aSign ^ ( z < 0 ) ) && z ) { in float64_to_int32_round_to_zero()
1516 return z; in float64_to_int32_round_to_zero()
1521 -------------------------------------------------------------------------------
1522 Returns the result of converting the double-precision floating-point value
1523 `a' to the single-precision floating-point format. The conversion is
1524 performed according to the IEC/IEEE Standard for Binary Floating-Point
1526 -------------------------------------------------------------------------------
1547 return roundAndPackFloat32( aSign, aExp - 0x381, zSig ); in float64_to_float32()
1553 -------------------------------------------------------------------------------
1554 Rounds the double-precision floating-point value `a' to an integer,
1555 and returns the result as a double-precision floating-point value. The
1557 Floating-Point Arithmetic.
1558 -------------------------------------------------------------------------------
1566 float64 z; in float64_round_to_int() local
1578 lastBitMask = ( lastBitMask<<( 0x432 - aExp ) )<<1; in float64_round_to_int()
1579 roundBitsMask = lastBitMask - 1; in float64_round_to_int()
1580 z = a; in float64_round_to_int()
1584 add64( z.high, z.low, 0, lastBitMask>>1, &z.high, &z.low ); in float64_round_to_int()
1585 if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask; in float64_round_to_int()
1588 if ( (sbits32) z.low < 0 ) { in float64_round_to_int()
1589 ++z.high; in float64_round_to_int()
1590 if ( (bits32) ( z.low<<1 ) == 0 ) z.high &= ~1; in float64_round_to_int()
1595 if ( extractFloat64Sign( z ) in float64_round_to_int()
1597 add64( z.high, z.low, 0, roundBitsMask, &z.high, &z.low ); in float64_round_to_int()
1600 z.low &= ~ roundBitsMask; in float64_round_to_int()
1604 if ( ( ( (bits32) ( a.high<<1 ) ) | a.low ) == 0 ) return a; in float64_round_to_int()
1627 lastBitMask <<= 0x413 - aExp; in float64_round_to_int()
1628 roundBitsMask = lastBitMask - 1; in float64_round_to_int()
1629 z.low = 0; in float64_round_to_int()
1630 z.high = a.high; in float64_round_to_int()
1633 z.high += lastBitMask>>1; in float64_round_to_int()
1634 if ( ( ( z.high & roundBitsMask ) | a.low ) == 0 ) { in float64_round_to_int()
1635 z.high &= ~ lastBitMask; in float64_round_to_int()
1639 if ( extractFloat64Sign( z ) in float64_round_to_int()
1641 z.high |= ( a.low != 0 ); in float64_round_to_int()
1642 z.high += roundBitsMask; in float64_round_to_int()
1645 z.high &= ~ roundBitsMask; in float64_round_to_int()
1647 if ( ( z.low != a.low ) || ( z.high != a.high ) ) { in float64_round_to_int()
1650 return z; in float64_round_to_int()
1656 -------------------------------------------------------------------------------
1657 Returns the result of adding the absolute values of the double-precision
1658 floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
1661 Floating-Point Arithmetic.
1662 -------------------------------------------------------------------------------
1676 expDiff = aExp - bExp; in addFloat64Sigs()
1683 --expDiff; in addFloat64Sigs()
1704 aSig0, aSig1, 0, - expDiff, &aSig0, &aSig1, &zSig2 ); in addFloat64Sigs()
1723 --zExp; in addFloat64Sigs()
1734 -------------------------------------------------------------------------------
1735 Returns the result of subtracting the absolute values of the double-
1736 precision floating-point values `a' and `b'. If `zSign' is 1, the
1739 Standard for Binary Floating-Point Arithmetic.
1740 -------------------------------------------------------------------------------
1754 expDiff = aExp - bExp; in subFloat64Sigs()
1786 shift64RightJamming( aSig0, aSig1, - expDiff, &aSig0, &aSig1 ); in subFloat64Sigs()
1799 --expDiff; in subFloat64Sigs()
1810 --zExp; in subFloat64Sigs()
1811 return normalizeRoundAndPackFloat64( zSign, zExp - 10, zSig0, zSig1 ); in subFloat64Sigs()
1816 -------------------------------------------------------------------------------
1817 Returns the result of adding the double-precision floating-point values `a'
1819 Binary Floating-Point Arithmetic.
1820 -------------------------------------------------------------------------------
1838 -------------------------------------------------------------------------------
1839 Returns the result of subtracting the double-precision floating-point values
1841 for Binary Floating-Point Arithmetic.
1842 -------------------------------------------------------------------------------
1860 -------------------------------------------------------------------------------
1861 Returns the result of multiplying the double-precision floating-point values
1863 for Binary Floating-Point Arithmetic.
1864 -------------------------------------------------------------------------------
1906 zExp = aExp + bExp - 0x400; in float64_mul()
1922 -------------------------------------------------------------------------------
1923 Returns the result of dividing the double-precision floating-point value `a'
1925 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
1926 -------------------------------------------------------------------------------
1972 zExp = aExp - bExp + 0x3FD; in float64_div()
1983 --zSig0; in float64_div()
1991 --zSig1; in float64_div()
2003 -------------------------------------------------------------------------------
2004 Returns the remainder of the double-precision floating-point value `a'
2006 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2007 -------------------------------------------------------------------------------
2016 float64 z; in float64_rem() local
2049 expDiff = aExp - bExp; in float64_rem()
2050 if ( expDiff < -1 ) return a; in float64_rem()
2052 aSig0 | 0x00100000, aSig1, 11 - ( expDiff < 0 ), &aSig0, &aSig1 ); in float64_rem()
2056 expDiff -= 32; in float64_rem()
2059 q = ( 4 < q ) ? q - 4 : 0; in float64_rem()
2064 expDiff -= 29; in float64_rem()
2066 if ( -32 < expDiff ) { in float64_rem()
2068 q = ( 4 < q ) ? q - 4 : 0; in float64_rem()
2069 q >>= - expDiff; in float64_rem()
2073 shift64Right( aSig0, aSig1, - expDiff, &aSig0, &aSig1 ); in float64_rem()
2101 normalizeRoundAndPackFloat64( aSign ^ zSign, bExp - 4, aSig0, aSig1 ); in float64_rem()
2108 -------------------------------------------------------------------------------
2109 Returns the square root of the double-precision floating-point value `a'.
2111 Floating-Point Arithmetic.
2112 -------------------------------------------------------------------------------
2120 float64 z; in float64_sqrt() local
2141 zExp = ( ( aExp - 0x3FF )>>1 ) + 0x3FE; in float64_sqrt()
2147 shortShift64Left( aSig0, aSig1, 9 - ( aExp & 1 ), &aSig0, &aSig1 ); in float64_sqrt()
2151 --zSig0; in float64_sqrt()
2152 doubleZSig0 -= 2; in float64_sqrt()
2163 --zSig1; in float64_sqrt()
2178 -------------------------------------------------------------------------------
2179 Returns 1 if the double-precision floating-point value `a' is equal to
2181 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2182 -------------------------------------------------------------------------------
2203 -------------------------------------------------------------------------------
2204 Returns 1 if the double-precision floating-point value `a' is less than
2206 is performed according to the IEC/IEEE Standard for Binary Floating-Point
2208 -------------------------------------------------------------------------------
2233 -------------------------------------------------------------------------------
2234 Returns 1 if the double-precision floating-point value `a' is less than
2236 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2237 -------------------------------------------------------------------------------
2264 -------------------------------------------------------------------------------
2265 Returns 1 if the double-precision floating-point value `a' is equal to
2268 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2269 -------------------------------------------------------------------------------
2287 -------------------------------------------------------------------------------
2288 Returns 1 if the double-precision floating-point value `a' is less than or
2291 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2292 -------------------------------------------------------------------------------
2316 -------------------------------------------------------------------------------
2317 Returns 1 if the double-precision floating-point value `a' is less than
2320 Standard for Binary Floating-Point Arithmetic.
2321 -------------------------------------------------------------------------------