Php shift operation and shift operation learning Notes

Bitwise operations must be used and when the bit is cleared. if a location can be used or reversed or exchanged, it is easy to use an exclusive or shift operation. Point 1 is a binary operator, both computation components are integer, and the result is also an integer. 2 quot; left... Bit operation application tips

The bitwise is to be used with or at a specified position.

To reverse and exchange, you can easily use an exception or

Shift operation

Key points

1. they are all binary operators. Both calculation components are integer and the result is also an integer.

2 "<" left shift: fill 0 on the right blank bit. the left bit will be squeezed out from the header, and its value is equal to 2.

3 ">" right shift: the right bit is squeezed out. For the vacant positions removed from the left, if it is a positive number, the vacant space is supplemented with 0. if it is a negative number, it may be supplemented with 0 or 1, depending on the computer system used.

4 ">>>" operator, the right bit is squeezed out, and 0 is added for the left Removed space.

Application of bitwise operators (source operand s mask)

(1) bitwise and --&

1. reset the special location (0 for a specific position in the mask, 1 for other bits, s = s & mask)

2. locate a specified position in a specified number (1 in mask, 0 for other bits, s = s & mask)

(2) bitwise OR -- |

It is often used to set the source operand to some positions of 1, and the other bits remain unchanged. (In mask, the specific position is 1, and the other bit is 0 s = s | mask)

(3) bitwise OR -- ^

1. reverse the value of the specific location (1 in a specific position in mask and 0 s = s ^ mask in other bits)

2. if the third variable is not introduced, the values of the two variables are exchanged (set a = a1, B = b1)

Status after operation

A = a1 ^ b1 a = a ^ B a = a1 ^ b1, B = b1

B = a1 ^ b1 ^ b1 B = a ^ B a = a1 ^ b1, B = a1

A = b1 ^ a1 ^ a1 a = a ^ B a = b1, B = a1

Binary complement calculation formula:

-X = ~ X + 1 = ~ X-1)

~ X =-X-1

-(~ X) = x + 1

~ (-X) = x-1

X + y = x -~ Y-1 = (x | y) + (x & y)

X-y = x ++ ~ Y + 1 = (x | ~ Y )-(~ X & y)

X ^ y = (x | y)-(x & y)

X | y = (x &~ Y) + y

X & y = (~ X | y )-~ X

X = y :~ (X-y | y-x)

X! = Y: x-y | y-x

X <y: (x-y) ^ (x ^ y) & (x-y) ^ x ))

X <= y: (x | ~ Y) & (x ^ y) | ~ (Y-x ))

