How To Use Bit Operators To Clear Bits 2-6 Of A Register

Calculator performance that operates on values at the level of their private bits

In reckoner programming, a bitwise operation operates on a fleck string, a bit array or a binary numeral (considered as a flake string) at the level of its private bits. Information technology is a fast and simple activeness, basic to the higher-level arithmetic operations and directly supported past the processor. Most bitwise operations are presented every bit ii-operand instructions where the event replaces one of the input operands.

On simple low-toll processors, typically, bitwise operations are essentially faster than division, several times faster than multiplication, and sometimes significantly faster than add-on. While modern processors usually perform addition and multiplication just as fast every bit bitwise operations due to their longer instruction pipelines and other architectural design choices, bitwise operations do commonly use less power because of the reduced use of resources.^[1]

Bitwise operators [edit]

In the explanations below, any indication of a bit's position is counted from the right (least significant) side, advancing left. For instance, the binary value 0001 (decimal one) has zeroes at every position simply the first (i.due east., the rightmost) one.

Non [edit]

The bitwise Non, or bitwise complement, is a unary operation that performs logical negation on each bit, forming the ones' complement of the given binary value. Bits that are 0 become ane, and those that are one become 0. For example:

NOT          0111  (decimal vii)   =          1000  (decimal 8)

Not 10101011  (decimal 171)   = 01010100  (decimal 84)

The result is equal to the two'due south complement of the value minus one. If 2'south complement arithmetics is used, then NOT x = -x − 1.

For unsigned integers, the bitwise complement of a number is the "mirror reflection" of the number across the half-way point of the unsigned integer'south range. For example, for viii-bit unsigned integers, NOT ten = 255 - x, which can exist visualized on a graph equally a downwardly line that finer "flips" an increasing range from 0 to 255, to a decreasing range from 255 to 0. A simple but illustrative instance use is to capsize a grayscale image where each pixel is stored as an unsigned integer.

AND [edit]

Bitwise AND of 4-bit integers

A bitwise AND is a binary operation that takes two equal-length binary representations and performs the logical AND operation on each pair of the respective bits. Thus, if both bits in the compared position are one, the flake in the resulting binary representation is 1 (1 × 1 = 1); otherwise, the result is 0 (1 × 0 = 0 and 0 × 0 = 0). For example:

          010i          (decimal 5) AND 001i          (decimal 3)   = 000ane          (decimal 1)

The operation may be used to decide whether a particular bit is fix (1) or articulate (0). For example, given a bit pattern 0011 (decimal 3), to decide whether the second flake is set we utilize a bitwise AND with a fleck pattern containing 1 just in the second fleck:

          0011 (decimal iii) AND 00i0 (decimal 2)   = 00ane0 (decimal two)

Because the result 0010 is non-zero, nosotros know the second chip in the original pattern was set. This is oftentimes called bit masking. (By analogy, the use of masking tape covers, or masks, portions that should not be altered or portions that are non of interest. In this case, the 0 values mask the bits that are not of involvement.)

The bitwise AND may exist used to clear selected bits (or flags) of a register in which each fleck represents an individual Boolean country. This technique is an efficient way to store a number of Boolean values using equally little retentiveness equally possible.

For example, 0110 (decimal 6) can be considered a set of four flags, where the first and 4th flags are articulate (0), and the second and third flags are set (1). The third flag may exist cleared by using a bitwise AND with the pattern that has a zero only in the third scrap:

          01x (decimal six) AND one011 (decimal xi)   = 00ten (decimal two)

Because of this belongings, it becomes easy to check the parity of a binary number by checking the value of the everyman valued bit. Using the example in a higher place:

          0110 (decimal 6) AND 0001 (decimal 1)   = 0000 (decimal 0)

Because 6 AND ane is zero, 6 is divisible by ii and therefore even.

OR [edit]

Bitwise OR of 4-bit integers

A bitwise OR is a binary functioning that takes two flake patterns of equal length and performs the logical inclusive OR operation on each pair of respective bits. The effect in each position is 0 if both $.25 are 0, while otherwise the result is i. For example:

          0101          (decimal 5) OR 0011          (decimal three)  = 0111          (decimal 7)

