Cleanup

Author: MichaelS239

src/core/algorithms/dc/FastADC/util/evidence_aux_structures_builder.cpp

@@ -5,6 +5,7 @@
 #include <stdexcept>
 
 #include "core/algorithms/dc/FastADC/model/predicate.h"
+#include "core/util/logger.h"
 
 namespace algos::fastadc {
 

src/core/algorithms/dd/fastdd/CMakeLists.txt

@@ -2,11 +2,8 @@ set(NAME dd.fastdd.structs)
 desbordante_add_lib(NAME OBJECT)
 target_sources(
     ${NAME}
-    PRIVATE model/pli_shard.cpp
-            trees/translating_tree_search.cpp
-            util/differential_function_builder.cpp
-            util/isn_info.cpp
-            util/threshold_calculator.cpp
+    PRIVATE model/pli_shard.cpp trees/translating_tree_search.cpp
+            util/differential_function_builder.cpp util/isn_info.cpp util/threshold_calculator.cpp
 )
 target_link_libraries(${NAME} PUBLIC magic_enum::magic_enum)
 target_link_libraries(${NAME} PRIVATE spdlog::spdlog_header_only Boost::headers)

src/core/algorithms/dd/fastdd/fastdd.cpp

@@ -138,7 +138,7 @@ unsigned long long FastDD::ExecuteInternal() {
     LOG_INFO("Built PLIs");
     LOG_DEBUG("Number of PLI shards: {}", pli_shards.size());
 
-    DifferentialFunctionBuilder df_builder(typed_relation_, num_rows_, num_columns_);
+    DifferentialFunctionBuilder df_builder(typed_relation_, num_columns_);
     df_builder.BuildDFList(thresholds);
     LOG_INFO("Built DF set");
     LOG_INFO("Initial search space size: {}", df_builder.GetDifFuncNum());

src/core/algorithms/dd/fastdd/fastdd.h

@@ -50,7 +50,7 @@ class FastDD final : public DDAlgorithm {
     void RunAlgo(DifferentialFunctionBuilder& df_builder,
                  std::shared_ptr<DistanceCalculator> const& distance_calculator,
                  std::vector<PliShard> pli_shards,
-                 std::chrono::_V2::system_clock::time_point start_time) {
+                 std::chrono::system_clock::time_point start_time) {
         DiffSetBuilder<Bitset> diff_set_builder(df_builder, distance_calculator);
         diff_set_builder.BuildDiffSet(std::move(pli_shards));
         DiffSet<Bitset> diff_set = diff_set_builder.GetDiffSet();

src/core/algorithms/dd/fastdd/trees/tree_search.h

@@ -102,13 +102,16 @@ class TreeSearch {
         std::stack<StackNode> traversal_;
     };
 
+    // NOLINTBEGIN(readability-identifier-naming)
     Iterator begin() {
         return Iterator(root_.get());
     }
 
     Iterator end() {
         return Iterator(root_.get(), true);
     }
+
+    // NOLINTEND(readability-identifier-naming)
 };
 
 }  // namespace algos::dd

src/core/algorithms/dd/fastdd/util/differential_function_builder.h

@@ -51,7 +51,6 @@ class DifferentialFunctionBuilder {
     std::vector<std::vector<DifferentialFunction>> differential_functions_;
 
     std::shared_ptr<model::ColumnLayoutTypedRelationData> typed_relation_;
-    unsigned num_rows_;
     model::ColumnIndex num_columns_;
 
     std::vector<std::vector<ThresholdInfo>> thresholds_;
@@ -68,9 +67,9 @@ class DifferentialFunctionBuilder {
 
 public:
     DifferentialFunctionBuilder(
-            std::shared_ptr<model::ColumnLayoutTypedRelationData> typed_relation, unsigned num_rows,
+            std::shared_ptr<model::ColumnLayoutTypedRelationData> typed_relation,
             model::ColumnIndex num_columns)
-        : typed_relation_(typed_relation), num_rows_(num_rows), num_columns_(num_columns) {}
+        : typed_relation_(typed_relation), num_columns_(num_columns) {}
 
     void BuildDFList(std::vector<std::vector<model::DFConstraint>> const& thresholds,
                      std::vector<model::DFConstraint> const& min_max_dif = {});

src/core/algorithms/dd/fastdd/util/distance_calculator.h

@@ -55,7 +55,6 @@ class DistanceCalculator {
             std::byte const* first_value = column.GetValue(tuple_pair.first);
             std::byte const* second_value = column.GetValue(tuple_pair.second);
             if (column.GetTypeId() == model::TypeId::kString) {
-                auto const& type = column.GetType();
                 auto first_ptr = &model::Type::GetValue<model::String>(first_value);
                 auto second_ptr = &model::Type::GetValue<model::String>(second_value);
                 std::size_t const max_dist = std::max(first_ptr->size(), second_ptr->size());

src/core/algorithms/dd/fastdd/util/mmcs.h

@@ -22,14 +22,14 @@ class MMCS {
 
     std::vector<Edge> column_to_dif_funcs_;
 
-    void UpdateCritAndUncov(std::vector<std::vector<Edgemark>>& removed_criticals_stack,
+    void UpdateCritAndUncov(std::vector<std::vector<Edgemark>>& removed_critical_stack,
                             std::vector<Edgemark>& crit, Edgemark& uncov,
                             Edgemark const& v_hittings) const {
         // update crit[] for vertices in S and put changes on stack
 
-        removed_criticals_stack.push_back(crit);
+        removed_critical_stack.push_back(crit);
 
-        std::ranges::for_each(removed_criticals_stack.back(),
+        std::ranges::for_each(removed_critical_stack.back(),
                               [&v_hittings](Edgemark& edgemark) { edgemark -= v_hittings; });
         std::ranges::for_each(crit, [&v_hittings](Edgemark& edgemark) { edgemark &= v_hittings; });
 
@@ -39,16 +39,16 @@ class MMCS {
         uncov &= v_hittings;
     }
 
-    void RestoreCritAndUncov(std::vector<std::vector<Edgemark>>& removed_criticals_stack,
+    void RestoreCritAndUncov(std::vector<std::vector<Edgemark>>& removed_critical_stack,
                              std::vector<Edgemark>& crit, Edgemark& uncov) const {
         uncov |= crit.back();
         crit.pop_back();
 
         for (std::size_t i = 0; i < crit.size(); ++i) {
-            crit[i] |= removed_criticals_stack.back()[i];
+            crit[i] |= removed_critical_stack.back()[i];
         }
 
-        removed_criticals_stack.pop_back();
+        removed_critical_stack.pop_back();
     }
 
     bool VertexWouldViolate(std::vector<Edgemark> const& crit, Edgemark const& v_hittings) const {
@@ -63,9 +63,9 @@ class MMCS {
 
     void ExtendOrConfirmS(Edge& s, Edge& cand, std::vector<Edgemark>& crit, Edgemark& uncov,
                           std::vector<Edgemark>& vertex_hittings,
-                          std::vector<std::vector<Edgemark>>& removed_criticals_stack,
+                          std::vector<std::vector<Edgemark>>& removed_critical_stack,
                           std::vector<Edge>& result) const {
-        // find edge from uncov with smallest intersecton C with CAND
+        // find edge from uncov with smallest intersection C with CAND
         Edge c = cand;
         c -= hypergraph_[uncov.find_first()];
         for (std::size_t i_e = uncov.find_next(uncov.find_first()); i_e != Edgemark::npos;
@@ -94,19 +94,19 @@ class MMCS {
                     }
 
                     // branch
-                    UpdateCritAndUncov(removed_criticals_stack, crit, uncov, vertex_hittings[v]);
+                    UpdateCritAndUncov(removed_critical_stack, crit, uncov, vertex_hittings[v]);
 
                     s.set(v);
                     if (uncov.none()) {
                         result.push_back(s);
                     } else if (!cand.none()) {
                         ExtendOrConfirmS(s, cand, crit, uncov, vertex_hittings,
-                                         removed_criticals_stack, result);
+                                         removed_critical_stack, result);
                     }
                     // update CAND
                     cand.set(v);
                     s.reset(v);
-                    RestoreCritAndUncov(removed_criticals_stack, crit, uncov);
+                    RestoreCritAndUncov(removed_critical_stack, crit, uncov);
                 }
             }
         }
@@ -151,10 +151,10 @@ class MMCS {
             }
         }
 
-        std::vector<std::vector<Edgemark>> removed_criticals_stack;
+        std::vector<std::vector<Edgemark>> removed_critical_stack;
         std::vector<Edge> result;
 
-        ExtendOrConfirmS(s, cand, crit, uncov, vertex_hittings, removed_criticals_stack, result);
+        ExtendOrConfirmS(s, cand, crit, uncov, vertex_hittings, removed_critical_stack, result);
 
         return result;
     }

src/core/algorithms/dd/fastdd/util/static_bitset.h

@@ -128,7 +128,7 @@ inline StaticBitset<N> operator-(StaticBitset<N> const& left, StaticBitset<N> co
 
 template <std::size_t Size>
 inline bool operator<(StaticBitset<Size> const& left, StaticBitset<Size> const& right) {
-    assert(left_.size() == right.size());
+    assert(left.size() == right.size());
 
     return left.static_bitset_ < right.static_bitset_;
 }

src/core/algorithms/dd/fastdd/util/threshold_calculator.cpp

@@ -22,10 +22,7 @@ ThresholdCalculator::ThresholdCalculator(
         std::shared_ptr<model::ColumnLayoutTypedRelationData> const& difference_typed_relation,
         std::shared_ptr<DistanceCalculator> distance_calculator, unsigned num_rows,
         model::ColumnIndex num_columns)
-    : distance_calculator_(distance_calculator),
-      thresholds_(num_columns),
-      num_rows_(num_rows),
-      num_columns_(num_columns) {
+    : distance_calculator_(distance_calculator), thresholds_(num_columns), num_rows_(num_rows) {
     if (difference_typed_relation) {
         for (model::ColumnIndex column_index = 0; column_index != num_columns; ++column_index) {
             GetThresholds(difference_typed_relation->GetColumnData(column_index), column_index);