Lines Matching defs:zSign
117 input. If `zSign' is 1, the input is negated before being converted to an
125 static int32 roundAndPackInt32( flag zSign, bits64 absZ )
141 if ( zSign ) {
153 if ( zSign ) z = - z;
154 if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
156 return zSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
168 If `zSign' is 1, the input is negated before being converted to an integer.
176 static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 )
190 if ( zSign ) {
204 if ( zSign ) z = - z;
205 if ( z && ( ( z < 0 ) ^ zSign ) ) {
209 zSign ? (sbits64) LIT64( 0x8000000000000000 )
275 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
285 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
288 return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
294 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
315 static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
331 if ( zSign ) {
346 return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 );
363 return packFloat32( zSign, zExp, zSig );
369 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
378 normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
383 return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount );
444 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
454 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
457 return FLOAT64_MANGLE( ( ( (bits64) zSign )<<63 ) +
464 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
485 static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
501 if ( zSign ) {
517 FLOAT64_DEMANGLE(packFloat64( zSign, 0x7FF, 0 )) -
535 return packFloat64( zSign, zExp, zSig );
541 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
550 normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
555 return roundAndPackFloat64( zSign, zExp - shiftCount, zSig<<shiftCount );
621 Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
625 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
630 z.high = (bits32)( ( ( (bits32) zSign )<<15 ) + zExp )<<X80SHIFT;
637 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
662 int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
690 if ( zSign ) {
722 return packFloatx80( zSign, zExp, zSig0 );
737 return packFloatx80( zSign, zExp, zSig0 );
745 if ( zSign ) {
764 || ( zSign && ( roundingMode == float_round_up ) )
765 || ( ! zSign && ( roundingMode == float_round_down ) )
767 return packFloatx80( zSign, 0x7FFE, ~ roundMask );
769 return packFloatx80( zSign, 0x7FFF, 0 );
785 if ( zSign ) {
798 return packFloatx80( zSign, zExp, zSig0 );
815 return packFloatx80( zSign, zExp, zSig0 );
821 Takes an abstract floating-point value having sign `zSign', exponent
831 int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
845 roundAndPackFloatx80( roundingPrecision, zSign, zExp, zSig0, zSig1 );
948 Packs the sign `zSign', the exponent `zExp', and the significand formed
951 proper positions, the three fields `zSign', `zExp', and `zSig0' are simply
961 packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )
966 z.high = ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + zSig0;
973 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
995 flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 )
1008 if ( zSign ) {
1030 || ( zSign && ( roundingMode == float_round_up ) )
1031 || ( ! zSign && ( roundingMode == float_round_down ) )
1035 zSign,
1041 return packFloat128( zSign, 0x7FFF, 0, 0 );
1062 if ( zSign ) {
1079 return packFloat128( zSign, zExp, zSig0, zSig1 );
1085 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1096 flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )
1116 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
1131 flag zSign;
1135 zSign = ( a < 0 );
1136 return normalizeRoundAndPackFloat32(zSign, 0x9C, (uint32)(zSign ? - a : a));
1158 flag zSign;
1164 zSign = ( a < 0 );
1165 absA = zSign ? - a : a;
1168 return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );
1195 flag zSign;
1201 zSign = ( a < 0 );
1202 absA = zSign ? - a : a;
1205 return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
1233 flag zSign;
1239 zSign = ( a < 0 );
1240 absA = zSign ? - a : a;
1243 return packFloat128( zSign, 0x402E - shiftCount, zSig0<<shiftCount, 0 );
1270 flag zSign;
1275 zSign = ( a < 0 );
1276 absA = zSign ? - a : a;
1279 return packFloat32( zSign, 0x95 - shiftCount, absA<<shiftCount );
1289 return roundAndPackFloat32( zSign, 0x9C - shiftCount, absA );
1303 flag zSign;
1309 zSign = ( a < 0 );
1310 return normalizeRoundAndPackFloat64( zSign, 0x43C, zSign ? - a : a );
1326 flag zSign;
1331 zSign = ( a < 0 );
1332 absA = zSign ? - a : a;
1334 return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );
1353 flag zSign;
1360 zSign = ( a < 0 );
1361 absA = zSign ? - a : a;
1374 return packFloat128( zSign, zExp, zSig0, zSig1 );
1707 floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
1708 before being returned. `zSign' is ignored if the result is a NaN.
1713 static float32 addFloat32Sigs( float32 a, float32 b, flag zSign )
1743 return packFloat32( zSign, 0xFF, 0 );
1759 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1772 return roundAndPackFloat32( zSign, zExp, zSig );
1779 precision floating-point values `a' and `b'. If `zSign' is 1, the
1780 difference is negated before being returned. `zSign' is ignored if the
1785 static float32 subFloat32Sigs( float32 a, float32 b, flag zSign )
1815 return packFloat32( zSign ^ 1, 0xFF, 0 );
1828 zSign ^= 1;
1848 return normalizeRoundAndPackFloat32( zSign, zExp, zSig );
1905 flag aSign, bSign, zSign;
1917 zSign = aSign ^ bSign;
1926 return packFloat32( zSign, 0xFF, 0 );
1934 return packFloat32( zSign, 0xFF, 0 );
1937 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1941 if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1953 return roundAndPackFloat32( zSign, zExp, zSig );
1966 flag aSign, bSign, zSign;
1976 zSign = aSign ^ bSign;
1984 return packFloat32( zSign, 0xFF, 0 );
1988 return packFloat32( zSign, 0, 0 );
1997 return packFloat32( zSign, 0xFF, 0 );
2002 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
2016 return roundAndPackFloat32( zSign, zExp, zSig );
2030 flag aSign, bSign, zSign;
2116 zSign = ( (sbits32) aSig < 0 );
2117 if ( zSign ) aSig = - aSig;
2118 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2673 floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
2674 before being returned. `zSign' is ignored if the result is a NaN.
2679 static float64 addFloat64Sigs( float64 a, float64 b, flag zSign )
2709 return packFloat64( zSign, 0x7FF, 0 );
2725 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2738 return roundAndPackFloat64( zSign, zExp, zSig );
2745 precision floating-point values `a' and `b'. If `zSign' is 1, the
2746 difference is negated before being returned. `zSign' is ignored if the
2751 static float64 subFloat64Sigs( float64 a, float64 b, flag zSign )
2781 return packFloat64( zSign ^ 1, 0x7FF, 0 );
2794 zSign ^= 1;
2814 return normalizeRoundAndPackFloat64( zSign, zExp, zSig );
2871 flag aSign, bSign, zSign;
2881 zSign = aSign ^ bSign;
2890 return packFloat64( zSign, 0x7FF, 0 );
2898 return packFloat64( zSign, 0x7FF, 0 );
2901 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2905 if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2917 return roundAndPackFloat64( zSign, zExp, zSig0 );
2930 flag aSign, bSign, zSign;
2942 zSign = aSign ^ bSign;
2950 return packFloat64( zSign, 0x7FF, 0 );
2954 return packFloat64( zSign, 0, 0 );
2963 return packFloat64( zSign, 0x7FF, 0 );
2968 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2988 return roundAndPackFloat64( zSign, zExp, zSig );
3002 flag aSign, bSign, zSign;
3073 zSign = ( (sbits64) aSig < 0 );
3074 if ( zSign ) aSig = - aSig;
3075 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3659 precision floating-point values `a' and `b'. If `zSign' is 1, the sum is
3660 negated before being returned. `zSign' is ignored if the result is a NaN.
3665 static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign )
3688 return packFloatx80( zSign, 0x7FFF, 0 );
3719 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3726 double-precision floating-point values `a' and `b'. If `zSign' is 1, the
3727 difference is negated before being returned. `zSign' is ignored if the
3732 static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign )
3766 return packFloatx80( zSign ^ 1, 0x7FFF, 0 );
3773 zSign ^= 1;
3788 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3845 flag aSign, bSign, zSign;
3856 zSign = aSign ^ bSign;
3863 return packFloatx80( zSign, 0x7FFF, 0 );
3874 return packFloatx80( zSign, 0x7FFF, 0 );
3877 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3881 if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
3892 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3905 flag aSign, bSign, zSign;
3917 zSign = aSign ^ bSign;
3924 return packFloatx80( zSign, 0x7FFF, 0 );
3928 return packFloatx80( zSign, 0, 0 );
3940 return packFloatx80( zSign, 0x7FFF, 0 );
3945 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3973 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3986 flag aSign, zSign;
4024 zSign = aSign;
4067 zSign = ! zSign;
4071 80, zSign, bExp + expDiff, aSig0, aSig1 );
4808 floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
4809 before being returned. `zSign' is ignored if the result is a NaN.
4814 static float128 addFloat128Sigs( float128 a, float128 b, flag zSign )
4845 return packFloat128( zSign, 0x7FFF, 0, 0 );
4865 if ( aExp == 0 ) return packFloat128( zSign, 0, zSig0, zSig1 );
4880 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
4887 precision floating-point values `a' and `b'. If `zSign' is 1, the
4888 difference is negated before being returned. `zSign' is ignored if the
4893 static float128 subFloat128Sigs( float128 a, float128 b, flag zSign )
4932 return packFloat128( zSign ^ 1, 0x7FFF, 0, 0 );
4945 zSign ^= 1;
4965 return normalizeRoundAndPackFloat128( zSign, zExp - 14, zSig0, zSig1 );
5022 flag aSign, bSign, zSign;
5035 zSign = aSign ^ bSign;
5042 return packFloat128( zSign, 0x7FFF, 0, 0 );
5053 return packFloat128( zSign, 0x7FFF, 0, 0 );
5056 if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
5060 if ( ( bSig0 | bSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
5074 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
5087 flag aSign, bSign, zSign;
5101 zSign = aSign ^ bSign;
5108 return packFloat128( zSign, 0x7FFF, 0, 0 );
5112 return packFloat128( zSign, 0, 0, 0 );
5124 return packFloat128( zSign, 0x7FFF, 0, 0 );
5129 if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
5159 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
5172 flag aSign, zSign;
5266 zSign = ( (sbits64) aSig0 < 0 );
5267 if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 );
5269 normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 );
Indexes created Thu Nov 06 21:09:53 GMT 2025