Lines Matching refs:zSig
159 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
162 together to form the result. This means that any integer portion of `zSig'
165 than the desired result exponent whenever `zSig' is a complete, normalized
169 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
171 return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
177 and significand `zSig', and returns the proper single-precision floating-
187 The input significand `zSig' has its binary point between bits 30
189 significand must be normalized or smaller. If `zSig' is not normalized,
191 and it must not require rounding. In the usual case that `zSig' is
197 static float32 roundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
221 roundBits = zSig & 0x7F;
225 && ( (sbits32) ( zSig + roundIncrement ) < 0 ) )
234 || ( zSig + roundIncrement < 0x80000000 );
235 shift32RightJamming( zSig, - zExp, &zSig );
237 roundBits = zSig & 0x7F;
242 zSig = ( zSig + roundIncrement )>>7;
243 zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
244 if ( zSig == 0 ) zExp = 0;
245 return packFloat32( zSign, zExp, zSig );
252 and significand `zSig', and returns the proper single-precision floating-
254 `roundAndPackFloat32' except that `zSig' does not have to be normalized in
260 normalizeRoundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
264 shiftCount = countLeadingZeros32( zSig ) - 1;
265 return roundAndPackFloat32( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
320 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
323 together to form the result. This means that any integer portion of `zSig'
326 than the desired result exponent whenever `zSig' is a complete, normalized
330 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
333 return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;
340 and significand `zSig', and returns the proper double-precision floating-
350 The input significand `zSig' has its binary point between bits 62
352 significand must be normalized or smaller. If `zSig' is not normalized,
354 and it must not require rounding. In the usual case that `zSig' is
360 static float64 roundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
384 roundBits = zSig & 0x3FF;
388 && ( (sbits64) ( zSig + roundIncrement ) < 0 ) )
399 || ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );
400 shift64RightJamming( zSig, - zExp, &zSig );
402 roundBits = zSig & 0x3FF;
407 zSig = ( zSig + roundIncrement )>>10;
408 zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );
409 if ( zSig == 0 ) zExp = 0;
410 return packFloat64( zSign, zExp, zSig );
417 and significand `zSig', and returns the proper double-precision floating-
419 `roundAndPackFloat64' except that `zSig' does not have to be normalized in
425 normalizeRoundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
429 shiftCount = countLeadingZeros64( zSig ) - 1;
430 return roundAndPackFloat64( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
496 Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
500 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
504 z.low = zSig;
757 bits64 zSig;
763 zSig = absA;
764 return packFloat64( aSign, 0x432 - shiftCount, zSig<<shiftCount );
783 bits64 zSig;
789 zSig = absA;
790 return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
812 bits64 zSig;
820 zSig = aSig;
821 zSig <<= 32;
822 if ( 0 < shiftCount ) shift64RightJamming( zSig, shiftCount, &zSig );
823 return roundAndPackInt32( roundData, aSign, zSig );
1004 bits32 aSig, bSig, zSig;
1048 zSig = 0x40000000 + aSig + bSig;
1053 zSig = ( aSig + bSig )<<1;
1055 if ( (sbits32) zSig < 0 ) {
1056 zSig = aSig + bSig;
1060 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1076 bits32 aSig, bSig, zSig;
1114 zSig = bSig - aSig;
1132 zSig = aSig - bSig;
1136 return normalizeRoundAndPackFloat32( roundData, zSign, zExp, zSig );
1197 bits32 zSig;
1236 zSig = zSig64;
1237 if ( 0 <= (sbits32) ( zSig<<1 ) ) {
1238 zSig <<= 1;
1241 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1256 bits32 aSig, bSig, zSig;
1303 zSig = tmp;
1305 if ( ( zSig & 0x3F ) == 0 ) {
1306 zSig |= ( ( (bits64) bSig ) * zSig != ( (bits64) aSig )<<32 );
1308 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1426 bits32 aSig, zSig;
1449 zSig = estimateSqrt32( aExp, aSig ) + 2;
1450 if ( ( zSig & 0x7F ) <= 5 ) {
1451 if ( zSig < 2 ) {
1452 zSig = 0xFFFFFFFF;
1456 term = ( (bits64) zSig ) * zSig;
1459 --zSig;
1460 rem += ( ( (bits64) zSig )<<1 ) | 1;
1462 zSig |= ( rem != 0 );
1465 shift32RightJamming( zSig, 1, &zSig );
1466 return roundAndPackFloat32( roundData, 0, zExp, zSig );
1773 bits32 zSig;
1783 zSig = aSig;
1784 if ( aExp || zSig ) {
1785 zSig |= 0x40000000;
1788 return roundAndPackFloat32( roundData, aSign, aExp, zSig );
1900 bits64 aSig, bSig, zSig;
1944 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
1949 zSig = ( aSig + bSig )<<1;
1951 if ( (sbits64) zSig < 0 ) {
1952 zSig = aSig + bSig;
1956 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
1972 bits64 aSig, bSig, zSig;
2010 zSig = bSig - aSig;
2028 zSig = aSig - bSig;
2032 return normalizeRoundAndPackFloat64( roundData, zSign, zExp, zSig );
2150 bits64 aSig, bSig, zSig;
2196 zSig = estimateDiv128To64( aSig, 0, bSig );
2197 if ( ( zSig & 0x1FF ) <= 2 ) {
2198 mul64To128( bSig, zSig, &term0, &term1 );
2201 --zSig;
2204 zSig |= ( rem1 != 0 );
2206 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
2307 bits64 aSig, zSig;
2331 zSig = estimateSqrt32( aExp, aSig>>21 );
2332 zSig <<= 31;
2334 zSig = estimateDiv128To64( aSig, 0, zSig ) + zSig + 2;
2335 if ( ( zSig & 0x3FF ) <= 5 ) {
2336 if ( zSig < 2 ) {
2337 zSig = LIT64( 0xFFFFFFFFFFFFFFFF );
2341 mul64To128( zSig, zSig, &term0, &term1 );
2344 --zSig;
2345 shortShift128Left( 0, zSig, 1, &term0, &term1 );
2349 zSig |= ( ( rem0 | rem1 ) != 0 );
2352 shift64RightJamming( zSig, 1, &zSig );
2353 return roundAndPackFloat64( roundData, 0, zExp, zSig );
2617 bits64 aSig, zSig;
2628 shift64RightJamming( aSig, 1, &zSig );
2630 return roundAndPackFloat64( roundData, aSign, aExp, zSig );