Add missing comments. Remove rotate function.

Author: Galfurian

include/bvlib/bitvector.hpp

@@ -49,7 +49,7 @@ inline auto popcount(T x) -> std::size_t
 /// @param N The size of the BitVector in bits.
 template <std::size_t N>
 struct BlockTypeHelper {
-    // Determine the smallest unsigned integer type that can store N bits.
+    /// Determine the smallest unsigned integer type that can store N bits.
     using type = std::conditional_t<
         (N <= 8),
         std::uint8_t, // 8-bit
@@ -282,7 +282,13 @@ class BitVector
         if (pos >= N) {
             throw std::out_of_range("Bit position out of range.");
         }
-        data[pos / BitsPerBlock] |= static_cast<BlockType>(BlockType(1) << (pos % BitsPerBlock));
+        // Get the block index and bit position for the given position.
+        std::size_t block = get_block_index(pos);
+        std::size_t bit   = get_bit_position(pos);
+
+        // Set the bit at the calculated position.
+        data[block] |= static_cast<BlockType>(BlockType(1) << bit);
+
         return *this;
     }
 
@@ -304,8 +310,12 @@ class BitVector
         if (pos >= N) {
             throw std::out_of_range("Bit position out of range");
         }
-        // Ensure same indexing as `set(pos)`
-        data[pos / BitsPerBlock] = static_cast<BlockType>(data[pos / BitsPerBlock] & ~(1U << (pos % BitsPerBlock)));
+        // Get the block index and bit position for the given position.
+        std::size_t block = get_block_index(pos);
+        std::size_t bit   = get_bit_position(pos);
+
+        // Reset the bit at the calculated position.
+        data[block] = static_cast<BlockType>(data[block] & ~(1U << bit));
         return *this;
     }
 
@@ -341,7 +351,12 @@ class BitVector
         if (pos >= N) {
             throw std::out_of_range("BitVector index out of range");
         }
-        data[pos / BitsPerBlock] = static_cast<BlockType>(data[pos / BitsPerBlock] ^ (1 << (pos % BitsPerBlock)));
+        // Get the block index and bit position for the given position.
+        std::size_t block = get_block_index(pos);
+        std::size_t bit   = get_bit_position(pos);
+
+        // Flip the bit at the calculated position.
+        data[block] = static_cast<BlockType>(data[block] ^ (1 << bit));
         return *this;
     }
 
@@ -505,7 +520,12 @@ class BitVector
         if (pos >= N) {
             throw std::out_of_range("Accessing values outside bitvector");
         }
-        return (data[pos / BitsPerBlock] & (BlockType(1) << (pos % BitsPerBlock))) != 0;
+        // Get the block index and bit position for the given position.
+        std::size_t block = get_block_index(pos);
+        std::size_t bit   = get_bit_position(pos);
+
+        // Return the bit at the calculated position.
+        return (data[block] & (BlockType(1) << bit)) != 0;
     }
 
     /// @brief Returns a modifiable reference-like proxy to a bit.
@@ -516,7 +536,12 @@ class BitVector
         if (pos >= N) {
             throw std::out_of_range("Accessing values outside bitvector");
         }
-        return detail::BitReference<BlockType>(data[pos / BitsPerBlock], pos % BitsPerBlock);
+        // Get the block index and bit position for the given position.
+        std::size_t block = get_block_index(pos);
+        std::size_t bit   = get_bit_position(pos);
+
+        // Return the bit reference at the calculated position.
+        return detail::BitReference<BlockType>(data[block], bit);
     }
 
     /// @brief Copies the contents of the provided BitVector into this BitVector.
@@ -617,6 +642,7 @@ class BitVector
     }
 
     /// @brief Converts the BitVector to a string.
+    /// @param split if true, it will add spaces between blocks based on BitsPerBlock.
     /// @return The binary string representing the bitvector.
     auto to_string(bool split = false) const -> std::string
     {
@@ -629,6 +655,16 @@ class BitVector
         }
         return str;
     }
