How do I perform a circular shift in Swift? - swift

Question

I am trying to perform a circular shift in Swift and I currently have the following code which uses a string containing the bits of the number I am trying to perform the circular shift on. Here is the code I have so far,
func circularRightShift(_ input: UInt8, _ amount: UInt8) -> UInt8 {
guard amount > 0 else { return input }
var a = String(UInt("\(input)")!, radix: 2)
if a.count != 8 {
a = "".padding(toLength: 8-a.count, withPad: "0", startingAt: 0) + a
}
for _ in 1...amount {
a.insert(a.last!, at: a.startIndex)
a.removeLast()
}
return UInt8(a, radix: 2)!
}
This code works properly, but it's a bit slow. Is there any better way to achieve this, possibly without using a string? Thanks in advance.

Answer 1

You can achieve this with two bit shift operators and a bitwise OR:
func circularRightShift(_ input: UInt8, _ amount: UInt8) -> UInt8 {
let amount = amount % 8 // Reduce to the range 0...7
return (input >> amount) | (input << (8 - amount))
}
Example (amount=5):
abcdefgh <- bits of input
00000abc <- bits of input >> amount
defgh000 <- bits of input << (8 - amount)
defghabc <- bits of result

Answer 2

Another, more general answer is this:
func circularShift<ShiftType: BinaryInteger>(_ first: ShiftType, by shiftAmount: Int) -> ShiftType {
(first << shiftAmount) | (first >> (first.bitWidth - shiftAmount))
}
You can also create an extension:
extension BinaryInteger {
func circularShifted(by shiftAmount: Int) -> Self {
(self << shiftAmount) | (self >> (self.bitWidth - shiftAmount))
}
}
To be even more flexible, you can take the sign of the operation into account and differentiate between left and right shifting:
extension BinaryInteger where Self: UnsignedInteger {
func rotateLeft(by shiftAmount: Int) -> Self {
if shiftAmount < 0 {
return rotateRight(by: -shiftAmount)
}
return (self << shiftAmount) | (self >> (self.bitWidth - shiftAmount))
}
func rotateRight(by shiftAmount: Int) -> Self {
if shiftAmount < 0 {
return rotateLeft(by: -shiftAmount)
}
return (self >> shiftAmount) | (self << (self.bitWidth - shiftAmount))
}
}
which can then be used like
let x: UInt8 = 0xE
String(x.rotateLeft(by: 2), radix: 16) // 3A
String(x.rotateRight(by: 2), radix: 16) // A3

Answer 3

One approach is to shift your number as 16-bits, and then combine the two bytes with each other, like this:
func circular(n: UInt8, k: UInt8) -> UInt8 {
var s = UInt16(n) << (k & 0x07)
return UInt8(s & 0xFF) | UInt8(s >> 8)
}
Demo