C++ API#

The C++ API reference is generated from headers in core/, plugins/, and routing/.

Note

This section is populated by Breathe once Doxygen XML is available.

struct Appointment : public routing::Attribute<Appointment>#

#include <Appointment.hpp>

Appointment flexibility metrics (solution values)

Appointment stores solution-dependent values related to time window flexibility: maximum shift and waiting time.

Public Functions

inline Appointment(const Duration &p_maxshift, const Duration &p_wait)#

inline Duration getMaxshift() const#

inline void setMaxshift(Duration maxshift)#

inline Duration getWait() const#

inline void setWait(Duration wait)#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

SolutionValue<Duration> maxshift#

SolutionValue<Duration> wait#

template<typename Derived> class Attribute : public routing::IAttribute #

#include <IAttribute.hpp>

CRTP base class for concrete attributes.

Public Functions

inline virtual AttributeTypeId typeId() const override#: Returns the unique type identifier for this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

class BoolVar#

#include <MIPTypes.hpp>

Handle for a binary variable in MIP model.

Public Functions

BoolVar() = default#

inline explicit BoolVar(int id)#

inline bool isValid() const#

inline int id() const#

inline bool operator==(const BoolVar &other) const#

inline bool operator!=(const BoolVar &other) const#

inline operator Var() const#

inline operator IntVar() const#

Private Members

int id_ = -1#

Friends

friend class IMIPBackend

class CapacityConstraintGenerator : public routing::IConstraintGenerator #

#include <CapacityConstraintGenerator.hpp>

Capacity constraint generator.

Implements vehicle capacity constraints:

Consumption variables (q_i) for tracking load
Vehicle capacity limits per route
MTZ-style load propagation constraints

Requires: Consumer (on clients) and Stock (on vehicles)

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

class CapacityEvaluator : public routing::IEvaluator #

#include <CapacityEvaluator.hpp>

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this evaluator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types required for this evaluator.

inline virtual int priority() const override#: Priority for evaluation ordering (lower = earlier). Default: 100.

inline virtual bool checkFeasibility(const Tour &tour, const InsertionContext &ctx) const override#

Check if an insertion is feasible.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

true if the insertion maintains feasibility for this evaluator’s constraints

inline virtual double evaluateInsertionDelta(const Tour&, const InsertionContext&) const override#

Compute the cost delta for an insertion.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

The change in cost (positive = worse, negative = better)

inline virtual void applyInsertion(Tour&, const InsertionContext&) override#

Apply an insertion and update internal state.

Called after an insertion is accepted. The evaluator should update any cached state (e.g., total load, arrival times).

Parameters:

tour – The tour being modified
ctx – The insertion context

class CapacityPlugin : public routing::IPlugin #

#include <CapacityPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual std::string description() const override#: Get the plugin description.

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

struct ChromosomeCmp#

#include <GASolver.hpp>

Public Functions

inline bool operator()(const Sequence *lhs, const Sequence *rhs) const#

class Client : public routing::Entity, public routing::models::Client #

#include <Entity.hpp>

Client entity with runtime attributes.

Public Functions

inline explicit Client(unsigned id)#

struct Client : public virtual routing::Model #

#include <Client.hpp>

Subclassed by routing::Client

Public Functions

inline explicit Client(unsigned id)#

class ComposableCorePlugin : public routing::IPlugin #

#include <ComposableCorePlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry&) override#: Initialize the plugin and register components.

class Configuration#

#include <Configuration.hpp>

Public Functions

inline int getIntParam(const std::string &id)#

inline bool getBoolParam(const std::string &id)#

inline double getDoubleParam(const std::string &id)#

inline void setIntParam(const std::string &id, int value)#

inline void setBoolParam(const std::string &id, bool value)#

inline void setDoubleParam(const std::string &id, double value)#

Public Static Attributes

static constexpr const char *iterMax = "iterMax"#

Private Members

std::map<std::string, int> intParams#

std::map<std::string, double> doubleParams#

std::map<std::string, bool> boolParams#

struct ConstraintConfig#

#include <GASolver.hpp>

Public Members

ConstraintMode mode = ConstraintMode::DistanceOnly #

double penaltyWeight = 1000.0#

double unservedPenalty = 100000.0#

class ConstructionParameters#

#include <Constructor.hpp>

Public Static Functions

static inline ConstructionParameters *getDefault()#

class Constructor#

#include <Constructor.hpp>

Subclassed by routing::GreedyConstructor

Public Functions

inline Constructor(routing::ConstructionParameters *p_params)#

inline Constructor()#

inline Constructor *setParams(routing::ConstructionParameters *p_params)#

inline virtual bool bestInsertion(Solution *solution)#

inline virtual bool insertClient(Solution *solution, models::Client *client)#

virtual bool bestInsertion(Solution *solution, const std::vector<models::Client*> &clients) = 0#

Public Members

routing::ConstructionParameters *params = nullptr#

struct Consumer : public routing::Attribute<Consumer>#

#include <Consumer.hpp>

A node with demand (capacity consumption)

Consumer models the demand that must be satisfied at a node, consuming vehicle capacity.

Public Functions

inline explicit Consumer(const Demand &p_demand)#

inline Demand getDemand() const#

inline Demand getConsumption() const#

inline void setConsumption(Demand consumption)#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<Demand> demand#

SolutionValue<Demand> consumption#

class CPCapacityGenerator : public routing::cp::ICPConstraintGenerator #

#include <CPCapacityGenerator.hpp>

CP Capacity constraint generator.

Implements vehicle capacity constraints using CP primitives:

Load variables tracking cumulative demand per vehicle
Capacity constraints ensuring load <= vehicle capacity

For each vehicle, the sum of demands of visited clients must not exceed the vehicle’s capacity.

Public Functions

inline virtual std::string name() const override#: Name of this generator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Attribute types required by this generator.

inline virtual int priority() const override#: Priority for ordering (lower = earlier)

inline void setRoutingGenerator(CPRoutingGenerator *routing)#

inline virtual void addVariables(ICPBackend &cp, Problem &problem) override#

Add variables to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addConstraints(ICPBackend &cp, Problem &problem) override#

Add constraints to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addObjectiveTerms(ICPBackend &cp, Problem &problem, LinearExpr &expr) override#

Add terms to the objective function.

Parameters:

cp – The CP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const ICPBackend &cp, Problem &problem) override#

Called after solving to extract solution data.

Parameters:

cp – The CP backend (with solution)
problem – The problem instance

inline const std::vector<IntVar> &getLoadVars() const#

inline const std::vector<int> &getDemands() const#

inline const std::vector<int> &getCapacities() const#

inline const std::vector<int> &getLoads() const#

Private Members

CPRoutingGenerator *routingGen_ = nullptr#

std::vector<IntVar> loadVars_#

std::vector<int> demands_#

std::vector<int> capacities_#

std::vector<int> loads_#

struct CPEntry#

Public Members

CPGeneratorFactory factory#

std::vector<AttributeTypeId> requiredAttrs#

int priority#

struct CPGeneratorEntry#

Public Members

CPGeneratorFactory factory#

std::vector<AttributeTypeId> requiredAttrs#

int priority#

class CPLEXMIPBackend : public routing::mip::IMIPBackend #

#include <CPLEXMIPBackend.hpp>

Stub implementation when CPLEX is not available.

Public Functions

inline CPLEXMIPBackend()#

inline virtual std::string name() const override#: Get backend name (e.g., “cplex”, “gurobi”, “highs”)

inline virtual Var newVar(double, double, const std::string&) override#

Create a continuous variable.

Parameters:

lb – Lower bound (default: 0)
ub – Upper bound (default: infinity)
name – Optional variable name

inline virtual IntVar newIntVar(int, int, const std::string&) override#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

inline virtual BoolVar newBoolVar(const std::string&) override#

Create a binary variable (0-1)

Parameters:: name – Optional variable name

inline virtual void addLessEqual(const LinearExpr&, double, const std::string&) override#: Add constraint: expr <= rhs.

inline virtual void addGreaterEqual(const LinearExpr&, double, const std::string&) override#: Add constraint: expr >= rhs.

inline virtual void addEqual(const LinearExpr&, double, const std::string&) override#: Add constraint: expr == rhs.

inline virtual void addRange(const LinearExpr&, double, double, const std::string&) override#: Add constraint: lb <= expr <= ub.

inline virtual void addIndicator(BoolVar, int, const LinearExpr&, Sense, double, const std::string&) override#

Add indicator constraint: if indicator == value, then expr sense rhs.

Parameters:

indicator – Boolean variable
value – Value that activates the constraint (0 or 1)
expr – Linear expression
sense – Constraint sense
rhs – Right-hand side

inline virtual void addSOS1(const std::vector<Var>&, const std::vector<double>&, const std::string&) override#: Add SOS1 constraint (at most one variable in set is non-zero)

inline virtual void addSOS2(const std::vector<Var>&, const std::vector<double>&, const std::string&) override#: Add SOS2 constraint (at most two adjacent variables are non-zero)

inline virtual void addLazyConstraint(const LinearExpr&, Sense, double) override#: Add a lazy constraint (checked only when integer solution found)

inline virtual void addUserCut(const LinearExpr&, Sense, double) override#: Add a user cut (can be added at any time, must not cut off feasible solutions)

inline virtual void minimize(const LinearExpr&) override#: Set objective to minimize.

inline virtual void maximize(const LinearExpr&) override#: Set objective to maximize.

inline virtual void minimizeQuad(const QuadExpr&) override#: Set quadratic objective to minimize.

inline virtual void maximizeQuad(const QuadExpr&) override#: Set quadratic objective to maximize.

inline virtual void setWarmStart(const std::vector<Var>&, const std::vector<double>&) override#

Provide a warm start solution.

Parameters:

vars – Variables to set
values – Values for the variables

inline virtual void setMIPStart(const std::vector<std::pair<Var, double>>&) override#: Provide MIP start hint for integer variables.

inline virtual MIPStatus solve(double) override#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

inline virtual double getValue(Var) const override#: Get value of variable in solution.

inline virtual double getObjectiveValue() const override#: Get objective value of solution.

inline virtual double getObjectiveBound() const override#: Get best objective bound.

inline virtual double getReducedCost(Var) const override#: Get reduced cost of a variable.

inline virtual double getDual(int) const override#

Get dual value (shadow price) of a constraint.

Parameters:: constraintIndex – Index of the constraint

inline virtual double getSolveTime() const override#: Get solving time in seconds.

inline virtual long long getNumIterations() const override#: Get number of simplex iterations.

inline virtual long long getNumNodes() const override#: Get number of nodes explored in branch-and-bound.

inline virtual int getNumSolutions() const override#: Get number of solutions found.

inline virtual void setTimeLimit(double) override#: Set time limit in seconds.

inline virtual void setGapTolerance(double) override#: Set MIP gap tolerance.

inline virtual void setNumThreads(int) override#: Set number of threads.

inline virtual void setRandomSeed(int) override#: Set random seed.

inline virtual void setVerbosity(int) override#: Set verbosity level (0 = quiet, higher = more verbose)

inline virtual void setPresolve(bool) override#: Enable/disable presolve.

inline virtual void setNodeLimit(long long) override#: Set node limit.

inline virtual void setSolutionLimit(int) override#: Set solution limit.

inline virtual void clear() override#: Clear the model (remove all variables and constraints)

inline virtual int getNumVars() const override#: Get number of variables.

inline virtual int getNumConstraints() const override#: Get number of constraints.

inline virtual long long getNumNonZeros() const override#: Get number of non-zeros in constraint matrix.

inline virtual bool exportModel(const std::string&) const override#

Export model to file.

Parameters:: filename – File path (extension determines format: .lp, .mps, .sav)

inline virtual bool importModel(const std::string&) override#: Import model from file.

inline virtual MIPStatus solveRelaxation() override#: Solve LP relaxation only.

inline virtual MIPStatus solveFixed() override#: Fix integer variables to their current values and resolve Useful for getting dual values after MIP solve.

class CPOptimizerBackend : public routing::cp::ICPBackend #

#include <CPOptimizerBackend.hpp>

Stub implementation when CP Optimizer is not available.

Public Functions

inline CPOptimizerBackend()#

inline virtual std::string name() const override#: Get backend name (e.g., “cpoptimizer”, “ortools”, “gecode”)

inline virtual IntVar newIntVar(int, int, const std::string&) override#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

inline virtual IntVar newBoolVar(const std::string&) override#

Create a boolean variable (0-1)

Parameters:: name – Optional variable name

inline virtual IntVar newConstant(int) override#

Create an integer constant.

Parameters:: value – Constant value

inline virtual IntervalVar newIntervalVar(int, int, int, int, const std::string&) override#

Create an interval variable for scheduling.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

inline virtual OptionalIntervalVar newOptionalIntervalVar(int, int, int, int, const std::string&) override#

Create an optional interval variable.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

Returns:

OptionalIntervalVar with presence indicator

inline virtual void addEquality(const LinearExpr&, int) override#: Add constraint: expr == value.

inline virtual void addEquality(IntVar, IntVar) override#: Add constraint: var1 == var2.

inline virtual void addLinearConstraint(const LinearExpr&, int, int) override#: Add constraint: lb <= expr <= ub.

inline virtual void addLessOrEqual(IntVar, IntVar, int) override#: Add constraint: var1 <= var2 + offset.

inline virtual void addImplication(IntVar, const LinearExpr&, int, int) override#: Add implication: if condition is true, then expr op bound.

inline virtual void addReification(IntVar, IntVar, int) override#: Add reification: indicator == 1 iff var == value This creates a channeling constraint linking a boolean indicator to a condition.

inline virtual void addAllDifferent(const std::vector<IntVar>&) override#: All-different constraint All variables must take different values.

inline virtual void addElement(IntVar, const std::vector<int>&, IntVar) override#: Element constraint: result = array[index].

inline virtual void addElement(IntVar, const std::vector<IntVar>&, IntVar) override#: Element constraint with variable array: result = vars[index].

inline virtual void addCircuit(const std::vector<IntVar>&) override#: Circuit constraint Variables define a Hamiltonian circuit over nodes 0..n-1 next[i] = j means arc from i to j.

inline virtual void addSubCircuit(const std::vector<IntVar>&) override#: Sub-circuit constraint (allows nodes to point to themselves) Used for TSP with optional nodes.

inline virtual void addInverse(const std::vector<IntVar>&, const std::vector<IntVar>&) override#: Inverse constraint: next[prev[i]] == i and prev[next[i]] == i.

inline virtual void addNoOverlap(const std::vector<IntervalVar>&) override#: No-overlap constraint Intervals cannot overlap in time.

inline virtual void addNoOverlap(const std::vector<OptionalIntervalVar>&) override#: No-overlap constraint with optional intervals.

inline virtual void addCumulative(const std::vector<IntervalVar>&, const std::vector<int>&, int) override#: Cumulative constraint At any time point, sum of demands of active intervals <= capacity.

inline virtual void addCumulative(const std::vector<OptionalIntervalVar>&, const std::vector<int>&, int) override#: Cumulative with optional intervals.

inline virtual void addEndBeforeStart(IntervalVar, IntervalVar, int) override#: Precedence constraint: interval1 ends before interval2 starts end(interval1) + delay <= start(interval2)

inline virtual IntVar startOf(IntervalVar) override#: Get start variable of an interval.

inline virtual IntVar endOf(IntervalVar) override#: Get end variable of an interval.

inline virtual IntVar durationOf(IntervalVar) override#: Get duration variable of an interval.

inline virtual IntVar startOf(OptionalIntervalVar, int) override#: Get start variable of optional interval (undefined if absent)

inline virtual IntVar endOf(OptionalIntervalVar, int) override#: Get end variable of optional interval (undefined if absent)

inline virtual void minimize(const LinearExpr&) override#: Set objective to minimize.

inline virtual void maximize(const LinearExpr&) override#: Set objective to maximize.

inline virtual void minimizeMakespan(const std::vector<IntervalVar>&) override#: Minimize the makespan (max end time of intervals)

inline virtual CPStatus solve(double) override#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

inline virtual void setHint(const std::vector<std::pair<IntVar, int>>&) override#: Provide hints/warm start.

inline virtual void setNumWorkers(int) override#: Set number of worker threads.

inline virtual void setRandomSeed(int) override#: Set random seed for reproducibility.

inline virtual int getValue(IntVar) const override#: Get value of integer variable in solution.

inline virtual bool getBoolValue(IntVar) const override#: Get value of boolean variable (0 or 1)

inline virtual int getStart(IntervalVar) const override#: Get start time of interval in solution.

inline virtual int getEnd(IntervalVar) const override#: Get end time of interval in solution.

inline virtual int getDuration(IntervalVar) const override#: Get duration of interval in solution.

inline virtual bool isPresent(OptionalIntervalVar) const override#: Check if optional interval is present in solution.

inline virtual double getObjectiveValue() const override#: Get objective value of solution.

inline virtual double getObjectiveBound() const override#: Get lower bound on objective.

inline virtual double getSolveTime() const override#: Get solving time in seconds.

inline virtual long long getNumBranches() const override#: Get number of search branches.

inline virtual long long getNumFailures() const override#: Get number of failures/backtracks.

inline virtual void clear() override#: Clear the model (remove all variables and constraints)

class CPRoutingGenerator : public routing::cp::ICPConstraintGenerator #

#include <CPRoutingGenerator.hpp>

CP Routing constraint generator.

Implements the fundamental VRP routing constraints using CP primitives:

Successor variables (next[i] = j means node j follows node i)
Visit interval variables for each node
Circuit constraint for tour structure
Vehicle assignment

The model uses a multi-depot multi-vehicle formulation where:

Each vehicle has its own start/end at depot copies
Successor variables encode the tour structure
No-overlap ensures each customer is visited at most once

Public Functions

inline virtual std::string name() const override#: Name of this generator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Attribute types required by this generator.

inline virtual int priority() const override#: Priority for ordering (lower = earlier)

inline virtual void addVariables(ICPBackend &cp, Problem &problem) override#

Add variables to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addConstraints(ICPBackend &cp, Problem &problem) override#

Add constraints to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addObjectiveTerms(ICPBackend &cp, Problem &problem, LinearExpr &expr) override#

Add terms to the objective function.

Parameters:

cp – The CP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const ICPBackend &cp, Problem &problem) override#

Called after solving to extract solution data.

Parameters:

cp – The CP backend (with solution)
problem – The problem instance

inline const std::vector<IntVar> &getNextVars() const#

inline const std::vector<std::vector<int>> &getRoutes() const#

inline size_t getNumClients() const#

inline size_t getNumVehicles() const#

inline size_t getTotalNodes() const#

inline size_t clientNodeIndex(size_t clientIdx) const#

Private Functions

inline void computeDistanceMatrix(Problem &problem)#

Private Members

std::vector<IntVar> next_#

std::vector<std::vector<int>> distanceMatrix_#

std::vector<std::vector<int>> routes_#

size_t totalNodes_ = 0#

size_t numClients_ = 0#

size_t numVehicles_ = 0#

class CPSolver : public routing::ISolver #

#include <CPSolver.hpp>

CP-based solver using pluggable backends.

This solver uses the ICPBackend interface to solve routing problems using constraint programming. It automatically discovers and uses ICPConstraintGenerator instances based on the problem’s enabled attributes.

Public Functions

inline explicit CPSolver(Problem *problem, const std::string &backendType = "cpoptimizer")#

Construct a CP solver for a problem.

Parameters:

problem – The problem to solve
backendType – Backend to use (“cpoptimizer”, “ortools”, “gecode”)

