feat: Add BitRotate utility for circular bit rotations

Author: Yajunesh M R

src/main/java/com/thealgorithms/bitmanipulation/BitRotate.java

@@ -4,7 +4,7 @@
  * Utility class for performing circular bit rotations on 32-bit integers.
  * Bit rotation is a circular shift operation where bits shifted out on one end
  * are reinserted on the opposite end.
- * 
+ *
  * <p>This class provides methods for both left and right circular rotations,
  * supporting only 32-bit integer operations with proper shift normalization
  * and error handling.</p>
@@ -29,24 +29,24 @@ private BitRotate() {
      * @param shift the number of positions to rotate left (must be non-negative)
      * @return the result of left rotating the value by the specified shift amount
      * @throws IllegalArgumentException if shift is negative
-     * 
-     * @example 
+     *
+     * @example
      * // Binary: 10000000 00000000 00000000 00000001
-     * rotateLeft(0x80000001, 1) 
+     * rotateLeft(0x80000001, 1)
      * // Returns: 3 (binary: 00000000 00000000 00000000 00000011)
      */
     public static int rotateLeft(int value, int shift) {
         if (shift < 0) {
             throw new IllegalArgumentException("Shift amount cannot be negative: " + shift);
         }
-        
+
         // Normalize shift to the range [0, 31] using modulo 32
         shift = shift % 32;
-        
+
         if (shift == 0) {
             return value;
         }
-        
+
         // Left rotation: (value << shift) | (value >>> (32 - shift))
         return (value << shift) | (value >>> (32 - shift));
     }
@@ -59,25 +59,25 @@ public static int rotateLeft(int value, int shift) {
      * @param shift the number of positions to rotate right (must be non-negative)
      * @return the result of right rotating the value by the specified shift amount
      * @throws IllegalArgumentException if shift is negative
-     * 
+     *
      * @example
-     * // Binary: 00000000 00000000 00000000 00000011  
+     * // Binary: 00000000 00000000 00000000 00000011
      * rotateRight(3, 1)
      * // Returns: -2147483647 (binary: 10000000 00000000 00000000 00000001)
      */
     public static int rotateRight(int value, int shift) {
         if (shift < 0) {
             throw new IllegalArgumentException("Shift amount cannot be negative: " + shift);
         }
-        
+
         // Normalize shift to the range [0, 31] using modulo 32
         shift = shift % 32;
-        
+
         if (shift == 0) {
             return value;
         }
-        
+
         // Right rotation: (value >>> shift) | (value << (32 - shift))
         return (value >>> shift) | (value << (32 - shift));
     }
-}
+}

src/test/java/com/thealgorithms/bitmanipulation/BitRotateTest.java

@@ -1,6 +1,7 @@
 package com.thealgorithms.bitmanipulation;
 
 import static org.junit.jupiter.api.Assertions.*;
+
 import org.junit.jupiter.api.Test;
 
 /**
@@ -23,10 +24,10 @@ void testRotateLeftBasic() {
     void testRotateLeftWithCarry() {
         // Test bits carrying from left to right
         // Binary: 10000000_00000000_00000000_00000001
-        int value = 0x80000001; 
+        int value = 0x80000001;
         // After left rotate by 1: 00000000_00000000_00000000_00000011
         assertEquals(3, BitRotate.rotateLeft(value, 1));
-        
+
         // Binary: 11000000_00000000_00000000_00000000
         value = 0xC0000000;
         // After left rotate by 1: 10000000_00000000_00000000_00000001
@@ -74,7 +75,7 @@ void testRotateRightWithCarry() {
         int value = 3;
         // After right rotate by 1: 10000000_00000000_00000000_00000001
         assertEquals(0x80000001, BitRotate.rotateRight(value, 1));
-        
+
         // Binary: 00000000_00000000_00000000_00000001
         value = 1;
         // After right rotate by 1: 10000000_00000000_00000000_00000000
@@ -146,16 +147,14 @@ void testRotateAllZeros() {
     @Test
     void testRotateLeftNegativeShift() {
         // Negative shifts should throw IllegalArgumentException
-        Exception exception = assertThrows(IllegalArgumentException.class, 
-            () -> BitRotate.rotateLeft(42, -1));
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> BitRotate.rotateLeft(42, -1));
         assertTrue(exception.getMessage().contains("negative"));
     }
 
     @Test
     void testRotateRightNegativeShift() {
         // Negative shifts should throw IllegalArgumentException
-        Exception exception = assertThrows(IllegalArgumentException.class, 
-            () -> BitRotate.rotateRight(42, -5));
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> BitRotate.rotateRight(42, -5));
         assertTrue(exception.getMessage().contains("negative"));
     }
 
@@ -166,10 +165,10 @@ void testRotateLeftRightComposition() {
         // Rotating left then right by same amount should return original value
         int original = 0x12345678;
         int shift = 7;
-        
+
         int leftRotated = BitRotate.rotateLeft(original, shift);
         int restored = BitRotate.rotateRight(leftRotated, shift);
-        
+
         assertEquals(original, restored);
     }
 
@@ -178,10 +177,10 @@ void testRotateRightLeftComposition() {
         // Rotating right then left by same amount should return original value
         int original = 0x9ABCDEF0;
         int shift = 13;
-        
+
         int rightRotated = BitRotate.rotateRight(original, shift);
         int restored = BitRotate.rotateLeft(rightRotated, shift);
-        
+
         assertEquals(original, restored);
     }
 
@@ -191,4 +190,4 @@ void testRotateLeft31IsSameAsRotateRight1() {
         int value = 0x55555555;
         assertEquals(BitRotate.rotateLeft(value, 31), BitRotate.rotateRight(value, 1));
     }
-}
+}