The bitwise OR may be used to ready to 1 the selected $.25 of the annals described higher up. For example, the fourth scrap of 0010 (decimal 2) may be set past performing a bitwise OR with the blueprint with just the quaternary bit fix:

          0010 (decimal ii) OR          ane000 (decimal 8)  =          1010 (decimal 10)

XOR [edit]

Bitwise XOR of 4-fleck integers

A bitwise XOR is a binary performance that takes two scrap patterns of equal length and performs the logical sectional OR operation on each pair of corresponding bits. The result in each position is 1 if only one of the bits is 1, but will exist 0 if both are 0 or both are 1. In this we perform the comparing of two bits, beingness 1 if the two bits are unlike, and 0 if they are the same. For example:

          0101 (decimal 5) XOR 0011 (decimal 3)   = 0110 (decimal six)

The bitwise XOR may be used to invert selected bits in a register (also called toggle or flip). Any bit may be toggled by XORing information technology with ane. For example, given the bit design 0010 (decimal 2) the second and fourth bits may be toggled by a bitwise XOR with a bit design containing one in the 2nd and fourth positions:

          0010 (decimal 2) XOR          one0i0 (decimal 10)   =          one000 (decimal viii)

This technique may be used to dispense scrap patterns representing sets of Boolean states.

Associates language programmers and optimizing compilers sometimes use XOR equally a brusque-cut to setting the value of a register to cipher. Performing XOR on a value confronting itself always yields zip, and on many architectures this operation requires fewer clock cycles and memory than loading a zero value and saving it to the register.

If the set of bit strings of fixed length north (i.due east. machine words) is thought of as an n-dimensional vector space ${\bf {F}}_{2}^{n}$ over the field ${\bf {F}}_{2}$ , then vector addition corresponds to the bitwise XOR.

Mathematical equivalents [edit]

Bold $10\geq y$ , for the non-negative integers, the bitwise operations can be written as follows:

{\begin{aligned}\operatorname {Non} x&=\sum _{northward=0}^{\lfloor \log _{2}(10)\rfloor }2^{n}\left[\left(\left\lfloor {\frac {x}{2^{due north}}}\right\rfloor {\bmod {2}}+one\correct){\bmod {ii}}\right]=2^{\left\lfloor \log _{ii}(x)\right\rfloor +i}-1-x\\x\operatorname {AND} y&=\sum _{due north=0}^{\lfloor \log _{2}(x)\rfloor }ii^{n}\left(\left\lfloor {\frac {x}{2^{n}}}\right\rfloor {\bmod {2}}\right)\left(\left\lfloor {\frac {y}{2^{n}}}\right\rfloor {\bmod {2}}\right)\\10\operatorname {OR} y&=\sum _{n=0}^{\lfloor \log _{two}(10)\rfloor }2^{n}\left(\left[\left(\left\lfloor {\frac {x}{two^{n}}}\right\rfloor {\bmod {2}}\right)+\left(\left\lfloor {\frac {y}{2^{due north}}}\correct\rfloor {\bmod {two}}\correct)+\left(\left\lfloor {\frac {10}{two^{north}}}\right\rfloor {\bmod {two}}\right)\left(\left\lfloor {\frac {y}{two^{n}}}\right\rfloor {\bmod {two}}\correct)\correct]{\bmod {2}}\correct)\\x\operatorname {XOR} y&=\sum _{north=0}^{\lfloor \log _{ii}(x)\rfloor }two^{northward}\left(\left[\left(\left\lfloor {\frac {10}{ii^{n}}}\right\rfloor {\bmod {2}}\right)+\left(\left\lfloor {\frac {y}{2^{n}}}\right\rfloor {\bmod {2}}\right)\right]{\bmod {2}}\right)=\sum _{north=0}^{\lfloor \log _{ii}(ten)\rfloor }2^{n}\left[\left(\left\lfloor {\frac {10}{ii^{northward}}}\right\rfloor +\left\lfloor {\frac {y}{2^{due north}}}\right\rfloor \right){\bmod {two}}\right]\end{aligned}}

