BALDES documentation

New to BALDES? Follow Your first solve to build the CLI, run a small instance, and understand the result. Commands in these guides run from the repository root.

Choose your task

I want to…	Start here
Run a small example and understand its output	Your first solve
Find a feasible routing solution quickly	HGS and CLI usage
Search for an integer solution with bounds	Branch-and-price tree
Model customer data in Python	Python API
Use multiple route families in one master	Multi-pricing
Configure backends or troubleshoot a build	Build and installation

Getting started

Your first solve: a complete CLI walkthrough, result interpretation, and common setup fixes.
Build and installation: dependencies, optional backends, and Make configuration.
Source layout: production modules, CLI commands, and test organization.
Command-line usage: routing solves, HGS, flags, and output.
Python API: installation, model inputs, solver options, and result export.

Solver

Tree and node lifecycle: integer routing, inherited state, bounds, and limits.
Routing feasibility recovery: zero-objective phase I, objective restoration, proof scope and limits.
Branching: branching families and selection.
Cuts: cut configuration and coefficient consistency.
Dual-price stabilization: smoothing, center updates, and retries.
Enumerated MIP: optional HiGHS integer solving and proof coverage.

Reference

Algorithms and references: solver components and research references.
BALDES options: supported controls, defaults, types, and scope.
Scalar resources: resource dimensions and bucket indexing.
SIMD dispatch: optional kernels and runtime portability.

Extensions and modeling

Coupled resources: simultaneous pickup/delivery, selected values, cumulative costs and affine dependencies in the physical-graph labeling engine.
Multiple time windows: disjoint service-start domains for scalar pricing resources.
Multi-pricing: shared masters, multiple route families, and assignment branching.
Finite column imports: original-vector patterns and multiplicity constraints.
P-step CVRP: compact p-step LP relaxation.
Electric-vehicle routing: charging models, schedule replay, and current limitations.
Robust vehicle routing: budgeted demand and travel-time uncertainty in bucket graph labeling, plus an independent validation reference.
Interior-point solver: native LP backend, interfaces, and implementation details.
Column elimination (CE): decision-diagram route relaxation and refinement.

Benchmarks

Root benchmarks: published root relaxation timings and measurement setup.

Capabilities and interfaces

Operation	Rust	CLI	Python	Backend
RCSP pricing and enumeration	Yes	Through routing solves	Low-level `Solver`	Core Rust
Routing root relaxation	Yes	Default `vrptw` / `cvrp` mode	`pybaldes.solve_root`	Clp model store; Clp/IPM/optional HiGHS solves
Branch-and-price tree	Yes	`--tree`	Not exposed	Clp model store; Clp/IPM/optional HiGHS solves
Complete enumerated node MIP	Yes, opt-in	`--tree --enumerated-mip`	Not exposed	Clp + HiGHS
Generic mixed-integer master solve	`highs::solve_integer`	Not exposed directly	Not exposed	HiGHS

The vrptw and cvrp routing tree uses one pricing network. For models with multiple route families, use the multi-pricing interface, including its CLI and Python APIs and assignment tree. Its supported branching families and solve limitations differ from the single-network routing tree.

Root Optimal means the LP relaxation converged. Tree Optimal means the integer routing gap closed within the configured tolerances. A feasible restricted-column solution supplies an incumbent; its objective alone does not prove a lower bound for the full routing problem.

Rust module organization

Core modules implement graphs, labeling, pricing, cuts, enumeration and the master. master::mp coordinates one master with multiple pricing subproblems and belongs to the core master framework. Rust callers can also use master::mp::solve_master for original master variables with no pricing subproblems.

Module	Purpose
`extensions::hgs`	Hybrid Genetic Search and primal heuristics
`extensions::ipm`	Native interior-point LP backend
`extensions::evrp`	Electric-vehicle routing models and charging schedules
`extensions::pstep`	P-step CVRP LP with parallel bucket pricing and reference enumeration
`master::mp`	Shared rows, per-subproblem multiplicities and node lifecycle

extensions groups algorithms and specialized models in the same crate; it does not imply runtime plugins or new build features. Existing baldes::hgs, baldes::ipm, baldes::evrp and master::networks paths remain compatibility re-exports. New Rust code should use the module paths above. CLI JSON fields and Python names such as NetworkProblem and solve_networks stay compatible.