fix: Corrige manejo de casos borde y mejora robustez en algoritmos

- En tpl_bipartite.H se agrega verificación para grafo vacío en matching
- En Knapsack.H se corrige verificación de overflow para tipos sin límites
- En tpl_mincost.H se simplifica declaración de cola de prioridad
- En Tests/bipartite_test.cc se actualizan pruebas para reflejar nuevo comportamiento
- En stat_utils.H se reemplaza std::map por DynMapTree para consistencia
- En scripts/ci_policy_checks.rb se añade soporte para archivos copiados
- En ah-chronos-utils.H se corrige formato y comentarios
- En scripts/test_ci_policy_checks.rb se añaden pruebas para literales raw strings
- En Matrix_Chain.H se clarifica documentación de validación

Author: lrleon

AUDIT_ADVERSARIAL_BRANCH.md

@@ -342,9 +342,17 @@ template <typename V, std::integral W>
         {
           const size_t take = std::min(k, rem);
 
-          const V maxV = std::numeric_limits<V>::max();
-          if ((wi == 0 or take <= C / wi) and
-              (items[i].value == V{0} or static_cast<V>(take) <= maxV / items[i].value))
+          bool value_ok;
+          if constexpr (std::numeric_limits<V>::is_specialized)
+            {
+              const V maxV = std::numeric_limits<V>::max();
+              value_ok = (items[i].value == V{0} or
+                          static_cast<V>(take) <= maxV / items[i].value);
+            }
+          else
+            value_ok = true;
+
+          if ((wi == 0 or take <= C / wi) and value_ok)
             {
               expanded.append(Knapsack_Item<W, V>{static_cast<W>(wi * take),
                                                   static_cast<V>(take) * items[i].value});

Knapsack.H

@@ -119,7 +119,7 @@ inline void build_parens(const Array<Array<size_t>> &s, size_t i, size_t j, std:
  *          representation of the parenthesization, and the split table.
  *
  *  @throws ah_domain_error if `dims` has fewer than 2 entries.
- *  @throws ah_domain_error if any dimension is zero or negative.
+ *  @throws ah_domain_error if any `dims` dimension is zero.
  *  @throws ah_runtime_error if the cost calculation overflows `size_t`.
  *
  *  @note **Complexity**: Time O(n^3), Space O(n^2), where n is the number of matrices.
@@ -185,8 +185,8 @@ inline void build_parens(const Array<Array<size_t>> &s, size_t i, size_t j, std:
 
 /** @brief Compute only the minimum multiplication cost (value only).
  *
- *  A convenience version that only returns the minimum number of scalar
- *  multiplications required, without reconstruction.
+ *  A convenience version that delegates to `matrix_chain_order` and returns
+ *  the `min_multiplications` value computed there.
  *
  *  @param[in] dims  Array of matrix dimensions (@f$n+1@f$entries for@f$n@f$matrices).
  *  @return The minimum number of scalar multiplications.

Matrix_Chain.H

@@ -280,14 +280,14 @@ TEST(Bipartite, DISABLED_EmptyGraph)
   EXPECT_TRUE(r.is_empty());
 }
 
-// This test documents the current (buggy) behavior
 TEST(Bipartite, EmptyGraphThrowsRangeError)
 {
   Graph g;
   DynDlist<Graph::Node *> l, r;
 
-  // BUG: Empty graph throws range_error instead of succeeding with empty partitions
-  EXPECT_THROW(compute_bipartite<Graph>(g, l, r), std::range_error);
+  EXPECT_NO_THROW(compute_bipartite<Graph>(g, l, r));
+  EXPECT_TRUE(l.is_empty());
+  EXPECT_TRUE(r.is_empty());
 }
 
 TEST(Bipartite, SingleNode)
@@ -540,18 +540,15 @@ TEST(ComputeBipartiteClass, ThrowsOnNonBipartite)
 // ============================================================================
 // Maximum Matching Tests
 // ============================================================================
-// KNOWN BUG: The maximum matching algorithm is not returning correct results.
-// The flow network-based algorithm returns 0 matches for all cases.
-// Empty graph throws range_error (consistent with compute_bipartite behavior)
 TEST(MaximumMatching, EmptyGraphThrowsRangeError)
 {
   Graph g;
 
   DynDlist<Graph::Arc *> matching;
 
-  EXPECT_THROW(
-    compute_maximum_cardinality_bipartite_matching<Graph>(g, matching),
-    std::range_error);
+  EXPECT_NO_THROW(
+    compute_maximum_cardinality_bipartite_matching<Graph>(g, matching));
+  EXPECT_TRUE(matching.is_empty());
 }
 
 TEST(MaximumMatching, SingleEdge)

Tests/bipartite_test.cc

@@ -28,7 +28,6 @@
   SOFTWARE.
 */
 
-
 /** @file ah-chronos-utils.H
  *  @brief Time duration conversion utilities.
  *
@@ -43,57 +42,56 @@
 #ifndef AH_CHRONOS_UTILS_H
 #define AH_CHRONOS_UTILS_H
 
-# include <string>
-# include <chrono>
-# include <format>
+#include <string>
+#include <chrono>
+#include <format>
 
-namespace Aleph
-{
+namespace Aleph {
 // given a duration, return the number of seconds
-inline double duration_to_seconds(const std::chrono::duration<double> & d)
+inline double duration_to_seconds(const std::chrono::duration<double> &d)
 {
   return d.count();
 }
 
 // given a duration, return the number of milliseconds
-inline double duration_to_milliseconds(const std::chrono::duration<double> & d)
+inline double duration_to_milliseconds(const std::chrono::duration<double> &d)
 {
   return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
 }
 
 // given a duration, return the number of microseconds
-inline double duration_to_microseconds(const std::chrono::duration<double> & d)
+inline double duration_to_microseconds(const std::chrono::duration<double> &d)
 {
   return std::chrono::duration_cast<std::chrono::microseconds>(d).count();
 }
 
 // given a duration, return the number of nanoseconds
-inline double duration_to_nanoseconds(const std::chrono::duration<double> & d)
+inline double duration_to_nanoseconds(const std::chrono::duration<double> &d)
 {
   return std::chrono::duration_cast<std::chrono::nanoseconds>(d).count();
 }
 
 // given a duration, return the number of minutes
-inline double duration_to_minutes(const std::chrono::duration<double> & d)
+inline double duration_to_minutes(const std::chrono::duration<double> &d)
 {
   return std::chrono::duration_cast<std::chrono::minutes>(d).count();
 }
 
 // given a duration, return the number of hours
-inline double duration_to_hours(const std::chrono::duration<double> & d)
+inline double duration_to_hours(const std::chrono::duration<double> &d)
 {
   return std::chrono::duration_cast<std::chrono::hours>(d).count();
 }
 
 // given a duration, return the number of days
-inline double duration_to_days(const std::chrono::duration<double> & d)
+inline double duration_to_days(const std::chrono::duration<double> &d)
 {
   return std::chrono::duration_cast<std::chrono::days>(d).count();
 }
 
 // given a duration, return a string with the proper units
-// acording to the magnitude of the duration
-inline std::string duration_to_string(const auto & d)
+// according to the magnitude of the duration
+inline std::string duration_to_string(const auto &d)
 {
   if (d < std::chrono::seconds(1))
     return std::format("{} ms", duration_to_milliseconds(d));
@@ -107,6 +105,6 @@ inline std::string duration_to_string(const auto & d)
 
   return std::format("{} days", duration_to_days(d));
 }
-}
+}  // namespace Aleph
 
-#endif //AH_CHRONOS_UTILS_H
+#endif  // AH_CHRONOS_UTILS_H