Bitwise

From CryptoDox, The Online Encyclopedia on Cryptography and Information Security

A bitwise operation operates on one or two bits at the level of their individual bits.

Contents 1 Bitwise operators 1.1 NOT 1.2 OR 1.3 XOR 1.4 AND 1.5 External Links

Bitwise operators

NOT

A bitwise NOT or complement is a unary operation which performs logical negation on each bit. 0 digits become 1, and vice versa. For example:

NOT 0111
  = 1000

In the C and C++ programming languages, and even in some interpreted languages like Python and Perl, the bitwise NOT operator is "~" (tilde). For example:

x = ~y; 

assigns x the result of "NOT y". This is different from the C and C++ logical "not" operator, "!" (exclamation point), which treats the entire numeral as a single Boolean value. For example:

x = !y;

assigns x a Boolean value of "true" if y is "false", or "false" if y is "true". In C and C++, a numerical value is interpreted as "true" if it is non-zero. (In C and C++, the relational, equality, and logical operators return an integer 1 for true and an integer 0 for false.) The logical "not" is not normally considered a bitwise operation, since it does not operate at the bit level.

Bitwise NOT is useful in finding the one's complement of a binary numeral, and may be an intermediate step in finding the two's complement of the same numeral.

OR

A bitwise OR takes two bit patterns of equal length, and produces another one of the same length by matching up corresponding bits (the first of each; the second of each; and so on) and performing the logical disjunction operation on each pair of corresponding bits. In each pair, the result is 1 if the first bit is 1 OR the second bit is 1. Otherwise, the result is zero. For example:

   0101
OR 0011
 = 0111 

In C/C++, the bitwise OR operator is "|". For example:

x = y | z;

assigns x the result of "y OR z". This is different from the C and C++ logical "or" operator, "||" (two vertical bars), which treats its operands as Boolean values, and results in "true" or "false".

The bitwise OR may be used in situations where a set of bits are used as flags; the bits in a single binary numeral may each represent a distinct Boolean variable. Applying the bitwise OR operation to the numeral along with a bit pattern containing 1 in some positions will result in a new numeral with those bits set. For example:

0010

can be considered as a set of four flags. The first, second, and fourth flags are not set (0); the third flag is set (1). The first flag may be set by applying the bitwise OR to this value, along with another value in which only the first flag is set:

   0010
OR 1000
 = 1010

This technique may be employed by programmers who are working under restrictions of memory space; one bit pattern can represent the states of several independent variables at once.

XOR

A bitwise exclusive OR takes two bit patterns of equal length and performs the logical XOR operation on each pair of corresponding bits. The result in each position is 1 if the two bits are different, and 0 if they are the same. For example:

    0101
XOR 0011
  = 0110

In C/C++, the bitwise XOR operator is "^" (circumflex). For example:

x = y ^ z;

assigns x the result of "y XOR z".

Assembly language programmers sometimes use the XOR operation as a short-cut to set the value of a processor register to zero. Performing XOR on a value against itself always yields zero, and on many architectures, this operation requires fewer CPU clock cycles than the sequence of operations that may be required to load a zero value and save it to the register.

The bitwise XOR may also be used to toggle flags in a set of bits. Given a bit pattern:

0010

The first and third bits may be toggled simultaneously by a bitwise XOR with another bit pattern containing 1 in the first and third positions:

    0010
XOR 1010
  = 1000

This technique may be used to manipulate bit patterns representing sets of Boolean variables.

AND

A bitwise AND takes two binary representations of equal length and performs the logical AND on each pair of corresponding bits. In each pair, the result is 1 if the first bit is 1 AND the second bit is 1. Otherwise, the result is zero. For example:

    0101
AND 0011
  = 0001

In C/C++, the bitwise AND operator is "&" (ampersand). For example:

x = y & z;

assigns x the result of "y AND z". This is different from the C and C++ logical "and" operator, "&&", which takes two logical operands as input and produces a result of "true" or "false".

The bitwise AND may be used to perform a bit mask operation. This operation may be used to isolate part of a string of bits, or to determine whether a particular bit is 1 or 0. For example, given a bit pattern:

0011

To determine whether the third bit is 1, a bitwise AND is applied to it along with another bit pattern containing 1 in the third bit, and 0 in all other bits:

    0011
AND 0010
  = 0010

Since the result is 0010 (not zero), the third bit in the original pattern was 1. Using bitwise AND in this manner is called bit masking, by analogy to the use of masking tape to cover, or mask, portions that should not be altered, or are not of interest. The 0 values mask the bits that are not of concern, in this case.

External Links

• GameDev.net - Bitwise Operations in C
• Bitwise Operators and Bit Masks