Truth table for all binary logical operators [edit]

There are 16 possible truth functions of ii binary variables; this defines a truth tabular array.

Here is the bitwise equivalent operations of ii $.25 P and Q:

Bitwise equivalents		0	Not (p OR q)	(Non p) AND q	Non p	p AND (Non q)	NOT q	p XOR q	Non (p AND q)	p AND q	Non (p XOR q)	q	(Non p) OR q	p	p OR (Not q)	p OR q	1
p	q	F⁰	NORⁱ	Xq²	¬p ³	↛^four	¬q ⁵	XOR⁶	NAND⁷	AND⁸	XNOR⁹	q^x	If/then^xi	p¹²	Then/if^xiii	OR¹⁴	T^xv
1	i	0	0	0	0	0	0	0	0	ane	1	ane	1	1	one	i	ane
1	0	0	0	0	0	ane	one	1	1	0	0	0	0	1	1	i	1
0	1	0	0	1	one	0	0	1	1	0	0	1	1	0	0	1	ane
0	0	0	ane	0	1	0	1	0	1	0	1	0	i	0	one	0	1

Scrap shifts [edit]

The chip shifts are sometimes considered bitwise operations, because they treat a value as a serial of bits rather than every bit a numerical quantity. In these operations, the digits are moved, or shifted, to the left or right. Registers in a computer processor accept a fixed width, so some bits will be "shifted out" of the register at one end, while the aforementioned number of bits are "shifted in" from the other end; the differences betwixt bit shift operators prevarication in how they determine the values of the shifted-in $.25.

Bit addressing [edit]

If the width of the register (often 32 or even 64) is larger than the number of bits (usually viii) of the smallest addressable unit, frequently called byte, the shift operations induce an addressing scheme from the bytes to the $.25. Thereby the orientations "left" and "right" are taken from the standard writing of numbers in a place-value notation, such that a left shift increases and a right shift decreases the value of the number ― if the left digits are read first, this makes up a large-endian orientation. Disregarding the boundary furnishings at both ends of the register, arithmetics and logical shift operations behave the same, and a shift past eight bit positions transports the bit pattern by 1 byte position in the post-obit mode:

Trivial-endian ordering:	a left shift by eight positions increases the byte accost by 1,
	a right shift past 8 positions decreases the byte address by one.
Big-endian ordering:	a left shift by 8 positions decreases the byte address by 1,
	a correct shift by 8 positions increases the byte accost by 1.

Arithmetic shift [edit]