+
+    /// @brief Gets the block index for a given bit position.
+    /// @param pos The bit position in the BitVector.
+    /// @return The index of the block containing the bit.
+    inline std::size_t get_block_index(std::size_t pos) const { return pos / BitsPerBlock; }
+
+    /// @brief Gets the bit position within a block for a given bit position.
+    /// @param pos The bit position in the BitVector.
+    /// @return The position of the bit within its block.
+    inline std::size_t get_bit_position(std::size_t pos) const { return pos % BitsPerBlock; }
 };
 
 } // namespace bvlib

include/bvlib/math.hpp

@@ -127,43 +127,6 @@ inline auto subtract_block(BlockType lhs_block, BlockType rhs_block, bool &borro
     return lhs_block;
 }
 
-/// @brief Rotates the bits of the BitVector to the right by a given number of positions, modifying the current BitVector.
-/// @param n The number of positions to rotate to the right.
-/// @return A reference to the modified BitVector.
-template <std::size_t N>
-inline BitVector<N> &rotate_right_inplace(BitVector<N> &bv, std::size_t n)
-{
-    // Normalize the number of positions to prevent unnecessary rotations.
-    n %= N;
-    // No need to rotate if n is zero
-    if (n == 0) {
-        return bv;
-    }
-    // Perform the right rotation using a temporary variable for the bitwise
-    // operation.
-    for (std::size_t i = 0; i < N; ++i) {
-        std::size_t new_pos = (i + N - n) % N;
-        if (bv.at(i)) {
-            bv.set(new_pos);
-        } else {
-            bv.reset(new_pos);
-        }
-    }
-    return bv;
-}
-
-/// @brief Rotates the bits of the BitVector to the right by a given number of positions.
-/// @param bv The BitVector to rotate.
-/// @param n The number of positions to rotate to the right.
-/// @return A new BitVector with bits rotated to the right.
-template <std::size_t N>
-inline BitVector<N> rotate_right(const BitVector<N> &bv, std::size_t n)
-{
-    // Create a copy to avoid modifying the original BitVector.
-    BitVector<N> result = bv;
-    return detail::rotate_right_inplace(result, n);
-}
-
 /// @brief Shifts full blocks of a BitVector to the right or left.
 /// @tparam direction The direction to shift: positive for right shift, negative for left shift.
 /// @param bv The BitVector to shift.
@@ -245,9 +208,9 @@ inline auto shift_left_inplace(BitVector<N> &bitvector, std::size_t shift) -> Bi
         return bitvector;
     }
     // Shift full blocks to the left, passing -1 for left shift.
-    detail::shift_full_blocks<-1>(bitvector, shift / BitVector<N>::BitsPerBlock);
+    detail::shift_full_blocks<-1>(bitvector, bitvector.get_block_index(shift));
     // Shift bits within blocks, passing -1 for left shift.
-    detail::shift_within_blocks<-1>(bitvector, shift % BitVector<N>::BitsPerBlock);
+    detail::shift_within_blocks<-1>(bitvector, bitvector.get_bit_position(shift));
     // Ensure extra bits beyond N are cleared.
     bitvector.trim();
     return bitvector;
@@ -270,9 +233,9 @@ inline auto shift_right_inplace(BitVector<N> &bitvector, std::size_t shift) -> B
         return bitvector;
     }
     // Shift full blocks to the right, passing +1 for right shift.
-    detail::shift_full_blocks<+1>(bitvector, shift / BitVector<N>::BitsPerBlock);
+    detail::shift_full_blocks<+1>(bitvector, bitvector.get_block_index(shift));
     // Shift bits within blocks, passing +1 for right shift.
-    detail::shift_within_blocks<+1>(bitvector, shift % BitVector<N>::BitsPerBlock);
+    detail::shift_within_blocks<+1>(bitvector, bitvector.get_bit_position(shift));
     return bitvector;
 }