X <y :(~ X & y) | ((~ X | y) & (x-y) // comparison of unsigned x and y

X <= y :(~ X | y) & (x ^ y) | ~ (Y-x) // unsigned x, y comparison

Application example

(1) judge whether int variable a is an odd or even number.

A & 1 = 0 even

A & 1 = 1 Odd

(2) take the k-bit (k =, 2…) Of int-type variable ...... Sizeof (int), that is, a> k & 1

(3) clear the k bit of int variable a by 0, that is, a = &~ (1 <

(4) place the k position of int type variable a 1, that is, a = a | (1 <

(5) int type variable loops are shifted k times left, that is, a = a < > 16-k (set sizeof (int) = 16)

(6) int type variable a shifts k times to the right, that is, a = a> k | a <16-k (set sizeof (int) = 16)

(7) average integer

If two integers x and y are used to calculate the average value (x + y)/2, the overflow will occur, because x + y may be greater than INT_MAX, however, we know that their average values will certainly not overflow. We use the following algorithm:

Int average (int x, int y) // returns the average values of X and Y {return (x & y) + (x ^ y)> 1 );}

(8) judge whether an integer is the power of 2. for a number x> = 0, determine whether it is the power of 2.

boolean power2(int x) {     return ((x&(x-1))==0)&&(x!=0)； }

(9) two integers are not exchanged using temp.

void swap(int x , int y) {     x ^= y;     y ^= x;     x ^= y; }

(10) calculate the absolute value

int abs( int x ) { int y ; y = x >> 31 ; return (x^y)-y ;        //or: (x+y)^y }

(11) modulo operation into bitwise operation (without overflow)

A % (2 ^ n) is equivalent to a & (2 ^ n-1)

(12) multiplication is converted into bitwise operations (without overflow)

A * (2 ^ n) is equivalent to a <n

(13) division operations are converted into bitwise operations (without overflow)

A/(2 ^ n) is equivalent to a> n examples: 12/8 = 12> 3

(14) a % 2 is equivalent to a & 1

(15) if (x = a) x = B;

Else x = a; equivalent to x = a ^ B ^ x;

(16) the opposite number of x is expressed (~ X + 1)

Finally, add some binary displacement operations.

PHP is mainly designed for text operations. In fact, PHP is not suitable for mathematical operations and is inefficient. However, this project has something that must be used for binary displacement operations, I encountered some trouble in PHP.

Because PHP only has 32-bit signed integers, neither 64-bit long integers nor unsigned integers. The integer range is-231-1 ~ 231, beyond this range, will be interpreted as floating point. Therefore, 0 xFFFFFFFF is printed directly, and the display is 4294967295, and 232:

> 0 xFFFFFFFFF

4294967295

> Gettype (0 xFFFFFFFF)

'Double'

In a 32-bit signed integer, 0xFFFFFFFF indicates-1:

> (Int) 0 xFFFFFFFFF

-1

PHP does not support binary displacement of floating point numbers. if you want to perform this operation, it will first convert it to an integer type. The final result will also be returned according to the integer type:

>> 1 << 31 -2147483648 >> 1 << 30 1073741824 >> 1 << 32 1 >> 0xFFFFFFFF >> 1 -1

At the same time, PHP's right displacement operation will fill the sign bit in the high position, and PHP does not provide a Java-like >>> to force fill 0:

>> 1 << 32 1 >> 0xFFFFFFFF >> 1 -1 >> 0xFFFFFFFF >> 2 -1 >> 0xFFFFFFFF >> 3 -1 >> 0xFFFFFFFF >> 31 -1

How can I solve this problem? I have considered using the BCMath function library to directly process integers expressed by strings, or GMP/BigInt extensions. However, since I want to use strings, I can thoroughly convert the numbers into 32 binary strings, then manually fill them with 0, and finally convert them back.

I don't know which one has a better method. please let me know. In addition, the code can be extended to any bitwise binary displacement operation. I didn't do it here. the PHP code is as follows:

 = 32) {return 0 ;}// convert to a string representing a binary number $ bin = decbin ($ x); $ l = strlen ($ bin ); // if the string length exceeds the upper limit, it is truncated to 32 characters. if ($ l> 32) {$ bin = substr ($ bin, $ l-32, 32);} elseif ($ l <32) {$ bin = str_pad ($ bin, 32, '0', STR_PAD_LEFT );} // Retrieve the number of digits to be moved and fill 0 return bindec (str_pad (substr ($ bin, 0, 32-$ bits), 32, '0 ', STR_PAD_LEFT);}/*** unsigned 32-bit left shift * @ param mixed $ x number to be operated. if it is a string, it must be in decimal format * @ param string $ bits Left-shifted digits * @ return mixed result. if the integer range is exceeded, the floating point number */function shl32 ($ x, $ bits) is returned) {// if ($ bits <= 0) {return $ x;} if ($ bits >=32) {return 0 ;} // Convert to a string representing a binary number $ bin = decbin ($ x); $ l = strlen ($ bin); // if the string length is exceeded, the base 32 characters are truncated, if the length is not enough, the filling height is 0 to 32 if ($ l> 32) {$ bin = substr ($ bin, $ l-32, 32 );} elseif ($ l <32) {$ bin = str_pad ($ bin, 32, '0', STR_PAD_LEFT);} // retrieves the number of digits to be moved, and fill in 0 return bindec (str_pad (subst R ($ bin, $ bits), 32, '0', STR_PAD_RIGHT);}?>

Article link:

Save this article for favorites!