This article needs additional citations for verification. (December 2009) (Learn how and when to remove this template message) 
In combinatorial mathematics, a circular shift is the operation of rearranging the entries in a tuple, either by moving the final entry to the first position, while shifting all other entries to the next position, or by performing the inverse operation. A circular shift is a special kind of cyclic permutation, which in turn is a special kind of permutation. Formally, a circular shift is a permutation σ of the n entries in the tuple such that either
 modulo n, for all entries i = 1, ..., n
or
 modulo n, for all entries i = 1, ..., n.
The result of repeatedly applying circular shifts to a given tuple are also called the circular shifts of the tuple.
For example, repeatedly applying circular shifts to the fourtuple (a, b, c, d) successively gives
 (d, a, b, c),
 (c, d, a, b),
 (b, c, d, a),
 (a, b, c, d) (the original fourtuple),
and then the sequence repeats; this fourtuple therefore has four distinct circular shifts. However, not all ntuples have n distinct circular shifts. For instance, the 4tuple (a, b, a, b) only has 2 distinct circular shifts. In general the number of circular shifts of an ntuple could be any divisor of n, depending on the entries of the tuple.
In computer programming, a circular shift (or bitwise rotation) is a shift operator that shifts all bits of its operand. Unlike an arithmetic shift, a circular shift does not preserve a number's sign bit or distinguish a number's exponent from its significand (sometimes referred to as the mantissa). Unlike a logical shift, the vacant bit positions are not filled in with zeros but are filled in with the bits that are shifted out of the sequence.
Implementing circular shifts
Circular shifts are used often in cryptography in order to permute bit sequences. Unfortunately, many programming languages, including C, do not have operators or standard functions for circular shifting, even though virtually all processors have bitwise operation instructions for it (e.g. Intel x86 has ROL and ROR). However, some compilers may provide access to the processor instructions by means of intrinsic functions. In addition, it is possible to write standard ANSI C code that compiles down to the "rotate" assembly language instruction (on CPUs that have such an instruction). Most C compilers recognize the following idiom, and compile it to a single 32bit rotate instruction.^{[1]}^{[2]}
/*
* Shift operations in C are only defined for shift values which are
* not negative and smaller than sizeof(value) * CHAR_BIT.
* The mask, used with bitwiseand (&), prevents undefined behaviour
* when the shift count is 0 or >= the width of unsigned int.
*/
#include <stdint.h> // for uint32_t, to get 32bitwide rotates, regardless of the size of int.
#include <limits.h> // for CHAR_BIT
uint32_t rotl32 (uint32_t value, unsigned int count) {
const unsigned int mask = CHAR_BIT*sizeof(value)  1;
count &= mask;
return (value << count)  (value >> (count & mask));
}
uint32_t rotr32 (uint32_t value, unsigned int count) {
const unsigned int mask = CHAR_BIT*sizeof(value)  1;
count &= mask;
return (value >> count)  (value << (count & mask));
}
This safe and compilerfriendly implementation was developed by John Regehr,^{[3]} and further polished by Peter Cordes.^{[4]}^{[5]}
A simpler version is often seen when the count
is limited to the range of 1 to 31 bits:
uint32_t rotl32 (uint32_t value, unsigned int count) {
return value<<count  value>>(32count);
}
This version is dangerous because if the count
is 0 or 32, it asks for a 32bit shift, which is undefined behaviour in the C language standard. However, it tends to work anyway, because most microprocessors implement value>>32
as either a 32bit shift (producing 0) or a 0bit shift (producing the original value
), and either one produces the correct result in this application.
For C++, the use of templates can expand the support to all integer types:
// https://stackoverflow.com/a/776550/3770260
template <typename INT>
#if __cplusplus > 201100L // Apply constexpr to C++ 11 to ease optimization
constexpr
#endif // See also https://stackoverflow.com/a/7269693/3770260
INT rol(INT val, size_t len) {
#if __cplusplus > 201100L && _wp_force_unsigned_rotate // Apply unsigned check C++ 11 to make sense
static_assert(std::is_unsigned<INT>::value,
"Rotate Left only makes sense for unsigned types");
#endif
return (val << len)  ((unsigned) val >> (len & (sizeof(INT) * CHAR_BIT  1)));
}
Example
If the bit sequence 0001 0111 were subjected to a circular shift of one bit position... (see images below)


If the bit sequence 1001 0110 were subjected to the following operations:
 left circular shift by 2 positions: 0101 1010
 left circular shift by 3 positions: 1011 0100
 right circular shift by 5 positions: 1010 0101
 right circular shift by 1 position: 1101 0010
 left circular shift by 3 positions: 1001 0110
Applications
Cyclic codes are a kind of block code with the property that the circular shift of a codeword will always yield another codeword. This motivates the following general definition: For a string s over an alphabet Σ, let shift(s) denote the set of circular shifts of s, and for a set L of strings, let shift(L) denote the set of all circular shifts of strings in L. As already noted, if L is a cyclic code, we have L = shift(L). The operation shift(L) has been studied in formal language theory. For instance, if L is a contextfree language, then shift(L) is again contextfree.^{[6]}^{[7]} Also, if L is described by a regular expression of length n, there is a regular expression of length O(n^{3}) describing shift(L).^{[8]}
See also
References
 ^ GCC: "Optimize common rotate constructs"
 ^ "Cleanups in ROTL/ROTR DAG combiner code" mentions that this code supports the "rotate" instruction in the CellSPU
 ^ Safe, Efficient, and Portable Rotate in C/C++
 ^ Stackoverflow: Best practices for rotates in C/C++
 ^ Near constant time rotate that does not violate the standards
 ^ T. Oshiba, "Closure property of the family of contextfree languages under the cyclic shift operation", Transactions of IECE, 55D:119–122, 1972.
 ^ A. N. Maslov, "Cyclic shift operation for languages", Problems of Information Transmission 9:333–338, 1973.
 ^ Gruber, Hermann; Holzer, Markus (2009). "Language operations with regular expressions of polynomial size" (PDF). Theoretical Computer Science. 410 (35): 3281–3289. doi:10.1016/j.tcs.2009.04.009. Zbl 1176.68105..