In an arithmetic shift, the bits that are shifted out of either cease are discarded. In a left arithmetic shift, zeros are shifted in on the right; in a right arithmetic shift, the sign fleck (the MSB in two's complement) is shifted in on the left, thus preserving the sign of the operand.

This case uses an viii-flake annals, interpreted as 2'south complement:

          00010111 (decimal +23) LEFT-SHIFT =  00101110          (decimal +46)

          10010111 (decimal −105) Right-SHIFT =          ane1001011 (decimal −53)

In the first instance, the leftmost digit was shifted by the end of the register, and a new 0 was shifted into the rightmost position. In the second case, the rightmost 1 was shifted out (perhaps into the carry flag), and a new i was copied into the leftmost position, preserving the sign of the number. Multiple shifts are sometimes shortened to a unmarried shift past some number of digits. For example:

          00010111 (decimal +23) LEFT-SHIFT-Past-TWO =  01011100          (decimal +92)

A left arithmetic shift by n is equivalent to multiplying by two^{due north} (provided the value does not overflow), while a correct arithmetic shift by n of a two's complement value is equivalent to taking the flooring of division by 2ⁿ. If the binary number is treated as ones' complement, so the same right-shift performance results in sectionalization by 2ⁿ and rounding toward aught.

Logical shift [edit]

In a logical shift, zeros are shifted in to supercede the discarded bits. Therefore, the logical and arithmetics left-shifts are exactly the aforementioned.

However, every bit the logical right-shift inserts value 0 bits into the most significant fleck, instead of copying the sign scrap, it is ideal for unsigned binary numbers, while the arithmetics correct-shift is ideal for signed ii'southward complement binary numbers.

Circular shift [edit]

Another grade of shift is the circular shift, bitwise rotation or bit rotation.

Rotate [edit]

Left round shift or rotate

Right circular shift or rotate

In this performance, sometimes called rotate no bear, the bits are "rotated" every bit if the left and right ends of the register were joined. The value that is shifted into the right during a left-shift is whatever value was shifted out on the left, and vice versa for a right-shift operation. This is useful if it is necessary to retain all the existing bits, and is frequently used in digital cryptography.^{[ clarification needed ]}

Rotate through carry [edit]

Left rotate through deport

Right rotate through carry

Rotate through comport is a variant of the rotate operation, where the bit that is shifted in (on either cease) is the former value of the bear flag, and the bit that is shifted out (on the other end) becomes the new value of the conduct flag.

A unmarried rotate through deport tin simulate a logical or arithmetics shift of one position past setting up the carry flag beforehand. For example, if the carry flag contains 0, then 10 Correct-ROTATE-THROUGH-Conduct-BY-One is a logical right-shift, and if the acquit flag contains a copy of the sign bit, so x RIGHT-ROTATE-THROUGH-CARRY-BY-ONE is an arithmetic right-shift. For this reason, some microcontrollers such as depression end PICs only have rotate and rotate through carry, and don't carp with arithmetic or logical shift instructions.

Rotate through carry is particularly useful when performing shifts on numbers larger than the processor'southward native word size, because if a large number is stored in two registers, the bit that is shifted off one stop of the first register must come in at the other end of the 2nd. With rotate-through-behave, that bit is "saved" in the carry flag during the starting time shift, ready to shift in during the second shift without any extra grooming.

In high-level languages [edit]

C-family and Python [edit]

In C-family languages, the logical shift operators are "<<" for left shift and ">>" for correct shift. The number of places to shift is given as the 2nd argument to the operator. For case,

assigns x the effect of shifting y to the left by ii bits, which is equivalent to a multiplication by four.

Shifts can consequence in implementation-divers behavior or undefined behavior, so care must exist taken when using them. The consequence of shifting by a bit count greater than or equal to the discussion's size is undefined behavior in C and C++.^[2] ^[3] Right-shifting a negative value is implementation-defined and not recommended by good coding practice;^[4] the result of left-shifting a signed value is undefined if the result cannot be represented in the result blazon.^[2]

In C#, the right-shift is an arithmetics shift when the starting time operand is an int or long. If the starting time operand is of blazon uint or ulong, the right-shift is a logical shift.^[5]

Circular shifts [edit]

The C-family of languages lack a rotate operator (although C++20 provides std::rotl and std::rotr), but one tin can be synthesized from the shift operators. Care must be taken to ensure the argument is well formed to avert undefined behavior and timing attacks in software with security requirements.^[6] For case, a naive implementation that left-rotates a 32-bit unsigned value x by n positions is only

                        uint32_t                                    10                                    =                                    ...,                                    north                                    =                                    ...;                        uint32_t                                    y                                    =                                    (            x                                    <<                                    n            )                                    |                                    (            x                                    >>                                    (            32                                    -                                    n            ));

However, a shift by 0 bits results in undefined behavior in the correct-manus expression (x >> (32 - due north)) because 32 - 0 is 32, and 32 is outside the range 0–31 inclusive. A 2nd try might result in

                        uint32_t                                    x                                    =                                    ...,                                    north                                    =                                    ...;                        uint32_t                                    y                                    =                                    due north                                    ?                                    (            ten                                    <<                                    n            )                                    |                                    (            x                                    >>                                    (            32                                    -                                    n            ))                                    :                                    x            ;

where the shift corporeality is tested to ensure that it does not innovate undefined behavior. However, the branch adds an additional lawmaking path and presents an opportunity for timing analysis and assail, which is frequently not acceptable in loftier-integrity software.^[6] In add-on, the code compiles to multiple motorcar instructions, which is often less efficient than the processor'due south native instruction.

To avoid the undefined behavior and branches under GCC and Clang, the following is recommended. The pattern is recognized by many compilers, and the compiler will emit a single rotate instruction:^[7] ^[8] ^[9]

                        uint32_t                                    x                                    =                                    ...,                                    n                                    =                                    ...;                        uint32_t                                    y                                    =                                    (            ten                                    <<                                    n            )                                    |                                    (            x                                    >>                                    (            -            n                                    &                                    31            ));

At that place are also compiler-specific intrinsics implementing round shifts, like _rotl8, _rotl16, _rotr8, _rotr16 in Microsoft Visual C++. Clang provides some rotate intrinsics for Microsoft compatibility that suffers the problems above.^[9] GCC does not offer rotate intrinsics. Intel as well provides x86 intrinsics.

Java [edit]

In Java, all integer types are signed, and so the "<<" and ">>" operators perform arithmetic shifts. Java adds the operator ">>>" to perform logical right shifts, but since the logical and arithmetics left-shift operations are identical for signed integer, there is no "<<<" operator in Coffee.

More details of Java shift operators:^[10]

The operators << (left shift), >> (signed right shift), and >>> (unsigned right shift) are called the shift operators.
The type of the shift expression is the promoted type of the left-hand operand. For example, aByte >>> ii is equivalent to (( int ) aByte ) >>> 2 .
If the promoted type of the left-hand operand is int, only the five lowest-order $.25 of the right-mitt operand are used as the shift distance. It is as if the right-manus operand were subjected to a bitwise logical AND operator & with the mask value 0x1f (0b11111).^[eleven] The shift altitude actually used is therefore always in the range 0 to 31, inclusive.
If the promoted type of the left-mitt operand is long, then only the vi lowest-order $.25 of the right-mitt operand are used as the shift distance. It is as if the right-hand operand were subjected to a bitwise logical AND operator & with the mask value 0x3f (0b111111).^[xi] The shift distance actually used is therefore always in the range 0 to 63, inclusive.
The value of north >>> s is n right-shifted south flake positions with zero-extension.
In fleck and shift operations, the blazon byte is implicitly converted to int . If the byte value is negative, the highest bit is one, so ones are used to fill upwards the extra bytes in the int. And then byte b1 = - v ; int i = b1 | 0x0200 ; volition upshot in i == -5.

JavaScript [edit]

JavaScript uses bitwise operations to evaluate each of two or more units place to 1 or 0.^[12]

Pascal [edit]

In Pascal, as well as in all its dialects (such equally Object Pascal and Standard Pascal), the logical left and correct shift operators are "shl" and "shr", respectively. Even for signed integers, shr behaves similar a logical shift, and does not copy the sign chip. The number of places to shift is given every bit the second argument. For example, the following assigns x the result of shifting y to the left by 2 $.25:

Other [edit]

popcount, used in cryptography
count leading zeros

Applications [edit]

Bitwise operations are necessary especially in lower-level programming such as device drivers, depression-level graphics, communications protocol packet associates, and decoding.

Although machines often have efficient born instructions for performing arithmetic and logical operations, all these operations tin exist performed past combining the bitwise operators and nothing-testing in various ways.^[13] For instance, here is a pseudocode implementation of ancient Egyptian multiplication showing how to multiply two capricious integers a and b (a greater than b) using simply bitshifts and addition:

                        c                                    ←                                    0                        while                                    b                                    ≠                                    0                                                if                                    (            b                                    and                                    1            )                                    ≠                                    0                                                c                                    ←                                    c                                    +                                    a                                                left                                    shift                                    a                                    by                                    1                                                correct                                    shift                                    b                                    by                                    one                        return                                    c

Another example is a pseudocode implementation of add-on, showing how to summate a sum of two integers a and b using bitwise operators and zero-testing:

                        while                                    a                                    ≠                                    0                                                c                                    ←                                    b                                    and                                    a                                                b                                    ←                                    b                                    xor                                    a                                                left                                    shift                                    c                                    past                                    one                                                a                                    ←                                    c                        render                                    b

Boolean algebra [edit]

Sometimes it is useful to simplify complex expressions fabricated up of bitwise operations. For example, when writing compilers. The goal of a compiler is to interpret a high level programming language into the most efficient machine code possible. Boolean algebra is used to simplify complex bitwise expressions.

AND [edit]

x & y = y & ten
x & (y & z) = (x & y) & z
x & 0xFFFF = 10 ^[14]
ten & 0 = 0

x & 10 = x

OR [edit]

x | y = y | x
10 | (y | z) = (x | y) | z
10 | 0 = x
x | 0xFFFF = 0xFFFF
ten | 10 = x

NOT [edit]

~(~x) = ten

XOR [edit]

x ^ y = y ^ x
x ^ (y ^ z) = (x ^ y) ^ z
x ^ 0 = x
x ^ y ^ y = x
ten ^ x = 0
ten ^ 0xFFFF = ~x

Additionally, XOR can be composed using the iii basic operations (AND, OR, Not)

a ^ b = (a | b) & (~a | ~b)
a ^ b = (a & ~b) | (~a & b)

Others [edit]

x | (ten & y) = 10
x & (x | y) = ten
~(x | y) = ~10 & ~y
~(x & y) = ~x | ~y
x | (y & z) = (x | y) & (x | z)
x & (y | z) = (x & y) | (x & z)
x & (y ^ z) = (x & y) ^ (x & z)
x + y = (ten ^ y) + ((10 & y) << 1)
x - y = ~(~x + y)

Inverses and solving equations [edit]

It can be difficult to solve for variables in boolean algebra, because dissimilar regular algebra, several operations do not have inverses. Operations without inverses lose some of the original data $.25 when they are performed, and it is not possible to recover this missing information.

Has inverse
- Not
- XOR
- Rotate left
- Rotate correct
No inverse
- AND
- OR
- Shift left
- Shift right

Club of operations [edit]

Operations at the top of this list are executed first. See the main article for a more complete list.

( )
~ - ^[15]
* / %
+ - ^[16]
<< >>
&
^
|

References [edit]

^ "CMicrotek Depression-power Design Blog". CMicrotek. Retrieved 2015-08-12 .
^ ^a ^b JTC1/SC22/WG14 N843 "C programming linguistic communication", section 6.v.seven
^ "Arithmetics operators - cppreference.com". en.cppreference.com . Retrieved 2016-07-06 .
^ "INT13-C. Apply bitwise operators only on unsigned operands". CERT: Secure Coding Standards. Software Engineering Institute, Carnegie Mellon University. Retrieved 2015-09-07 .
^ "Operator (C# Reference)". Microsoft. Retrieved 2013-07-fourteen .
^ ^a ^b "Near constant time rotate that does not violate the standards?". Stack Exchange Network. Retrieved 2015-08-12 .
^ "Poor optimization of portable rotate idiom". GNU GCC Project. Retrieved 2015-08-11 .
^ "Round rotate that does not violate C/C++ standard?". Intel Programmer Forums. Retrieved 2015-08-12 .
^ ^a ^b "Constant not propagated into inline assembly, results in "constraint 'I' expects an integer constant expression"". LLVM Project. Retrieved 2015-08-11 .
^ The Coffee Language Specification, section 15.nineteen. Shift Operators
^ ^a ^b "Chapter 15. Expressions". oracle.com.
^ "JavaScript Bitwise". W3Schools.com.
^ "Synthesizing arithmetic operations using bit-shifting tricks". Bisqwit.iki.fi. 2014-02-15. Retrieved 2014-03-08 .
^ Throughout this article, 0xFFFF means that all the bits in your data type demand to exist ready to one. The exact number of bits depends on the width of the data type.
^ - is negation hither, non subtraction
^ - is subtraction here, not negation

External links [edit]

Online Bitwise Calculator supports Bitwise AND, OR and XOR
Partition using bitshifts
"Bitwise Operations Mod N" by Enrique Zeleny, Wolfram Demonstrations Project.
"Plots Of Compositions Of Bitwise Operations" by Enrique Zeleny, The Wolfram Demonstrations Project.