Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/numeric/rotl"

From cppreference.com
< cpp‎ | numeric
(- nodiscard)
m (fmt.)
 
Line 6: Line 6:
 
}}
 
}}
  
−
Computes the result of bitwise left-rotating the value of {{c|x}} by {{c|s}} positions. This operation is also known as a left [[enwiki:Circular_shift|circular shift]].
+
Computes the result of bitwise left-rotating the value of {{c|x}} by {{c|s}} positions. This operation is also known as a left {{enwiki|Circular shift|circular shift}}.
  
−
Formally, let {{tt|N}} be {{c|std::numeric_limits<T>::digits}}, {{tt|r}} be {{c|s % N}}.
+
Formally, let {{tt|N}} be {{c/core|std::numeric_limits<T>::digits}} and {{c|r}} be {{c|s % N}}.
−
* If {{tt|r}} is 0, returns {{c|x}};
+
* If {{c|r}} is {{c|0}}, returns {{c|x}};
−
* if {{tt|r}} is positive, returns {{c|(x << r) {{!}} (x >> (N - r))}};
+
* if {{c|r}} is positive, returns {{c|(x << r) {{!}} (x >> (N - r))}};
−
* if {{tt|r}} is negative, returns {{c|std::rotr(x, -r)}}.
+
* if {{c|r}} is negative, returns {{c|std::rotr(x, -r)}}.
  
−
{{cpp/enable_if|{{tt|T}} is an unsigned integer type (that is, {{c|unsigned char}}, {{c|unsigned short}}, {{c|unsigned int}}, {{c|unsigned long}}, {{c|unsigned long long}}, or an extended unsigned integer type)}}.
+
{{cpp/enable if|{{tt|T}} is an unsigned integer type (that is, {{c/core|unsigned char}}, {{c/core|unsigned short}}, {{c/core|unsigned int}}, {{c/core|unsigned long}}, {{c/core|unsigned long long}}, or an extended unsigned integer type)}}.
  
 
===Parameters===
 
===Parameters===
Line 25: Line 25:
  
 
===Notes===
 
===Notes===
−
{{feature test macro|__cpp_lib_bitops|std=C++20|value=201907L|[[cpp/numeric#Bit_manipulation (since C++20)|Bit operations]]}}
+
{{feature test macro|__cpp_lib_bitops|std=C++20|value=201907L|[[cpp/numeric#Bit manipulation (since C++20)|Bit operations]]}}
  
−
=== Example ===
+
===Example===
 
{{example
 
{{example
 
|code=
 
|code=
Line 37: Line 37:
 
int main()
 
int main()
 
{
 
{
−
     const std::uint8_t i = 0b00011101;
+
     using bin = std::bitset<8>;
−
    std::cout << "i          = " << std::bitset<8>(i) << '\n';
+
     const std::uint8_t x{0b00011101};
−
     std::cout << "rotl(i,0)  = " << std::bitset<8>(std::rotl(i, 0)) << '\n';
+
     std::cout << bin(x) << " <- x\n";
−
     std::cout << "rotl(i,1) = " << std::bitset<8>(std::rotl(i, 1)) << '\n';
+
     for (const int s : {0, 1, 4, 9, -1})
−
     std::cout << "rotl(i,4)  = " << std::bitset<8>(std::rotl(i, 4)) << '\n';
+
        std::cout << bin(std::rotl(x, s)) << " <- rotl(x, " << s << ")\n";
−
    std::cout << "rotl(i,9)  = " << std::bitset<8>(std::rotl(i, 9)) << '\n';
+
−
    std::cout << "rotl(i,-1) = " << std::bitset<8>(std::rotl(i, -1)) << '\n';
+
 
}
 
}
 
|output=
 
|output=
−
i          = 00011101
+
00011101 <- x
−
rotl(i,0) = 00011101
+
00011101 <- rotl(x, 0)
−
rotl(i,1) = 00111010
+
00111010 <- rotl(x, 1)
−
rotl(i,4) = 11010001
+
11010001 <- rotl(x, 4)
−
rotl(i,9) = 00111010
+
00111010 <- rotl(x, 9)
−
rotl(i,-1) = 10001110
+
10001110 <- rotl(x, -1)
 
}}
 
}}
  
−
=== See also ===
+
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
 
{{dsc inc|cpp/numeric/dsc rotr}}
 
{{dsc inc|cpp/numeric/dsc rotr}}

Latest revision as of 13:28, 2 November 2024

 
C++
 
Numerics library
Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Factor operations
(C++17)
(C++17)
Interpolations
(C++20)
(C++20)
Saturation arithmetic
(C++26)
(C++26)
(C++26)
(C++26)
(C++26)

Generic numeric operations
Bit operations
(C++20)    
(C++20)
(C++20)
(C++20)
(C++20)
rotl
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++23)
(C++20)
 
Defined in header <bit>
template< class T >
constexpr T rotl( T x, int s ) noexcept;
 (since C++20)

Computes the result of bitwise left-rotating the value of x by s positions. This operation is also known as a left circular shift.

Formally, let N be std::numeric_limits<T>::digits and r be s % N.

  • If r is ​0​, returns x;
  • if r is positive, returns (x << r) | (x >> (N - r));
  • if r is negative, returns std::rotr(x, -r).

This overload participates in overload resolution only if T is an unsigned integer type (that is, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, or an extended unsigned integer type).

Contents

[edit] Parameters

x - value of unsigned integer type
s - number of positions to shift

[edit] Return value

The result of bitwise left-rotating x by s positions.

[edit] Notes

Feature-test macro Value Std Feature
__cpp_lib_bitops 201907L (C++20) Bit operations

[edit] Example

Run this code
#include <bit>
#include <bitset>
#include <cstdint>
#include <iostream>
 
int main()
{
    using bin = std::bitset<8>;
    const std::uint8_t x{0b00011101};
    std::cout << bin(x) << " <- x\n";
    for (const int s : {0, 1, 4, 9, -1})
        std::cout << bin(std::rotl(x, s)) << " <- rotl(x, " << s << ")\n";
}

Output: 

00011101 <- x
00011101 <- rotl(x, 0)
00111010 <- rotl(x, 1)
11010001 <- rotl(x, 4)
00111010 <- rotl(x, 9)
10001110 <- rotl(x, -1)

[edit] See also

(C++20)
 computes the result of bitwise right-rotation
(function template) [edit]
performs binary shift left and shift right
(public member function of std::bitset<N>) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/rotl&oldid=177490"