Small buffer optimization

.codecov.yml

@@ -1,5 +1,5 @@
 ignore:
   - "**/libpopcnt.h"
-  - "test/inc/*"
+  - "test/**"
   - "benchmark/**"
   - "example/**"

.github/workflows/cmake-multi-platform.yml

@@ -3,6 +3,7 @@
 name: CMake on multiple platforms
 
 on:
+  workflow_dispatch:
   push:
     branches: [ "master" ]
     paths-ignore:
@@ -12,6 +13,7 @@ on:
     paths-ignore:
       - '**/*.md'
 
+
 jobs:
   build:
     runs-on: ${{ matrix.distro }}

CMakeLists.txt

@@ -57,9 +57,25 @@ target_sources(bitlib INTERFACE
 )
 
 target_compile_features(bitlib INTERFACE cxx_std_23)
+include(CheckCXXSourceCompiles)
 
 if (BITLIB_MDSPAN)
   if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(USING_LIBSTDCXX 1)
+  endif()
+  if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    set(CODE "
+    #include <string>
+    #ifdef __GLIBCXX__
+    int main() { return 0; }
+    #else
+    #error Not using libstdc++
+    #endif
+    ")
+
+    check_cxx_source_compiles("${CODE}" USING_LIBSTDCXX)
+  endif()
+  if (USING_LIBSTDCXX)
     if (NOT TARGET std::mdspan)
       find_package(mdspan CONFIG)
       if (NOT mdspan_DIR OR "${mdspan_DIR}" STREQUAL "mdspan-NOTFOUND")

include/bitlib/bit-algorithms/bit_algorithm_details.hpp

@@ -4,6 +4,7 @@
 // Description: A set of utilities to assist in writing algorithms
 // Contributor(s): Vincent Reverdy [2019]
 //                 Bryce Kille [2019]
+//                 Peter McLean [2025]
 // License: BSD 3-Clause License
 // ========================================================================== //
 #ifndef _BIT_ALGORITHM_DETAILS_HPP_INCLUDED
@@ -103,12 +104,11 @@ constexpr bool is_within(
 
 // Get next len bits beginning at start and store them in a word of type T
 template <class T, class InputIt>
-T get_word(bit_iterator<InputIt> first, size_t len=binary_digits<T>::value)
-{
+T get_word(const bit_iterator<InputIt>& first, size_t len = binary_digits<T>::value) {
   using native_word_type = typename bit_iterator<InputIt>::word_type;
   constexpr T digits = binary_digits<native_word_type>::value;
   assert(digits >= len);
-  using non_const_T = std::remove_cv_t<T>;
+  using non_const_T = std::remove_cvref_t<T>;
   non_const_T offset = digits - first.position();
   non_const_T ret_word = lsr(*first.base(), first.position());
 
@@ -224,7 +224,7 @@ void write_word(src_type src, bit_iterator<OutputIt> dst_bit_it,
     } else {
       *dst_bit_it.base() = _bitblend<src_type>(
           *dst_bit_it.base(),
-          src << dst_bit_it.position(),
+          static_cast<src_type>(src << dst_bit_it.position()),
           dst_bit_it.position(),
           std::min<src_type>(
               dst_digits - dst_bit_it.position(),

include/bitlib/bit-algorithms/copy.hpp

@@ -22,64 +22,63 @@
 namespace bit {
 // ========================================================================== //
 
+struct copy_impl;
 
+// Status: Does not work for Input/Output iterators due to distance call
+template <typename RandomAccessIt1, typename RandomAccessIt2>
+constexpr bit_iterator<RandomAccessIt2> copy(
+    const bit_iterator<RandomAccessIt1>& first,
+    const bit_iterator<RandomAccessIt1>& last,
+    const bit_iterator<RandomAccessIt2>& d_first) {
+  return with_bit_iterator_adapter<copy_impl>(first, last, d_first);
+}
 
 // ---------------------------- Copy Algorithms ----------------------------- //
-
-// Status: Does not work for Input/Output iterators due to distance call
-template <class RandomAccessIt1, class RandomAccessIt2>
-constexpr bit_iterator<RandomAccessIt2> copy(bit_iterator<RandomAccessIt1> first,
-                            bit_iterator<RandomAccessIt1> last,
-                            bit_iterator<RandomAccessIt2> d_first
-)
-{
+struct copy_impl {
+  // Status: Does not work for Input/Output iterators due to distance call
+  template <typename RandomAccessIt1, typename RandomAccessIt2>
+  constexpr bit_iterator<RandomAccessIt2> operator()(
+      bit_iterator<RandomAccessIt1> first,
+      bit_iterator<RandomAccessIt1> last,
+      bit_iterator<RandomAccessIt2> d_first) {
     // Types and constants
     using dst_word_type = typename bit_iterator<RandomAccessIt2>::word_type;
     using src_word_type = typename bit_iterator<RandomAccessIt1>::word_type;
 
     // This checks for differing word types and uses an unoptimized copy in that event
-    if (!::std::is_same<dst_word_type, src_word_type>::value) {
-      while (first != last) {
-        *d_first = *first;
-        first++;
-        d_first++;
-      }
-      return d_first;
-    }
+    static_assert(std::is_same<dst_word_type, src_word_type>::value, "Both types must be the same");
+
     using word_type = dst_word_type;
     using size_type = typename bit_iterator<RandomAccessIt2>::size_type;
     constexpr size_type digits = binary_digits<word_type>::value;
 
     // Assertions
     _assert_range_viability(first, last);
-    if (first == last) return d_first;
-
+    if (first == last) {
+      return d_first;
+    }
 
     // Initialization
     const bool is_d_first_aligned = d_first.position() == 0;
     size_type total_bits_to_copy = distance(first, last);
     size_type remaining_bits_to_copy = total_bits_to_copy;
     auto it = d_first.base();
 
-
     // d_first is not aligned. Copy partial word to align it
     if (!is_d_first_aligned) {
-        size_type partial_bits_to_copy = ::std::min(
-                remaining_bits_to_copy,
-                digits - d_first.position()
-                );
-        *it = _bitblend(
-                *it,
-                static_cast<word_type>(
-                  get_word<word_type>(first, partial_bits_to_copy)
-                    << static_cast<word_type>(d_first.position())
-                ),
-                static_cast<word_type>(d_first.position()),
-                static_cast<word_type>(partial_bits_to_copy)
-                );
-        remaining_bits_to_copy -= partial_bits_to_copy;
-        advance(first, partial_bits_to_copy);
-        it++;
+      size_type partial_bits_to_copy = ::std::min(
+          remaining_bits_to_copy,
+          digits - d_first.position());
+      *it = _bitblend(
+          *it,
+          static_cast<word_type>(
+              get_word<word_type>(first, partial_bits_to_copy)
+              << static_cast<word_type>(d_first.position())),
+          static_cast<word_type>(d_first.position()),
+          static_cast<word_type>(partial_bits_to_copy));
+      remaining_bits_to_copy -= partial_bits_to_copy;
+      advance(first, partial_bits_to_copy);
+      it++;
     }
 
     if (remaining_bits_to_copy > 0) {
@@ -108,12 +107,13 @@ constexpr bit_iterator<RandomAccessIt2> copy(bit_iterator<RandomAccessIt1> first
         }
     }
     return d_first + total_bits_to_copy;
-}
+  }
+};
 // -------------------------------------------------------------------------- //
 
 
 
 // ========================================================================== //
-} // namespace bit
+}  // namespace bit
 #endif // _COPY_HPP_INCLUDED
 // ========================================================================== //

include/bitlib/bit-algorithms/copy_backward.hpp

@@ -56,13 +56,12 @@ constexpr bit_iterator<RandomAccessIt2> copy_backward(bit_iterator<RandomAccessI
                 d_last.position()
         );
         *it = _bitblend<word_type>(
-                *it,
-                static_cast<word_type>(
-                  get_word<word_type>(last - partial_bits_to_copy, partial_bits_to_copy)
-                ) << (d_last.position() - partial_bits_to_copy),
-                d_last.position() - partial_bits_to_copy,
-                static_cast<word_type>(partial_bits_to_copy)
-        );
+            *it,
+            static_cast<word_type>(
+                get_word<word_type>(last - partial_bits_to_copy, partial_bits_to_copy)
+                << (d_last.position() - partial_bits_to_copy)),
+            d_last.position() - partial_bits_to_copy,
+            static_cast<word_type>(partial_bits_to_copy));
         remaining_bits_to_copy -= partial_bits_to_copy;
         advance(last, -partial_bits_to_copy);
     }
@@ -87,14 +86,13 @@ constexpr bit_iterator<RandomAccessIt2> copy_backward(bit_iterator<RandomAccessI
             it--;
         }
         if (remaining_bits_to_copy > 0) {
-            *it = _bitblend<word_type>(
-                    *it,
-                    get_word<word_type>(last - remaining_bits_to_copy, remaining_bits_to_copy)
-                       << (digits - remaining_bits_to_copy),
-                    digits - remaining_bits_to_copy,
-                    remaining_bits_to_copy
-            );
-            remaining_bits_to_copy = 0;
+          *it = _bitblend<word_type>(
+              *it,
+              static_cast<word_type>(get_word<word_type>(last - remaining_bits_to_copy, remaining_bits_to_copy)
+                                     << (digits - remaining_bits_to_copy)),
+              digits - remaining_bits_to_copy,
+              remaining_bits_to_copy);
+          remaining_bits_to_copy = 0;
         }
     }
     return d_last - total_bits_to_copy;

include/bitlib/bit-algorithms/equal.hpp

@@ -2,14 +2,13 @@
 // Project:     The Experimental Bit Algorithms Library
 // Name:        equal.hpp
 // Contributor: Bryce Kille [2019]
+//              Peter McLean [2025]
 // License:     BSD 3-Clause License
 // ========================================================================== //
 #ifndef _EQUAL_HPP_INCLUDED
 #define _EQUAL_HPP_INCLUDED
 // ========================================================================== //
 
-
-
 // ================================ PREAMBLE ================================ //
 // C++ standard library
 #include <type_traits>
@@ -20,30 +19,39 @@
 // Miscellaneous
 namespace bit {
 // ========================================================================== //
+struct equal_impl;
 
-
+// Status: Does not work for Input/Output iterators due to distance call
+template <typename RandomAccessIt1, typename RandomAccessIt2>
+constexpr bool equal(
+    const bit_iterator<RandomAccessIt1>& first,
+    const bit_iterator<RandomAccessIt1>& last,
+    const bit_iterator<RandomAccessIt2>& d_first) {
+  return with_bit_iterator_adapter<equal_impl>(first, last, d_first);
+}
 
 // ---------------------------- Equal Algorithms ----------------------------- //
 
 // Status: Does not work for Input/Output iterators due to distance call
-template <class RandomAccessIt1, class RandomAccessIt2>
-constexpr bool equal(
-        bit_iterator<RandomAccessIt1> first,
-        bit_iterator<RandomAccessIt1> last,
-        bit_iterator<RandomAccessIt2> d_first
-)
-{
+struct equal_impl {
+  template <typename RandomAccessIt1, typename RandomAccessIt2>
+  constexpr bool operator()(
+      bit_iterator<RandomAccessIt1> first,
+      bit_iterator<RandomAccessIt1> last,
+      bit_iterator<RandomAccessIt2> d_first) {
     // Types and constants
     using dst_word_type = typename bit_iterator<RandomAccessIt2>::word_type;
     using src_word_type = typename bit_iterator<RandomAccessIt1>::word_type;
+    static_assert(::std::is_same<dst_word_type, src_word_type>::value, "Underlying word types must be equal");
     using word_type = dst_word_type;
     using size_type = typename bit_iterator<RandomAccessIt2>::size_type;
     constexpr size_type digits = binary_digits<word_type>::value;
 
     // Assertions
     _assert_range_viability(first, last);
-    static_assert(::std::is_same<dst_word_type, src_word_type>::value, "Underlying word types must be equal");
-    if (first == last) return true;
+    if (first == last) {
+      return true;
+    }
 
     // Initialization
     const bool is_d_first_aligned = d_first.position() == 0;
@@ -53,48 +61,55 @@
 
     // d_first is not aligned.
     if (!is_d_first_aligned) {
-        const size_type partial_bits_to_check = ::std::min(
-                remaining_bits_to_check,
-                digits - d_first.position());
-        const word_type mask = _mask<word_type>(partial_bits_to_check) << d_first.position();
-        const word_type comp = static_cast<word_type>(
-              get_word<word_type>(first, partial_bits_to_check)
-                << d_first.position());
-        if ((mask & *it) != (mask & comp)) { return false; }
-        remaining_bits_to_check -= partial_bits_to_check;
-        advance(first, partial_bits_to_check);
-        it++;
+      const size_type partial_bits_to_check = ::std::min(
+          remaining_bits_to_check,
+          digits - d_first.position());
+      const word_type mask = _mask<word_type>(partial_bits_to_check) << d_first.position();
+      const word_type comp = static_cast<word_type>(
+          get_word<word_type>(first, partial_bits_to_check)
+          << d_first.position());
+      if ((mask & *it) != (mask & comp)) {
+        return false;
+      }
+      remaining_bits_to_check -= partial_bits_to_check;
+      advance(first, partial_bits_to_check);
+      it++;
     }
 
     if (remaining_bits_to_check > 0) {
-        const bool is_first_aligned = first.position() == 0;
-        // d_first will be aligned at this point
-        if (is_first_aligned && remaining_bits_to_check >= digits) {
-            auto N = ::std::distance(first.base(), last.base());
-            bool found_mismatch = !::std::equal(first.base(), last.base(), it);
-            if (found_mismatch) {return false;}
-            it += N;
-            first += digits * N;
-            remaining_bits_to_check -= digits * N;
-        } else {
-            // TODO benchmark if its faster to ::std::check the entire range then shift
-            while (remaining_bits_to_check >= digits) {
-                if (*it != get_word<word_type>(first, digits)) {return false;}
-                remaining_bits_to_check -= digits;
-                it++;
-                advance(first, digits);
-            }
+      const bool is_first_aligned = first.position() == 0;
+      // d_first will be aligned at this point
+      if (is_first_aligned && remaining_bits_to_check >= digits) {
+        auto N = ::std::distance(first.base(), last.base());
+        bool found_mismatch = !::std::equal(first.base(), last.base(), it);
+        if (found_mismatch) {
+          return false;
         }
-        if (remaining_bits_to_check > 0) {
-          const word_type mask = _mask<word_type>(remaining_bits_to_check);
-          const word_type comp = get_word<word_type>(first, remaining_bits_to_check);
-          if ((mask & *it) != (mask & comp)) {
+        it += N;
+        first += digits * N;
+        remaining_bits_to_check -= digits * N;
+      } else {
+        // TODO benchmark if its faster to ::std::check the entire range then shift
+        while (remaining_bits_to_check >= digits) {
+          if (*it != get_word<word_type>(first, digits)) {
             return false;
           }
+          remaining_bits_to_check -= digits;
+          it++;
+          advance(first, digits);
+        }
+      }
+      if (remaining_bits_to_check > 0) {
+        const word_type mask = _mask<word_type>(remaining_bits_to_check);
+        const word_type comp = get_word<word_type>(first, remaining_bits_to_check);
+        if ((mask & *it) != (mask & comp)) {
+          return false;
         }
+      }
     }
     return true;
-}
+  }
+};
 // -------------------------------------------------------------------------- //