refactor solver into smaller pieces

Author: popmonkey

CMakeLists.txt

@@ -161,6 +161,9 @@ add_library(jres_solver_lib
   src/jres_internal_types.cpp
   src/jres_solver_base.cpp
   src/jres_standard_solver.cpp
+  src/analysis/capacity_analyzer.cpp
+  src/constraints/balancing.cpp
+  src/constraints/minimum_rest.cpp
 )
 set_target_properties(jres_solver_lib PROPERTIES OUTPUT_NAME "jres_solver")
 

CONTRIBUTING.md

@@ -15,11 +15,12 @@ It has been structured as a C-API library (`jres_solver`) and a simple CLI clien
 |   └── jres_solver/                # The public C-API header for the library
 ├── src/                            # The C++ library implementation
 |   ├── jres_solver.cpp             # C-API Wrapper and Orchestrator
-|   ├── jres_solver_base.cpp        # Shared logic for both solvers
-|   ├── jres_standard_solver.cpp    # Optimized Strict Solver
-|   ├── jres_diagnostic_solver.cpp  # Relaxed Diagnostic Solver
+|   ├── jres_solver_base.cpp        # Shared logic for the solver
+|   ├── jres_standard_solver.cpp    # Standard Solver (Elastic/Diagnostic enabled)
 |   ├── jres_internal_types.cpp     # Internal C++ data structures
 |   ├── jres_json_converter.cpp     # JSON conversion logic
+|   ├── analysis/                   # Analysis logic (e.g. capacity)
+|   ├── constraints/                # Constraint implementations
 |   ├── formatter/                  # Formatter implementation
 |   └── utils/                      # Utility functions
 ├── lib/

README.md

@@ -24,7 +24,7 @@ See [TOOLS.md](./TOOLS.md) for full usage.
 
 ## The Library
 
-**JresSolver** is a C++ library designed to optimize endurance racing schedules. It uses the **HiGHS** Mixed Integer Programming (MIP) solver to assign drivers (and optional spotters) to race stints while satisfying constraints such as fuel usage, maximum drive times, minimum rest periods, and driver availability.
+**JresSolver** is a C++ library designed to optimize endurance racing schedules. It uses the **HiGHS** Mixed Integer Programming (MIP) solver to assign drivers (and optional spotters) to race stints while satisfying constraints such as fuel usage, maximum drive times, minimum rest periods, and driver availability. The library utilizes a modular constraint architecture for flexibility and extensibility.
 
 ### Data Structures
 

src/analysis/capacity_analyzer.cpp

