Lines Matching defs:aSig
208 | by the denormalized significand `aSig'. The normalized exponent and
214 normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
218 shiftCount = countLeadingZeros32( aSig ) - 8;
219 *zSigPtr = aSig<<shiftCount;
372 | by the denormalized significand `aSig'. The normalized exponent and
378 normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
382 shiftCount = countLeadingZeros64( aSig ) - 11;
383 *zSigPtr = aSig<<shiftCount;
541 | represented by the denormalized significand `aSig'. The normalized exponent
547 normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
551 shiftCount = countLeadingZeros64( aSig );
552 *zSigPtr = aSig<<shiftCount;
1298 bits32 aSig;
1301 aSig = extractFloat32Frac( a );
1304 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1305 if ( aExp ) aSig |= 0x00800000;
1307 aSig64 = aSig;
1328 bits32 aSig;
1331 aSig = extractFloat32Frac( a );
1338 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1343 if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
1346 aSig = ( aSig | 0x00800000 )<<8;
1347 z = aSig>>( - shiftCount );
1348 if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
1370 bits32 aSig;
1373 aSig = extractFloat32Frac( a );
1379 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1384 if ( aExp ) aSig |= 0x00800000;
1385 aSig64 = aSig;
1406 bits32 aSig;
1410 aSig = extractFloat32Frac( a );
1417 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1424 if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
1427 aSig64 = aSig | 0x00800000;
1449 bits32 aSig;
1451 aSig = extractFloat32Frac( a );
1455 if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a STATUS_VAR ));
1459 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1460 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1463 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1480 bits32 aSig;
1482 aSig = extractFloat32Frac( a );
1486 if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a STATUS_VAR ) );
1490 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1491 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1493 aSig |= 0x00800000;
1494 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1513 bits32 aSig;
1515 aSig = extractFloat32Frac( a );
1519 if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a STATUS_VAR ) );
1523 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1524 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1527 return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1603 bits32 aSig, bSig, zSig;
1606 aSig = extractFloat32Frac( a );
1611 aSig <<= 6;
1615 if ( aSig ) return propagateFloat32NaN( a, b STATUS_VAR );
1636 aSig |= 0x20000000;
1638 shift32RightJamming( aSig, - expDiff, &aSig );
1643 if ( aSig | bSig ) return propagateFloat32NaN( a, b STATUS_VAR );
1648 return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1650 zSig = 0x40000000 + aSig + bSig;
1654 aSig |= 0x20000000;
1655 zSig = ( aSig + bSig )<<1;
1658 zSig = aSig + bSig;
1677 bits32 aSig, bSig, zSig;
1680 aSig = extractFloat32Frac( a );
1685 aSig <<= 7;
1690 if ( aSig | bSig ) return propagateFloat32NaN( a, b STATUS_VAR );
1698 if ( bSig < aSig ) goto aBigger;
1699 if ( aSig < bSig ) goto bBigger;
1710 aSig |= 0x40000000;
1712 shift32RightJamming( aSig, - expDiff, &aSig );
1715 zSig = bSig - aSig;
1721 if ( aSig ) return propagateFloat32NaN( a, b STATUS_VAR );
1731 aSig |= 0x40000000;
1733 zSig = aSig - bSig;
1793 bits32 aSig, bSig;
1797 aSig = extractFloat32Frac( a );
1805 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1816 if ( ( aExp | aSig ) == 0 ) {
1823 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1824 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1831 aSig = ( aSig | 0x00800000 )<<7;
1833 shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1853 bits32 aSig, bSig, zSig;
1855 aSig = extractFloat32Frac( a );
1863 if ( aSig ) return propagateFloat32NaN( a, b STATUS_VAR );
1877 if ( ( aExp | aSig ) == 0 ) {
1887 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1888 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1891 aSig = ( aSig | 0x00800000 )<<7;
1893 if ( bSig <= ( aSig + aSig ) ) {
1894 aSig >>= 1;
1897 zSig = ( ( (bits64) aSig )<<32 ) / bSig;
1899 zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
1915 bits32 aSig, bSig;
1921 aSig = extractFloat32Frac( a );
1927 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1945 if ( aSig == 0 ) return a;
1946 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1949 aSig |= 0x00800000;
1952 aSig <<= 8;
1956 aSig >>= 1;
1958 q = ( bSig <= aSig );
1959 if ( q ) aSig -= bSig;
1961 q = ( ( (bits64) aSig )<<32 ) / bSig;
1964 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
1967 aSig >>= 2;
1972 if ( bSig <= aSig ) aSig -= bSig;
1973 aSig64 = ( (bits64) aSig )<<40;
1987 aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
1990 alternateASig = aSig;
1992 aSig -= bSig;
1993 } while ( 0 <= (sbits32) aSig );
1994 sigMean = aSig + alternateASig;
1996 aSig = alternateASig;
1998 zSign = ( (sbits32) aSig < 0 );
1999 if ( zSign ) aSig = - aSig;
2000 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR );
2014 bits32 aSig, zSig;
2017 aSig = extractFloat32Frac( a );
2021 if ( aSig ) return propagateFloat32NaN( a, float32_zero STATUS_VAR );
2027 if ( ( aExp | aSig ) == 0 ) return a;
2032 if ( aSig == 0 ) return float32_zero;
2033 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2036 aSig = ( aSig | 0x00800000 )<<8;
2037 zSig = estimateSqrt32( aExp, aSig ) + 2;
2043 aSig >>= aExp & 1;
2045 rem = ( ( (bits64) aSig )<<32 ) - term;
2099 bits32 aSig;
2103 aSig = extractFloat32Frac( a );
2108 if ( aSig ) return propagateFloat32NaN( a, float32_zero STATUS_VAR );
2112 if (aSig == 0) return float32_one;
2146 bits32 aSig, zSig, i;
2148 aSig = extractFloat32Frac( a );
2153 if ( aSig == 0 ) return packFloat32( 1, 0xFF, 0 );
2154 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2161 if ( aSig ) return propagateFloat32NaN( a, float32_zero STATUS_VAR );
2166 aSig |= 0x00800000;
2171 aSig = ( (bits64)aSig * aSig ) >> 23;
2172 if ( aSig & 0x01000000 ) {
2173 aSig >>= 1;
2354 bits64 aSig;
2356 aSig = extractFloat64Frac( a );
2359 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2360 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2362 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
2363 return roundAndPackInt32( aSign, aSig STATUS_VAR );
2381 bits64 aSig, savedASig;
2384 aSig = extractFloat64Frac( a );
2388 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2392 if ( aExp || aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
2395 aSig |= LIT64( 0x0010000000000000 );
2397 savedASig = aSig;
2398 aSig >>= shiftCount;
2399 z = aSig;
2406 if ( ( aSig<<shiftCount ) != savedASig ) {
2427 bits64 aSig, aSigExtra;
2429 aSig = extractFloat64Frac( a );
2432 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2439 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2446 aSig <<= - shiftCount;
2449 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
2451 return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
2469 bits64 aSig;
2472 aSig = extractFloat64Frac( a );
2475 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2483 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2490 z = aSig<<shiftCount;
2494 if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
2497 z = aSig>>( - shiftCount );
2498 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
2518 bits64 aSig;
2521 aSig = extractFloat64Frac( a );
2525 if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a STATUS_VAR ) );
2528 shift64RightJamming( aSig, 22, &aSig );
2529 zSig = aSig;
2561 bits32 aSig;
2565 aSig = a & 0x3ff;
2568 if (aSig) {
2571 aSig |= 0x200;
2573 return packFloat32(aSign, 0xff, aSig << 13);
2578 if (aSig == 0) {
2582 shiftCount = countLeadingZeros32( aSig ) - 21;
2583 aSig = aSig << shiftCount;
2586 return packFloat32( aSign, aExp + 0x70, aSig << 13);
2593 bits32 aSig;
2598 aSig = extractFloat32Frac( a );
2602 if (aSig) {
2605 aSig |= 0x00400000;
2607 return packFloat16(aSign, 0x1f, aSig >> 13);
2613 aSig |= 0x00800000;
2625 if (aSig & mask) {
2631 if ((aSig & mask) == increment) {
2632 increment = aSig & (increment << 1);
2645 aSig += increment;
2646 if (aSig >= 0x01000000) {
2647 aSig >>= 1;
2670 aSig >>= -14 - aExp;
2673 return packFloat16(aSign, aExp + 14, aSig >> 13);
2689 bits64 aSig;
2691 aSig = extractFloat64Frac( a );
2695 if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a STATUS_VAR ) );
2699 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2700 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2704 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2723 bits64 aSig, zSig0, zSig1;
2725 aSig = extractFloat64Frac( a );
2729 if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a STATUS_VAR ) );
2733 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2734 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2737 shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
2827 bits64 aSig, bSig, zSig;
2830 aSig = extractFloat64Frac( a );
2835 aSig <<= 9;
2839 if ( aSig ) return propagateFloat64NaN( a, b STATUS_VAR );
2860 aSig |= LIT64( 0x2000000000000000 );
2862 shift64RightJamming( aSig, - expDiff, &aSig );
2867 if ( aSig | bSig ) return propagateFloat64NaN( a, b STATUS_VAR );
2872 return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2874 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
2878 aSig |= LIT64( 0x2000000000000000 );
2879 zSig = ( aSig + bSig )<<1;
2882 zSig = aSig + bSig;
2901 bits64 aSig, bSig, zSig;
2904 aSig = extractFloat64Frac( a );
2909 aSig <<= 10;
2914 if ( aSig | bSig ) return propagateFloat64NaN( a, b STATUS_VAR );
2922 if ( bSig < aSig ) goto aBigger;
2923 if ( aSig < bSig ) goto bBigger;
2934 aSig |= LIT64( 0x4000000000000000 );
2936 shift64RightJamming( aSig, - expDiff, &aSig );
2939 zSig = bSig - aSig;
2945 if ( aSig ) return propagateFloat64NaN( a, b STATUS_VAR );
2955 aSig |= LIT64( 0x4000000000000000 );
2957 zSig = aSig - bSig;
3017 bits64 aSig, bSig, zSig0, zSig1;
3019 aSig = extractFloat64Frac( a );
3027 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
3038 if ( ( aExp | aSig ) == 0 ) {
3045 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
3046 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3053 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
3055 mul64To128( aSig, bSig, &zSig0, &zSig1 );
3075 bits64 aSig, bSig, zSig;
3079 aSig = extractFloat64Frac( a );
3087 if ( aSig ) return propagateFloat64NaN( a, b STATUS_VAR );
3101 if ( ( aExp | aSig ) == 0 ) {
3111 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
3112 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3115 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
3117 if ( bSig <= ( aSig + aSig ) ) {
3118 aSig >>= 1;
3121 zSig = estimateDiv128To64( aSig, 0, bSig );
3124 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
3145 bits64 aSig, bSig;
3149 aSig = extractFloat64Frac( a );
3155 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
3173 if ( aSig == 0 ) return a;
3174 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3177 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
3181 aSig >>= 1;
3183 q = ( bSig <= aSig );
3184 if ( q ) aSig -= bSig;
3187 q = estimateDiv128To64( aSig, 0, bSig );
3189 aSig = - ( ( bSig>>2 ) * q );
3194 q = estimateDiv128To64( aSig, 0, bSig );
3198 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
3201 aSig >>= 2;
3205 alternateASig = aSig;
3207 aSig -= bSig;
3208 } while ( 0 <= (sbits64) aSig );
3209 sigMean = aSig + alternateASig;
3211 aSig = alternateASig;
3213 zSign = ( (sbits64) aSig < 0 );
3214 if ( zSign ) aSig = - aSig;
3215 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR );
3229 bits64 aSig, zSig, doubleZSig;
3232 aSig = extractFloat64Frac( a );
3236 if ( aSig ) return propagateFloat64NaN( a, a STATUS_VAR );
3242 if ( ( aExp | aSig ) == 0 ) return a;
3247 if ( aSig == 0 ) return float64_zero;
3248 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3251 aSig |= LIT64( 0x0010000000000000 );
3252 zSig = estimateSqrt32( aExp, aSig>>21 );
3253 aSig <<= 9 - ( aExp & 1 );
3254 zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );
3258 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
3279 bits64 aSig, aSig0, aSig1, zSig, i;
3281 aSig = extractFloat64Frac( a );
3286 if ( aSig == 0 ) return packFloat64( 1, 0x7FF, 0 );
3287 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3294 if ( aSig ) return propagateFloat64NaN( a, float64_zero STATUS_VAR );
3299 aSig |= LIT64( 0x0010000000000000 );
3303 mul64To128( aSig, aSig, &aSig0, &aSig1 );
3304 aSig = ( aSig0 << 12 ) | ( aSig1 >> 52 );
3305 if ( aSig & LIT64( 0x0020000000000000 ) ) {
3306 aSig >>= 1;
3490 bits64 aSig;
3492 aSig = extractFloatx80Frac( a );
3495 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3498 shift64RightJamming( aSig, shiftCount, &aSig );
3499 return roundAndPackInt32( aSign, aSig STATUS_VAR );
3517 bits64 aSig, savedASig;
3520 aSig = extractFloatx80Frac( a );
3524 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3528 if ( aExp || aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
3532 savedASig = aSig;
3533 aSig >>= shiftCount;
3534 z = aSig;
3541 if ( ( aSig<<shiftCount ) != savedASig ) {
3562 bits64 aSig, aSigExtra;
3564 aSig = extractFloatx80Frac( a );
3573 && ( aSig != LIT64( 0x8000000000000000 ) ) )
3582 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
3584 return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
3602 bits64 aSig;
3605 aSig = extractFloatx80Frac( a );
3610 aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
3611 if ( ( a.high != 0xC03E ) || aSig ) {
3613 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3620 if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
3623 z = aSig>>( - shiftCount );
3624 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
3643 bits64 aSig;
3645 aSig = extractFloatx80Frac( a );
3649 if ( (bits64) ( aSig<<1 ) ) {
3654 shift64RightJamming( aSig, 33, &aSig );
3655 if ( aExp || aSig ) aExp -= 0x3F81;
3656 return roundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
3671 bits64 aSig, zSig;
3673 aSig = extractFloatx80Frac( a );
3677 if ( (bits64) ( aSig<<1 ) ) {
3682 shift64RightJamming( aSig, 1, &zSig );
3683 if ( aExp || aSig ) aExp -= 0x3C01;
3701 bits64 aSig, zSig0, zSig1;
3703 aSig = extractFloatx80Frac( a );
3706 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {
3709 shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
3800 bits64 aSig, bSig, zSig0, zSig1;
3803 aSig = extractFloatx80Frac( a );
3810 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
3823 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3828 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3834 zSig0 = aSig + bSig;
3842 zSig0 = aSig + bSig;
3866 bits64 aSig, bSig, zSig0, zSig1;
3870 aSig = extractFloatx80Frac( a );
3878 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3891 if ( bSig < aSig ) goto aBigger;
3892 if ( aSig < bSig ) goto bBigger;
3900 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3902 sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
3908 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
3914 sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
3975 bits64 aSig, bSig, zSig0, zSig1;
3978 aSig = extractFloatx80Frac( a );
3986 if ( (bits64) ( aSig<<1 )
3995 if ( ( aExp | aSig ) == 0 ) {
4005 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
4006 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
4013 mul64To128( aSig, bSig, &zSig0, &zSig1 );
4034 bits64 aSig, bSig, zSig0, zSig1;
4038 aSig = extractFloatx80Frac( a );
4046 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
4059 if ( ( aExp | aSig ) == 0 ) {
4072 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
4073 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
4077 if ( bSig <= aSig ) {
4078 shift128Right( aSig, 0, 1, &aSig, &rem1 );
4081 zSig0 = estimateDiv128To64( aSig, rem1, bSig );
4083 sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
5794 bits32 aSig;
5796 aSig = extractFloat32Frac( a );
5804 aSig |= 0x00800000;
5805 else if ( aSig == 0 )
5809 aSig <<= 7;
5810 return normalizeRoundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
5817 bits64 aSig;
5819 aSig = extractFloat64Frac( a );
5827 aSig |= LIT64( 0x0010000000000000 );
5828 else if ( aSig == 0 )
5832 aSig <<= 10;
5833 return normalizeRoundAndPackFloat64( aSign, aExp, aSig STATUS_VAR );
5841 bits64 aSig;
5843 aSig = extractFloatx80Frac( a );
5850 if (aExp == 0 && aSig == 0)
5855 aSign, aExp, aSig, 0 STATUS_VAR );