~CPSolver() override = default#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem *problem) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline virtual bool isOptimal() const override#: Check if the problem was solved to optimality.

inline virtual std::string getStats() const override#: Get solving statistics.

inline void setVerbose(bool verbose)#

inline void setNumWorkers(int workers)#

inline void addGenerator(std::unique_ptr<ICPConstraintGenerator> generator)#: Add a custom CP constraint generator.

inline ICPBackend &getBackend()#: Get the backend for advanced usage.

inline const ICPBackend &getBackend() const#

Private Functions

inline void buildModel()#

inline void extractSolution()#

Private Members

Problem *problem_#

Solution *solution_#

double objectiveValue_#

double timeout_#

int numWorkers_#

bool verbose_#

std::unique_ptr<ICPBackend> backend_#

std::vector<std::unique_ptr<ICPConstraintGenerator>> customGenerators_#

std::vector<std::unique_ptr<ICPConstraintGenerator>> autoGenerators_#

generators::CPRoutingGenerator *routingGen_ = nullptr#

class CPSolverPlugin : public routing::IPlugin #

#include <CPSolverPlugin.hpp>

Plugin that registers the CP solver with the plugin registry.

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class CPTimeWindowGenerator : public routing::cp::ICPConstraintGenerator #

#include <CPTimeWindowGenerator.hpp>

CP Time Window constraint generator.

Implements time window constraints using CP interval variables:

Each visit is modeled as an interval with bounds from time windows
Service time defines the interval duration
Precedence constraints ensure temporal consistency
No-overlap ensures each vehicle visits nodes in sequence

The CP model naturally handles:

Waiting time (start can be later than arrival)
Service time as interval duration
Time window bounds as interval bounds

Public Functions

inline virtual std::string name() const override#: Name of this generator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Attribute types required by this generator.

inline virtual int priority() const override#: Priority for ordering (lower = earlier)

inline void setRoutingGenerator(CPRoutingGenerator *routing)#

inline virtual void addVariables(ICPBackend &cp, Problem &problem) override#

Add variables to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addConstraints(ICPBackend &cp, Problem &problem) override#

Add constraints to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addObjectiveTerms(ICPBackend &cp, Problem &problem, LinearExpr &expr) override#

Add terms to the objective function.

Parameters:

cp – The CP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const ICPBackend &cp, Problem &problem) override#

Called after solving to extract solution data.

Parameters:

cp – The CP backend (with solution)
problem – The problem instance

inline const std::vector<IntervalVar> &getVisitIntervals() const#

inline const std::vector<IntVar> &getStartTimes() const#

inline const std::vector<IntVar> &getEndTimes() const#

inline const std::vector<int> &getArrivalTimes() const#

Public Static Attributes

static constexpr int kTimeScale = 100#

Private Members

CPRoutingGenerator *routingGen_ = nullptr#

std::vector<IntervalVar> visitIntervals_#

std::vector<IntVar> startTimes_#

std::vector<IntVar> endTimes_#

std::vector<std::vector<OptionalIntervalVar>> vehicleVisits_#

std::vector<int> arrivalTimes_#

class Decoder#

#include <Decoder.hpp>

Subclassed by routing::dummyDecoder

Public Functions

virtual bool decode(const std::vector<models::Client*> &sequence, Solution *solution) = 0#

class DefaultInitializer : public routing::Initializer #

Default initializer for Problem.

Public Functions

inline explicit DefaultInitializer(Problem *p_problem)#

inline Solution *initialSolution() override#

inline Tour *initialTour(int vehicleID) override#

struct Delivery : public routing::Attribute<Delivery>#

#include <Delivery.hpp>

Delivery demand at a node.

Delivery models goods to be dropped off at this node, reducing the vehicle’s current load.

Public Functions

inline explicit Delivery(const DeliveryDemand &p_delivery)#

inline DeliveryDemand getDelivery() const#

inline DeliveryDemand getPickup() const#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<DeliveryDemand> deliveryDemand#

class Depot : public routing::Entity, public routing::models::Depot #

#include <Entity.hpp>

Depot entity with runtime attributes.

Public Functions

inline explicit Depot(unsigned id)#

struct Depot : public virtual routing::Model #

#include <Depot.hpp>

Subclassed by routing::Depot

Public Functions

inline explicit Depot(unsigned id)#

class DestructionParameters#

#include <Destructor.hpp>

Public Static Functions

static inline DestructionParameters *getDefault()#

class Destructor#

#include <Destructor.hpp>

Subclassed by routing::RandomDestructor

Public Functions

inline Destructor(routing::DestructionParameters *p_params)#

inline Destructor *setParams(routing::DestructionParameters *p_params)#

inline Destructor()#

virtual void destruct(Solution *solution) = 0#

Public Members

routing::DestructionParameters *params = nullptr#

class Diver#

#include <Diver.hpp>

Subclassed by routing::dummyDiver

Public Functions

virtual bool dive(routing::Solution *solution) = 0#

class dummyDecoder : public routing::Decoder #

#include <Decoder.hpp>

Public Functions

inline virtual bool decode(const std::vector<models::Client*> &sequence, Solution *solution)#

class dummyDiver : public routing::Diver #

#include <Diver.hpp>

Public Functions

inline virtual bool dive(routing::Solution *solution)#

class Entity : public virtual routing::Model #

#include <Entity.hpp>

Runtime-composable entity that can hold any combination of attributes.

Entity uses a runtime composition model where attributes are stored in a map and accessed dynamically, replacing multiple-inheritance model composition.

Usage: Entity entity(1); entity.addAttribute<GeoNode>(10.0, 20.0); entity.addAttribute<Consumer>(15);

if (entity.hasAttribute<Consumer>()) { auto demand = entity.getAttribute<Consumer>().getDemand(); }

Note: Uses virtual inheritance from Model to avoid diamond inheritance issues when combined with models::Client, models::Vehicle, or models::Depot.

Subclassed by routing::Client, routing::Depot, routing::Vehicle

Public Functions

inline explicit Entity(unsigned id)#

virtual ~Entity() = default#

Entity(const Entity&) = delete#

Entity &operator=(const Entity&) = delete#

Entity(Entity&&) = default#

Entity &operator=(Entity&&) = default#

template<typename Attr, typename ...Args> inline Attr &addAttribute(Args&&... args)#

Add an attribute to this entity.

Creates a new attribute instance with the given constructor arguments. If an attribute of this type already exists, it will be replaced.

Template Parameters:

Attr – The attribute type (must inherit from Attribute<Attr>)
Args – Constructor argument types

Parameters:

args – Constructor arguments forwarded to Attr’s constructor

Returns:

Reference to the newly created attribute

template<typename Attr> inline bool hasAttribute() const#: Check if this entity has a specific attribute type.

template<typename Attr> inline Attr &getAttribute()#: Get an attribute by type (throws if not found)

template<typename Attr> inline const Attr &getAttribute() const#: Get an attribute by type (const version)

template<typename Attr> inline Attr *tryGetAttribute()#: Try to get an attribute (returns nullptr if not found)

template<typename Attr> inline const Attr *tryGetAttribute() const#: Try to get an attribute (const version)

template<typename Attr> inline bool removeAttribute()#

Remove an attribute by type.

Returns:: true if the attribute was removed, false if it didn’t exist

inline std::set<AttributeTypeId> getAttributeTypes() const#: Get all attribute type IDs on this entity.

inline size_t attributeCount() const#: Get the number of attributes on this entity.

inline std::unique_ptr<Entity> clone() const#: Create a deep copy of this entity (including all attributes)

Private Members

std::map<AttributeTypeId, std::unique_ptr<IAttribute>> attributes_#

template<typename V> class EntityData : public routing::IEntityData #

#include <IAttribute.hpp>

Public Functions

inline EntityData(const V &p_val)#

template<typename T> inline bool is()#

inline V getValue() const#

Private Members

V val#

class GASolver : public routing::Solver #

#include <GASolver.hpp>

Subclassed by routing::MASolver

Public Functions

inline GASolver(routing::Problem *p_problem, Generator *p_generator, const std::vector<Neighborhood*> &p_neighbors, std::ostream &os = std::cout)#

inline GASolver(routing::Problem *p_problem, std::ostream &os = std::cout)#

inline virtual void setGenerator(Generator *p_generator)#

inline virtual void setNeighbors(std::vector<routing::Neighborhood*> p_neighbors)#

inline virtual void mutate(Sequence *sequence)#

inline virtual void setDefaultConfiguration() override#

inline virtual bool solve(double timeout = 3600) override#

virtual ~GASolver() = default#

Protected Attributes

std::vector<routing::Neighborhood*> neighbors#

routing::Generator *generator = nullptr#

Private Functions

inline ConstraintConfig buildConstraintConfig() const#

class GASolverPlugin : public routing::IPlugin #

#include <GASolverPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class GASolverWrapper : public routing::ISolver #

#include <GASolverPlugin.hpp>

Public Functions

inline explicit GASolverWrapper(Problem *problem)#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem*) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline virtual void setImprovementCallback(ImprovementCallback callback) override#: Set callback for solution improvements.

inline void setGenerator(Generator *generator)#

inline void setNeighbors(const std::vector<Neighborhood*> &neighbors)#

inline void setBoolParam(const std::string &name, bool value)#

inline void setDoubleParam(const std::string &name, double value)#

inline void setIntParam(const std::string &name, int value)#

Private Functions

inline void ensureConfig()#

Private Members

GASolver solver_#

class Generator#

#include <Generator.hpp>

Public Functions

inline Generator(Problem *p_problem, Constructor *p_constructor, Destructor *p_destructor)#

inline virtual Solution *initialSolution()#

inline virtual Solution *generate()#

inline Constructor *getConstructor() const#

inline Destructor *getDestructor() const#

inline routing::Problem *getProblem() const#

Protected Attributes

Constructor *constructor#

Destructor *destructor#

routing::Problem *problem#

class GeneratorRegistry#

#include <GeneratorRegistry.hpp>

Registry for constraint generators (CP and MIP)

Generators register themselves with factories. Solvers query the registry to get all generators whose required attributes are satisfied.

Public Types

using CPGeneratorFactory = std::function<std::unique_ptr<cp::ICPConstraintGenerator>()>#

using MIPGeneratorFactory = std::function<std::unique_ptr<mip::IMIPConstraintGenerator>()>#

Public Functions

inline void registerCPGenerator(const std::string &name, CPGeneratorFactory factory, std::vector<AttributeTypeId> requiredAttrs, int priority = 100)#

inline void registerMIPGenerator(const std::string &name, MIPGeneratorFactory factory, std::vector<AttributeTypeId> requiredAttrs, int priority = 100)#

inline std::vector<std::unique_ptr<cp::ICPConstraintGenerator>> getApplicableCPGenerators(const std::set<AttributeTypeId> &enabledAttrs) const#

inline std::vector<std::unique_ptr<mip::IMIPConstraintGenerator>> getApplicableMIPGenerators(const std::set<AttributeTypeId> &enabledAttrs) const#

inline std::vector<std::string> listCPGenerators() const#

inline std::vector<std::string> listMIPGenerators() const#

Public Static Functions

static inline GeneratorRegistry &instance()#

Private Functions

GeneratorRegistry() = default#

Private Members

std::map<std::string, CPEntry> cpGenerators_#

std::map<std::string, MIPEntry> mipGenerators_#

Private Static Functions

static inline bool isApplicable(const std::vector<AttributeTypeId> &required, const std::set<AttributeTypeId> &enabled)#

struct GeoNode : public routing::Attribute<GeoNode>#

#include <GeoNode.hpp>

A node with x, y coordinates.

GeoNode provides geographic positioning for entities. Used for distance calculations between nodes.

Public Functions

inline GeoNode(const Duration &p_x, const Duration &p_y)#

inline Duration getX() const#

inline Duration getY() const#

inline Duration distanceTo(const GeoNode &other) const#: Compute Euclidean distance to another GeoNode.

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<Duration> x#

EntityData<Duration> y#

class GreedyConstructor : public routing::Constructor #

#include <GreedyConstructor.hpp>

Public Functions

GreedyConstructor() = default#

inline virtual bool bestInsertion(Solution *solution, const std::vector<models::Client*> &clients) override#

Private Functions

inline void ensureTours(Solution *solution, Problem *problem)#

class HeuristicCallback : public IloCplex::HeuristicCallbackI#

#include <HeuristicCallback.hpp>

Public Functions

inline HeuristicCallback(IloEnv env, Problem *_problem, routing::Generator *p_generator, routing::Diver *p_diver, std::vector<routing::Neighborhood*> p_neighbors)#

~HeuristicCallback() override = default#

Protected Functions

inline void main() override#

inline IloCplex::CallbackI *duplicateCallback() const override#

inline virtual void extractSolution()#

inline virtual bool shouldDive()#

inline virtual routing::Solution *extractPartialSolution(routing::Problem *problem)#

Protected Attributes

Problem *problem#

routing::Generator *generator#

routing::Diver *diver#

std::vector<routing::Neighborhood*> neighbors#

double incumbent_looked#

Solution *solution = {}#

std::vector<double> starts#

class HiGHSMIPBackend : public routing::mip::IMIPBackend #

#include <HiGHSMIPBackend.hpp>

Stub implementation when HiGHS is not available.

Public Functions

inline HiGHSMIPBackend()#

inline virtual std::string name() const override#: Get backend name (e.g., “cplex”, “gurobi”, “highs”)

inline virtual Var newVar(double, double, const std::string&) override#

Create a continuous variable.

Parameters:

lb – Lower bound (default: 0)
ub – Upper bound (default: infinity)
name – Optional variable name

inline virtual IntVar newIntVar(int, int, const std::string&) override#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

inline virtual BoolVar newBoolVar(const std::string&) override#

Create a binary variable (0-1)

Parameters:: name – Optional variable name

inline virtual void addLessEqual(const LinearExpr&, double, const std::string&) override#: Add constraint: expr <= rhs.

inline virtual void addGreaterEqual(const LinearExpr&, double, const std::string&) override#: Add constraint: expr >= rhs.

inline virtual void addEqual(const LinearExpr&, double, const std::string&) override#: Add constraint: expr == rhs.

inline virtual void addRange(const LinearExpr&, double, double, const std::string&) override#: Add constraint: lb <= expr <= ub.

inline virtual void addIndicator(BoolVar, int, const LinearExpr&, Sense, double, const std::string&) override#

Add indicator constraint: if indicator == value, then expr sense rhs.

Parameters:

indicator – Boolean variable
value – Value that activates the constraint (0 or 1)
expr – Linear expression
sense – Constraint sense
rhs – Right-hand side

inline virtual void addSOS1(const std::vector<Var>&, const std::vector<double>&, const std::string&) override#: Add SOS1 constraint (at most one variable in set is non-zero)

inline virtual void addSOS2(const std::vector<Var>&, const std::vector<double>&, const std::string&) override#: Add SOS2 constraint (at most two adjacent variables are non-zero)

inline virtual void addLazyConstraint(const LinearExpr&, Sense, double) override#: Add a lazy constraint (checked only when integer solution found)

inline virtual void addUserCut(const LinearExpr&, Sense, double) override#: Add a user cut (can be added at any time, must not cut off feasible solutions)

inline virtual void minimize(const LinearExpr&) override#: Set objective to minimize.

inline virtual void maximize(const LinearExpr&) override#: Set objective to maximize.

inline virtual void minimizeQuad(const QuadExpr&) override#: Set quadratic objective to minimize.

inline virtual void maximizeQuad(const QuadExpr&) override#: Set quadratic objective to maximize.

inline virtual void setWarmStart(const std::vector<Var>&, const std::vector<double>&) override#

Provide a warm start solution.

Parameters:

vars – Variables to set
values – Values for the variables

inline virtual void setMIPStart(const std::vector<std::pair<Var, double>>&) override#: Provide MIP start hint for integer variables.

inline virtual MIPStatus solve(double) override#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

inline virtual double getValue(Var) const override#: Get value of variable in solution.

inline virtual double getObjectiveValue() const override#: Get objective value of solution.

inline virtual double getObjectiveBound() const override#: Get best objective bound.

inline virtual double getReducedCost(Var) const override#: Get reduced cost of a variable.

inline virtual double getDual(int) const override#

Get dual value (shadow price) of a constraint.

Parameters:: constraintIndex – Index of the constraint

inline virtual double getSolveTime() const override#: Get solving time in seconds.

inline virtual long long getNumIterations() const override#: Get number of simplex iterations.

inline virtual long long getNumNodes() const override#: Get number of nodes explored in branch-and-bound.

inline virtual int getNumSolutions() const override#: Get number of solutions found.

inline virtual void setTimeLimit(double) override#: Set time limit in seconds.

inline virtual void setGapTolerance(double) override#: Set MIP gap tolerance.

inline virtual void setNumThreads(int) override#: Set number of threads.

inline virtual void setRandomSeed(int) override#: Set random seed.

inline virtual void setVerbosity(int) override#: Set verbosity level (0 = quiet, higher = more verbose)

inline virtual void setPresolve(bool) override#: Enable/disable presolve.

inline virtual void setNodeLimit(long long) override#: Set node limit.

inline virtual void setSolutionLimit(int) override#: Set solution limit.

inline virtual void clear() override#: Clear the model (remove all variables and constraints)

inline virtual int getNumVars() const override#: Get number of variables.

inline virtual int getNumConstraints() const override#: Get number of constraints.

inline virtual long long getNumNonZeros() const override#: Get number of non-zeros in constraint matrix.

inline virtual bool exportModel(const std::string&) const override#

Export model to file.

Parameters:: filename – File path (extension determines format: .lp, .mps, .sav)

inline virtual bool importModel(const std::string&) override#: Import model from file.

inline virtual MIPStatus solveRelaxation() override#: Solve LP relaxation only.

inline virtual MIPStatus solveFixed() override#: Fix integer variables to their current values and resolve Useful for getting dual values after MIP solve.

class IAttribute#

#include <IAttribute.hpp>

Base interface for all composable attributes.

Subclassed by routing::Attribute< Appointment >, routing::Attribute< Consumer >, routing::Attribute< Delivery >, routing::Attribute< GeoNode >, routing::Attribute< Pickup >, routing::Attribute< Profiter >, routing::Attribute< Rendezvous >, routing::Attribute< Service >, routing::Attribute< ServiceQuery >, routing::Attribute< SoftTimeWindows >, routing::Attribute< Stock >, routing::Attribute< Synced >, routing::Attribute< Derived >

Public Functions

virtual ~IAttribute() = default#

virtual AttributeTypeId typeId() const = 0#: Returns the unique type identifier for this attribute.

virtual std::unique_ptr<IAttribute> clone() const = 0#: Creates a deep copy of this attribute.

virtual std::string name() const = 0#: Returns a human-readable name for this attribute type.

class IConstraintGenerator#

#include <IConstraintGenerator.hpp>

Interface for constraint generators.

Constraint generators are responsible for adding CPLEX variables, constraints, and objective terms for a specific problem aspect (e.g., capacity, time windows, synchronization).

Each generator declares which attributes it requires. The PluginRegistry uses this to automatically activate generators when their required attributes are enabled on a problem.

Subclassed by routing::constraints::CapacityConstraintGenerator, routing::constraints::PickupDeliveryConstraintGenerator, routing::constraints::ProfitObjectiveGenerator, routing::constraints::RoutingConstraintGenerator, routing::constraints::SoftTimeWindowGenerator, routing::constraints::SyncConstraintGenerator, routing::constraints::TimeWindowConstraintGenerator

Public Functions

virtual ~IConstraintGenerator() = default#

