272 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a

277 will have an integer portion equal to 1, the `zExp' input should be 1 less

282 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )

285     return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;

291 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

305 `zExp' must be 0; in that case, the result returned is a subnormal number,

307 normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.

312 static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )

337     if ( 0xFD <= (bits16) zExp ) {

338         if (    ( 0xFD < zExp )

339              || (    ( zExp == 0xFD )

345         if ( zExp < 0 ) {

348                 || ( zExp < -1 )

350             shift32RightJamming( zSig, - zExp, &zSig );

351             zExp = 0;

359     if ( zSig == 0 ) zExp = 0;

360     return packFloat32( zSign, zExp, zSig );

366 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

370 Bit 31 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''

375  normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )

380     return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount );

441 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a

446 will have an integer portion equal to 1, the `zExp' input should be 1 less

451 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )

455                            ( ( (bits64) zExp )<<52 ) + zSig );

461 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

475 `zExp' must be 0; in that case, the result returned is a subnormal number,

477 normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.

482 static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )

507     if ( 0x7FD <= (bits16) zExp ) {

508         if (    ( 0x7FD < zExp )

509              || (    ( zExp == 0x7FD )

517         if ( zExp < 0 ) {

520                 || ( zExp < -1 )

522             shift64RightJamming( zSig, - zExp, &zSig );

523             zExp = 0;

531     if ( zSig == 0 ) zExp = 0;

532     return packFloat64( zSign, zExp, zSig );

538 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

542 Bit 63 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''

547  normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )

552     return roundAndPackFloat64( zSign, zExp - shiftCount, zSig<<shiftCount );

618 Packs the sign `zSign', exponent `zExp', and significand `zSig' into an

622 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )

627     z.high = ( ( (bits16) zSign )<<15 ) + zExp;

634 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

651 significand is not normalized, `zExp' must be 0; in that case, the result

659      int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1

696     if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) {

697         if (    ( 0x7FFE < zExp )

698              || ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) )

702         if ( zExp <= 0 ) {

705                 || ( zExp < 0 )

707             shift64RightJamming( zSig0, 1 - zExp, &zSig0 );

708             zExp = 0;

713             if ( (sbits64) zSig0 < 0 ) zExp = 1;

719             return packFloatx80( zSign, zExp, zSig0 );

725         ++zExp;

733     if ( zSig0 == 0 ) zExp = 0;

734     return packFloatx80( zSign, zExp, zSig0 );

750     if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) {

751         if (    ( 0x7FFE < zExp )

752              || (    ( zExp == 0x7FFE )

768         if ( zExp <= 0 ) {

771                 || ( zExp < 0 )

774             shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 );

775             zExp = 0;

793                 if ( (sbits64) zSig0 < 0 ) zExp = 1;

795             return packFloatx80( zSign, zExp, zSig0 );

802             ++zExp;

810         if ( zSig0 == 0 ) zExp = 0;

812     return packFloatx80( zSign, zExp, zSig0 );

819 `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',

828      int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1

836         zExp -= 64;

840     zExp -= shiftCount;

842         roundAndPackFloatx80( roundingPrecision, zSign, zExp, zSig0, zSig1 );

945 Packs the sign `zSign', the exponent `zExp', and the significand formed

948 proper positions, the three fields `zSign', `zExp', and `zSig0' are simply

952 to 1, the `zExp' input should be 1 less than the desired result exponent

958  packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )

963     z.high = ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + zSig0;

970 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

983 significand is not normalized, `zExp' must be 0; in that case, the result

985 usual case that the input significand is normalized, `zExp' must be 1 less

992      flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 )

1013     if ( 0x7FFD <= (bits32) zExp ) {

1014         if (    ( 0x7FFD < zExp )

1015              || (    ( zExp == 0x7FFD )

1040         if ( zExp < 0 ) {

1043                 || ( zExp < -1 )

1052                 zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 );

1053             zExp = 0;

1074         if ( ( zSig0 | zSig1 ) == 0 ) zExp = 0;

1076     return packFloat128( zSign, zExp, zSig0, zSig1 );

1082 Takes an abstract floating-point value having sign `zSign', exponent `zExp',

1087 normalized.  In all cases, `zExp' must be 1 less than the ``true'' floating-

1093      flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )

1101         zExp -= 64;

1112     zExp -= shiftCount;

1113     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );

1353     int32 zExp;

1360     zExp = 0x406E - shiftCount;

1371     return packFloat128( zSign, zExp, zSig0, zSig1 );

1712     int16 aExp, bExp, zExp;

1735         zExp = aExp;

1749         zExp = bExp;

1758         zExp = aExp;

1763     --zExp;

1766         ++zExp;

1769     return roundAndPackFloat32( zSign, zExp, zSig );

1784     int16 aExp, bExp, zExp;

1824     zExp = bExp;

1842     zExp = aExp;

1844     --zExp;

1845     return normalizeRoundAndPackFloat32( zSign, zExp, zSig );

1903     int16 aExp, bExp, zExp;

1941     zExp = aExp + bExp - 0x7F;

1948         --zExp;

1950     return roundAndPackFloat32( zSign, zExp, zSig );

1964     int16 aExp, bExp, zExp;

2002     zExp = aExp - bExp + 0x7D;

2007         ++zExp;

2013     return roundAndPackFloat32( zSign, zExp, zSig );

2131     int16 aExp, zExp;

2153     zExp = ( ( aExp - 0x7F )>>1 ) + 0x7E;

2172     return roundAndPackFloat32( 0, zExp, zSig );

2678     int16 aExp, bExp, zExp;

2701         zExp = aExp;

2715         zExp = bExp;

2724         zExp = aExp;

2729     --zExp;

2732         ++zExp;

2735     return roundAndPackFloat64( zSign, zExp, zSig );

2750     int16 aExp, bExp, zExp;

2790     zExp = bExp;

2808     zExp = aExp;

2810     --zExp;

2811     return normalizeRoundAndPackFloat64( zSign, zExp, zSig );

2869     int16 aExp, bExp, zExp;

2905     zExp = aExp + bExp - 0x3FF;

2912         --zExp;

2914     return roundAndPackFloat64( zSign, zExp, zSig0 );

2928     int16 aExp, bExp, zExp;

2968     zExp = aExp - bExp + 0x3FD;

2973         ++zExp;

2985     return roundAndPackFloat64( zSign, zExp, zSig );

3086     int16 aExp, zExp;

3108     zExp = ( ( aExp - 0x3FF )>>1 ) + 0x3FE;

3124     return roundAndPackFloat64( 0, zExp, zSig );

3622     int32 aExp, bExp, zExp;

3638         zExp = aExp;

3647         zExp = bExp;

3659             normalizeFloatx80Subnormal( zSig0, &zExp, &zSig0 );

3662         zExp = aExp;

3670     ++zExp;

3674             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );

3689     int32 aExp, bExp, zExp;

3727     zExp = bExp;

3739     zExp = aExp;

3743             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );

3801     int32 aExp, bExp, zExp;

3839     zExp = aExp + bExp - 0x3FFE;

3843         --zExp;

3847             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );

3861     int32 aExp, bExp, zExp;

3903     zExp = aExp - bExp + 0x3FFE;

3907         ++zExp;

3928             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );

4040     int32 aExp, zExp;

4065     zExp = ( ( aExp - 0x3FFF )>>1 ) + 0x3FFF;

4097             floatx80_rounding_precision, 0, zExp, zSig0, zSig1 );

4771     int32 aExp, bExp, zExp;

4795         zExp = aExp;

4810         zExp = bExp;

4823         zExp = aExp;

4828     --zExp;

4830     ++zExp;

4835     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );

4850     int32 aExp, bExp, zExp;

4899     zExp = bExp;

4917     zExp = aExp;

4919     --zExp;

4920     return normalizeRoundAndPackFloat128( zSign, zExp - 14, zSig0, zSig1 );

4978     int32 aExp, bExp, zExp;

5018     zExp = aExp + bExp - 0x4000;

5027         ++zExp;

5029     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );

5043     int32 aExp, bExp, zExp;

5087     zExp = aExp - bExp + 0x3FFD;

5094         ++zExp;

5114     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );

5238     int32 aExp, zExp;

5264     zExp = (int32) ( (aExp - 0x3FFF) >> 1) + 0x3FFE;

5294     return roundAndPackFloat128( 0, zExp, zSig0, zSig1, zSig2 );

Indexes created Sun Sep 10 09:05:34 CEST 2017