Lines Matching defs:aSig
264 | by the denormalized significand `aSig'. The normalized exponent and
270 normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
274 shiftCount = countLeadingZeros32( aSig ) - 8;
275 *zSigPtr = aSig<<shiftCount;
425 | by the denormalized significand `aSig'. The normalized exponent and
431 normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
435 shiftCount = countLeadingZeros64( aSig ) - 11;
436 *zSigPtr = aSig<<shiftCount;
592 | represented by the denormalized significand `aSig'. The normalized exponent
598 normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
602 shiftCount = countLeadingZeros64( aSig );
603 *zSigPtr = aSig<<shiftCount;
1322 bits32 aSig;
1325 aSig = extractFloat32Frac( a );
1328 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1329 if ( aExp ) aSig |= 0x00800000;
1331 aSig64 = aSig;
1353 bits32 aSig;
1356 aSig = extractFloat32Frac( a );
1363 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1368 if ( aExp | aSig ) float_set_inexact();
1371 aSig = ( aSig | 0x00800000 )<<8;
1372 z = aSig>>( - shiftCount );
1373 if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
1396 bits32 aSig;
1399 aSig = extractFloat32Frac( a );
1405 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1410 if ( aExp ) aSig |= 0x00800000;
1411 aSig64 = aSig;
1432 bits32 aSig;
1436 aSig = extractFloat32Frac( a );
1443 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1450 if ( aExp | aSig ) float_set_inexact();
1453 aSig64 = aSig | 0x00800000;
1476 bits32 aSig;
1478 aSig = extractFloat32Frac( a );
1482 if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a ) );
1486 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1487 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1490 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1507 bits32 aSig;
1509 aSig = extractFloat32Frac( a );
1513 if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a ) );
1517 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1518 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1520 aSig |= 0x00800000;
1521 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1540 bits32 aSig;
1542 aSig = extractFloat32Frac( a );
1546 if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a ) );
1550 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1551 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1554 return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1632 bits32 aSig, bSig, zSig;
1635 aSig = extractFloat32Frac( a );
1640 aSig <<= 6;
1644 if ( aSig ) return propagateFloat32NaN( a, b );
1665 aSig |= 0x20000000;
1667 shift32RightJamming( aSig, - expDiff, &aSig );
1672 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1675 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1676 zSig = 0x40000000 + aSig + bSig;
1680 aSig |= 0x20000000;
1681 zSig = ( aSig + bSig )<<1;
1684 zSig = aSig + bSig;
1703 bits32 aSig, bSig, zSig;
1706 aSig = extractFloat32Frac( a );
1711 aSig <<= 7;
1716 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1724 if ( bSig < aSig ) goto aBigger;
1725 if ( aSig < bSig ) goto bBigger;
1736 aSig |= 0x40000000;
1738 shift32RightJamming( aSig, - expDiff, &aSig );
1741 zSig = bSig - aSig;
1747 if ( aSig ) return propagateFloat32NaN( a, b );
1757 aSig |= 0x40000000;
1759 zSig = aSig - bSig;
1819 bits32 aSig, bSig;
1823 aSig = extractFloat32Frac( a );
1831 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1842 aSig ) == 0 ) {
1849 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1850 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1857 aSig = ( aSig | 0x00800000 )<<7;
1859 shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1879 bits32 aSig, bSig, zSig;
1881 aSig = extractFloat32Frac( a );
1889 if ( aSig ) return propagateFloat32NaN( a, b );
1903 if ( ( aExp | aSig ) == 0 ) {
1913 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1914 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1917 aSig = ( aSig | 0x00800000 )<<7;
1919 if ( bSig <= ( aSig + aSig ) ) {
1920 aSig >>= 1;
1923 zSig = ( ( (bits64) aSig )<<32 ) / bSig;
1925 zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
1942 bits32 aSig, bSig;
1948 aSig = extractFloat32Frac( a );
1955 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1973 if ( aSig == 0 ) return a;
1974 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1977 aSig |= 0x00800000;
1980 aSig <<= 8;
1984 aSig >>= 1;
1986 q = ( bSig <= aSig );
1987 if ( q ) aSig -= bSig;
1989 q = ( ( (bits64) aSig )<<32 ) / bSig;
1992 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
1995 aSig >>= 2;
2000 if ( bSig <= aSig ) aSig -= bSig;
2001 aSig64 = ( (bits64) aSig )<<40;
2015 aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
2018 alternateASig = aSig;
2020 aSig -= bSig;
2021 } while ( 0 <= (sbits32) aSig );
2022 sigMean = aSig + alternateASig;
2024 aSig = alternateASig;
2026 zSign = ( (sbits32) aSig < 0 );
2027 if ( zSign ) aSig = - aSig;
2028 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2045 bits32 aSig, zSig;
2048 aSig = extractFloat32Frac( a );
2052 if ( aSig ) return propagateFloat32NaN( a, 0 );
2058 if ( ( aExp | aSig ) == 0 ) return a;
2063 if ( aSig == 0 ) return 0;
2064 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2067 aSig = ( aSig | 0x00800000 )<<8;
2068 zSig = estimateSqrt32( aExp, aSig ) + 2;
2074 aSig >>= aExp & 1;
2076 rem = ( ( (bits64) aSig )<<32 ) - term;
2247 bits64 aSig;
2249 aSig = extractFloat64Frac( a );
2252 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2253 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2255 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
2256 return roundAndPackInt32( aSign, aSig );
2275 bits64 aSig, savedASig;
2278 aSig = extractFloat64Frac( a );
2282 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2286 if ( aExp || aSig ) float_set_inexact();
2289 aSig |= LIT64( 0x0010000000000000 );
2291 savedASig = aSig;
2292 aSig >>= shiftCount;
2293 z = aSig;
2300 if ( ( aSig<<shiftCount ) != savedASig ) {
2322 bits64 aSig, aSigExtra;
2324 aSig = extractFloat64Frac( a );
2327 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2334 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2341 aSig <<= - shiftCount;
2344 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
2346 return roundAndPackInt64( aSign, aSig, aSigExtra );
2355 bits64 aSig, aSigExtra;
2357 aSig = extractFloat64Frac( a );
2365 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2372 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2379 aSig <<= - shiftCount;
2382 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
2384 return roundAndPackUInt64( aSig, aSigExtra );
2402 bits64 aSig;
2405 aSig = extractFloat64Frac( a );
2408 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2416 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2423 z = aSig<<shiftCount;
2427 if ( aExp | aSig ) float_set_inexact();
2430 z = aSig>>( - shiftCount );
2431 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
2452 bits64 aSig;
2455 aSig = extractFloat64Frac( a );
2459 if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a ) );
2462 shift64RightJamming( aSig, 22, &aSig );
2463 zSig = aSig;
2485 bits64 aSig;
2487 aSig = extractFloat64Frac( a );
2491 if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a ) );
2495 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2496 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2500 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2519 bits64 aSig, zSig0, zSig1;
2521 aSig = extractFloat64Frac( a );
2525 if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a ) );
2529 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2530 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2533 shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
2613 bits64 aSig, bSig, zSig;
2616 aSig = extractFloat64Frac( a );
2621 aSig <<= 9;
2625 if ( aSig ) return propagateFloat64NaN( a, b );
2646 aSig |= LIT64( 0x2000000000000000 );
2648 shift64RightJamming( aSig, - expDiff, &aSig );
2653 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2656 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2657 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
2661 aSig |= LIT64( 0x2000000000000000 );
2662 zSig = ( aSig + bSig )<<1;
2665 zSig = aSig + bSig;
2684 bits64 aSig, bSig, zSig;
2687 aSig = extractFloat64Frac( a );
2692 aSig <<= 10;
2697 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2705 if ( bSig < aSig ) goto aBigger;
2706 if ( aSig < bSig ) goto bBigger;
2717 aSig |= LIT64( 0x4000000000000000 );
2719 shift64RightJamming( aSig, - expDiff, &aSig );
2722 zSig = bSig - aSig;
2728 if ( aSig ) return propagateFloat64NaN( a, b );
2738 aSig |= LIT64( 0x4000000000000000 );
2740 zSig = aSig - bSig;
2800 bits64 aSig, bSig, zSig0, zSig1;
2802 aSig = extractFloat64Frac( a );
2810 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2821 if ( ( aExp | aSig ) == 0 ) {
2828 if ( aSig
2829 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2836 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2838 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2858 bits64 aSig, bSig, zSig;
2862 aSig = extractFloat64Frac( a );
2870 if ( aSig ) return propagateFloat64NaN( a, b );
2884 if ( ( aExp | aSig ) == 0 ) {
2894 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2895 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2898 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2900 if ( bSig <= ( aSig + aSig ) ) {
2901 aSig >>= 1;
2904 zSig = estimateDiv128To64( aSig, 0, bSig );
2907 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
2929 bits64 aSig, bSig;
2933 aSig = extractFloat64Frac( a );
2940 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2958 if ( aSig == 0 ) return a;
2959 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2962 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
2966 aSig >>= 1;
2968 q = ( bSig <= aSig );
2969 if ( q ) aSig -= bSig;
2972 q = estimateDiv128To64( aSig, 0, bSig );
2974 aSig = - ( ( bSig>>2 ) * q );
2979 q = estimateDiv128To64( aSig, 0, bSig );
2983 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2986 aSig >>= 2;
2990 alternateASig = aSig;
2992 aSig -= bSig;
2993 } while ( 0 <= (sbits64) aSig );
2994 sigMean = aSig + alternateASig;
2996 aSig = alternateASig;
2998 zSign = ( (sbits64) aSig < 0 );
2999 if ( zSign ) aSig = - aSig;
3000 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3014 bits64 aSig, zSig, doubleZSig;
3017 aSig = extractFloat64Frac( a );
3021 if ( aSig ) return propagateFloat64NaN( a, a );
3027 if ( ( aExp | aSig ) == 0 ) return a;
3032 if ( aSig == 0 ) return 0;
3033 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3036 aSig |= LIT64( 0x0010000000000000 );
3037 zSig = estimateSqrt32( aExp, aSig>>21 );
3038 aSig <<= 9 - ( aExp & 1 );
3039 zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );
3043 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
3214 bits64 aSig;
3216 aSig = extractFloatx80Frac( a );
3219 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3222 shift64RightJamming( aSig, shiftCount, &aSig );
3223 return roundAndPackInt32( aSign, aSig );
3241 bits64 aSig, savedASig;
3244 aSig = extractFloatx80Frac( a );
3248 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3252 if ( aExp || aSig ) float_set_inexact();
3256 savedASig = aSig;
3257 aSig >>= shiftCount;
3258 z = aSig;
3265 if ( ( aSig<<shiftCount ) != savedASig ) {
3286 bits64 aSig, aSigExtra;
3288 aSig
3297 && ( aSig != LIT64( 0x8000000000000000 ) ) )
3306 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
3308 return roundAndPackInt64( aSign, aSig, aSigExtra );
3326 bits64 aSig;
3329 aSig = extractFloatx80Frac( a );
3334 aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
3335 if ( ( a.high != 0xC03E ) || aSig ) {
3337 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3344 if ( aExp | aSig ) float_set_inexact();
3347 z = aSig>>( - shiftCount );
3348 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
3367 bits64 aSig;
3369 aSig = extractFloatx80Frac( a );
3373 if ( (bits64) ( aSig<<1 ) ) {
3378 shift64RightJamming( aSig, 33, &aSig );
3379 if ( aExp || aSig ) aExp -= 0x3F81;
3380 return roundAndPackFloat32( aSign, aExp, aSig );
3395 bits64 aSig, zSig;
3397 aSig = extractFloatx80Frac( a );
3401 if ( (bits64) ( aSig<<1 ) ) {
3406 shift64RightJamming( aSig, 1, &zSig );
3407 if ( aExp || aSig ) aExp -= 0x3C01;
3425 bits64 aSig, zSig0, zSig1;
3427 aSig = extractFloatx80Frac( a );
3430 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {
3433 shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
3524 bits64 aSig, bSig, zSig0, zSig1;
3527 aSig = extractFloatx80Frac( a );
3534 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3547 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3552 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3558 zSig0 = aSig + bSig;
3566 zSig0 = aSig + bSig;
3590 bits64 aSig, bSig, zSig0, zSig1;
3594 aSig = extractFloatx80Frac( a );
3602 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3615 if ( bSig < aSig ) goto aBigger;
3616 if ( aSig < bSig ) goto bBigger;
3624 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3626 sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
3632 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3638 sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
3699 bits64 aSig, bSig, zSig0, zSig1;
3702 aSig = extractFloatx80Frac( a );
3710 if ( (bits64) ( aSig<<1 )
3719 if ( ( aExp | aSig ) == 0 ) {
3729 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3730 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3737 mul64To128( aSig, bSig, &zSig0, &zSig1 );
3758 bits64 aSig, bSig, zSig0, zSig1;
3762 aSig = extractFloatx80Frac( a );
3770 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3783 if ( ( aExp | aSig ) == 0 ) {
3796 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3797 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3801 if ( bSig <= aSig ) {
3802 shift128Right( aSig, 0, 1, &aSig, &rem1 );
3805 zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3807 sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
5338 bits64 aSig, savedASig;
5341 aSig = extractFloat64Frac( a );
5355 if ( aExp || aSig ) float_set_inexact();
5358 aSig |= LIT64( 0x0010000000000000 );
5360 savedASig = aSig;
5361 aSig >>= shiftCount;
5362 z = aSig;
5363 if ( ( aSig<<shiftCount ) != savedASig ) {
5383 bits32 aSig;
5386 aSig = extractFloat32Frac( a );
5400 if ( aExp | aSig ) float_set_inexact();
5403 aSig = ( aSig | 0x800000 )<<8;
5404 z = aSig>>( - shiftCount );
5405 if ( aSig<<( shiftCount & 31 ) ) {
Indexes created Tue Sep 30 11:09:46 GMT 2025