virtual std::string name() const = 0#: Returns a unique name for this generator (for debugging/logging)

virtual std::vector<AttributeTypeId> requiredAttributes() const = 0#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual std::vector<AttributeTypeId> conflictingAttributes() const#: Returns attribute types that conflict with this generator (optional)

inline virtual int priority() const#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

inline bool isApplicable(const std::set<AttributeTypeId> &enabledAttrs) const#: Check if this generator should be active given the enabled attributes.

class ICPBackend#

#include <ICPBackend.hpp>

Abstract interface for Constraint Programming backends.

This interface provides a unified API for different CP solvers:

IBM ILOG CP Optimizer
Google OR-Tools CP-SAT
Gecode

The interface focuses on the constraints commonly used in vehicle routing:

Interval variables for time windows
Circuit/path constraints
Cumulative constraints for capacity
No-overlap constraints for synchronization

Subclassed by routing::cp::CPOptimizerBackend, routing::cp::ORToolsCPSATBackend, routing::cp::XCSP3Backend

Public Functions

virtual ~ICPBackend() = default#

virtual std::string name() const = 0#: Get backend name (e.g., “cpoptimizer”, “ortools”, “gecode”)

virtual IntVar newIntVar(int lb, int ub, const std::string &name = "") = 0#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

virtual IntVar newBoolVar(const std::string &name = "") = 0#

Create a boolean variable (0-1)

Parameters:: name – Optional variable name

virtual IntVar newConstant(int value) = 0#

Create an integer constant.

Parameters:: value – Constant value

virtual IntervalVar newIntervalVar(int minStart, int maxEnd, int minDuration, int maxDuration, const std::string &name = "") = 0#

Create an interval variable for scheduling.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

inline virtual IntervalVar newFixedIntervalVar(int minStart, int maxEnd, int duration, const std::string &name = "")#: Create an interval variable with fixed duration.

virtual OptionalIntervalVar newOptionalIntervalVar(int minStart, int maxEnd, int minDuration, int maxDuration, const std::string &name = "") = 0#

Create an optional interval variable.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

Returns:

OptionalIntervalVar with presence indicator

virtual void addEquality(const LinearExpr &expr, int value) = 0#: Add constraint: expr == value.

virtual void addEquality(IntVar var1, IntVar var2) = 0#: Add constraint: var1 == var2.

inline virtual void addEquality(IntVar var, int value)#: Add constraint: var == value.

virtual void addLinearConstraint(const LinearExpr &expr, int lb, int ub) = 0#: Add constraint: lb <= expr <= ub.

inline virtual void addLessOrEqual(const LinearExpr &expr, int ub)#: Add constraint: expr <= ub.

inline virtual void addGreaterOrEqual(const LinearExpr &expr, int lb)#: Add constraint: expr >= lb.

virtual void addLessOrEqual(IntVar var1, IntVar var2, int offset = 0) = 0#: Add constraint: var1 <= var2 + offset.

virtual void addImplication(IntVar condition, const LinearExpr &expr, int lb, int ub) = 0#: Add implication: if condition is true, then expr op bound.

virtual void addReification(IntVar indicator, IntVar var, int value) = 0#: Add reification: indicator == 1 iff var == value This creates a channeling constraint linking a boolean indicator to a condition.

virtual void addAllDifferent(const std::vector<IntVar> &vars) = 0#: All-different constraint All variables must take different values.

virtual void addElement(IntVar index, const std::vector<int> &array, IntVar result) = 0#: Element constraint: result = array[index].

virtual void addElement(IntVar index, const std::vector<IntVar> &vars, IntVar result) = 0#: Element constraint with variable array: result = vars[index].

virtual void addCircuit(const std::vector<IntVar> &next) = 0#: Circuit constraint Variables define a Hamiltonian circuit over nodes 0..n-1 next[i] = j means arc from i to j.

virtual void addSubCircuit(const std::vector<IntVar> &next) = 0#: Sub-circuit constraint (allows nodes to point to themselves) Used for TSP with optional nodes.

virtual void addInverse(const std::vector<IntVar> &next, const std::vector<IntVar> &prev) = 0#: Inverse constraint: next[prev[i]] == i and prev[next[i]] == i.

virtual void addNoOverlap(const std::vector<IntervalVar> &intervals) = 0#: No-overlap constraint Intervals cannot overlap in time.

virtual void addNoOverlap(const std::vector<OptionalIntervalVar> &intervals) = 0#: No-overlap constraint with optional intervals.

virtual void addCumulative(const std::vector<IntervalVar> &intervals, const std::vector<int> &demands, int capacity) = 0#: Cumulative constraint At any time point, sum of demands of active intervals <= capacity.

virtual void addCumulative(const std::vector<OptionalIntervalVar> &intervals, const std::vector<int> &demands, int capacity) = 0#: Cumulative with optional intervals.

virtual void addEndBeforeStart(IntervalVar interval1, IntervalVar interval2, int delay = 0) = 0#: Precedence constraint: interval1 ends before interval2 starts end(interval1) + delay <= start(interval2)

virtual IntVar startOf(IntervalVar interval) = 0#: Get start variable of an interval.

virtual IntVar endOf(IntervalVar interval) = 0#: Get end variable of an interval.

virtual IntVar durationOf(IntervalVar interval) = 0#: Get duration variable of an interval.

virtual IntVar startOf(OptionalIntervalVar interval, int defaultValue = 0) = 0#: Get start variable of optional interval (undefined if absent)

virtual IntVar endOf(OptionalIntervalVar interval, int defaultValue = 0) = 0#: Get end variable of optional interval (undefined if absent)

virtual void minimize(const LinearExpr &expr) = 0#: Set objective to minimize.

virtual void maximize(const LinearExpr &expr) = 0#: Set objective to maximize.

virtual void minimizeMakespan(const std::vector<IntervalVar> &intervals) = 0#: Minimize the makespan (max end time of intervals)

virtual CPStatus solve(double timeout = 3600.0) = 0#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

virtual void setHint(const std::vector<std::pair<IntVar, int>> &hints) = 0#: Provide hints/warm start.

virtual void setNumWorkers(int workers) = 0#: Set number of worker threads.

virtual void setRandomSeed(int seed) = 0#: Set random seed for reproducibility.

virtual int getValue(IntVar var) const = 0#: Get value of integer variable in solution.

virtual bool getBoolValue(IntVar var) const = 0#: Get value of boolean variable (0 or 1)

virtual int getStart(IntervalVar interval) const = 0#: Get start time of interval in solution.

virtual int getEnd(IntervalVar interval) const = 0#: Get end time of interval in solution.

virtual int getDuration(IntervalVar interval) const = 0#: Get duration of interval in solution.

virtual bool isPresent(OptionalIntervalVar interval) const = 0#: Check if optional interval is present in solution.

virtual double getObjectiveValue() const = 0#: Get objective value of solution.

virtual double getObjectiveBound() const = 0#: Get lower bound on objective.

inline virtual double getGap() const#: Get gap between objective and bound.

virtual double getSolveTime() const = 0#: Get solving time in seconds.

virtual long long getNumBranches() const = 0#: Get number of search branches.

virtual long long getNumFailures() const = 0#: Get number of failures/backtracks.

virtual void clear() = 0#: Clear the model (remove all variables and constraints)

inline virtual bool exportModel(const std::string &filename) const#: Export model to file (format depends on backend)

class ICPConstraintGenerator#

#include <ICPConstraintGenerator.hpp>

Interface for CP constraint generators.

Similar to IConstraintGenerator but uses ICPBackend instead of CPLEX. Each generator adds variables, constraints, and objective terms for a specific aspect of the problem (routing, time windows, capacity, etc.)

Subclassed by routing::cp::generators::CPCapacityGenerator, routing::cp::generators::CPRoutingGenerator, routing::cp::generators::CPTimeWindowGenerator

Public Functions

virtual ~ICPConstraintGenerator() = default#

virtual std::string name() const = 0#: Name of this generator.

inline virtual int priority() const#: Priority for ordering (lower = earlier)

virtual std::vector<AttributeTypeId> requiredAttributes() const = 0#: Attribute types required by this generator.

virtual void addVariables(ICPBackend &cp, Problem &problem) = 0#

Add variables to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

virtual void addConstraints(ICPBackend &cp, Problem &problem) = 0#

Add constraints to the CP model.

Parameters:

cp – The CP backend
problem – The problem instance

inline virtual void addObjectiveTerms(ICPBackend &cp, Problem &problem, LinearExpr &expr)#

Add terms to the objective function.

Parameters:

cp – The CP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const ICPBackend &cp, Problem &problem)#

Called after solving to extract solution data.

Parameters:

cp – The CP backend (with solution)
problem – The problem instance

class IDCH : public routing::Neighborhood #

#include <IDCH.hpp>

Public Functions

inline IDCH(Constructor *p_constructor, Destructor *p_destructor)#

inline virtual bool look(Solution *solution)#

Parameters:: solution – the solution to shake it returns the best neighbor
Returns:: true if solution improved

Protected Attributes

Constructor *constructor#

Destructor *destructor#

class IDCHNeighborhood : public routing::INeighborhood #

#include <IDCHPlugin.hpp>

Public Functions

IDCHNeighborhood() = default#

inline explicit IDCHNeighborhood(Constructor *constructor, Destructor *destructor)#

inline virtual std::string name() const override#: Get neighborhood name.

inline virtual std::string description() const override#: Get neighborhood description.

inline virtual std::optional<NeighborhoodMove> explore(Solution&) override#: Explore the neighborhood and find the best move.

inline virtual void apply(Solution&, const NeighborhoodMove&) override#: Apply a move to the solution.

inline virtual bool improve(Solution &solution) override#: Convenience method: explore and apply best move.

inline void setOperators(Constructor *constructor, Destructor *destructor)#

Private Functions

inline void rebuild()#

Private Members

Constructor *constructor_ = nullptr#

Destructor *destructor_ = nullptr#

std::unique_ptr<IDCH> idch_#

class IDCHPlugin : public routing::IPlugin #

#include <IDCHPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class IEntityData#: #include <IAttribute.hpp>

Subclassed by routing::EntityData< Demand >, routing::EntityData< DeliveryDemand >, routing::EntityData< Duration >, routing::EntityData< PickupDemand >, routing::EntityData< Profit >, routing::EntityData< TW >, routing::EntityData< Capacity >, routing::EntityData< V >

class IEvaluator#

#include <IEvaluator.hpp>

Interface for incremental solution evaluators.

Evaluators are responsible for checking feasibility and computing cost deltas for move operations in metaheuristic search.

Each evaluator is associated with specific attributes (e.g., capacity evaluator requires Consumer and Stock attributes). The PluginRegistry uses this information to activate evaluators based on enabled attributes.

Subclassed by routing::evaluators::CapacityEvaluator, routing::evaluators::RoutingEvaluator, routing::evaluators::TimeWindowEvaluator

Public Functions

virtual ~IEvaluator() = default#

virtual std::string name() const = 0#: Returns a unique name for this evaluator.

virtual std::vector<AttributeTypeId> requiredAttributes() const = 0#: Returns the attribute types required for this evaluator.

inline virtual int priority() const#: Priority for evaluation ordering (lower = earlier). Default: 100.

virtual bool checkFeasibility(const Tour &tour, const InsertionContext &ctx) const = 0#

Check if an insertion is feasible.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

true if the insertion maintains feasibility for this evaluator’s constraints

virtual double evaluateInsertionDelta(const Tour &tour, const InsertionContext &ctx) const = 0#

Compute the cost delta for an insertion.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

The change in cost (positive = worse, negative = better)

virtual void applyInsertion(Tour &tour, const InsertionContext &ctx) = 0#

Apply an insertion and update internal state.

Called after an insertion is accepted. The evaluator should update any cached state (e.g., total load, arrival times).

Parameters:

tour – The tour being modified
ctx – The insertion context

inline bool isApplicable(const std::set<AttributeTypeId> &enabledAttrs) const#: Check if this evaluator is applicable given enabled attributes.

class IMIPBackend#

#include <IMIPBackend.hpp>

Abstract interface for Mixed Integer Programming backends.

This interface provides a unified API for different MIP solvers:

IBM ILOG CPLEX
Gurobi
HiGHS
SCIP
CBC

The interface focuses on building and solving MIP models for vehicle routing.

Subclassed by routing::mip::CPLEXMIPBackend, routing::mip::HiGHSMIPBackend

Public Types

using LazyCallback = std::function<void(IMIPBackend &backend)>#: Callback function type for lazy constraints Called when an integer feasible solution is found. The callback receives the backend to query solution values and add cuts.

using CutCallback = std::function<void(IMIPBackend &backend)>#: Callback function type for user cuts Called during the branch-and-bound process.

using IncumbentCallback = std::function<void(IMIPBackend &backend, double objValue)>#: Callback for incumbent solutions Called when a new best solution is found.

Public Functions

virtual ~IMIPBackend() = default#

virtual std::string name() const = 0#: Get backend name (e.g., “cplex”, “gurobi”, “highs”)

virtual Var newVar(double lb = 0.0, double ub = std::numeric_limits<double>::infinity(), const std::string &name = "") = 0#

Create a continuous variable.

Parameters:

lb – Lower bound (default: 0)
ub – Upper bound (default: infinity)
name – Optional variable name

virtual IntVar newIntVar(int lb, int ub, const std::string &name = "") = 0#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

virtual BoolVar newBoolVar(const std::string &name = "") = 0#

Create a binary variable (0-1)

Parameters:: name – Optional variable name

inline virtual std::vector<std::vector<BoolVar>> newBoolVarArray2D(size_t rows, size_t cols, const std::string &namePrefix = "")#

Create a 2D array of binary variables.

Parameters:

rows – Number of rows
cols – Number of columns
namePrefix – Prefix for variable names

virtual void addLessEqual(const LinearExpr &expr, double rhs, const std::string &name = "") = 0#: Add constraint: expr <= rhs.

virtual void addGreaterEqual(const LinearExpr &expr, double rhs, const std::string &name = "") = 0#: Add constraint: expr >= rhs.

virtual void addEqual(const LinearExpr &expr, double rhs, const std::string &name = "") = 0#: Add constraint: expr == rhs.

virtual void addRange(const LinearExpr &expr, double lb, double ub, const std::string &name = "") = 0#: Add constraint: lb <= expr <= ub.

inline virtual void addEqual(const LinearExpr &expr1, const LinearExpr &expr2, const std::string &name = "")#: Add constraint: expr1 == expr2.

virtual void addIndicator(BoolVar indicator, int value, const LinearExpr &expr, Sense sense, double rhs, const std::string &name = "") = 0#

Add indicator constraint: if indicator == value, then expr sense rhs.

Parameters:

indicator – Boolean variable
value – Value that activates the constraint (0 or 1)
expr – Linear expression
sense – Constraint sense
rhs – Right-hand side

virtual void addSOS1(const std::vector<Var> &vars, const std::vector<double> &weights = {}, const std::string &name = "") = 0#: Add SOS1 constraint (at most one variable in set is non-zero)

virtual void addSOS2(const std::vector<Var> &vars, const std::vector<double> &weights = {}, const std::string &name = "") = 0#: Add SOS2 constraint (at most two adjacent variables are non-zero)

virtual void addLazyConstraint(const LinearExpr &expr, Sense sense, double rhs) = 0#: Add a lazy constraint (checked only when integer solution found)

virtual void addUserCut(const LinearExpr &expr, Sense sense, double rhs) = 0#: Add a user cut (can be added at any time, must not cut off feasible solutions)

virtual void minimize(const LinearExpr &expr) = 0#: Set objective to minimize.

virtual void maximize(const LinearExpr &expr) = 0#: Set objective to maximize.

virtual void minimizeQuad(const QuadExpr &expr) = 0#: Set quadratic objective to minimize.

virtual void maximizeQuad(const QuadExpr &expr) = 0#: Set quadratic objective to maximize.

virtual void setWarmStart(const std::vector<Var> &vars, const std::vector<double> &values) = 0#

Provide a warm start solution.

Parameters:

vars – Variables to set
values – Values for the variables

virtual void setMIPStart(const std::vector<std::pair<Var, double>> &solution) = 0#: Provide MIP start hint for integer variables.

virtual MIPStatus solve(double timeout = 3600.0) = 0#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

virtual double getValue(Var var) const = 0#: Get value of variable in solution.

inline virtual int getIntValue(IntVar var) const#: Get value of integer variable in solution.

inline virtual bool getBoolValue(BoolVar var) const#: Get value of boolean variable (0 or 1)

virtual double getObjectiveValue() const = 0#: Get objective value of solution.

virtual double getObjectiveBound() const = 0#: Get best objective bound.

inline virtual double getGap() const#: Get MIP gap.

virtual double getReducedCost(Var var) const = 0#: Get reduced cost of a variable.

virtual double getDual(int constraintIndex) const = 0#

Get dual value (shadow price) of a constraint.

Parameters:: constraintIndex – Index of the constraint

virtual double getSolveTime() const = 0#: Get solving time in seconds.

virtual long long getNumIterations() const = 0#: Get number of simplex iterations.

virtual long long getNumNodes() const = 0#: Get number of nodes explored in branch-and-bound.

virtual int getNumSolutions() const = 0#: Get number of solutions found.

virtual void setTimeLimit(double seconds) = 0#: Set time limit in seconds.

virtual void setGapTolerance(double gap) = 0#: Set MIP gap tolerance.

virtual void setNumThreads(int threads) = 0#: Set number of threads.

virtual void setRandomSeed(int seed) = 0#: Set random seed.

virtual void setVerbosity(int level) = 0#: Set verbosity level (0 = quiet, higher = more verbose)

virtual void setPresolve(bool enable) = 0#: Enable/disable presolve.

virtual void setNodeLimit(long long limit) = 0#: Set node limit.

virtual void setSolutionLimit(int limit) = 0#: Set solution limit.

virtual void clear() = 0#: Clear the model (remove all variables and constraints)

virtual int getNumVars() const = 0#: Get number of variables.

virtual int getNumConstraints() const = 0#: Get number of constraints.

virtual long long getNumNonZeros() const = 0#: Get number of non-zeros in constraint matrix.

virtual bool exportModel(const std::string &filename) const = 0#

Export model to file.

Parameters:: filename – File path (extension determines format: .lp, .mps, .sav)

virtual bool importModel(const std::string &filename) = 0#: Import model from file.

inline virtual void setLazyCallback(LazyCallback callback)#: Set lazy constraint callback.

inline virtual void setCutCallback(CutCallback callback)#: Set user cut callback.

inline virtual void setIncumbentCallback(IncumbentCallback callback)#: Set incumbent callback.

virtual MIPStatus solveRelaxation() = 0#: Solve LP relaxation only.

virtual MIPStatus solveFixed() = 0#: Fix integer variables to their current values and resolve Useful for getting dual values after MIP solve.

Protected Attributes

LazyCallback lazyCallback_#

CutCallback cutCallback_#

IncumbentCallback incumbentCallback_#

class IMIPConstraintGenerator#

#include <IMIPConstraintGenerator.hpp>

Interface for MIP constraint generators.

Similar to ICPConstraintGenerator but uses IMIPBackend instead. Each generator adds variables, constraints, and objective terms for a specific aspect of the problem (routing, time windows, capacity, etc.)

Subclassed by routing::mip::generators::MIPCapacityGenerator, routing::mip::generators::MIPRoutingGenerator, routing::mip::generators::MIPTimeWindowGenerator

Public Functions

virtual ~IMIPConstraintGenerator() = default#

virtual std::string name() const = 0#: Name of this generator.

