formatted and fixed macro.hpp contains function

now properly checks set  and subset

Author: Lukas Thomann

CMakeLists.txt

@@ -2,14 +2,19 @@ cmake_minimum_required(VERSION 4.1.1)
 project(
   cth
   LANGUAGES CXX
-  VERSION 1.0.0)
+  VERSION 1.0.0
+)
 
 include(cth_setup_utilities)
 include(cth_target_utilities)
 include(cth_install_utilities)
 
 cth_set_compiler_specifics()
 cth_set_latest_c_cpp_standard()
+set(CMAKE_CXX_SCAN_FOR_MODULES FALSE)
+
+set(CMAKE_C_COMPILER_LAUNCHER "buildcache")
+set(CMAKE_CXX_COMPILER_LAUNCHER "buildcache")
 
 # exported
 add_subdirectory(cth)
@@ -30,14 +35,13 @@ cth_glob_cpp(
   FORMAT_FILES
   "cth"
   "cth_coro"
-  "cth_coro_tests"
   "cth_cthm"
-  "cth_tests"
   "cth_win"
-  "cth_win_tests"
   "integration_tests"
+  "playground"
 )
 
-cth_add_uncrustify_target(uncrustify-format OPTIONAL ${FORMAT_FILES})
+#cth_add_uncrustify_target(uncrustify-format OPTIONAL ${FORMAT_FILES})
+
 # playground
 add_subdirectory(playground)

cth/incl/cth/algorithm/combine.hpp

@@ -12,8 +12,6 @@
 #include <unordered_set>
 #include <vector>
 
-
-
 /**
  * @brief creates a vector of unique elements with exactly one element from each given range. order is
  *  preserved
@@ -97,36 +95,37 @@ template<mta::range2d_over_cpt<CPT(std::equality_comparable)> Rng>
 
 }
 
-
-
 namespace cth::alg {
 
 /**
- * \brief assigns a's to b's based of every a's options for b's
+ * \brief assigns a's to b's based of every a's options for b's, prioritizing spread
  * \tparam Rng1 rng<rng<std::integral>>
  * \tparam Rng2 rng<std::integral>
  * \param a_b_options range of b options from a's
  * \param b_max  max assignments for b's
  * \return vector<integral> based on Rng1
  */
 template<mta::range2d_over_cpt<CPT(std::integral)> Rng1, mta::range_over_cpt<CPT(std::integral)> Rng2>
-[[nodiscard]] auto assign(Rng1 const& a_b_options, Rng2 const& b_max) -> std::vector<mta::range2d_value_t<Rng1>> {
+[[nodiscard]] auto assign(
+    Rng1 const& a_b_options,
+    Rng2 const& b_max
+) -> std::vector<mta::range2d_value_t<Rng1>> {
     using T = std::remove_cvref_t<mta::range2d_value_t<Rng1>>;
     static constexpr size_t UNASSIGNED = static_cast<size_t>(-1);
 
     CTH_CRITICAL(
         !std::ranges::all_of(
             a_b_options,
             [&b_max](std::span<T const> b_options) {
-            return std::ranges::all_of(b_options, [&b_max](auto const index) {
+            return std::ranges::all_of(b_options,
+                [&b_max](auto const index) {
                 return 0 <= index && index < std::ranges::size(b_max);
-                });
+                }
+            );
             }
         ),
         "0 <= indices < size(b_max) required"
-    ) {
-        details->add("size(b_max): {}", std::ranges::size(b_max));
-    }
+    ) { details->add("size(b_max): {}", std::ranges::size(b_max)); }
 
     auto const aCount = std::ranges::size(a_b_options);
     auto const bCount = std::ranges::size(b_max);
@@ -146,6 +145,10 @@ template<mta::range2d_over_cpt<CPT(std::integral)> Rng1, mta::range_over_cpt<CPT
     std::vector<bool> visitedB(bCount, false);
     std::vector<bool> visitedA(aCount, false);
 
+    // NEW: State for "Water-filling" spreading
+    size_t assignedCount = 0;
+    std::vector<size_t> current_b_max(bCount, 0);
+
     // 2. Isolated BFS Engine
     auto find_augmenting_path = [&](size_t startA) -> size_t {
         std::ranges::fill(visitedB, false);
@@ -165,55 +168,73 @@ template<mta::range2d_over_cpt<CPT(std::integral)> Rng1, mta::range_over_cpt<CPT
                 visitedB[b] = true;
                 parentB[b] = currentA; // Record path
 
-                // Path End: Open slot found
-                if(std::ranges::size(bToA[b]) < static_cast<size_t>(b_max[b]))
+                // MODIFIED: Compare against the current water level, NOT absolute max
+                if(std::ranges::size(bToA[b]) < current_b_max[b])
                     return b;
 
                 // Path Continuation: Displace existing residents
-                for(auto previousA : bToA[b]) {
+                for(auto previousA : bToA[b])
                     if(!visitedA[previousA]) {
                         visitedA[previousA] = true;
                         parentA[previousA] = b;
                         q.push(previousA);
                     }
-                }
             }
         }
         return UNASSIGNED;
     };
 