@@ -0,0 +1,115 @@
+#include "capacity_analyzer.hpp"
+#include <sstream>
+#include <iomanip>
+#include <chrono>
+
+namespace jres::internal {
+
+CapacityAnalysis CapacityAnalyzer::calculate_max_potential_capacity(
+    const std::vector<TeamMember>& participants,
+    const SolverInput& input)
+{
+    // Parse stint times once
+    std::vector<std::chrono::system_clock::time_point> startTimes;
+    std::vector<std::chrono::system_clock::time_point> endTimes;
+    startTimes.reserve(input.stints.size());
+    endTimes.reserve(input.stints.size());
+
+    std::chrono::system_clock::time_point raceStart;
+    std::chrono::system_clock::time_point raceEnd;
+    bool raceTimesInit = false;
+
+    for (const auto& stint : input.stints) {
+        auto s = TimeHelpers::stringToTimePoint(stint.startTime);
+        auto e = TimeHelpers::stringToTimePoint(stint.endTime);
+        startTimes.push_back(s);
+        endTimes.push_back(e);
+
+        if(!raceTimesInit) {
+            raceStart = s;
+            raceEnd = e;
+            raceTimesInit = true;
+        } else {
+            if(s < raceStart) raceStart = s;
+            if(e > raceEnd) raceEnd = e;
+        }
+    }
+
+    CapacityAnalysis analysis;
+    analysis.totalCapacity = 0;
+    std::ostringstream ss;
+
+    for (const auto& p : participants) {
+        // Build Availability
+        std::vector<bool> is_available(input.stints.size(), true);
+        auto member_availability_it = input.availability.find(p.name);
+        if (member_availability_it != input.availability.end()) {
+            for (size_t s = 0; s < input.stints.size(); ++s) {
+                std::string key = TimeHelpers::timePointToKey(startTimes[s]);
+                auto time_it = member_availability_it->second.find(key);
+                if (time_it != member_availability_it->second.end() && 
+                    time_it->second == Availability::Unavailable) {
+                    is_available[s] = false;
+                }
+            }
+        }
+
+        std::vector<bool> planned_drive(input.stints.size(), false);
+        int base_capacity = 0;
+        double driver_total_hours = 0.0;
+
+        for(size_t s=0; s<input.stints.size(); ++s) {
+            if (is_available[s]) {
+                planned_drive[s] = true;
+                base_capacity++;
+                
+                auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(endTimes[s] - startTimes[s]).count();
+                driver_total_hours += static_cast<double>(duration_ms) / 3600000.0;
+            }
+        }
+        
+        // Adjust for Global Minimum Rest (One Instance)
+        int final_capacity = base_capacity;
+        if (input.minimumRestHours > 0) {
+             auto minRestDuration = std::chrono::hours(input.minimumRestHours);
+             int min_loss = base_capacity; 
+             bool found_valid_window = false;
+
+             std::vector<std::chrono::system_clock::time_point> candidateStarts;
+             candidateStarts.push_back(raceStart);
+             for(const auto& t : endTimes) candidateStarts.push_back(t);
+
+             for(const auto& tStart : candidateStarts) {
+                 auto tEnd = tStart + minRestDuration;
+                 if (tEnd > raceEnd) continue;
+                 found_valid_window = true;
+
+                 int current_loss = 0;
+                 for(size_t s=0; s<input.stints.size(); ++s) {
+                     if (planned_drive[s]) {
+                         if (startTimes[s] < tEnd && endTimes[s] > tStart) {
+                             current_loss++;
+                         }
+                     }
+                 }
+                 if (current_loss < min_loss) min_loss = current_loss;
+             }
+             
+             if (!found_valid_window) {
+                 final_capacity = 0; // Impossible to satisfy rest
+             } else {
+                 final_capacity -= min_loss;
+             }
+        }
+        
+        analysis.totalCapacity += final_capacity;
+        
+        ss << "\n- " << p.name << ": " << final_capacity 
+           << " stints (approx " << std::fixed << std::setprecision(1) << driver_total_hours 
+           << "h, MinRest=" << input.minimumRestHours << "h)";
+    }
+    analysis.details = ss.str();
+    return analysis;
+}
+
+} // namespace jres::internal

src/analysis/capacity_analyzer.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include "../jres_internal_types.hpp"
+
+namespace jres::internal {
+
+    struct CapacityAnalysis {
+        int totalCapacity;
+        std::string details;
+    };
+
+    class CapacityAnalyzer {
+    public:
+        static CapacityAnalysis calculate_max_potential_capacity(
+            const std::vector<TeamMember>& participants,
+            const SolverInput& input
+        );
+    };
+
+}

src/constraints/balancing.cpp