inline virtual int priority() const#: Priority for ordering (lower = earlier)

virtual std::vector<AttributeTypeId> requiredAttributes() const = 0#: Attribute types required by this generator.

virtual void addVariables(IMIPBackend &mip, Problem &problem) = 0#

Add variables to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

virtual void addConstraints(IMIPBackend &mip, Problem &problem) = 0#

Add constraints to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addObjectiveTerms(IMIPBackend &mip, Problem &problem, LinearExpr &expr)#

Add terms to the objective function.

Parameters:

mip – The MIP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const IMIPBackend &mip, Problem &problem, Solution &solution)#

Called after solving to extract solution data.

Parameters:

mip – The MIP backend (with solution)
problem – The problem instance
solution – The solution to populate

class IncumbentCallback : public IloCplex::IncumbentCallbackI#

#include <IncumbentCallback.hpp>

callback trigger every time a new incumbent is found

Public Functions

inline IncumbentCallback(IloEnv env, Problem *_problem)#

inline ~IncumbentCallback()#

Protected Functions

inline virtual void main()#

inline IloCplex::CallbackI *duplicateCallback() const#

inline virtual void extractIncumbentSolution()#

Protected Attributes

Problem *problem#

Solution *solution = nullptr#

class INeighborhood#

#include <INeighborhood.hpp>

Interface for neighborhood operators.

Subclassed by routing::plugins::IDCHNeighborhood, routing::plugins::TwoOptNeighborhood

Public Functions

virtual ~INeighborhood() = default#

virtual std::string name() const = 0#: Get neighborhood name.

inline virtual std::string description() const#: Get neighborhood description.

virtual std::optional<NeighborhoodMove> explore(Solution &solution) = 0#: Explore the neighborhood and find the best move.

virtual void apply(Solution &solution, const NeighborhoodMove &move) = 0#: Apply a move to the solution.

inline virtual bool improve(Solution &solution)#: Convenience method: explore and apply best move.

class InformationCallback : public IloCplex::MIPCallbackI#

#include <InformationCallback.hpp>

Public Functions

inline InformationCallback(IloEnv env, Problem *_problem)#

inline ~InformationCallback()#

Protected Functions

inline void main()#

inline IloCplex::CallbackI *duplicateCallback() const#

inline virtual Solution *getIncumbentSolution()#

Protected Attributes

Problem *problem#

class Initializer#

#include <Problem.hpp>

Initializer interface for creating solutions and tours.

Public Functions

inline explicit Initializer(Problem *p_problem)#

virtual ~Initializer() = default#

inline Problem *getProblem() const#

virtual Solution *initialSolution() = 0#

virtual Tour *initialTour(int vehicleID) = 0#

Private Members

Problem *problem_#

struct InsertionContext#

#include <IEvaluator.hpp>

Context for insertion operations.

Contains all information needed to evaluate and perform an insertion of a client into a tour.

Public Members

Entity *client#

int position#

Entity *predecessor#

Entity *successor#

class InsertionCost#

#include <InsertionCost.hpp>

Public Functions

inline bool operator>(const InsertionCost &rhs) const#

inline routing::Duration getDelta() const#

inline void setDelta(routing::Duration delta)#

inline bool isPossible() const#

inline void setPossible(bool possible)#

inline InsertionCost(routing::Duration delta, bool possible)#

inline InsertionCost()#

inline InsertionCost(const InsertionCost &cost)#

Private Members

routing::Duration delta#

bool possible#

class IntervalVar#

#include <CPTypes.hpp>

Handle for an interval variable in CP model.

Represents a time interval with start, end, and duration. Used for scheduling constraints (no-overlap, cumulative, etc.)

Public Functions

IntervalVar() = default#

inline explicit IntervalVar(int id)#

inline bool isValid() const#

inline int id() const#

inline bool operator==(const IntervalVar &other) const#

inline bool operator!=(const IntervalVar &other) const#

Private Members

int id_ = -1#

Friends

friend class ICPBackend

class IntVar#

#include <CPTypes.hpp>

Handle for an integer variable in CP model.

This is a lightweight handle that references a variable in a backend. The actual variable is owned by the backend implementation.

Public Functions

IntVar() = default#

inline explicit IntVar(int id)#

inline bool isValid() const#

inline int id() const#

inline bool operator==(const IntVar &other) const#

inline bool operator!=(const IntVar &other) const#

Private Members

int id_ = -1#

Friends

friend class ICPBackend

class IntVar#

#include <MIPTypes.hpp>

Handle for an integer variable in MIP model.

Public Functions

IntVar() = default#

inline explicit IntVar(int id)#

inline bool isValid() const#

inline int id() const#

inline bool operator==(const IntVar &other) const#

inline bool operator!=(const IntVar &other) const#

inline operator Var() const#

Private Members

int id_ = -1#

Friends

friend class IMIPBackend

class IPlugin#

#include <IPlugin.hpp>

Base interface for all plugins.

Public Functions

virtual ~IPlugin() = default#

virtual std::string name() const = 0#: Get the plugin name (unique identifier)

inline virtual std::string version() const#: Get the plugin version.

inline virtual std::string description() const#: Get the plugin description.

virtual PluginType type() const = 0#: Get the plugin type.

inline virtual std::vector<std::string> dependencies() const#: Get dependencies (other plugin names this depends on)

virtual void initialize(PluginRegistry &registry) = 0#: Initialize the plugin and register components.

inline virtual void shutdown()#: Shutdown hook.

class IReader#

#include <IReader.hpp>

Interface for instance file readers.

Subclassed by routing::plugins::SolomonReader, routing::plugins::TSPLIBReader

Public Functions

virtual ~IReader() = default#

virtual std::string formatName() const = 0#: Get the format name (e.g., “solomon”, “tsplib”)

virtual std::vector<std::string> supportedExtensions() const = 0#: Get supported file extensions.

virtual bool canRead(const std::string &filepath) const = 0#: Check if this reader can read the given file.

virtual Problem *readFile(const std::string &filepath) = 0#: Read an instance file and create a Problem.

inline virtual std::string detectedProblemType() const#: Get the detected problem type after reading.

class ISolutionValue#: #include <IAttribute.hpp>

Subclassed by routing::SolutionValue< Duration >, routing::SolutionValue< Demand >, routing::SolutionValue< V >

class ISolver#

#include <ISolver.hpp>

Interface for all solver implementations.

Subclassed by routing::MIPSolver, routing::cp::CPSolver, routing::cp::XCSP3Solver, routing::plugins::GASolverWrapper, routing::plugins::LSSolverWrapper, routing::plugins::MASolverWrapper, routing::plugins::PSOSolverWrapper, routing::plugins::VNSSolverWrapper

Public Functions

virtual ~ISolver() = default#

virtual std::string name() const = 0#: Get solver name.

inline virtual std::string description() const#: Get solver description.

virtual void setProblem(Problem *problem) = 0#: Set the problem to solve.

virtual Problem *getProblem() const = 0#: Get the current problem.

virtual void setConfiguration(Configuration *config) = 0#: Set solver configuration.

virtual void setDefaultConfiguration() = 0#: Set default configuration.

virtual bool solve(double timeout = 3600) = 0#: Solve the problem.

virtual Solution *getSolution() const = 0#: Get the best solution found.

virtual double getObjectiveValue() const = 0#: Get the objective value of the best solution.

inline virtual bool isOptimal() const#: Check if the problem was solved to optimality.

inline virtual std::string getStats() const#: Get solving statistics.

inline virtual void setImprovementCallback(ImprovementCallback)#: Set callback for solution improvements.

class LazyConstraintCallback : public IloCplex::LazyConstraintCallbackI#

#include <LazyConstraintCallback.hpp>

Public Functions

inline LazyConstraintCallback(IloEnv env, Problem *_problem)#

inline ~LazyConstraintCallback()#

Protected Functions

inline void main()#

inline IloCplex::CallbackI *duplicateCallback() const#

Protected Attributes

Problem *problem#

class LinearExpr#

#include <CPTypes.hpp>

Linear expression over integer variables.

Represents: constant + sum(coeff[i] * var[i])

Public Functions

LinearExpr() = default#

inline explicit LinearExpr(int constant)#

inline explicit LinearExpr(IntVar var)#

inline LinearExpr(IntVar var, int coeff)#

inline LinearExpr &addTerm(IntVar var, int coeff = 1)#

inline LinearExpr &addConstant(int c)#

inline LinearExpr &operator+=(const LinearExpr &other)#

inline LinearExpr &operator+=(IntVar var)#

inline LinearExpr &operator-=(IntVar var)#

inline LinearExpr &operator*=(int coeff)#

inline const std::vector<std::pair<IntVar, int>> &terms() const#

inline int constant() const#

inline bool isEmpty() const#

Private Members

std::vector<std::pair<IntVar, int>> terms_#

int constant_ = 0#

class LinearExpr#

#include <MIPTypes.hpp>

Linear expression over variables.

Represents: constant + sum(coeff[i] * var[i])

Public Functions

LinearExpr() = default#

inline explicit LinearExpr(double constant)#

inline explicit LinearExpr(Var var)#

inline LinearExpr(Var var, double coeff)#

inline LinearExpr &addTerm(Var var, double coeff = 1.0)#

inline LinearExpr &addTerm(IntVar var, double coeff = 1.0)#

inline LinearExpr &addTerm(BoolVar var, double coeff = 1.0)#

inline LinearExpr &addConstant(double c)#

inline LinearExpr &operator+=(const LinearExpr &other)#

inline LinearExpr &operator+=(Var var)#

inline LinearExpr &operator-=(Var var)#

inline LinearExpr &operator*=(double coeff)#

inline const std::vector<std::pair<int, double>> &terms() const#

inline double constant() const#

inline bool isEmpty() const#

Private Members

std::vector<std::pair<int, double>> terms_#

double constant_ = 0.0#

class LSSolver : public routing::Solver #

#include <LSSolver.hpp>

Public Functions

inline LSSolver(routing::Problem *p_problem, Generator *p_generator, const std::vector<Neighborhood*> &p_neighbors, std::ostream &os = std::cout)#

inline LSSolver(routing::Problem *p_problem, std::ostream &os = std::cout)#

inline virtual void setGenerator(Generator *p_generator)#

inline virtual void setNeighbors(std::vector<routing::Neighborhood*> p_neighbors)#

inline virtual void setDefaultConfiguration() override#

inline virtual bool solve(double timeout = 3600) override#

virtual ~LSSolver() = default#

Protected Attributes

std::vector<routing::Neighborhood*> neighbors#

routing::Generator *generator = nullptr#

class LSSolverPlugin : public routing::IPlugin #

#include <LSSolverPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class LSSolverWrapper : public routing::ISolver #

#include <LSSolverPlugin.hpp>

Public Functions

inline explicit LSSolverWrapper(Problem *problem)#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem*) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline void setGenerator(Generator *generator)#

inline void setNeighbors(const std::vector<Neighborhood*> &neighbors)#

Private Members

LSSolver solver_#

class MASolver : public routing::GASolver #

#include <MASolver.hpp>

Subclassed by routing::PSOSolver

Public Functions

inline MASolver(routing::Problem *p_problem, Generator *p_generator, const std::vector<Neighborhood*> &p_neighbors, std::ostream &os = std::cout)#

inline MASolver(routing::Problem *p_problem, std::ostream &os = std::cout)#

inline virtual void mutate(Sequence *sequence) override#

class MASolverPlugin : public routing::IPlugin #

#include <MASolverPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class MASolverWrapper : public routing::ISolver #

#include <MASolverPlugin.hpp>

Public Functions

inline explicit MASolverWrapper(Problem *problem)#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem*) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline void setGenerator(Generator *generator)#

inline void setNeighbors(const std::vector<Neighborhood*> &neighbors)#

inline void setBoolParam(const std::string &name, bool value)#

inline void setDoubleParam(const std::string &name, double value)#

inline void setIntParam(const std::string &name, int value)#

Private Functions

inline void ensureConfig()#

Private Members

MASolver solver_#

class Memory#

#include <Memory.hpp>

Public Functions

Memory(const Memory&) = delete#

Memory() = default#

Memory &operator=(const Memory&) = delete#

inline std::pair<bool, double> at(long hash)#

inline void add(long hash, double cost)#

Protected Attributes

std::map<long, double> space#

Protected Static Attributes

static Memory *singleton#

class MIPCapacityGenerator : public routing::mip::IMIPConstraintGenerator #

#include <MIPCapacityGenerator.hpp>

MIP Capacity constraint generator.

Implements vehicle capacity constraints using continuous load variables:

load[i] = cumulative load when arriving at node i
Capacity bounds: load[i] <= capacity
Load propagation: if x[i][j] = 1, then load[j] >= load[i] + demand[j]
Uses big-M formulation for conditional constraints

Public Functions

inline virtual std::string name() const override#: Name of this generator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Attribute types required by this generator.

inline virtual int priority() const override#: Priority for ordering (lower = earlier)

inline void setRoutingGenerator(MIPRoutingGenerator *routing)#

inline virtual void addVariables(IMIPBackend &mip, Problem &problem) override#

Add variables to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addConstraints(IMIPBackend &mip, Problem &problem) override#

Add constraints to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addObjectiveTerms(IMIPBackend &mip, Problem &problem, LinearExpr &expr) override#

Add terms to the objective function.

Parameters:

mip – The MIP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const IMIPBackend &mip, Problem &problem, Solution &solution) override#

Called after solving to extract solution data.

Parameters:

mip – The MIP backend (with solution)
problem – The problem instance
solution – The solution to populate

inline const std::vector<Var> &getLoadVars() const#

inline const std::vector<double> &getDemands() const#

inline const std::vector<double> &getCapacities() const#

inline const std::vector<double> &getLoads() const#

Private Members

MIPRoutingGenerator *routingGen_ = nullptr#

std::vector<Var> loadVars_#

std::vector<double> demands_#

std::vector<double> capacities_#

std::vector<double> loads_#

double maxCapacity_ = 0.0#

struct MIPEntry#

Public Members

MIPGeneratorFactory factory#

std::vector<AttributeTypeId> requiredAttrs#

int priority#

struct MIPGeneratorEntry#

Public Members

MIPGeneratorFactory factory#

std::vector<AttributeTypeId> requiredAttrs#

int priority#

class MIPRoutingGenerator : public routing::mip::IMIPConstraintGenerator #

#include <MIPRoutingGenerator.hpp>

MIP Routing constraint generator.

Implements arc-based VRP formulation:

Binary arc variables x[i][j] = 1 if arc (i,j) is used
Flow conservation: each client visited exactly once
Vehicle limit: at most m vehicles leave depot
MTZ subtour elimination constraints
Distance-based objective

Node indices:

0: depot
1 to n: clients

Public Functions

inline virtual std::string name() const override#: Name of this generator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Attribute types required by this generator.

inline virtual int priority() const override#: Priority for ordering (lower = earlier)

inline virtual void addVariables(IMIPBackend &mip, Problem &problem) override#

Add variables to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addConstraints(IMIPBackend &mip, Problem &problem) override#

Add constraints to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addObjectiveTerms(IMIPBackend &mip, Problem &problem, LinearExpr &expr) override#

Add terms to the objective function.

Parameters:

mip – The MIP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const IMIPBackend &mip, Problem &problem, Solution &solution) override#

Called after solving to extract solution data.

Parameters:

mip – The MIP backend (with solution)
problem – The problem instance
solution – The solution to populate

inline const std::vector<std::vector<BoolVar>> &getArcVars() const#

inline const std::vector<IntVar> &getMTZVars() const#

inline size_t getNumClients() const#

inline size_t getNumVehicles() const#

Private Members

std::vector<std::vector<BoolVar>> arcVars_#

std::vector<IntVar> mtzVars_#

size_t numClients_ = 0#

size_t numVehicles_ = 0#

class MIPSolver : public routing::ISolver #

#include <MIPSolver.hpp>

MIP-based solver using pluggable backends.

This solver uses the IMIPBackend interface to solve routing problems using mixed integer programming. It supports different backends:

CPLEX (commercial, high performance)
HiGHS (open-source, good performance)
Gurobi (future)

Public Functions

inline explicit MIPSolver(Problem *problem, const std::string &backendType = "auto")#

Construct a MIP solver for a problem.

Parameters:

problem – The problem to solve
backendType – Backend to use (“cplex”, “highs”, “auto”) “auto” selects best available: CPLEX > HiGHS

inline MIPSolver(Problem *problem, std::unique_ptr<IMIPBackend> backend)#

Construct a MIP solver with a custom backend.

Parameters:

problem – The problem to solve
backend – Custom backend instance

~MIPSolver() override = default#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem *problem) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline virtual bool isOptimal() const override#: Check if the problem was solved to optimality.

inline virtual std::string getStats() const override#: Get solving statistics.

inline void setVerbose(bool verbose)#

inline void setGapTolerance(double gap)#

inline void setNumThreads(int threads)#

inline void setNodeLimit(long long limit)#

inline void setSolutionLimit(int limit)#

inline void setRandomSeed(int seed)#

inline void setPresolve(bool enable)#

inline IMIPBackend &getBackend()#: Get the backend for advanced usage.

inline const IMIPBackend &getBackend() const#

inline bool exportModel(const std::string &filename) const#: Export the model to a file.

Public Static Functions

static inline std::unique_ptr<IMIPBackend> createBestBackend()#: Create the best available backend Priority: CPLEX > HiGHS.

Protected Functions

inline virtual void buildModel()#: Build the MIP model using dynamically discovered constraint generators.

inline virtual void extractSolution()#: Extract solution from the MIP model using generators.

Protected Attributes

Problem *problem_#

std::unique_ptr<IMIPBackend> backend_#

Solution *solution_#

double objectiveValue_#

double timeout_#

bool verbose_#

std::vector<std::unique_ptr<mip::IMIPConstraintGenerator>> autoGenerators_#

std::vector<mip::IMIPConstraintGenerator*> generators_#

class MIPSolverPlugin : public routing::IPlugin #

#include <MIPSolverPlugin.hpp>

Plugin for MIP-based solvers with pluggable backends.

Registers MIP solver variants using different backends:

”mip” / “auto”: Auto-select best available (CPLEX > HiGHS)
”cplex”: CPLEX backend (commercial)
”highs”: HiGHS backend (open-source)

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class MIPTimeWindowGenerator : public routing::mip::IMIPConstraintGenerator #

#include <MIPTimeWindowGenerator.hpp>

MIP Time Window constraint generator.

Implements time window constraints using continuous time variables:

t[i] = arrival time at node i
Time window bounds: tw_open[i] <= t[i] <= tw_close[i]
Precedence constraints: if x[i][j] = 1, then t[i] + service[i] + travel[i][j] <= t[j]
Uses big-M formulation with indicator constraints

Public Functions

inline virtual std::string name() const override#: Name of this generator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Attribute types required by this generator.

inline virtual int priority() const override#: Priority for ordering (lower = earlier)

inline void setRoutingGenerator(MIPRoutingGenerator *routing)#

inline virtual void addVariables(IMIPBackend &mip, Problem &problem) override#

Add variables to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addConstraints(IMIPBackend &mip, Problem &problem) override#

Add constraints to the MIP model.

Parameters:

mip – The MIP backend
problem – The problem instance

inline virtual void addObjectiveTerms(IMIPBackend &mip, Problem &problem, LinearExpr &expr) override#

Add terms to the objective function.

Parameters:

mip – The MIP backend
problem – The problem instance
expr – The linear expression to add to

inline virtual void extractSolution(const IMIPBackend &mip, Problem &problem, Solution &solution) override#