-    // 3. Main Logic
-    for(size_t i = 0; i < aCount; ++i) {
-        auto endB = find_augmenting_path(i);
+    // 3. Main Logic (Water-filling Loop)
+    bool capacity_increased = true;
 
-        if(endB == UNASSIGNED) return std::vector<T>{}; // Dead end
+    // Loop until all 'a's are assigned or we've exhausted true capacities
+    while(assignedCount < aCount && capacity_increased) {
+        capacity_increased = false;
 
-        // Backtrack and flip assignments
-        auto currentB = endB;
-        while(true) {
-            auto currentA = parentB[currentB];
+        // Step 3a: Raise the water level (allow 1 more allocation per family)
+        for(size_t i = 0; i < bCount; ++i)
+            if(current_b_max[i] < static_cast<size_t>(b_max[i])) {
+                current_b_max[i]++;
+                capacity_increased = true;
+            }
+
+        // Step 3b: Try to assign all unassigned elements at this new capacity level
+        for(size_t i = 0; i < aCount; ++i) {
+            if(aToB[i] != static_cast<T>(UNASSIGNED)) continue; // Already assigned
+
+            auto endB = find_augmenting_path(i);
+
+            if(endB != UNASSIGNED) {
+                // Backtrack and flip assignments
+                auto currentB = endB;
+                while(true) {
+                    auto currentA = parentB[currentB];
 
-            if(currentA != i) {
-                auto previousB = parentA[currentA];
+                    if(currentA != i) {
+                        auto previousB = parentA[currentA];
 
-                // O(1) Swap-and-pop
-                auto it = std::ranges::find(bToA[previousB], currentA);
-                *it = bToA[previousB].back();
-                bToA[previousB].pop_back();
+                        // O(1) Swap-and-pop
+                        auto it = std::ranges::find(bToA[previousB], currentA);
+                        *it = bToA[previousB].back();
+                        bToA[previousB].pop_back();
 
-                bToA[currentB].push_back(currentA);
-                aToB[currentA] = static_cast<T>(currentB);
+                        bToA[currentB].push_back(currentA);
+                        aToB[currentA] = static_cast<T>(currentB);
 
-                currentB = previousB; // Move up
-            } else {
-                bToA[currentB].push_back(currentA);
-                aToB[currentA] = static_cast<T>(currentB);
-                break;
+                        currentB = previousB; // Move up
+                    } else {
+                        bToA[currentB].push_back(currentA);
+                        aToB[currentA] = static_cast<T>(currentB);
+                        break;
+                    }
+                }
+                assignedCount++; // Successfully placed an 'a'
             }
         }
     }
 
+    if(assignedCount < aCount) return std::vector<T>{}; // Dead end
+
     return aToB;
 }
-
 }

cth/incl/cth/algorithm/ranges.hpp

@@ -1,7 +1,2 @@
 #pragma once
 #include "cth/algorithm/views.hpp"
-
-
-
-
-

cth/incl/cth/algorithm/views.hpp

@@ -7,7 +7,6 @@
 #include <format>
 #include <ranges>
 
-
 namespace cth::views {
 struct to_ptr_range_fn : cth::ranges::piped_fn {
     template<std::ranges::viewable_range Rng> requires std::is_lvalue_reference_v<std::ranges::range_reference_t<Rng>>
@@ -18,15 +17,14 @@ struct to_ptr_range_fn : cth::ranges::piped_fn {
 
 inline cxpr to_ptr_range_fn to_ptr_range;
 
-
 struct split_into_fn {
     /**
-     * 
+     *
      * @param rng to chunk
      * @param max_chunks count of chunks to split into
      * @pre chunks > 0
-     * @post split into `N` chunks where `N <= chunks` 
-     * @return view of 
+     * @post split into `N` chunks where `N <= chunks`
+     * @return view of
      */
     template<std::ranges::sized_range Rng>
     cxpr auto operator()(Rng&& rng, std::ranges::range_difference_t<Rng> const max_chunks) const {
@@ -40,7 +38,9 @@ struct split_into_fn {
 
     template<class Fn, class T> requires std::constructible_from<std::decay_t<T>, T>
     cxpr auto operator()(this Fn&&, T&& chunks) {
-        return ranges::pipe_call_closure<std::remove_cvref_t<Fn>, std::decay_t<T>>{std::forward<T>(chunks)};
+        return ranges::pipe_call_closure<
+            std::remove_cvref_t<Fn>, std::decay_t<T>
+        >{std::forward<T>(chunks)};
     }
 };
 
@@ -49,18 +49,16 @@ struct split_into_fn {
  */
 inline cxpr split_into_fn split_into;
 
-
 struct drop_stride_fn {
     template<std::ranges::viewable_range Rng>
     cxpr auto operator()(
         Rng&& rng,
         std::ranges::range_difference_t<Rng> const drop,
         std::ranges::range_difference_t<Rng> const stride
-    ) const {
-        return std::views::stride(std::views::drop(std::forward<Rng>(rng), drop), stride);
-    }
+    ) const { return std::views::stride(std::views::drop(std::forward<Rng>(rng), drop), stride); }
 
-    template<class Fn, class T, class U> requires(std::constructible_from<std::decay_t<T>, T> && std::constructible_from<std::decay_t<U>, U>)
+    template<class Fn, class T, class U> requires(std::constructible_from<std::decay_t<T>, T> && std::constructible_from
+        <std::decay_t<U>, U>)
     cxpr auto operator()(this Fn&&, T&& drop, U&& stride) {
         return ranges::pipe_call_closure<std::remove_cvref_t<Fn>, std::decay_t<T>, std::decay_t<U>>{
             std::forward<T>(drop),
@@ -71,17 +69,16 @@ struct drop_stride_fn {
 
 inline cxpr drop_stride_fn drop_stride;
 
-
 struct transform_call_fn {
     template<class Rng>
     using range_value_t = std::ranges::range_value_t<Rng>;
 
-    template<std::ranges::range Rng, class Call, class... Args> requires(
-        std::invocable<Call, std::ranges::range_value_t<Rng>, Args...>)
+    template<std::ranges::range Rng, class Call, class... Args> requires(std::invocable<Call, std::ranges::range_value_t
+        <Rng>, Args...>)
     cxpr auto operator()(Rng&& rng, Call&& call, Args&&... args) const {
         return std::views::transform(
             std::forward<Rng>(rng),
-            [&call, &args...]<class T>(T&& element) {
+            [&call, &args...] < class T >(T&& element) {
                 return std::invoke(
                     std::forward<Call>(call),
                     std::forward<T>(element),
@@ -103,7 +100,6 @@ struct transform_call_fn {
 inline cxpr transform_call_fn transform_call;
 }
 
-
 namespace cth::views {
 template<std::ranges::input_range Rng>
 struct format_view {
@@ -129,9 +125,7 @@ struct format_fn {
         std::string_view sep,
         std::string_view pre = "",
         std::string_view post = ""
-    ) const {
-        return format_view{std::views::all(std::forward<Rng>(rng)), sep, pre, post};
-    }
+    ) const { return format_view{std::views::all(std::forward<Rng>(rng)), sep, pre, post}; }
 
     template<class Me>
     [[nodiscard]] cxpr auto operator()(
@@ -161,17 +155,13 @@ template<class Rng>
 struct std::formatter<cth::views::format_view<Rng>> {
     using value_type = std::ranges::range_value_t<Rng>;
 
-
-    [[nodiscard]] cxpr auto parse(std::format_parse_context& ctx) {
-        return _formatter.parse(ctx);
-    }
+    [[nodiscard]] cxpr auto parse(std::format_parse_context& ctx) { return _formatter.parse(ctx); }
 
     template<typename FormatContext>
     [[nodiscard]] cxpr auto format(
         cth::views::format_view<Rng>& obj,
         FormatContext& ctx
     ) const {
-
         auto& [rng, sep, pre, post] = obj;
 
         _formatter.set_separator(sep);

cth/incl/cth/constants.hpp

@@ -16,38 +16,34 @@
 #endif
 #endif
 
-
 #ifdef CTH_DEBUG_MODE
 #ifdef CTH_RELEASE_MODE
 #error "CTH_DEBUG_MODE and CTH_RELEASE_MODE must not be defined at the same time."
 #endif
 #endif
 
-
 #ifndef CTH_DEBUG_MODE
 #ifndef CTH_RELEASE_MODE
 #error "Neither CTH_DEBUG_MODE nor CTH_RELEASE_MODE is defined."
 #endif
 #endif
 
-
 #ifdef CTH_DEBUG_MODE
 #define CTH_DEBUG_IMPL
-#define CTH_DEBUG_INLINE_IMPL(code) {code}
+#define CTH_DEBUG_INLINE_IMPL(code) { code }
 
 #define CTH_RELEASE_NOEXCEPT noexcept(false)
 #define CTH_RELEASE_CONSTEXPR
 #else
 #define CTH_DEBUG_IMPL = default;
-#define CTH_DEBUG_INLINE_IMPL(code)                                                                          \
-    {}
+#define CTH_DEBUG_INLINE_IMPL(code) \
+        {}
 
 #define CTH_RELEASE_NOEXCEPT noexcept(true)
 #define CTH_RELEASE_CONSTEXPR constexpr
 #endif
 #include <cstdint>
 
-
 namespace cth {
 enum class CompilationMode {
     DEBUG,

cth/incl/cth/coro/fence.hpp

@@ -1,7 +1,6 @@
 #pragma once
 #include "cth/coro/utility.hpp"
 
-
 #include <atomic>
 #include <memory>
 
@@ -34,7 +33,6 @@ class fence {
 public:
     bool signaled() const noexcept { return _state.load(std::memory_order_acquire); }
 
-
     fence(fence const&) = delete;
     fence& operator=(fence const&) = delete;
     fence(fence&&) = delete;
@@ -62,7 +60,6 @@ class heap_fence {
             _fence->force_signal();
     }
 
-
     void reset() {
         if(_fence)
             _fence->reset();