@@ -0,0 +1,95 @@
+#include "balancing.hpp"
+#include "Highs.h"
+#include <cmath>
+
+namespace jres::constraints {
+
+static const double kCostFairness = 10.0; 
+
+void add_role_coupling_incentive(
+    Highs* highs,
+    const std::vector<jres::internal::TeamMember>& pool,
+    const std::map<std::pair<std::string, int>, int>& driverVars,
+    const std::map<std::pair<std::string, int>, int>& spotterVars,
+    size_t numStints,
+    double weight)
+{
+    if (std::abs(weight) < 1e-6) return;
+
+    for (const auto &p : pool) {
+        for (size_t s = 0; s < numStints - 1; ++s) {
+            bool hasDriver = driverVars.count({p.name, (int)s});
+            bool hasSpotter = spotterVars.count({p.name, (int)s + 1});
+
+            if (hasDriver && hasSpotter) {
+                int d_var = driverVars.at({p.name, (int)s});
+                int s_var = spotterVars.at({p.name, (int)s + 1});
+
+                // If there is a transition from driving (stint s) to spotting (stint s+1), reward it.
+                
+                int coupling_var = highs->getNumCol();
+                highs->addVar(0.0, 1.0);
+                highs->changeColIntegrality(coupling_var, HighsVarType::kInteger);
+                highs->changeColCost(coupling_var, -weight);
+
+                // z <= d_var
+                highs->addRow(-kHighsInf, 0.0, 2, std::vector<int>{coupling_var, d_var}.data(), std::vector<double>{1.0, -1.0}.data());
+                // z <= s_var
+                highs->addRow(-kHighsInf, 0.0, 2, std::vector<int>{coupling_var, s_var}.data(), std::vector<double>{1.0, -1.0}.data());
+            }
+        }
+    }
+}
+
+void add_balancing_constraints(
+    Highs &highs,
+    const std::vector<jres::internal::TeamMember> &participants,
+    const jres::internal::SolverInput& input,
+    const std::map<std::pair<std::string, int>, int>& workVars,
+    double avgStints)
+{
+    for (const auto &p : participants) {
+        std::vector<int> stint_indices;
+        std::vector<double> stint_values;
+        
+        std::map<int, double> varCounts;
+        for (size_t s = 0; s < input.stints.size(); ++s) {
+            if (workVars.count({p.name, (int)s})) {
+                int v = workVars.at({p.name, (int)s});
+                varCounts[v] += 1.0;
+            }
+        }
+        for(auto const& [v, count] : varCounts) {
+            stint_indices.push_back(v);
+            stint_values.push_back(count);
+        }
+
+        if (stint_indices.empty()) continue;
+
+        int total_stints_var = highs.getNumCol();
+        highs.addVar(0.0, kHighsInf);
+        stint_indices.push_back(total_stints_var);
+        stint_values.push_back(-1.0);
+        highs.addRow(0.0, 0.0, (int)stint_indices.size(), stint_indices.data(), stint_values.data());
+
+        int over_avg_var = highs.getNumCol();
+        highs.addVar(0.0, kHighsInf);
+        int under_avg_var = highs.getNumCol();
+        highs.addVar(0.0, kHighsInf);
+        
+        std::vector<int> idx_over = {over_avg_var, total_stints_var};
+        std::vector<double> val_over = {1.0, -1.0};
+        highs.addRow(0.0, kHighsInf, 2, idx_over.data(), val_over.data());
+        highs.changeRowBounds(highs.getNumRow() - 1, -avgStints, kHighsInf);
+        
+        std::vector<int> idx_under = {under_avg_var, total_stints_var};
+        std::vector<double> val_under = {1.0, 1.0};
+        highs.addRow(0.0, kHighsInf, 2, idx_under.data(), val_under.data());
+        highs.changeRowBounds(highs.getNumRow() - 1, avgStints, kHighsInf);
+
+        highs.changeColCost(over_avg_var, kCostFairness);
+        highs.changeColCost(under_avg_var, kCostFairness);
+    }
+}
+
+} // namespace jres::constraints

src/constraints/balancing.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include "../jres_internal_types.hpp"
+#include <map>
+#include <vector>
+
+class Highs;
+
+namespace jres::constraints {
+
+    void add_role_coupling_incentive(
+        Highs* highs,
+        const std::vector<jres::internal::TeamMember>& pool,
+        const std::map<std::pair<std::string, int>, int>& driverVars,
+        const std::map<std::pair<std::string, int>, int>& spotterVars,
+        size_t numStints,
+        double weight);
+
+    void add_balancing_constraints(
+        Highs &highs,
+        const std::vector<jres::internal::TeamMember> &participants,
+        const jres::internal::SolverInput& input,
+        const std::map<std::pair<std::string, int>, int>& workVars,
+        double avgStints);
+
+}