fix some linter warnings

include/CustomExceptions.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <cstddef>
 #include <exception>
 #include <string>
 #include <utility>

include/Definitions.hpp

@@ -1,8 +1,13 @@
 #pragma once
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <filesystem>
 #include <limits>
+#include <stdexcept>
+#include <string>
+#include <system_error>
+#include <utility>
 #include <vector>
 
 namespace cda_rail {
@@ -17,24 +22,36 @@ constexpr double ABS_PWL_ERROR            = 10;
 constexpr double LINE_SPEED_ACCURACY      = 0.1;
 constexpr double LINE_SPEED_TIME_ACCURACY = 0.1;
 
-enum class VertexType { NoBorder = 0, VSS = 1, TTD = 2, NoBorderVSS = 3 };
-enum class SolutionStatus {
+enum class VertexType : std::uint8_t {
+  NoBorder    = 0,
+  VSS         = 1,
+  TTD         = 2,
+  NoBorderVSS = 3
+};
+enum class SolutionStatus : std::uint8_t {
   Optimal    = 0,
   Feasible   = 1,
   Infeasible = 2,
   Timeout    = 3,
   Unknown    = 4
 };
-enum class ExportOption {
+enum class ExportOption : std::uint8_t {
   NoExport                        = 0,
   ExportSolution                  = 1,
   ExportSolutionWithInstance      = 2,
   ExportLP                        = 3,
   ExportSolutionAndLP             = 4,
   ExportSolutionWithInstanceAndLP = 5
 };
-enum class OptimalityStrategy { Optimal = 0, TradeOff = 1, Feasible = 2 };
-enum class VelocityRefinementStrategy { None = 0, MinOneStep = 1 };
+enum class OptimalityStrategy : std::uint8_t {
+  Optimal  = 0,
+  TradeOff = 1,
+  Feasible = 2
+};
+enum class VelocityRefinementStrategy : std::uint8_t {
+  None       = 0,
+  MinOneStep = 1
+};
 
 // Helper functions
 

include/EOMHelper.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <utility>
 
 // EOM = Equations of Motion
@@ -74,7 +75,7 @@ double max_time_profile_from_rear_to_ma_point(double v_1, double v_2,
                                               double v_m, double a, double d,
                                               double s, double obd);
 
-enum class MATimingStrategy { ExtremeProfiles = 0 };
+enum class MATimingStrategy : std::uint8_t { ExtremeProfiles = 0 };
 
 double min_time_from_rear_to_ma_point(
     double v_1, double v_2, double v_min, double v_max, double a, double d,

include/MultiArray.hpp

@@ -1,6 +1,5 @@
 #pragma once
 #include <cstddef>
-#include <memory>
 #include <sstream>
 #include <stdexcept>
 #include <vector>

include/VSSModel.hpp

@@ -1,16 +1,19 @@
 #pragma once
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <limits>
 #include <stdexcept>
+#include <utility>
 #include <vector>
 
 namespace cda_rail::vss {
 using SeparationFunction = std::function<double(size_t, size_t)>;
 
-enum class ModelType {
+enum class ModelType : std::uint8_t {
   Discrete    = 0,
   Continuous  = 1,
   Inferred    = 2,
@@ -20,9 +23,7 @@ enum class ModelType {
 namespace functions {
 [[nodiscard]] static double uniform(size_t i, size_t n) {
   double ret_val = (static_cast<double>(i) + 1) / static_cast<double>(n);
-  if (ret_val > 1) {
-    ret_val = 1;
-  }
+  ret_val        = std::min<double>(ret_val, 1);
   return ret_val;
 }
 
@@ -34,7 +35,7 @@ namespace functions {
   const auto       n_points = static_cast<double>(n) - 1;
   const auto       k        = n_points - static_cast<double>(i);
   constexpr double pi       = 3.14159265358979323846;
-  return 0.5 + 0.5 * std::cos((2 * k - 1) * pi / (2 * n_points));
+  return 0.5 + (0.5 * std::cos((2 * k - 1) * pi / (2 * n_points)));
 }
 
 [[nodiscard]] static size_t max_n_blocks(const SeparationFunction& sep_func,
@@ -57,15 +58,15 @@ namespace functions {
     }
   }
 
-  return static_cast<size_t>(std::floor(1 / min_frac + eps));
+  return static_cast<size_t>(std::floor((1 / min_frac) + eps));
 }
 } // namespace functions
 
 class Model {
 private:
-  ModelType                       model_type           = ModelType::Continuous;
-  bool                            only_stop_at_vss     = false;
-  std::vector<SeparationFunction> separation_functions = {};
+  ModelType                       model_type       = ModelType::Continuous;
+  bool                            only_stop_at_vss = false;
+  std::vector<SeparationFunction> separation_functions;
 
 public:
   // Constructors

include/solver/GeneralSolver.hpp

@@ -3,11 +3,13 @@
 #include "probleminstances/GeneralProblemInstance.hpp"
 
 #include <chrono>
-#include <cstddef>
+#include <cstdint>
+#include <filesystem>
 #include <plog/Appenders/ColorConsoleAppender.h>
 #include <plog/Formatters/TxtFormatter.h>
-#include <plog/Initializers/ConsoleInitializer.h>
-#include <plog/Log.h>
+#include <plog/Init.h>
+#include <plog/Severity.h>
+#include <string>
 #include <type_traits>
 
 namespace cda_rail::solver {

include/solver/mip-based/GenPOMovingBlockMIPSolver.hpp

@@ -1,11 +1,14 @@
 #pragma once
 
 #include "Definitions.hpp"
-#include "datastructure/GeneralTimetable.hpp"
+#include "datastructure/RailwayNetwork.hpp"
+#include "datastructure/Train.hpp"
+#include "gurobi_c++.h"
 #include "probleminstances/GeneralPerformanceOptimizationInstance.hpp"
 #include "solver/GeneralSolver.hpp"
 #include "solver/mip-based/GeneralMIPSolver.hpp"
 
+// NOLINTNEXTLINE(misc-include-cleaner)
 #include "gtest/gtest_prod.h"
 #include <cstddef>
 #include <cstdint>

include/solver/mip-based/GeneralMIPSolver.hpp

@@ -1,15 +1,19 @@
 #pragma once
 
+#include "Definitions.hpp"
 #include "MultiArray.hpp"
 #include "gurobi_c++.h"
+#include "gurobi_c.h"
+#include "probleminstances/GeneralProblemInstance.hpp"
 #include "solver/GeneralSolver.hpp"
 
-#include <cstddef>
+#include <filesystem>
 #include <optional>
 #include <plog/Log.h>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
+#include <vector>
 
 namespace cda_rail::solver::mip_based {
 

include/solver/mip-based/VSSGenTimetableSolver.hpp

@@ -5,17 +5,20 @@
 #include "gurobi_c++.h"
 #include "probleminstances/GeneralPerformanceOptimizationInstance.hpp"
 #include "probleminstances/VSSGenerationTimetable.hpp"
+#include "solver/GeneralSolver.hpp"
 #include "unordered_map"
 
 #include <cstddef>
+#include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace cda_rail::solver::mip_based {
 
-enum class UpdateStrategy { Fixed = 0, Relative = 1 };
+enum class UpdateStrategy : std::uint8_t { Fixed = 0, Relative = 1 };
 
 struct SolverStrategy {
   bool                         iterative_approach = false;
@@ -46,6 +49,7 @@ struct ModelDetailMBInformation {
 };
 
 struct ModelSettings {
+  // NOLINTNEXTLINE(readability-redundant-member-init)
   vss::Model model_type        = vss::Model();
   bool       use_pwl           = false;
   bool       use_schedule_cuts = true;

src/solver/mip-based/VSSGenTimetableSolver_fixedRoutes.cpp

@@ -7,7 +7,6 @@
 
 #include <cmath>
 #include <cstddef>
-#include <math.h>
 #include <string>
 
 // NOLINTBEGIN(performance-inefficient-string-concatenation,bugprone-unchecked-optional-access)