Logical shift

In computer science, a logical shift is a bitwise operation that shifts all the bits of its operand. The two base variants are the logical left shift and the logical right shift. This is further modulated by the number of bit positions a given value shall be shifted, such as shift left by 1 or shift right by n. Unlike an arithmetic shift, a logical shift does not preserve a number's sign bit or distinguish a number's exponent from its significand (mantissa); every bit in the operand is simply moved a given number of bit positions, and the vacant bit-positions are filled, usually with zeros, and possibly ones (contrast with a circular shift). A logical shift is often used when its operand is being treated as a sequence of bits instead of as a number. Logical shifts can be useful as efficient ways to perform multiplication or division of unsigned integers by powers of two. Shifting left by n bits on a signed or unsigned binary number has the effect of multiplying it by 2n. Shifting right by n bits on an unsigned binary number has the effect of dividing it by 2n (rounding towards 0). Logical right shift differs from arithmetic right shift. Thus, many languages have different operators for them. For example, in Java and JavaScript, the logical right shift operator is >>>, but the arithmetic right shift operator is >>. (Java has only one left shift operator (<<), because left shift via logic and arithmetic have the same effect.) The programming languages C, C++, and Go, however, have only one right shift operator, >>. Most C and C++ implementations, and Go, choose which right shift to perform depending on the type of integer being shifted: signed integers are shifted using the arithmetic shift, and unsigned integers are shifted using the logical shift. In particular, C++ uses its logical shift operators as part of the syntax of its input and output functions, called "cin" and "cout" respectively. All currently relevant C standards (ISO/IEC 9899:1999 to 2011) leave a definition gap for cases where the number of shifts is equal to or bigger than the number of bits in the operands in a way that the result is undefined. This helps allow C compilers to emit efficient code for various platforms by allowing direct use of the native shift instructions which have differing behavior. For example, shift-left-word in PowerPC chooses the more-intuitive behavior where shifting by the bit width or above gives zero, whereas SHL in x86 chooses to mask the shift amount to the lower bits to reduce the maximum execution time of the instructions, and as such a shift by the bit width doesn't change the value. Some languages, such as the .NET Framework and LLVM, also leave shifting by the bit width and above unspecified (.NET) or undefined (LLVM). Others choose to specify the behavior of their most common target platforms, such as C# which specifies the x86 behavior.

Bit-level computer operation

"shift left" redirects here. For the software testing practice, see shift-left testing.

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Logical shift" – news · newspapers · books · scholar · JSTOR (April 2016) (Learn how and when to remove this message)

In computer science, a logical shift is a bitwise operation that shifts all the bits of its operand. The two base variants are the logical left shift and the logical right shift. This is further modulated by the number of bit positions a given value shall be shifted, such as shift left by 1 or shift right by n. Unlike an arithmetic shift, a logical shift does not preserve a number's sign bit or distinguish a number's exponent from its significand (mantissa); every bit in the operand is simply moved a given number of bit positions, and the vacant bit-positions are filled, usually with zeros, and possibly ones (contrast with a circular shift).

A logical shift is often used when its operand is being treated as a sequence of bits instead of as a number.

Logical shift operators in various programming languages and processors

Language or processor	Left	Right
Ada[1]	Shift_Left	Shift_Right
Batch,[2] C, C++, Go, Swift (unsigned types only); Standard ML, Verilog, PHP, Python,[3] Rust[4] (unsigned types only[5])	<<	>>
D, Java, JavaScript, Julia	<<	>>>
F# (unsigned types only)	<<<	>>>
Fortran	LSHIFT	RSHIFT
OCaml	lsl	lsr
Object Pascal, Delphi, x86 assembly, Kotlin, Powershell	shl	shr
VHDL, MIPS, RISC-V	sll	srl
PowerPC	slw	srw

Logical shifts can be useful as efficient ways to perform multiplication or division of unsigned integers by powers of two. Shifting left by n bits on a signed or unsigned binary number has the effect of multiplying it by 2ⁿ. Shifting right by n bits on an unsigned binary number has the effect of dividing it by 2ⁿ (rounding towards 0).

Logical right shift differs from arithmetic right shift. Thus, many languages have different operators for them. For example, in Java and JavaScript, the logical right shift operator is >>>, but the arithmetic right shift operator is >>. (Java has only one left shift operator (<<), because left shift via logic and arithmetic have the same effect.)

The programming languages C, C++, and Go, however, have only one right shift operator, >>. Most C and C++ implementations, and Go, choose which right shift to perform depending on the type of integer being shifted: signed integers are shifted using the arithmetic shift, and unsigned integers are shifted using the logical shift. In particular, C++ uses its logical shift operators as part of the syntax of its input and output functions, called "cin" and "cout" respectively.

All currently relevant C standards (ISO/IEC 9899:1999 to 2011) leave a definition gap for cases where the number of shifts is equal to or bigger than the number of bits in the operands in a way that the result is undefined. This helps allow C compilers to emit efficient code for various platforms by allowing direct use of the native shift instructions which have differing behavior. For example, shift-left-word in PowerPC chooses the more-intuitive behavior where shifting by the bit width or above gives zero,^[6] whereas SHL in x86 chooses to mask the shift amount to the lower bits to reduce the maximum execution time of the instructions, and as such a shift by the bit width doesn't change the value.^[7]

Some languages, such as the .NET Framework and LLVM, also leave shifting by the bit width and above unspecified (.NET)^[8] or undefined (LLVM).^[9] Others choose to specify the behavior of their most common target platforms, such as C# which specifies the x86 behavior.^[10]

Example

[edit]

If the bit sequence 0001 0111 (decimal 23) is logically shifted by one bit position, then:

Shift left yields: 0010 1110 (decimal 46)

Shift right yields: 0000 1011 (decimal 11)

Note: MSB = Most Significant Bit, LSB = Least Significant Bit

References

[edit]

1. ^ "The Package Interfaces". www.adaic.org.
2. ^ "Set - Environment Variable - Windows CMD - SS64.com". ss64.com.
3. ^ "BitwiseOperators - Python Wiki". wiki.python.org. Retrieved 2018-01-24.
4. ^ "Shl in std::ops - Rust". doc.rust-lang.org. Retrieved 2022-01-17.
5. ^ "Operator Expressions: Arithmetic and Logical Binary Operators". doc.rust-lang.org. Retrieved 2022-11-13.
6. ^ "PowerPC Instruction Set: slw". pds.twi.tudelft.nl. Archived from the original on 4 September 2014. Retrieved 9 April 2016.
7. ^ "x86 Instruction Set Reference". x86.renejeschke.de. Archived from the original on 19 February 2018. Retrieved 9 April 2016.
8. ^ "Opcodes.Shl Field". msdn.microsoft.com. Microsoft. Retrieved 9 April 2016.
9. ^ "LLVM Language Reference Manual - shl Instruction". llvm.org. LLVM Project. Retrieved 9 April 2016.
10. ^ "<< Operator (C# Reference)". msdn.microsoft.com. Microsoft. Retrieved 9 April 2016.