Called after solving to extract solution data.

Parameters:

mip – The MIP backend (with solution)
problem – The problem instance
solution – The solution to populate

inline const std::vector<Var> &getTimeVars() const#

inline const std::vector<double> &getArrivalTimes() const#

Private Members

MIPRoutingGenerator *routingGen_ = nullptr#

std::vector<Var> timeVars_#

std::vector<double> arrivalTimes_#

Var depotEndVar_#

struct Model#

#include <Model.hpp>

Subclassed by routing::Entity, routing::Solution, routing::models::Client, routing::models::Depot, routing::models::Tour, routing::models::Vehicle

Public Functions

inline unsigned getID() const#

inline void setID(const unsigned &p_id)#

virtual ~Model() = default#

inline bool operator==(const Model &other)#

inline bool operator!=(const Model &other)#

Public Members

std::string name#

Private Members

unsigned int id#

class Move : public routing::Neighborhood #

#include <Move.hpp>

Public Functions

inline Move(Constructor *p_constructor)#

inline virtual bool look(Solution *solution)#

Parameters:: solution – the solution to shake it returns the best neighbor
Returns:: true if solution improved

Private Members

Constructor *constructor#

class Neighborhood#

#include <Neighborhood.hpp>

Subclassed by routing::IDCH, routing::Move, routing::TwoOpt

Public Functions

virtual bool look(Solution *solution) = 0#

Parameters:: solution – the solution to shake it returns the best neighbor
Returns:: true if solution improved

struct NeighborhoodMove#

#include <INeighborhood.hpp>

Represents a move in a neighborhood.

Public Functions

inline bool isImproving() const#

Public Members

std::string type#

double delta = 0.0#

std::vector<int> data#

class OptionalIntervalVar#

#include <CPTypes.hpp>

Handle for an optional interval variable.

Like IntervalVar but can be absent (not scheduled). Used for optional activities.

Public Functions

OptionalIntervalVar() = default#

inline OptionalIntervalVar(int id, IntVar presence)#

inline bool isValid() const#

inline int id() const#

inline IntVar presenceVar() const#

inline bool operator==(const OptionalIntervalVar &other) const#

inline bool operator!=(const OptionalIntervalVar &other) const#

Private Members

int id_ = -1#

IntVar presence_#

Friends

friend class ICPBackend

class ORToolsCPSATBackend : public routing::cp::ICPBackend #

#include <ORToolsCPSATBackend.hpp>

Stub implementation when OR-Tools is not available.

Public Functions

inline ORToolsCPSATBackend()#

inline virtual std::string name() const override#: Get backend name (e.g., “cpoptimizer”, “ortools”, “gecode”)

inline virtual IntVar newIntVar(int, int, const std::string&) override#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

inline virtual IntVar newBoolVar(const std::string&) override#

Create a boolean variable (0-1)

Parameters:: name – Optional variable name

inline virtual IntVar newConstant(int) override#

Create an integer constant.

Parameters:: value – Constant value

inline virtual IntervalVar newIntervalVar(int, int, int, int, const std::string&) override#

Create an interval variable for scheduling.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

inline virtual OptionalIntervalVar newOptionalIntervalVar(int, int, int, int, const std::string&) override#

Create an optional interval variable.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

Returns:

OptionalIntervalVar with presence indicator

inline virtual void addEquality(const LinearExpr&, int) override#: Add constraint: expr == value.

inline virtual void addEquality(IntVar, IntVar) override#: Add constraint: var1 == var2.

inline virtual void addLinearConstraint(const LinearExpr&, int, int) override#: Add constraint: lb <= expr <= ub.

inline virtual void addLessOrEqual(IntVar, IntVar, int) override#: Add constraint: var1 <= var2 + offset.

inline virtual void addImplication(IntVar, const LinearExpr&, int, int) override#: Add implication: if condition is true, then expr op bound.

inline virtual void addReification(IntVar, IntVar, int) override#: Add reification: indicator == 1 iff var == value This creates a channeling constraint linking a boolean indicator to a condition.

inline virtual void addAllDifferent(const std::vector<IntVar>&) override#: All-different constraint All variables must take different values.

inline virtual void addElement(IntVar, const std::vector<int>&, IntVar) override#: Element constraint: result = array[index].

inline virtual void addElement(IntVar, const std::vector<IntVar>&, IntVar) override#: Element constraint with variable array: result = vars[index].

inline virtual void addCircuit(const std::vector<IntVar>&) override#: Circuit constraint Variables define a Hamiltonian circuit over nodes 0..n-1 next[i] = j means arc from i to j.

inline virtual void addSubCircuit(const std::vector<IntVar>&) override#: Sub-circuit constraint (allows nodes to point to themselves) Used for TSP with optional nodes.

inline virtual void addInverse(const std::vector<IntVar>&, const std::vector<IntVar>&) override#: Inverse constraint: next[prev[i]] == i and prev[next[i]] == i.

inline virtual void addNoOverlap(const std::vector<IntervalVar>&) override#: No-overlap constraint Intervals cannot overlap in time.

inline virtual void addNoOverlap(const std::vector<OptionalIntervalVar>&) override#: No-overlap constraint with optional intervals.

inline virtual void addCumulative(const std::vector<IntervalVar>&, const std::vector<int>&, int) override#: Cumulative constraint At any time point, sum of demands of active intervals <= capacity.

inline virtual void addCumulative(const std::vector<OptionalIntervalVar>&, const std::vector<int>&, int) override#: Cumulative with optional intervals.

inline virtual void addEndBeforeStart(IntervalVar, IntervalVar, int) override#: Precedence constraint: interval1 ends before interval2 starts end(interval1) + delay <= start(interval2)

inline virtual IntVar startOf(IntervalVar) override#: Get start variable of an interval.

inline virtual IntVar endOf(IntervalVar) override#: Get end variable of an interval.

inline virtual IntVar durationOf(IntervalVar) override#: Get duration variable of an interval.

inline virtual IntVar startOf(OptionalIntervalVar, int) override#: Get start variable of optional interval (undefined if absent)

inline virtual IntVar endOf(OptionalIntervalVar, int) override#: Get end variable of optional interval (undefined if absent)

inline virtual void minimize(const LinearExpr&) override#: Set objective to minimize.

inline virtual void maximize(const LinearExpr&) override#: Set objective to maximize.

inline virtual void minimizeMakespan(const std::vector<IntervalVar>&) override#: Minimize the makespan (max end time of intervals)

inline virtual CPStatus solve(double) override#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

inline virtual void setHint(const std::vector<std::pair<IntVar, int>>&) override#: Provide hints/warm start.

inline virtual void setNumWorkers(int) override#: Set number of worker threads.

inline virtual void setRandomSeed(int) override#: Set random seed for reproducibility.

inline virtual int getValue(IntVar) const override#: Get value of integer variable in solution.

inline virtual bool getBoolValue(IntVar) const override#: Get value of boolean variable (0 or 1)

inline virtual int getStart(IntervalVar) const override#: Get start time of interval in solution.

inline virtual int getEnd(IntervalVar) const override#: Get end time of interval in solution.

inline virtual int getDuration(IntervalVar) const override#: Get duration of interval in solution.

inline virtual bool isPresent(OptionalIntervalVar) const override#: Check if optional interval is present in solution.

inline virtual double getObjectiveValue() const override#: Get objective value of solution.

inline virtual double getObjectiveBound() const override#: Get lower bound on objective.

inline virtual double getSolveTime() const override#: Get solving time in seconds.

inline virtual long long getNumBranches() const override#: Get number of search branches.

inline virtual long long getNumFailures() const override#: Get number of failures/backtracks.

inline virtual void clear() override#: Clear the model (remove all variables and constraints)

inline virtual bool exportModel(const std::string&) const override#: Export model to file (format depends on backend)

class ParameterNotFound : public std::exception#

#include <Configuration.hpp>

Public Functions

inline explicit ParameterNotFound(const std::string &p_name)#

inline const char *what() const noexcept override#

Private Members

std::string message#

class Particle#

#include <PSOSolver.hpp>

Public Functions

inline Particle(Problem *p_problem)#

inline void initializePositionFromSolutions(Solution *solution_1, Solution *solution_2)#

inline void initializeBestPositionFromSolution(Solution *solution)#

inline void updateCurrentPosition(double inertia, double local, double global, Sequence *global_best)#

inline void returnToLocalBest()#

Protected Attributes

routing::Duration cost#

routing::Duration best_cost#

Sequence *sequence#

Sequence *local_best_position#

Problem *problem#

struct Pickup : public routing::Attribute<Pickup>#

#include <Pickup.hpp>

Pickup demand at a node.

Pickup models goods to be collected from this node, adding to the vehicle’s current load.

Public Functions

inline explicit Pickup(const PickupDemand &p_pickup)#

inline PickupDemand getPickup() const#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<PickupDemand> pickup#

class PickupDeliveryConstraintGenerator : public routing::IConstraintGenerator #

#include <PickupDeliveryConstraintGenerator.hpp>

Pickup and Delivery constraint generator.

Extends capacity constraints for pickup-delivery scenarios where:

Pickup adds goods to the vehicle (increases load)
Delivery removes goods from the vehicle (decreases load)
Net demand = pickup - delivery

This generator conflicts with CapacityConstraintGenerator since it provides alternative capacity handling for P&D problems.

Requires: Pickup, Delivery, and Stock attributes

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual std::vector<AttributeTypeId> conflictingAttributes() const override#: Returns attribute types that conflict with this generator (optional)

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

class PickupDeliveryPlugin : public routing::IPlugin #

#include <PickupDeliveryPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual std::string description() const override#: Get the plugin description.

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

template<typename T> class PluginRegistrar#

#include <IPlugin.hpp>

Helper class for static registration.

Public Functions

PluginRegistrar()#

class PluginRegistry#

#include <PluginRegistry.hpp>

Central registry for all plugins and components.

Public Types

using CPGeneratorFactory = std::function<std::unique_ptr<cp::ICPConstraintGenerator>()>#

using MIPGeneratorFactory = std::function<std::unique_ptr<mip::IMIPConstraintGenerator>()>#

using SolverFactory = std::function<std::unique_ptr<ISolver>(Problem*)>#

using SolverWithBackendFactory = std::function<std::unique_ptr<ISolver>(Problem*, const std::string&)>#

using MIPBackendFactory = std::function<std::unique_ptr<mip::IMIPBackend>()>#

using CPBackendFactory = std::function<std::unique_ptr<cp::ICPBackend>()>#

using NeighborhoodFactory = std::function<std::unique_ptr<INeighborhood>()>#

using ReaderFactory = std::function<std::unique_ptr<IReader>()>#

Public Functions

inline void registerPlugin(std::unique_ptr<IPlugin> plugin)#

inline void initializeAll()#

inline void shutdownAll()#

inline IPlugin *getPlugin(const std::string &name) const#

inline void registerGenerator(std::unique_ptr<IConstraintGenerator> generator)#

inline IConstraintGenerator *getGenerator(const std::string &name) const#

inline bool hasGenerator(const std::string &name) const#

inline std::vector<IConstraintGenerator*> getGenerators(const std::set<AttributeTypeId> &enabledAttrs) const#

inline const std::vector<std::unique_ptr<IConstraintGenerator>> &allGenerators() const#

inline void registerCPGenerator(const std::string &name, CPGeneratorFactory factory, std::vector<AttributeTypeId> requiredAttrs, int priority = 100)#

Register a CP generator factory.

Parameters:

name – Generator name (used for lookup)
factory – Function that creates a new generator instance
requiredAttrs – Attributes required for this generator
priority – Generator priority (lower = earlier execution)

inline bool hasCPGenerator(const std::string &name) const#: Check if a CP generator is registered.

inline std::unique_ptr<cp::ICPConstraintGenerator> createCPGenerator(const std::string &name) const#: Create a single CP generator by name.

inline std::vector<std::unique_ptr<cp::ICPConstraintGenerator>> createCPGenerators(const std::set<AttributeTypeId> &enabledAttrs) const#

Create all applicable CP generators for the given enabled attributes.

Parameters:: enabledAttrs – Set of enabled attribute type IDs
Returns:: Vector of fresh generator instances, sorted by priority

inline std::vector<std::string> availableCPGenerators() const#

inline void registerMIPGenerator(const std::string &name, MIPGeneratorFactory factory, std::vector<AttributeTypeId> requiredAttrs, int priority = 100)#

Register a MIP generator factory.

Parameters:

name – Generator name (used for lookup)
factory – Function that creates a new generator instance
requiredAttrs – Attributes required for this generator
priority – Generator priority (lower = earlier execution)

inline bool hasMIPGenerator(const std::string &name) const#: Check if a MIP generator is registered.

inline std::unique_ptr<mip::IMIPConstraintGenerator> createMIPGenerator(const std::string &name) const#: Create a single MIP generator by name.

inline std::vector<std::unique_ptr<mip::IMIPConstraintGenerator>> createMIPGenerators(const std::set<AttributeTypeId> &enabledAttrs) const#

Create all applicable MIP generators for the given enabled attributes.

Parameters:: enabledAttrs – Set of enabled attribute type IDs
Returns:: Vector of fresh generator instances, sorted by priority

inline std::vector<std::string> availableMIPGenerators() const#

inline void registerEvaluator(std::unique_ptr<IEvaluator> evaluator)#

inline IEvaluator *getEvaluator(const std::string &name) const#

inline bool hasEvaluator(const std::string &name) const#

inline std::vector<IEvaluator*> getEvaluators(const std::set<AttributeTypeId> &enabledAttrs) const#

inline const std::vector<std::unique_ptr<IEvaluator>> &allEvaluators() const#

inline void registerSolver(const std::string &name, SolverFactory factory)#

inline std::unique_ptr<ISolver> createSolver(const std::string &name, Problem *problem) const#

inline std::vector<std::string> availableSolvers() const#

inline void registerSolverWithBackend(const std::string &name, SolverWithBackendFactory factory)#

inline std::unique_ptr<ISolver> createSolverWithBackend(const std::string &name, Problem *problem, const std::string &backend) const#

inline void registerMIPBackend(const std::string &name, MIPBackendFactory factory)#

inline std::unique_ptr<mip::IMIPBackend> createMIPBackend(const std::string &name) const#

inline std::vector<std::string> availableMIPBackends() const#

inline void registerCPBackend(const std::string &name, CPBackendFactory factory)#

inline std::unique_ptr<cp::ICPBackend> createCPBackend(const std::string &name) const#

inline std::vector<std::string> availableCPBackends() const#

inline void registerNeighborhood(const std::string &name, NeighborhoodFactory factory)#

inline std::unique_ptr<INeighborhood> createNeighborhood(const std::string &name) const#

inline std::vector<std::string> availableNeighborhoods() const#

inline void registerReader(const std::string &formatName, const std::vector<std::string> &extensions, ReaderFactory factory)#

inline std::unique_ptr<IReader> createReader(const std::string &formatName) const#

inline std::unique_ptr<IReader> createReaderForExtension(const std::string &extension) const#

inline std::vector<std::string> availableReaders() const#

inline std::vector<std::string> availableGenerators() const#

inline std::vector<std::string> availableEvaluators() const#

inline void clear()#

Public Static Functions

static inline PluginRegistry &instance()#

Private Functions

PluginRegistry() = default#

inline std::vector<std::string> resolveDependencies()#

Private Members

std::map<std::string, std::unique_ptr<IPlugin>> plugins_#

std::set<std::string> initializedPlugins_#

std::vector<std::string> initializedOrder_#

bool initialized_ = false#

std::vector<std::unique_ptr<IConstraintGenerator>> generators_#

std::map<std::string, IConstraintGenerator*> generatorByName_#

std::map<std::string, CPGeneratorEntry> cpGeneratorEntries_#

std::map<std::string, MIPGeneratorEntry> mipGeneratorEntries_#

std::vector<std::unique_ptr<IEvaluator>> evaluators_#

std::map<std::string, IEvaluator*> evaluatorByName_#

std::map<std::string, SolverFactory> solverFactories_#

std::map<std::string, SolverWithBackendFactory> solverWithBackendFactories_#

std::map<std::string, MIPBackendFactory> mipBackendFactories_#

std::map<std::string, CPBackendFactory> cpBackendFactories_#

std::map<std::string, NeighborhoodFactory> neighborhoodFactories_#

std::map<std::string, ReaderFactory> readerFactories_#

std::map<std::string, std::string> extensionToFormat_#

Private Static Functions

static inline bool isApplicable(const std::vector<AttributeTypeId> &required, const std::set<AttributeTypeId> &enabled)#

class Population#

#include <GASolver.hpp>

Public Functions

inline Population(Problem *p_problem, ConstraintConfig cfg)#

inline Sequence *best() const#

inline virtual Sequence *evolve()#

inline bool insert(Sequence *sequence)#

inline ~Population()#

Public Members

Problem *problem#

ConstraintConfig config#

std::set<Sequence*, ChromosomeCmp> sequences#

Public Static Functions

static inline Population *initialize(Problem *p_problem, ConstraintConfig cfg)#

class Problem#

#include <Problem.hpp>

A composable VRP problem with runtime attribute configuration.

Problem replaces the inheritance-based problem hierarchy (VRP -> CVRP -> CVRPTW) with a runtime composition model.

Usage: Problem problem; problem.enableAttributes<GeoNode, Consumer, Stock, Rendezvous, ServiceQuery>();

auto* client = problem.addClient(1); client->addAttribute<GeoNode>(10.0, 20.0); client->addAttribute<Consumer>(15);

problem.generateModel(); // Constraints auto-added based on enabled attrs

Public Functions

Problem() = default#

inline virtual ~Problem()#

inline std::string getName() const#

inline void setName(const std::string &value)#

template<typename Attr> inline void enableAttribute()#: Enable an attribute type for this problem.

template<typename ...Attrs> inline void enableAttributes()#: Enable multiple attribute types at once.

template<typename Attr> inline bool hasAttribute() const#: Check if an attribute type is enabled.

inline const std::set<AttributeTypeId> &getEnabledAttributes() const#: Get all enabled attribute type IDs.

inline Client *addClient(unsigned id)#: Add a new client.

inline Vehicle *addVehicle(unsigned id)#: Add a new vehicle.

inline Depot *addDepot(unsigned id)#: Add a new depot.

inline std::vector<Client*> getClients() const#: Get all clients.

inline std::vector<Vehicle*> getVehicles() const#: Get all vehicles.

inline std::vector<Depot*> getDepots() const#: Get all depots.

inline Depot *getDepot() const#: Get first depot (convenience)

inline size_t numClients() const#: Get number of clients.

inline size_t numVehicles() const#: Get number of vehicles.

inline std::vector<Client*> getComposableClients() const#

inline std::vector<Vehicle*> getComposableVehicles() const#

inline std::vector<Depot*> getComposableDepots() const#

inline size_t numDepots() const#: Get number of depots.

inline void syncLegacyPointers()#

inline const std::vector<IConstraintGenerator*> &getActiveGenerators() const#: Get active constraint generators (sorted by priority)

inline const std::vector<IEvaluator*> &getActiveEvaluators() const#: Get active evaluators (sorted by priority)

inline void setDistanceMatrix(const double *data, size_t n)#

Set a custom distance matrix.

The matrix should include all nodes: depot(s) first, then clients. Index 0 is typically the depot, indices 1..n-1 are clients.

Parameters:

data – Pointer to row-major distance data
n – Size of the matrix (n x n)

inline bool hasCustomDistances() const#: Check if custom distances are enabled.

inline void clearDistanceMatrix()#: Clear custom distance matrix.

