Perform left shift, logical right shift, and arithmetic right shift with bit-by-bit visualization, shift tables, sign extension, and multiply/divide equivalences.
Bit shifting is one of the most fundamental and performance-critical operations in computing. A left shift moves every bit toward the most significant position, filling vacated positions with zeros — effectively multiplying the number by a power of two. A right shift does the opposite, dividing by a power of two, but with an important distinction: logical right shift fills with zeros (treating the value as unsigned), while arithmetic right shift preserves the sign bit (treating the value as signed).
Left shifts are used throughout systems programming for creating bitmasks, packing data into compact binary formats, and performing fast multiplication. Right shifts handle fast division, extracting specific bit fields, and sign-extending values during type conversions. The choice between arithmetic and logical right shift affects whether negative numbers stay negative or wrap to large positive values — a common source of subtle bugs.
This calculator lets you experiment with all three shift types across 4-bit to 32-bit widths. The bit-movement visualization shows exactly which bits move where, which bits are lost off the edge, and which new bits are filled in. The shift table displays all possible shift amounts for your value, making it easy to spot patterns like doubling (left shift) and halving (right shift). Sign bit tracking and signed/unsigned interpretations help you understand the difference between arithmetic and logical shifts.
Tracking which bits fall off the edge, which fill in, and whether the sign bit propagates correctly is hard to do in your head — especially for arithmetic right shifts on negative numbers. This calculator shows the binary before and after, highlights each bit's movement, and displays the equivalent multiplication or division so you can validate your reasoning instantly. Embedded programmers use it to design bit-packing schemes, systems students verify homework on sign extension, and anyone debugging shift-related bugs can see exactly what the hardware produces.
Left shift: A << n = A × 2ⁿ. Logical right shift: A >>> n = floor(A / 2ⁿ) (unsigned). Arithmetic right shift: A >> n preserves the MSB (sign bit) while shifting.
Result: 168
170 = 10101010. Left shift by 2: 10101000 = 168 (in 8-bit). Top 2 bits (10) are lost; bottom 2 zeros fill in. 170 × 4 = 680, but 680 mod 256 = 168 due to 8-bit overflow.
A left shift by n positions is equivalent to multiplying by 2ⁿ. Compilers routinely replace `x * 8` with `x << 3` because shift hardware is simpler and faster than a full multiplier. The caveat is **overflow**: in an 8-bit register, 170 << 2 does not give 680 but 168 (680 mod 256), because the two most-significant bits are lost. Understanding overflow is critical in embedded systems where registers are narrow and in cryptographic code where every bit matters.
Logical right shift (>>>) fills vacated high bits with 0, which correctly divides *unsigned* values by 2ⁿ. Arithmetic right shift (>>) copies the sign bit (MSB) into the vacated positions, preserving the sign of *signed* values. For example, −8 in 8-bit two's complement is 11111000; an arithmetic right shift by 1 gives 11111100 = −4, while a logical right shift gives 01111100 = 124. Getting this wrong is a subtle bug because it only manifests for negative inputs, which may be rare in test suites.
- **Power-of-two multiply/divide**: `1 << n` gives 2ⁿ, useful for creating bitmasks like `(1 << 5) - 1 = 31`. - **Extracting a field**: shift right to move the field to the LSB, then AND with a mask: `(reg >> 4) & 0xF` extracts bits 7–4. - **Packing two values**: `(high << 8) | low` packs two bytes into a 16-bit word. - **Fast floor division**: `x >> 1` is a fast floor(x/2) for non-negative x; for signed x, beware that C's `>>` is implementation-defined. - **Pixel manipulation**: colour channels are often packed in 32 bits (ARGB). Extracting Blue: `pixel & 0xFF`. Extracting Green: `(pixel >> 8) & 0xFF`.
Understanding these idioms is essential for systems programming, graphics, and protocol parsing.
Logical right shift (>>>) fills vacated bits with 0. Arithmetic right shift (>>) fills with the sign bit (MSB), preserving the sign of negative numbers. For positive numbers, both produce the same result.
Each bit position represents a power of 2. Moving every bit one position left doubles each bit's positional value. Shifting left by n multiplies by 2ⁿ. This is much faster than multiplication in hardware.
They are simply discarded. In a left shift, the most significant bits fall off; in a right shift, the least significant bits fall off. This is why overflow can occur with left shifts.
Sign extension is the process of filling new high-order bits with the sign bit when performing an arithmetic right shift. This ensures that a negative number remains negative after the shift.
Use logical right shift (>>>). It always fills with zeros, giving the correct unsigned division result. Arithmetic right shift can give wrong results for large unsigned values in languages with signed shift operators.
Yes. Common bugs include: using arithmetic shift on unsigned values (or vice versa), shifting by more than the bit width (undefined in C/C++), and not accounting for overflow when left-shifting large values.