Lines Matching +full:128 +full:a
12 of this code was written as part of a project to build a fixed-point vector
34 Shifts `a' right by the number of bits given in `count'. If any nonzero
38 result will be either 0 or 1, depending on whether `a' is zero or nonzero.
42 INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
46 z = a;
49 z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
52 z = ( a != 0 );
59 Shifts `a' right by the number of bits given in `count'. If any nonzero
63 result will be either 0 or 1, depending on whether `a' is zero or nonzero.
67 INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr )
73 z = a;
76 z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );
79 z = ( a != 0 );
87 Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
90 bits shifted off form a second 64-bit result as follows: The _last_ bit
95 (This routine makes more sense if `a0' and `a1' are considered to form a
134 Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
137 than 128, the result will be 0. The result is broken into two 64-bit pieces
167 Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
171 in particular, if `count' is greater than 128, the result will be either 0
196 else if ( count < 128 ) {
213 at most 128 nonzero bits; these are broken into two 64-bit pieces which are
215 off form a third 64-bit result as follows: The _last_ bit shifted off is
221 to form a fixed-point value with binary point between `a1' and `a2'. This
261 if ( count < 128 ) {
266 z2 = ( count == 128 ) ? a0 : ( a0 != 0 );
282 Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
338 Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
339 value formed by concatenating `b0' and `b1'. Addition is modulo 2^128, so
397 Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
398 128-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
399 2^128, so any borrow out (carry out) is lost. The result is broken into two
455 Multiplies `a' by `b' to obtain a 128-bit product. The product is broken
460 INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )
465 aLow = a;
466 aHigh = a>>32;
485 Multiplies the 128-bit value formed by concatenating `a0' and `a1' by `b' to
486 obtain a 192-bit product. The product is broken into three 64-bit pieces
514 Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
515 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
553 `b' into the 128-bit value formed by concatenating `a0' and `a1'. The
595 by `a'. Considered as an integer, `a' must be at least 2^31. If bit 0 of
597 2^31*sqrt(`a'/2^31), where `a' is considered an integer. If bit 0 of `aExp'
598 is 0, the integer returned approximates 2^31*sqrt(`a'/2^30). In either
603 static bits32 estimateSqrt32( int16 aExp, bits32 a )
615 bits64 A;
617 index = ( a>>27 ) & 15;
619 z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
620 z = ( ( a / z )<<14 ) + ( z<<15 );
621 a >>= 1;
624 z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
625 z = a / z + z;
627 if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );
629 A = ( (bits64) a )<<31;
630 do_div( A, z );
631 return ( (bits32) A ) + ( z>>1 );
638 of `a'. If `a' is zero, 32 is returned.
641 static int8 countLeadingZeros32( bits32 a )
664 if ( a < 0x10000 ) {
666 a <<= 16;
668 if ( a < 0x1000000 ) {
670 a <<= 8;
672 shiftCount += countLeadingZerosHigh[ a>>24 ];
680 of `a'. If `a' is zero, 64 is returned.
683 static int8 countLeadingZeros64( bits64 a )
688 if ( a < ( (bits64) 1 )<<32 ) {
692 a >>= 32;
694 shiftCount += countLeadingZeros32( a );
701 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
702 is equal to the 128-bit value formed by concatenating `b0' and `b1'.
715 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
716 than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
729 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
730 than the 128-bit value formed by concatenating `b0' and `b1'. Otherwise,
743 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is
744 not equal to the 128-bit value formed by concatenating `b0' and `b1'.