inline Duration getCustomDistance(size_t from, size_t to) const#: Get distance from custom matrix by node indices.

inline virtual Duration getDistance(const models::Client &c1, const models::Client &c2) const#

inline virtual Duration getDistance(const models::Client &c1, const models::Depot &d) const#

inline virtual Duration getDistance(const models::Depot &d, const models::Client &c1) const#

inline Duration getDistanceEntity(const Entity &e1, const Entity &e2) const#: Get distance between two entities.

inline Duration getDistanceEntity(const Entity *e1, const Entity *e2) const#

inline Duration getDistanceComposable(const Entity &e1, const Entity &e2) const#

inline Duration getDistanceComposable(const Entity *e1, const Entity *e2) const#

inline virtual Memory *getMemory()#

inline virtual Initializer *initializer()#

Public Members

std::vector<models::Client*> clients#

std::vector<models::Vehicle*> vehicles#

std::vector<models::Depot*> depots#

Private Functions

inline void refreshActiveComponents()#

Private Members

std::string name_#

std::set<AttributeTypeId> enabledAttributes_#

std::vector<IConstraintGenerator*> activeGenerators_#

std::vector<IEvaluator*> activeEvaluators_#

std::vector<std::unique_ptr<Client>> clients_#

std::vector<std::unique_ptr<Vehicle>> vehicles_#

std::vector<std::unique_ptr<Depot>> depots_#

std::vector<Client*> clientPtrs_#

std::vector<Vehicle*> vehiclePtrs_#

std::vector<Depot*> depotPtrs_#

std::unique_ptr<Memory> memory_#

std::unique_ptr<Initializer> initializer_#

std::vector<std::vector<double>> customDistanceMatrix_#

bool useCustomDistances_ = false#

struct Profiter : public routing::Attribute<Profiter>#

#include <Profiter.hpp>

Profit/reward for visiting a node.

Profiter models the benefit gained from visiting this node, used in problems like TOP (Team Orienteering Problem).

Public Functions

inline Profiter(const Profit &p_profit)#

inline double getProfit() const#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<Profit> profit#

class ProfitObjectiveGenerator : public routing::IConstraintGenerator #

#include <ProfitObjectiveGenerator.hpp>

Profit objective generator for TOP (Team Orienteering Problem)

Replaces the default distance minimization objective with profit maximization. Only clients that are visited contribute to the objective.

Requires: Profiter attribute (on clients)

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

class ProfitPlugin : public routing::IPlugin #

#include <ProfitPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual std::string description() const override#: Get the plugin description.

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

struct PSOKey#

#include <PSOSolver.hpp>

Public Functions

inline PSOKey(const double &length)#

inline bool operator<(const PSOKey &key) const#

inline bool operator>(const PSOKey &key) const#

inline bool operator==(const PSOKey &key)#

Public Members

double _cost#

class PSOSolver : public routing::MASolver #

#include <PSOSolver.hpp>

Public Functions

inline PSOSolver(routing::Problem *p_problem, Generator *p_generator, const std::vector<Neighborhood*> &p_neighbors, std::ostream &os = std::cout)#

inline PSOSolver(routing::Problem *p_problem, std::ostream &os = std::cout)#

Protected Functions

inline virtual void initializeSwarm()#

inline virtual bool addParticleToSwarm(Particle &particle)#

inline virtual bool updateLocalBestSwarm(unsigned int i)#

Protected Attributes

std::vector<Particle> swarm#

std::map<PSOKey, unsigned int> sorted_swarm#

class PSOSolverPlugin : public routing::IPlugin #

#include <PSOSolverPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class PSOSolverWrapper : public routing::ISolver #

#include <PSOSolverPlugin.hpp>

Public Functions

inline explicit PSOSolverWrapper(Problem *problem)#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem*) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline void setGenerator(Generator *generator)#

inline void setNeighbors(const std::vector<Neighborhood*> &neighbors)#

inline void setBoolParam(const std::string &name, bool value)#

inline void setDoubleParam(const std::string &name, double value)#

inline void setIntParam(const std::string &name, int value)#

Private Functions

inline void ensureConfig()#

Private Members

PSOSolver solver_#

class QuadExpr#

#include <MIPTypes.hpp>

Quadratic expression over variables.

Represents: constant + sum(linear_coeff[i] * var[i]) + sum(quad_coeff[i,j] * var[i] * var[j])

Public Functions

QuadExpr() = default#

inline explicit QuadExpr(const LinearExpr &linear)#

inline QuadExpr &addLinearTerm(Var var, double coeff = 1.0)#

inline QuadExpr &addQuadTerm(Var var1, Var var2, double coeff = 1.0)#

inline const LinearExpr &linearPart() const#

inline const std::vector<std::tuple<int, int, double>> &quadTerms() const#

Private Members

LinearExpr linear_#

std::vector<std::tuple<int, int, double>> quadTerms_#

class RandomDestructor : public routing::Destructor #

#include <RandomDestructor.hpp>

Public Functions

inline explicit RandomDestructor(double fraction = 0.2)#

inline virtual void destruct(Solution *solution) override#

Private Members

double fraction_#

class Reader#

#include <Reader.hpp>

Public Functions

virtual Problem *readFile(const std::string &filepath) = 0#

Public Static Functions

static inline std::vector<std::string> splitString(std::string line, char sep)#

class RemoveCost#

#include <RemoveCost.hpp>

Public Functions

inline bool operator>(const RemoveCost &rhs) const#

inline routing::Duration getDelta() const#

inline void setDelta(routing::Duration delta)#

inline explicit RemoveCost(routing::Duration delta)#

inline RemoveCost()#

inline RemoveCost(const RemoveCost &cost)#

Private Members

routing::Duration delta#

struct Rendezvous : public routing::Attribute<Rendezvous>#

#include <Rendezvous.hpp>

Time window constraint for a node.

Rendezvous models a time window within which service must begin at this node.

Public Functions

inline Rendezvous(const TW &timewindow)#

inline Rendezvous(const Duration &twOpen, const Duration &twClose)#

inline TW getTw() const#

inline Duration getTwOpen() const#

inline Duration getTwClose() const#

inline Duration getEST() const#

inline Duration getLST() const#

inline bool isWithinWindow(Duration time) const#: Check if a given time falls within the time window.

inline Duration getWindowWidth() const#: Get the width of the time window.

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<TW> tw#

class RoutingConstraintGenerator : public routing::IConstraintGenerator #

#include <RoutingConstraintGenerator.hpp>

Base routing constraint generator.

Implements the fundamental VRP constraints:

Arc decision variables (X_i_j)
Vehicle affectation variables (A_i_k)
Order variables for subtour elimination (o_i)
Flow conservation constraints
MTZ subtour elimination constraints

This is always active as it provides the foundation for all VRP variants.

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

class RoutingEvaluator : public routing::IEvaluator #

#include <RoutingEvaluator.hpp>

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this evaluator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types required for this evaluator.

inline virtual int priority() const override#: Priority for evaluation ordering (lower = earlier). Default: 100.

inline virtual bool checkFeasibility(const Tour&, const InsertionContext&) const override#

Check if an insertion is feasible.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

true if the insertion maintains feasibility for this evaluator’s constraints

inline virtual double evaluateInsertionDelta(const Tour &tour, const InsertionContext &ctx) const override#

Compute the cost delta for an insertion.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

The change in cost (positive = worse, negative = better)

inline virtual void applyInsertion(Tour&, const InsertionContext&) override#

Apply an insertion and update internal state.

Called after an insertion is accepted. The evaluator should update any cached state (e.g., total load, arrival times).

Parameters:

tour – The tour being modified
ctx – The insertion context

class RoutingPlugin : public routing::IPlugin #

#include <RoutingPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual std::string description() const override#: Get the plugin description.

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class Sequence#

#include <GASolver.hpp>

Public Functions

inline Sequence(Solution *p_solution, ConstraintConfig config = {})#

inline Sequence(Problem *p_problem, const std::vector<models::Client*> &p_sequence, ConstraintConfig config = {})#

inline Sequence(Problem *p_problem, ConstraintConfig config = {})#

inline ~Sequence()#

inline Solution *decode()#

inline double getCost()#

inline long getHash()#

Public Members

Problem *problem#

std::vector<models::Client*> sequence#

Protected Attributes

bool updated = true#

bool decoded = false#

long hash = 0#

routing::Duration cost = 0#

Solution *solution = nullptr#

ConstraintConfig config_#

Private Functions

inline Solution *buildSolutionFromSequence(Solution *base)#

Friends

inline friend bool operator<(const Sequence &lhs, const Sequence &rhs)#

struct Service : public routing::Attribute<Service>#

#include <Service.hpp>

Service start time (solution value)

Service stores the actual start time of service at a node in the current solution. This is a mutable solution value.

Public Functions

inline Service(const Duration &p_start)#

inline Duration getStart() const#

inline void setStart(Duration start)#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

SolutionValue<Duration> start#

struct ServiceQuery : public routing::Attribute<ServiceQuery>#

#include <ServiceQuery.hpp>

Service time required at a node.

ServiceQuery models the time duration required to perform service at this node (loading, unloading, etc.).

Public Functions

inline ServiceQuery(const Duration &p_service)#

inline Duration getService() const#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<Duration> service#

class SoftTimeWindowGenerator : public routing::IConstraintGenerator #

#include <SoftTimeWindowGenerator.hpp>

Soft time window constraint generator for CVRPSTW.

Unlike hard time windows, soft time windows allow violations with penalties:

Wait penalty: for arriving before the time window opens
Delay penalty: for arriving after the time window closes

The objective is lexicographic:

Minimize total wait + delay penalty
Minimize travel distance

This generator conflicts with TimeWindowConstraintGenerator since it provides alternative (soft) time window handling.

Requires: Rendezvous (time windows) and ServiceQuery (service times)

Public Functions

inline SoftTimeWindowGenerator(double waitPenalty = 1.0, double delayPenalty = 1.0)#

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

inline void setWaitPenalty(double penalty)#

inline void setDelayPenalty(double penalty)#

inline double getWaitPenalty() const#

inline double getDelayPenalty() const#

Private Members

double waitPenalty_#

double delayPenalty_#

struct SoftTimeWindows : public routing::Attribute<SoftTimeWindows>#

#include <SoftTimeWindows.hpp>

Soft time window configuration attribute.

Used for CVRPSTW (CVRP with Soft Time Windows) problems. Unlike hard time windows, soft time windows allow violations with penalties for early arrival (wait) and late arrival (delay).

This attribute is typically attached to the depot to configure problem-wide penalty settings.

Public Functions

inline SoftTimeWindows(double waitPenalty = 1.0, double delayPenalty = 1.0)#

inline double getWaitPenalty() const#

inline void setWaitPenalty(double penalty)#

inline double getDelayPenalty() const#

inline void setDelayPenalty(double penalty)#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Private Members

double waitPenalty_#

double delayPenalty_#

class SolomonReader : public routing::IReader #

#include <SolomonReaderPlugin.hpp>

Standalone Solomon format reader using composable API.

Reads standard Solomon CVRPTW benchmark instances. Format: Line 1: Instance name Lines 2-4: Empty/header Line 5: Number of vehicles, vehicle capacity Lines 6-9: Empty/header Line 10+: CUST NO. XCOORD. YCOORD. DEMAND READY TIME DUE DATE SERVICE TIME

Public Functions

inline virtual std::string formatName() const override#: Get the format name (e.g., “solomon”, “tsplib”)

inline virtual std::vector<std::string> supportedExtensions() const override#: Get supported file extensions.

inline virtual bool canRead(const std::string &filepath) const override#: Check if this reader can read the given file.

inline virtual Problem *readFile(const std::string &filepath) override#: Read an instance file and create a Problem.

inline virtual std::string detectedProblemType() const override#: Get the detected problem type after reading.

Private Members

std::string detectedType_ = "unknown"#

class SolomonReaderPlugin : public routing::IPlugin #

#include <SolomonReaderPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class Solution : public routing::Model #

#include <Solution.hpp>

Solution implementation for composable problems.

This class represents a complete solution consisting of multiple tours.

Public Functions

inline explicit Solution(Problem *p_problem)#

inline Solution(const Solution &other)#

inline virtual ~Solution()#

inline virtual void update()#

inline virtual double getCost()#

inline virtual void setPenalty(double penalty)#

inline virtual double getPenalty() const#

inline virtual void pushTour(Tour *tour)#

inline virtual void addTour(Tour *tour, unsigned long position)#

inline virtual void overrideTour(Tour *tour, unsigned long position)#

inline virtual unsigned long getNbTour() const#

inline virtual Tour *getTour(unsigned t) const#

inline virtual void copy(const Solution *p_solution)#

inline virtual std::vector<models::Client*> getSequence()#

inline virtual Solution *initFromSequence(Problem *problem, std::vector<models::Client*> sequence)#

inline virtual void print(std::ostream &out)#

inline virtual Solution *clone() const#

inline Problem *getProblem()#

inline Solution &operator=(const Solution &p_solution)#

inline virtual void pushClient(unsigned long index_tour, models::Client *client)#

inline virtual void addClient(unsigned long index_tour, models::Client *client, unsigned long position, InsertionCost *cost)#

inline virtual void removeClient(unsigned long index_tour, unsigned long position)#

Public Members

std::vector<models::Client*> notserved#

Protected Attributes

Problem *problem_#

double penaltyCost_#

Private Members

std::vector<Tour*> tours_#

double totalCost_#

template<typename V> class SolutionValue : public routing::ISolutionValue #

#include <IAttribute.hpp>

Public Functions

inline SolutionValue(const V &p_val)#

template<typename T> inline bool is()#

inline V getValue() const#

inline void setValue(V v)#

Private Members

V val#

class Solver#

#include <Solver.hpp>

Subclassed by routing::GASolver, routing::LSSolver, routing::VNSSolver

Public Functions

inline explicit Solver(Problem *p_problem, std::ostream &os = std::cout)#

virtual ~Solver() = default#

virtual bool solve(double timeout = 3600) = 0#

virtual void setDefaultConfiguration() = 0#

inline Solution *getSolution() const#

inline Problem *getProblem() const#

inline virtual void save(std::ofstream &output) const#

inline void setImprovementCallback(ImprovementCallback callback)#

Public Members

std::ostream &os#

Configuration *configuration = {}#

Protected Functions

inline void notifyImprovement(Solution *sol, double cost)#

Protected Attributes

Problem *problem = {}#

Solution *solution = {}#

ImprovementCallback improvementCallback_#

struct Stock : public routing::Attribute<Stock>#

#include <Stock.hpp>

Vehicle capacity attribute.

Stock models the capacity of a vehicle, limiting how much demand it can satisfy in a single route.

Public Functions

inline explicit Stock(const Capacity &p_capacity)#

inline Capacity getCapacity() const#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Public Members

EntityData<Capacity> capacity#

class SyncConstraintGenerator : public routing::IConstraintGenerator #

#include <SyncConstraintGenerator.hpp>

Synchronization constraint generator for VRPTWTD.

Implements temporal synchronization constraints:

If client A has a sync relation to client B with delta D: start[A] + D <= start[B]
Additionally, direct arcs between synced clients are forbidden

This is used for problems where services at different nodes must be coordinated in time (e.g., home healthcare, technician routing).

Requires: Synced attribute (and implicitly Rendezvous for start times)

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

struct Synced : public routing::Attribute<Synced>#

#include <Synced.hpp>

Synchronization attribute for nodes requiring coordination.

Used in VRPTWTD (VRP with Time Windows and Temporal Dependencies) and similar problems where service at one node must happen before/after service at another node with a time delta.

A synchronized node has “brothers” that must be visited with a minimum time difference (delta).

Example: In home healthcare, a nurse must visit patient A before the doctor visits patient A (different service types).

Public Functions

Synced() = default#

inline explicit Synced(const std::vector<SyncRelation> &relations)#

inline void addBrother(unsigned brotherId, Duration delta)#

inline size_t getBrothersCount() const#

inline unsigned getBrotherId(size_t index) const#

inline Duration getDelta(size_t index) const#

inline const std::vector<SyncRelation> &getRelations() const#

inline virtual std::unique_ptr<IAttribute> clone() const override#: Creates a deep copy of this attribute.

inline virtual std::string name() const override#: Returns a human-readable name for this attribute type.

Private Members

std::vector<SyncRelation> relations_#

class SyncPlugin : public routing::IPlugin #

#include <SyncPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual std::string description() const override#: Get the plugin description.

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

struct SyncRelation#

#include <Synced.hpp>

Public Members

unsigned brotherId#

Duration delta#

class TimeWindowConstraintGenerator : public routing::IConstraintGenerator #

#include <TimeWindowConstraintGenerator.hpp>

Time window constraint generator.

Implements time window constraints:

Start time variables (t_i) for each node
Time window bounds (open/close)
Sequence constraints with service times and travel times

Requires: Rendezvous (time windows) and ServiceQuery (service times)

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this generator (for debugging/logging)

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types that must be enabled for this generator to be active.

inline virtual int priority() const override#: Priority for ordering generators (lower = earlier). Default: 100 Routing constraints should be ~10, capacity ~50, time windows ~60

class TimeWindowEvaluator : public routing::IEvaluator #

#include <TimeWindowEvaluator.hpp>

Public Functions

inline virtual std::string name() const override#: Returns a unique name for this evaluator.

inline virtual std::vector<AttributeTypeId> requiredAttributes() const override#: Returns the attribute types required for this evaluator.

inline virtual int priority() const override#: Priority for evaluation ordering (lower = earlier). Default: 100.

inline virtual bool checkFeasibility(const Tour &tour, const InsertionContext &ctx) const override#

Check if an insertion is feasible.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

true if the insertion maintains feasibility for this evaluator’s constraints

inline virtual double evaluateInsertionDelta(const Tour&, const InsertionContext&) const override#

Compute the cost delta for an insertion.

Parameters:

tour – The tour to insert into
ctx – The insertion context

Returns:

The change in cost (positive = worse, negative = better)

inline virtual void applyInsertion(Tour&, const InsertionContext&) override#

Apply an insertion and update internal state.

Called after an insertion is accepted. The evaluator should update any cached state (e.g., total load, arrival times).

Parameters:

tour – The tour being modified
ctx – The insertion context

class TimeWindowPlugin : public routing::IPlugin #

#include <TimeWindowPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual std::string description() const override#: Get the plugin description.

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

struct Tour : public routing::Model #

#include <Tour.hpp>

Subclassed by routing::Tour

Public Functions

inline Tour(Problem *p_problem, unsigned vehicleID)#

inline Problem *getProblem() const#

virtual void update() = 0#

virtual void pushClient(Client *client, routing::InsertionCost *cost) = 0#

virtual InsertionCost *_pushClient(Client *client) = 0#

virtual void addClient(Client *client, unsigned long position, routing::InsertionCost *cost) = 0#

virtual void removeClient(unsigned long position) = 0#

virtual void clear() = 0#

virtual Client *getClient(unsigned long) const = 0#

virtual unsigned long getNbClient() const = 0#

virtual Tour *clone() const = 0#

virtual routing::InsertionCost *evaluateInsertion(Client *client, unsigned long position) = 0#

virtual routing::RemoveCost *evaluateRemove(unsigned long position) = 0#

virtual long getHash() = 0#

Protected Attributes

Problem *problem#

class Tour : public routing::models::Tour #

#include <Solution.hpp>

Tour implementation for composable problems.

This class stores a sequence of clients assigned to a vehicle.

Public Functions

inline Tour(Problem *p_problem, unsigned vehicleID)#

