[1.1.5] Logical shifts (8‑bit)

Logical Binary Shifts

Computers need to perform mathematical operations quickly and efficiently. Whilst addition and multiplication are fundamental operations, there exists a remarkably fast way to multiply or divide binary numbers by powers of 2: logical binary shifts. A binary shift is an operation that moves all the bits in a binary number either left or right by a specified number of positions. Understanding how shifts work and their effects on values is essential for efficient computing and forms the basis of many optimization techniques used in software development.

Binary shifts are particularly important because they can be performed extremely quickly by computer hardware - much faster than traditional multiplication or division operations. Processors have dedicated circuits for shifting that complete the operation in a single clock cycle, making shifts one of the fastest operations a computer can perform. This efficiency explains why shifts appear in graphics processing, compression algorithms, network protocols, and countless other computing applications.

Understanding Logical Shift Left

How Logical Shift Left Works

A logical shift left (LSL) operation moves every bit in a binary number one position to the left. When bits shift left, the leftmost bit (the most significant bit) is lost or discarded, and a 0 is inserted at the rightmost position (the least significant bit). This operation is sometimes written as LSL or simply as a left shift with the symbol <<.

Think of a logical shift left as a conveyor belt moving left. Each bit moves one space to the left, the bit at the far left falls off the end, and a zero enters from the right. This simple mechanical process has a profound mathematical effect on the value represented by the binary number.

Effect on Value: Multiplication by 2

The remarkable property of logical shift left is that shifting a binary number left by one position multiplies its value by 2. This happens because in binary, each position represents a power of 2, and moving a bit one position left doubles the power of 2 it represents. For example, a bit in the 2³ position (value 8) moves to the 2⁴ position (value 16), effectively doubling its contribution to the total value.

Example: Shift 00000101 (5 in denary) left by one position

Result: 00000101 (5) becomes 00001010 (10)

Effect: 5 × 2 = 10 ✓

Notice how each bit moved one position left (toward the more significant positions), the leftmost 0 was discarded, and a 0 was added on the right. The value doubled from 5 to 10, demonstrating the multiplicative effect of the left shift.

Multiple Left Shifts

Shifting left by multiple positions multiplies by higher powers of 2. Shifting left by n positions multiplies the value by 2ⁿ. Each additional shift left doubles the value again, so two shifts multiply by 4, three shifts multiply by 8, and so on.

Example: Shift 00000011 (3 in denary) left by three positions

Result: Shifting left by 3 positions multiplied the value by 2³ = 8

Verification: 3 × 8 = 24 ✓

Understanding Logical Shift Right

How Logical Shift Right Works

A logical shift right (LSR) operation moves every bit in a binary number one position to the right. When bits shift right, the rightmost bit (the least significant bit) is lost or discarded, and a 0 is inserted at the leftmost position (the most significant bit). This operation is sometimes written as LSR or simply as a right shift with the symbol >>.

Using the conveyor belt analogy again, logical shift right moves the belt to the right. Each bit moves one space right, the bit at the far right falls off, and a zero enters from the left. This produces the opposite mathematical effect to a left shift.

Effect on Value: Division by 2

Logical shift right divides the value by 2, using integer division (which discards any remainder). This occurs because moving bits right halves the power of 2 each bit represents. A bit in the 2⁴ position (value 16) moves to the 2³ position (value 8), halving its contribution to the total value. Any fractional result is lost when the rightmost bit is discarded.

Example: Shift 00001010 (10 in denary) right by one position

Result: 00001010 (10) becomes 00000101 (5)

Effect: 10 ÷ 2 = 5 ✓

Each bit moved one position right (toward the less significant positions), a 0 was inserted on the left, and the rightmost 0 was discarded. The value halved from 10 to 5.

Multiple Right Shifts and Integer Division

Shifting right by n positions divides by 2ⁿ, using integer division. When the result would be a fraction, the remainder is lost because the bits that would represent the fractional part are discarded. This is equivalent to performing floor division in mathematics.

Example: Shift 00001011 (11 in denary) right by two positions

Result: Shifting right by 2 positions divided by 2² = 4

Verification: 11 ÷ 4 = 2.75, which becomes 2 with integer division ✓

Data lost: The fractional part (0.75) is permanently lost when the rightmost bits are discarded.

Data Loss in Binary Shifts

Bits Lost in Left Shifts

When performing a left shift, any 1 bits that move beyond the leftmost position are permanently lost. This is critical to understand because it means that left shifts do not always accurately multiply by 2 - if significant bits are lost, the result will be incorrect. This situation is similar to overflow in addition, where the result becomes too large to fit in the available bits.

Example of data loss in left shift:

Shift 11000000 (192 in denary) left by one position:

• Original: 11000000 (192)
• Expected result: 192 × 2 = 384
• Actual 8-bit result: 10000000 (128)
• Problem: The leftmost 1 bit was lost, making the result incorrect
• Correct result requires 9 bits: 110000000 (384)

This data loss means that left shifts can only safely multiply values when the result fits within 8 bits (i.e. when the result is ≤ 255). Any value over 127 cannot be doubled without losing bits, and any value over 63 cannot be quadrupled without losing bits.

Bits Lost in Right Shifts

Right shifts also lose data, but in a different way. When shifting right, the rightmost bits are discarded, which means any information they contained is permanently lost. This is why right shifts perform integer division - the fractional part that would be represented by the lost bits simply disappears.

Example of data loss in right shift:

Shift 00000111 (7 in denary) right by one position:

• Original: 00000111 (7)
• After LSR 1: 00000011 (3)
• Mathematical division: 7 ÷ 2 = 3.5
• Lost information: The 0.5 fractional part (represented by the rightmost 1 bit) is discarded

This data loss is acceptable when integer division is desired, but it means that repeatedly shifting right and then left will not recover the original value if bits with 1s were lost. Right shifts are non-reversible operations when data loss occurs.

Practical Examples with 8-bit Numbers

Example 1: Successful Left Shift

Task: Shift 00010110 (22 in denary) left by two positions

Result: 01011000 (88)

Verification: 22 × 4 = 88 ✓ (No data loss because 88 < 256)

Example 2: Left Shift with Data Loss

Task: Shift 01100100 (100 in denary) left by two positions

Result: 10010000 (144)

Expected: 100 × 4 = 400

Problem: The leftmost 1 bit was lost when shifting from 11001000 to 10010000, causing incorrect result. The value 400 requires 9 bits to represent (110010000), but only 8 bits are available.

Example 3: Right Shift with Integer Division

Task: Shift 01010101 (85 in denary) right by three positions

Result: 00001010 (10)

Verification: 85 ÷ 8 = 10.625, which rounds down to 10 ✓

Data lost: The fractional part 0.625 was discarded through the rightmost bits being lost.

Summary of Effects

Remember that shifts are powerful tools when used correctly, but they come with important limitations regarding data loss. Always consider whether the mathematical operation you need can be accurately performed with the available bits, and understand that right shifts permanently discard fractional information.