inline virtual void update() override#

inline virtual void pushClient(models::Client *client, InsertionCost *cost) override#

inline virtual InsertionCost *_pushClient(models::Client *client) override#

inline virtual void addClient(models::Client *client, unsigned long position, InsertionCost *cost) override#

inline virtual void removeClient(unsigned long position) override#

inline virtual void clear() override#

inline virtual models::Client *getClient(unsigned long pos) const override#

inline virtual unsigned long getNbClient() const override#

inline virtual models::Tour *clone() const override#

inline virtual InsertionCost *evaluateInsertion(models::Client *client, unsigned long position) override#

inline virtual RemoveCost *evaluateRemove(unsigned long position) override#

inline virtual long getHash() override#

inline double getCost() const#

inline const std::vector<models::Client*> &getClients() const#

Private Members

std::vector<models::Client*> clients_#

double cost_#

class TSPLIBReader : public routing::IReader #

#include <TSPLIBReaderPlugin.hpp>

Standalone TSPLIB/CVRPLIB format reader using composable API.

Reads standard TSPLIB-format CVRP benchmark instances. Supports NODE_COORD_SECTION, DEMAND_SECTION, and DEPOT_SECTION.

Public Functions

inline virtual std::string formatName() const override#: Get the format name (e.g., “solomon”, “tsplib”)

inline virtual std::vector<std::string> supportedExtensions() const override#: Get supported file extensions.

inline virtual bool canRead(const std::string &filepath) const override#: Check if this reader can read the given file.

inline virtual Problem *readFile(const std::string &filepath) override#: Read an instance file and create a Problem.

inline virtual std::string detectedProblemType() const override#: Get the detected problem type after reading.

Private Members

std::string detectedType_ = "unknown"#

class TSPLIBReaderPlugin : public routing::IPlugin #

#include <TSPLIBReaderPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class TwoOpt : public routing::Neighborhood #

#include <TwoOpt.hpp>

Public Functions

inline virtual bool look(Solution *solution)#

Parameters:: solution – the solution to shake it returns the best neighbor
Returns:: true if solution improved

class TwoOptMovement#

#include <TwoOpt.hpp>

Public Functions

inline bool operator>(const TwoOptMovement &rhs) const#

inline routing::Duration getDelta() const#

inline void setDelta(routing::Duration delta)#

inline bool isPossible() const#

inline void setPossible(bool possible)#

inline TwoOptMovement(int first_point, int second_point, int tour, routing::Duration delta, bool possible)#

inline TwoOptMovement()#

inline TwoOptMovement(const TwoOptMovement &cost)#

Public Members

int i#

int j#

int t#

Private Members

routing::Duration delta#

bool possible#

class TwoOptNeighborhood : public routing::INeighborhood #

#include <TwoOptPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get neighborhood name.

inline virtual std::string description() const override#: Get neighborhood description.

inline virtual std::optional<NeighborhoodMove> explore(Solution&) override#: Explore the neighborhood and find the best move.

inline virtual void apply(Solution&, const NeighborhoodMove&) override#: Apply a move to the solution.

inline virtual bool improve(Solution &solution) override#: Convenience method: explore and apply best move.

Private Members

TwoOpt neighborhood_#

class TwoOptPlugin : public routing::IPlugin #

#include <TwoOptPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class UserCutCallback : public IloCplex::UserCutCallbackI#

#include <UserCutCallback.hpp>

Public Functions

inline UserCutCallback(IloEnv env, Problem *_problem)#

inline ~UserCutCallback()#

Protected Functions

inline void main()#

inline IloCplex::CallbackI *duplicateCallback() const#

Protected Attributes

Problem *problem#

class Var#

#include <MIPTypes.hpp>

Handle for a continuous variable in MIP model.

Public Functions

Var() = default#

inline explicit Var(int id)#

inline bool isValid() const#

inline int id() const#

inline bool operator==(const Var &other) const#

inline bool operator!=(const Var &other) const#

Private Members

int id_ = -1#

Friends

friend class IMIPBackend

struct Vehicle : public virtual routing::Model #

#include <Vehicle.hpp>

Subclassed by routing::Vehicle

Public Functions

inline explicit Vehicle(unsigned id)#

class Vehicle : public routing::Entity, public routing::models::Vehicle #

#include <Entity.hpp>

Vehicle entity with runtime attributes.

Public Functions

inline explicit Vehicle(unsigned id)#

class VNSSolver : public routing::Solver #

#include <VNSSolver.hpp>

Public Functions

inline VNSSolver(routing::Problem *p_problem, Generator *p_generator, const std::vector<Neighborhood*> &p_neighbors, std::ostream &os = std::cout)#

inline VNSSolver(routing::Problem *p_problem, std::ostream &os = std::cout)#

inline virtual void setGenerator(Generator *p_generator)#

inline virtual void setNeighbors(std::vector<routing::Neighborhood*> p_neighbors)#

inline virtual void shake(Solution *solution)#

inline virtual void setDefaultConfiguration() override#

inline virtual bool solve(double timeout = 3600) override#

virtual ~VNSSolver() = default#

Protected Attributes

std::vector<routing::Neighborhood*> neighbors#

routing::Generator *generator = nullptr#

class VNSSolverPlugin : public routing::IPlugin #

#include <VNSSolverPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

class VNSSolverWrapper : public routing::ISolver #

#include <VNSSolverPlugin.hpp>

Public Functions

inline explicit VNSSolverWrapper(Problem *problem)#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem*) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline void setGenerator(Generator *generator)#

inline void setNeighbors(const std::vector<Neighborhood*> &neighbors)#

Private Members

VNSSolver solver_#

class XCSP3Backend : public routing::cp::ICPBackend #

#include <XCSP3Backend.hpp>

Public Functions

XCSP3Backend()#

~XCSP3Backend() override = default#

inline virtual std::string name() const override#: Get backend name (e.g., “cpoptimizer”, “ortools”, “gecode”)

virtual IntVar newIntVar(int lb, int ub, const std::string &name = "") override#

Create an integer variable.

Parameters:

lb – Lower bound
ub – Upper bound
name – Optional variable name

virtual IntVar newBoolVar(const std::string &name = "") override#

Create a boolean variable (0-1)

Parameters:: name – Optional variable name

virtual IntVar newConstant(int value) override#

Create an integer constant.

Parameters:: value – Constant value

virtual IntervalVar newIntervalVar(int minStart, int maxEnd, int minDuration, int maxDuration, const std::string &name = "") override#

Create an interval variable for scheduling.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

virtual OptionalIntervalVar newOptionalIntervalVar(int minStart, int maxEnd, int minDuration, int maxDuration, const std::string &name = "") override#

Create an optional interval variable.

Parameters:

minStart – Earliest possible start time
maxEnd – Latest possible end time
minDuration – Minimum duration
maxDuration – Maximum duration
name – Optional variable name

Returns:

OptionalIntervalVar with presence indicator

virtual void addEquality(const LinearExpr &expr, int value) override#: Add constraint: expr == value.

virtual void addEquality(IntVar var1, IntVar var2) override#: Add constraint: var1 == var2.

virtual void addLinearConstraint(const LinearExpr &expr, int lb, int ub) override#: Add constraint: lb <= expr <= ub.

virtual void addLessOrEqual(IntVar var1, IntVar var2, int offset = 0) override#: Add constraint: var1 <= var2 + offset.

virtual void addImplication(IntVar condition, const LinearExpr &expr, int lb, int ub) override#: Add implication: if condition is true, then expr op bound.

virtual void addReification(IntVar indicator, IntVar var, int value) override#: Add reification: indicator == 1 iff var == value This creates a channeling constraint linking a boolean indicator to a condition.

virtual void addAllDifferent(const std::vector<IntVar> &vars) override#: All-different constraint All variables must take different values.

virtual void addElement(IntVar index, const std::vector<int> &array, IntVar result) override#: Element constraint: result = array[index].

virtual void addElement(IntVar index, const std::vector<IntVar> &vars, IntVar result) override#: Element constraint with variable array: result = vars[index].

virtual void addCircuit(const std::vector<IntVar> &next) override#: Circuit constraint Variables define a Hamiltonian circuit over nodes 0..n-1 next[i] = j means arc from i to j.

virtual void addSubCircuit(const std::vector<IntVar> &next) override#: Sub-circuit constraint (allows nodes to point to themselves) Used for TSP with optional nodes.

virtual void addInverse(const std::vector<IntVar> &next, const std::vector<IntVar> &prev) override#: Inverse constraint: next[prev[i]] == i and prev[next[i]] == i.

virtual void addNoOverlap(const std::vector<IntervalVar> &intervals) override#: No-overlap constraint Intervals cannot overlap in time.

virtual void addNoOverlap(const std::vector<OptionalIntervalVar> &intervals) override#: No-overlap constraint with optional intervals.

virtual void addCumulative(const std::vector<IntervalVar> &intervals, const std::vector<int> &demands, int capacity) override#: Cumulative constraint At any time point, sum of demands of active intervals <= capacity.

virtual void addCumulative(const std::vector<OptionalIntervalVar> &intervals, const std::vector<int> &demands, int capacity) override#: Cumulative with optional intervals.

virtual void addEndBeforeStart(IntervalVar interval1, IntervalVar interval2, int delay = 0) override#: Precedence constraint: interval1 ends before interval2 starts end(interval1) + delay <= start(interval2)

virtual IntVar startOf(IntervalVar interval) override#: Get start variable of an interval.

virtual IntVar endOf(IntervalVar interval) override#: Get end variable of an interval.

virtual IntVar durationOf(IntervalVar interval) override#: Get duration variable of an interval.

virtual IntVar startOf(OptionalIntervalVar interval, int defaultValue = 0) override#: Get start variable of optional interval (undefined if absent)

virtual IntVar endOf(OptionalIntervalVar interval, int defaultValue = 0) override#: Get end variable of optional interval (undefined if absent)

virtual void minimize(const LinearExpr &expr) override#: Set objective to minimize.

virtual void maximize(const LinearExpr &expr) override#: Set objective to maximize.

virtual void minimizeMakespan(const std::vector<IntervalVar> &intervals) override#: Minimize the makespan (max end time of intervals)

virtual CPStatus solve(double timeout = 3600.0) override#

Solve the model.

Parameters:: timeout – Maximum solving time in seconds
Returns:: Solver status

virtual void setHint(const std::vector<std::pair<IntVar, int>> &hints) override#: Provide hints/warm start.

virtual void setNumWorkers(int workers) override#: Set number of worker threads.

virtual void setRandomSeed(int seed) override#: Set random seed for reproducibility.

virtual int getValue(IntVar var) const override#: Get value of integer variable in solution.

virtual bool getBoolValue(IntVar var) const override#: Get value of boolean variable (0 or 1)

virtual int getStart(IntervalVar interval) const override#: Get start time of interval in solution.

virtual int getEnd(IntervalVar interval) const override#: Get end time of interval in solution.

virtual int getDuration(IntervalVar interval) const override#: Get duration of interval in solution.

virtual bool isPresent(OptionalIntervalVar interval) const override#: Check if optional interval is present in solution.

virtual double getObjectiveValue() const override#: Get objective value of solution.

virtual double getObjectiveBound() const override#: Get lower bound on objective.

virtual double getSolveTime() const override#: Get solving time in seconds.

virtual long long getNumBranches() const override#: Get number of search branches.

virtual long long getNumFailures() const override#: Get number of failures/backtracks.

virtual void clear() override#: Clear the model (remove all variables and constraints)

virtual bool exportModel(const std::string &filename) const override#: Export model to file (format depends on backend)

Private Functions

std::string getVarName(int id) const#

Private Members

std::vector<XCSP3Variable> variables_#

std::vector<XCSP3Interval> intervals_#

std::vector<XCSP3Interval> optionalIntervals_#

std::vector<std::string> constraints_#

std::string objectiveXml_#

bool isMinimization_ = true#

bool solved_ = false#

std::map<int, int> integerValues_#

double bestObjective_ = 0.0#

double solveTime_ = 0.0#

struct XCSP3Interval#

#include <XCSP3Backend.hpp>

Public Members

int startVarId#

int endVarId#

int sizeVarId#

int presenceVarId#

class XCSP3Solver : public routing::ISolver #

#include <XCSP3Solver.hpp>

XCSP3-based solver.

Public Functions

inline explicit XCSP3Solver(Problem *problem)#

~XCSP3Solver() override = default#

inline virtual std::string name() const override#: Get solver name.

inline virtual std::string description() const override#: Get solver description.

inline virtual void setProblem(Problem *problem) override#: Set the problem to solve.

inline virtual Problem *getProblem() const override#: Get the current problem.

inline virtual void setConfiguration(Configuration *config) override#: Set solver configuration.

inline void setVerbose(bool verbose)#

inline void addGenerator(std::unique_ptr<ICPConstraintGenerator> generator)#

inline virtual void setDefaultConfiguration() override#: Set default configuration.

inline virtual bool solve(double timeout) override#: Solve the problem.

inline virtual Solution *getSolution() const override#: Get the best solution found.

inline virtual double getObjectiveValue() const override#: Get the objective value of the best solution.

inline virtual bool isOptimal() const override#: Check if the problem was solved to optimality.

inline virtual std::string getStats() const override#: Get solving statistics.

Private Functions

inline void buildModel()#

inline void extractSolution()#

Private Members

Problem *problem_#

Solution *solution_#

double objectiveValue_#

double timeout_#

int numWorkers_#

bool verbose_#

std::unique_ptr<XCSP3Backend> backend_#

std::vector<std::unique_ptr<ICPConstraintGenerator>> customGenerators_#

std::vector<std::unique_ptr<ICPConstraintGenerator>> autoGenerators_#

generators::CPRoutingGenerator *routingGen_ = nullptr#

class XCSP3SolverPlugin : public routing::IPlugin #

#include <XCSP3SolverPlugin.hpp>

Public Functions

inline virtual std::string name() const override#: Get the plugin name (unique identifier)

inline virtual PluginType type() const override#: Get the plugin type.

inline virtual void initialize(PluginRegistry &registry) override#: Initialize the plugin and register components.

struct XCSP3Variable#

#include <XCSP3Backend.hpp>

Public Members

std::string name#

int lb#

int ub#

bool isBool#

namespace IloCplex#

namespace routing#

Typedefs

using AttributeTypeId = std::type_index#

typedef Problem ComposableProblem#

typedef Tour ComposableTour#

typedef Entity ComposableEntity#

using ImprovementCallback = std::function<void(Solution*, double)>#: Callback type for solution improvement notifications Parameters: solution pointer, objective value

typedef int Demand#

typedef double Capacity#

using ComposableClient = Client #

using ComposableVehicle = Vehicle #

using ComposableDepot = Depot #

using ComposableSolution = Solution #

typedef int DeliveryDemand#

typedef int PickupDemand#

typedef double Profit#

typedef double Duration#

typedef std::pair<Duration, Duration> TW#

Enums

enum class PluginType#

Plugin type enumeration.

Values:

enumerator Attribute#

enumerator ConstraintGenerator#

enumerator Evaluator#

enumerator Solver#

enumerator Neighborhood#

enumerator Reader#

enum class ConstraintMode#

Values:

enumerator DistanceOnly#

enumerator FeasibleOnly#

enumerator Penalized#

namespace attributes#

namespace callback#

namespace constraints#

namespace cp#

Typedefs

using CPBackendFactory = std::function<std::unique_ptr<ICPBackend>()>#: Factory function type for creating CP backends.

Enums

enum class CPStatus#

Solver status after solving.

Values:

enumerator Unknown#

enumerator Optimal#: Not yet solved or no status.

enumerator Feasible#: Proven optimal solution found.

enumerator Infeasible#: Feasible solution found (not proven optimal)

enumerator Unbounded#: Problem is infeasible.

enumerator ModelInvalid#: Problem is unbounded.

enumerator Error#

Model is invalid.

Solver error

Functions

inline LinearExpr operator+(IntVar a, IntVar b)#

inline LinearExpr operator+(IntVar var, int constant)#

inline LinearExpr operator-(IntVar a, IntVar b)#

inline LinearExpr operator*(IntVar var, int coeff)#

inline LinearExpr operator*(int coeff, IntVar var)#

inline const char *toString(CPStatus status)#

namespace generators#

namespace evaluators#

namespace mip#

Typedefs

using MIPBackendFactory = std::function<std::unique_ptr<IMIPBackend>()>#: Factory function type for creating MIP backends.

Enums

enum class Sense#

Constraint sense for linear constraints.

Values:

enumerator LessEqual#

enumerator Equal#

enumerator GreaterEqual#

enum class MIPStatus#

Solver status after solving.

Values:

enumerator Unknown#

enumerator Optimal#

enumerator Feasible#

enumerator Infeasible#

enumerator InfeasibleOrUnbounded#

enumerator Unbounded#

enumerator NodeLimit#

enumerator TimeLimit#

enumerator SolutionLimit#

enumerator Error#

enum class VarType#

Variable type enumeration.

Values:

enumerator Continuous#

enumerator Integer#

enumerator Binary#

enum class OptSense#

Optimization sense.

Values:

enumerator Minimize#

enumerator Maximize#

Functions

inline LinearExpr operator+(Var a, Var b)#

inline LinearExpr operator+(Var var, double constant)#

inline LinearExpr operator+(double constant, Var var)#

inline LinearExpr operator-(Var a, Var b)#

inline LinearExpr operator*(Var var, double coeff)#

inline LinearExpr operator*(double coeff, Var var)#

inline const char *toString(MIPStatus status)#

namespace generators#

namespace models#

namespace plugins#

Functions

void registerCorePlugins()#

namespace solomon_detail#

Functions

inline std::string toLower(std::string value)#

inline bool hasExtension(const std::string &filepath, const std::vector<std::string> &extensions)#

namespace tsplib_detail#

Functions

inline std::string toLower(std::string value)#

inline std::string trim(const std::string &str)#

inline bool hasExtension(const std::string &filepath, const std::vector<std::string> &extensions)#

namespace std#

file CPTypes.hpp: #include <vector>

#include <limits>

file GeneratorRegistry.hpp

#include “core/interfaces/ICPConstraintGenerator.hpp”

#include “core/interfaces/IMIPConstraintGenerator.hpp”

#include <functional>

#include <memory>

#include <vector>

#include <map>

#include <string>

#include <algorithm>

Defines

ROUTING_REGISTER_CP_GENERATOR(GeneratorClass)#

ROUTING_REGISTER_MIP_GENERATOR(GeneratorClass)#

file IAttribute.hpp: #include <memory>

#include <string>

#include <type_traits>

#include <typeindex>

file IConstraintGenerator.hpp: #include “core/interfaces/IAttribute.hpp”

#include <vector>

#include <set>

#include <string>

file ICPBackend.hpp: #include “core/cp/CPTypes.hpp”

#include <string>

#include <vector>

#include <memory>

#include <functional>

#include <limits>

file ICPConstraintGenerator.hpp: #include “core/interfaces/ICPBackend.hpp”

#include “core/interfaces/IAttribute.hpp”

#include <string>

#include <vector>

#include <typeindex>

#include <set>

file IEvaluator.hpp: #include “core/interfaces/IAttribute.hpp”

#include <set>

#include <string>

#include <vector>

file IMIPBackend.hpp: #include “core/mip/MIPTypes.hpp”

#include <string>

#include <vector>

#include <memory>

#include <functional>

#include <limits>

file IMIPConstraintGenerator.hpp: #include “core/interfaces/IMIPBackend.hpp”

#include “core/interfaces/IAttribute.hpp”

#include <string>

#include <vector>

#include <typeindex>

#include <set>

file INeighborhood.hpp: #include <optional>

#include <string>

#include <vector>

file IReader.hpp: #include <string>

#include <vector>

file ISolver.hpp: #include <string>

#include <functional>

file IPlugin.hpp

#include <memory>

#include <string>

#include <vector>

Defines

ROUTING_REGISTER_PLUGIN(PluginClass)#: Macro for static plugin registration.

file MIPTypes.hpp: #include <vector>

#include <limits>

#include <string>

file PluginRegistry.hpp: #include “IPlugin.hpp”

#include “core/interfaces/ISolver.hpp”

#include “core/interfaces/INeighborhood.hpp”

#include “core/interfaces/IReader.hpp”

#include “core/interfaces/IConstraintGenerator.hpp”

#include “core/interfaces/IEvaluator.hpp”

#include “core/interfaces/IMIPBackend.hpp”

#include “core/interfaces/ICPBackend.hpp”

#include “core/interfaces/ICPConstraintGenerator.hpp”

#include “core/interfaces/IMIPConstraintGenerator.hpp”

#include <algorithm>

#include <functional>

#include <iostream>

#include <map>

#include <memory>

#include <set>

#include <stdexcept>

#include <string>

#include <utility>

#include <vector>

file Problem.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file Problem.hpp: #include “Entity.hpp”

#include “Memory.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/IConstraintGenerator.hpp”

#include “core/interfaces/IEvaluator.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include <set>

#include <vector>

#include <memory>

#include <algorithm>

#include <iostream>

#include <string>

#include “Solution.hpp”

file Solution.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file Solution.hpp: #include “Model.hpp”

#include “models/Tour.hpp”

#include “Entity.hpp”

#include <vector>

#include <iostream>

#include <algorithm>

#include <cassert>

file CapacityConstraintGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

file CapacityEvaluator.hpp: #include “core/interfaces/IEvaluator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

#include <cmath>

#include <limits>

#include <typeindex>

#include <vector>

file CapacityPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/CapacityPlugin/CapacityConstraintGenerator.hpp”

#include “plugins/attributes/CapacityPlugin/CPCapacityGenerator.hpp”

#include “plugins/attributes/CapacityPlugin/MIPCapacityGenerator.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

#include “plugins/attributes/CapacityPlugin/CapacityEvaluator.hpp”

file Consumer.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

file CPCapacityGenerator.hpp: #include “core/interfaces/ICPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

#include “plugins/attributes/RoutingPlugin/CPRoutingGenerator.hpp”

file MIPCapacityGenerator.hpp: #include “core/interfaces/IMIPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/ComposableCorePlugin/Solution.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

#include “plugins/attributes/RoutingPlugin/MIPRoutingGenerator.hpp”

#include <vector>

#include <algorithm>

file Stock.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

file InsertionCost.hpp: #include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

file RemoveCost.hpp: #include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

file ComposableCorePlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “Entity.hpp”

#include “Problem.hpp”

#include “Solution.hpp”

file Entity.hpp: #include “Model.hpp”

#include “core/interfaces/IAttribute.hpp”

#include “models/Client.hpp”

#include “models/Vehicle.hpp”

#include “models/Depot.hpp”

#include <map>

#include <set>

#include <memory>

#include <stdexcept>

#include <typeindex>

#include <utility>

#include <iostream>

#include <cstring>

file Memory.hpp: #include <map>

#include <utility>

file Model.hpp: #include <string>

file Client.hpp: #include “plugins/attributes/ComposableCorePlugin/Model.hpp”

file Depot.hpp: #include “plugins/attributes/ComposableCorePlugin/Model.hpp”

file Tour.hpp: #include “plugins/attributes/ComposableCorePlugin/Model.hpp”

#include “Client.hpp”

#include “plugins/attributes/ComposableCorePlugin/attributes/InsertionCost.hpp”

#include “plugins/attributes/ComposableCorePlugin/attributes/RemoveCost.hpp”

file Vehicle.hpp: #include “plugins/attributes/ComposableCorePlugin/Model.hpp”

file Delivery.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

file Pickup.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

file PickupDeliveryConstraintGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/PickupDeliveryPlugin/Pickup.hpp”

#include “plugins/attributes/PickupDeliveryPlugin/Delivery.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

file PickupDeliveryPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/PickupDeliveryPlugin/PickupDeliveryConstraintGenerator.hpp”

file Profiter.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

file ProfitObjectiveGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/ProfitPlugin/Profiter.hpp”

file ProfitPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/ProfitPlugin/ProfitObjectiveGenerator.hpp”

file CPRoutingGenerator.hpp: #include “core/interfaces/ICPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include <cmath>

#include <unordered_map>

file GeoNode.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

#include <cmath>

file MIPRoutingGenerator.hpp: #include “core/interfaces/IMIPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/ComposableCorePlugin/Solution.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include <vector>

#include <cmath>

file RoutingConstraintGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

file RoutingEvaluator.hpp: #include “core/interfaces/IEvaluator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include <typeindex>

#include <vector>

file RoutingPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/RoutingPlugin/RoutingConstraintGenerator.hpp”

#include “plugins/attributes/RoutingPlugin/CPRoutingGenerator.hpp”

#include “plugins/attributes/RoutingPlugin/MIPRoutingGenerator.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include “plugins/attributes/RoutingPlugin/RoutingEvaluator.hpp”

file SyncConstraintGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/SyncPlugin/Synced.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

file Synced.hpp: #include “core/interfaces/IAttribute.hpp”

#include <vector>

#include <memory>

file SyncPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/SyncPlugin/SyncConstraintGenerator.hpp”

file Appointment.hpp: #include “core/interfaces/IAttribute.hpp”

#include “Rendezvous.hpp”

#include <memory>

file CPTimeWindowGenerator.hpp: #include “core/interfaces/ICPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include “plugins/attributes/RoutingPlugin/CPRoutingGenerator.hpp”

#include <cmath>

file MIPTimeWindowGenerator.hpp: #include “core/interfaces/IMIPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/ComposableCorePlugin/Solution.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include “plugins/attributes/RoutingPlugin/MIPRoutingGenerator.hpp”

#include <vector>

#include <limits>

file Rendezvous.hpp: #include “core/interfaces/IAttribute.hpp”

#include “ServiceQuery.hpp”

#include <memory>

#include <utility>

file Service.hpp: #include “core/interfaces/IAttribute.hpp”

#include “ServiceQuery.hpp”

#include <memory>

file ServiceQuery.hpp: #include “core/interfaces/IAttribute.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include <memory>

file SoftTimeWindowGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

file SoftTimeWindows.hpp: #include “core/interfaces/IAttribute.hpp”

#include <memory>

file TimeWindowConstraintGenerator.hpp: #include “core/interfaces/IConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

file TimeWindowEvaluator.hpp: #include “core/interfaces/IEvaluator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

#include <algorithm>

#include <typeindex>

#include <vector>

file TimeWindowPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/TimeWindowPlugin/TimeWindowConstraintGenerator.hpp”

#include “plugins/attributes/TimeWindowPlugin/CPTimeWindowGenerator.hpp”

#include “plugins/attributes/TimeWindowPlugin/MIPTimeWindowGenerator.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

#include “plugins/attributes/TimeWindowPlugin/TimeWindowEvaluator.hpp”

file IDCH.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Destructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Constructor.hpp”

#include <cassert>

file IDCHPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/INeighborhood.hpp”

#include “plugins/neighborhoods/IDCHPlugin/IDCH.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Constructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Destructor.hpp”

#include <memory>

#include <optional>

file Move.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “Neighborhood.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Constructor.hpp”

#include <cassert>

file Neighborhood.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file TwoOpt.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include <cassert>

#include <utility>

file TwoOptPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/INeighborhood.hpp”

#include “plugins/neighborhoods/TwoOptPlugin/TwoOpt.hpp”

#include <optional>

file PluginBundle.cpp: #include “plugins/PluginBundle.hpp”

#include “core/PluginRegistry.hpp”

file PluginBundle.hpp: #include “plugins/attributes/ComposableCorePlugin/ComposableCorePlugin.hpp”

#include “plugins/attributes/RoutingPlugin/RoutingPlugin.hpp”

#include “plugins/attributes/CapacityPlugin/CapacityPlugin.hpp”

#include “plugins/attributes/TimeWindowPlugin/TimeWindowPlugin.hpp”

#include “plugins/attributes/ProfitPlugin/ProfitPlugin.hpp”

#include “plugins/attributes/PickupDeliveryPlugin/PickupDeliveryPlugin.hpp”

#include “plugins/attributes/SyncPlugin/SyncPlugin.hpp”

#include “plugins/solvers/GASolverPlugin/GASolverPlugin.hpp”

#include “plugins/solvers/LSSolverPlugin/LSSolverPlugin.hpp”

#include “plugins/solvers/MASolverPlugin/MASolverPlugin.hpp”

#include “plugins/solvers/MIPSolverPlugin/MIPSolverPlugin.hpp”

#include “plugins/solvers/PSOSolverPlugin/PSOSolverPlugin.hpp”

#include “plugins/solvers/VNSSolverPlugin/VNSSolverPlugin.hpp”

#include “plugins/neighborhoods/TwoOptPlugin/TwoOptPlugin.hpp”

#include “plugins/neighborhoods/IDCHPlugin/IDCHPlugin.hpp”

#include “plugins/readers/SolomonReaderPlugin/SolomonReaderPlugin.hpp”

#include “plugins/readers/TSPLIBReaderPlugin/TSPLIBReaderPlugin.hpp”

file Reader.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include <sstream>

file SolomonReaderPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/IReader.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

#include “plugins/attributes/TimeWindowPlugin/Rendezvous.hpp”

#include “plugins/attributes/TimeWindowPlugin/ServiceQuery.hpp”

#include <algorithm>

#include <cctype>

#include <fstream>

#include <sstream>

#include <string>

#include <vector>

#include <stdexcept>

file TSPLIBReaderPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/IReader.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/RoutingPlugin/GeoNode.hpp”

#include “plugins/attributes/CapacityPlugin/Consumer.hpp”

#include “plugins/attributes/CapacityPlugin/Stock.hpp”

#include <algorithm>

#include <cctype>

#include <fstream>

#include <sstream>

#include <string>

#include <vector>

#include <stdexcept>

#include <cmath>

#include <map>

file CPOptimizerBackend.hpp: #include “core/interfaces/ICPBackend.hpp”

#include <stdexcept>

#include <unordered_map>

file CPSolver.hpp: #include “core/interfaces/ISolver.hpp”

#include “core/interfaces/ICPBackend.hpp”

#include “core/interfaces/ICPConstraintGenerator.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “CPOptimizerBackend.hpp”

#include “ORToolsCPSATBackend.hpp”

#include “plugins/attributes/RoutingPlugin/CPRoutingGenerator.hpp”

#include “plugins/attributes/CapacityPlugin/CPCapacityGenerator.hpp”

#include “plugins/attributes/TimeWindowPlugin/CPTimeWindowGenerator.hpp”

#include <memory>

#include <vector>

#include <algorithm>

#include <iostream>

file CPSolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “CPSolver.hpp”

file ORToolsCPSATBackend.hpp: #include “core/interfaces/ICPBackend.hpp”

#include <stdexcept>

#include <unordered_map>

#include <chrono>

#include <algorithm>

file GASolver.hpp: #include “plugins/solvers/SolverCorePlugin/Solver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include “plugins/attributes/ComposableCorePlugin/Entity.hpp”

#include “core/interfaces/IEvaluator.hpp”

#include <cassert>

#include <algorithm>

#include <chrono>

#include <functional>

#include <set>

#include <limits>

#include <sstream>

#include <iomanip>

#include <utility>

file GASolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/ISolver.hpp”

#include “plugins/solvers/GASolverPlugin/GASolver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

file LSSolver.hpp: #include “plugins/solvers/SolverCorePlugin/Solver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/GreedyConstructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/RandomDestructor.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include “plugins/neighborhoods/TwoOptPlugin/TwoOpt.hpp”

#include <cassert>

file LSSolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/ISolver.hpp”

#include “plugins/solvers/LSSolverPlugin/LSSolver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include <vector>

file MASolver.hpp: #include “plugins/solvers/GASolverPlugin/GASolver.hpp”

#include “plugins/solvers/SolverCorePlugin/Solver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/GreedyConstructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/RandomDestructor.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include “plugins/neighborhoods/IDCHPlugin/IDCH.hpp”

#include “plugins/neighborhoods/TwoOptPlugin/TwoOpt.hpp”

#include <cassert>

#include <algorithm>

#include <set>

file MASolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/ISolver.hpp”

#include “plugins/solvers/MASolverPlugin/MASolver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include <vector>

file callbacks.hpp: #include “plugins/solvers/MIPSolverPlugin/callbacks/IncumbentCallback.hpp”

#include “plugins/solvers/MIPSolverPlugin/callbacks/HeuristicCallback.hpp”

#include “plugins/solvers/MIPSolverPlugin/callbacks/InformationCallback.hpp”

#include “plugins/solvers/MIPSolverPlugin/callbacks/LazyConstraintCallback.hpp”

#include “plugins/solvers/MIPSolverPlugin/callbacks/UserCutCallback.hpp”

file HeuristicCallback.hpp: #include <ilcplex/ilocplexi.h>

#include <utility>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Constructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Destructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Diver.hpp”

file IncumbentCallback.hpp: #include <ilcplex/ilocplexi.h>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file InformationCallback.hpp: #include <ilcplex/ilocplexi.h>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file LazyConstraintCallback.hpp: #include <ilcplex/ilocplexi.h>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file UserCutCallback.hpp: #include <ilcplex/ilocplexi.h>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file CPLEXMIPBackend.hpp: #include “core/interfaces/IMIPBackend.hpp”

#include <stdexcept>

#include <cmath>

file HiGHSMIPBackend.hpp: #include “core/interfaces/IMIPBackend.hpp”

#include <stdexcept>

#include <cmath>

#include <algorithm>

file MIPSolver.hpp: #include “core/interfaces/ISolver.hpp”

#include “core/interfaces/IMIPBackend.hpp”

#include “core/interfaces/IMIPConstraintGenerator.hpp”

#include “core/PluginRegistry.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/attributes/ComposableCorePlugin/Solution.hpp”

#include “plugins/attributes/RoutingPlugin/MIPRoutingGenerator.hpp”

#include “plugins/attributes/CapacityPlugin/MIPCapacityGenerator.hpp”

#include “plugins/attributes/TimeWindowPlugin/MIPTimeWindowGenerator.hpp”

#include “CPLEXMIPBackend.hpp”

#include “HiGHSMIPBackend.hpp”

#include <memory>

#include <vector>

#include <iostream>

#include <sstream>

#include <typeindex>

file MIPSolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/ISolver.hpp”

#include “core/interfaces/IMIPBackend.hpp”

#include “MIPSolver.hpp”

#include “CPLEXMIPBackend.hpp”

#include “HiGHSMIPBackend.hpp”

file Constructor.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file Decoder.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file Destructor.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

file Diver.hpp: #include <map>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/solvers/MIPSolverPlugin/callbacks.hpp”

file Generator.hpp: #include <random>

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include “Destructor.hpp”

#include “Constructor.hpp”

file GreedyConstructor.hpp: #include “Constructor.hpp”

#include <algorithm>

#include <limits>

#include <vector>

file RandomDestructor.hpp: #include “Destructor.hpp”

#include <algorithm>

#include <random>

#include <utility>

#include <vector>

file PSOSolver.hpp: #include “plugins/solvers/MASolverPlugin/MASolver.hpp”

#include “plugins/solvers/SolverCorePlugin/Solver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include <cassert>

#include <algorithm>

#include <set>

#include <map>

file PSOSolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/ISolver.hpp”

#include “plugins/solvers/PSOSolverPlugin/PSOSolver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include <vector>

file Configuration.hpp: #include <map>

#include <string>

#include <exception>

#include <utility>

file Solver.hpp: #include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “core/interfaces/ISolver.hpp”

#include “Configuration.hpp”

#include <filesystem>

#include <fstream>

#include <iostream>

file VNSSolver.hpp: #include “plugins/solvers/SolverCorePlugin/Solver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/GreedyConstructor.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/RandomDestructor.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

#include “plugins/neighborhoods/TwoOptPlugin/TwoOpt.hpp”

#include <cassert>

file VNSSolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “core/interfaces/ISolver.hpp”

#include “plugins/solvers/VNSSolverPlugin/VNSSolver.hpp”

#include “plugins/solvers/OperatorsPlugin/operators/Generator.hpp”

#include “plugins/neighborhoods/NeighborhoodCorePlugin/Neighborhood.hpp”

file XCSP3Backend.cpp: #include “XCSP3Backend.hpp”

#include <fstream>

#include <iostream>

#include <algorithm>

#include <cstdio>

#include <cstdlib>

#include <filesystem>

#include <regex>

file XCSP3Backend.hpp: #include “core/interfaces/ICPBackend.hpp”

#include <map>

#include <sstream>

#include <variant>

file XCSP3Solver.hpp: #include “core/interfaces/ISolver.hpp”

#include “core/interfaces/ICPBackend.hpp”

#include “core/interfaces/ICPConstraintGenerator.hpp”

#include “plugins/attributes/ComposableCorePlugin/Problem.hpp”

#include “XCSP3Backend.hpp”

#include “plugins/attributes/CapacityPlugin/CPCapacityGenerator.hpp”

#include “plugins/attributes/RoutingPlugin/CPRoutingGenerator.hpp”

#include “plugins/attributes/TimeWindowPlugin/CPTimeWindowGenerator.hpp”

#include <memory>

#include <vector>

#include <algorithm>

#include <iostream>

file XCSP3SolverPlugin.hpp: #include “core/IPlugin.hpp”

#include “core/PluginRegistry.hpp”

#include “XCSP3Solver.hpp”

file routing.hpp

dir plugins/attributes

dir plugins/attributes/ComposableCorePlugin/attributes

dir plugins/solvers/MIPSolverPlugin/callbacks

dir plugins/attributes/CapacityPlugin

dir plugins/attributes/ComposableCorePlugin

dir core

dir core/src/core

dir core/src/core/cp

dir plugins/solvers/CPSolverPlugin

dir plugins/solvers/GASolverPlugin

dir plugins/neighborhoods/IDCHPlugin

dir core/src/core/interfaces

dir plugins/solvers/LSSolverPlugin

dir plugins/solvers/MASolverPlugin

dir core/src/core/mip

dir plugins/solvers/MIPSolverPlugin

dir plugins/attributes/ComposableCorePlugin/models

dir plugins/neighborhoods/NeighborhoodCorePlugin

dir plugins/neighborhoods

dir plugins/solvers/OperatorsPlugin/operators

dir plugins/solvers/OperatorsPlugin

dir plugins/attributes/PickupDeliveryPlugin

dir plugins

dir plugins/attributes/ProfitPlugin

dir plugins/solvers/PSOSolverPlugin

dir plugins/readers/ReaderCorePlugin

dir plugins/readers

dir routing

dir plugins/attributes/RoutingPlugin

dir plugins/readers/SolomonReaderPlugin

dir plugins/solvers/SolverCorePlugin

dir plugins/solvers

dir core/src

dir plugins/attributes/SyncPlugin

dir plugins/attributes/TimeWindowPlugin

dir plugins/readers/TSPLIBReaderPlugin

dir plugins/neighborhoods/TwoOptPlugin

dir plugins/solvers/VNSSolverPlugin

dir plugins/solvers/XCSP3SolverPlugin