Skip to content

Solver catalogue

Every solver of DispatchAtlas, generated from the solver registry when this site is built. For each solver: what it does, the parameters it takes with their defaults, the problem features it does not model, the extra it needs, and the sources it implements. The same facts are available from the command line with dispatchatlas solvers show ID, and in Python from default_registry().info(id).

"Stochastic" solvers draw from the run's seed, "deterministic" ones ignore it. Solvers that run "until a stop criterion" need a time, evaluation, or iteration limit; the others finish on their own and still honour the limits they are given (see Solvers).

DispatchAtlas registers 72 solvers in 12 families. Every solver can be run by its id from Python, from the command line, and in campaign files.

Solver Family Runs Extra
earliest-due-date dispatching-rule deterministic, to completion -
input-order dispatching-rule deterministic, to completion -
least-slack dispatching-rule deterministic, to completion -
longest-processing-time dispatching-rule deterministic, to completion -
longest-remaining-path dispatching-rule deterministic, to completion -
most-work-remaining dispatching-rule deterministic, to completion -
shortest-processing-time dispatching-rule deterministic, to completion -
heft list-scheduling deterministic, to completion -
max-min list-scheduling deterministic, to completion -
min-min list-scheduling deterministic, to completion -
sufferage list-scheduling deterministic, to completion -
beam-search constructive deterministic, to completion -
monte-carlo-tree-search constructive stochastic, until a stop criterion -
neh constructive deterministic, to completion -
squeaky-wheel-optimization constructive stochastic, until a stop criterion -
alns local-search stochastic, until a stop criterion -
grasp local-search stochastic, until a stop criterion -
great-deluge local-search stochastic, until a stop criterion -
guided-local-search local-search stochastic, until a stop criterion -
hill-climbing local-search stochastic, until a stop criterion -
iterated-greedy local-search stochastic, until a stop criterion -
iterated-local-search local-search stochastic, until a stop criterion -
late-acceptance-hill-climbing local-search stochastic, until a stop criterion -
mode-assignment-tabu local-search stochastic, until a stop criterion -
record-to-record-travel local-search stochastic, until a stop criterion -
simulated-annealing local-search stochastic, until a stop criterion -
tabu-search local-search stochastic, until a stop criterion -
threshold-accepting local-search stochastic, until a stop criterion -
variable-neighbourhood-search local-search stochastic, until a stop criterion -
ant-colony-optimization population stochastic, until a stop criterion -
brkga population stochastic, until a stop criterion -
cma-es population stochastic, until a stop criterion -
differential-evolution population stochastic, until a stop criterion -
genetic-algorithm population stochastic, until a stop criterion -
lshade population stochastic, until a stop criterion -
memetic-algorithm population stochastic, until a stop criterion -
scatter-search population stochastic, until a stop criterion -
umda population stochastic, until a stop criterion -
arithmetic-optimization-algorithm swarm stochastic, until a stop criterion -
artificial-bee-colony swarm stochastic, until a stop criterion -
clpso swarm stochastic, until a stop criterion -
cuckoo-search swarm stochastic, until a stop criterion -
firefly-algorithm swarm stochastic, until a stop criterion -
gravitational-search-algorithm swarm stochastic, until a stop criterion -
grey-wolf-optimizer swarm stochastic, until a stop criterion -
harris-hawks-optimization swarm stochastic, until a stop criterion -
jaya swarm stochastic, until a stop criterion -
marine-predators-algorithm swarm stochastic, until a stop criterion -
moth-flame-optimization swarm stochastic, until a stop criterion -
particle-swarm-optimization swarm stochastic, until a stop criterion -
salp-swarm-algorithm swarm stochastic, until a stop criterion -
sine-cosine-algorithm swarm stochastic, until a stop criterion -
teaching-learning-based-optimization swarm stochastic, until a stop criterion -
whale-optimization-algorithm swarm stochastic, until a stop criterion -
age-moea-ii multi-objective stochastic, until a stop criterion, multi-objective -
ibea multi-objective stochastic, until a stop criterion, multi-objective -
moea-d multi-objective stochastic, until a stop criterion, multi-objective -
nsga-ii multi-objective stochastic, until a stop criterion, multi-objective -
nsga-iii multi-objective stochastic, until a stop criterion, multi-objective -
rvea multi-objective stochastic, until a stop criterion, multi-objective -
sms-emoa multi-objective stochastic, until a stop criterion, multi-objective -
spea2 multi-objective stochastic, until a stop criterion, multi-objective -
cp-sat exact deterministic, until a stop criterion exact
enumeration exact deterministic, to completion -
milp exact deterministic, to completion exact
restricted-neighbourhood-search matheuristic stochastic, until a stop criterion exact
q-learning-dispatching learning stochastic, until a stop criterion -
reinforce-priority-policy learning stochastic, until a stop criterion -
sarsa-dispatching learning stochastic, until a stop criterion -
gp-hyper-heuristic hyper-heuristic stochastic, until a stop criterion -
selection-hyper-heuristic hyper-heuristic stochastic, until a stop criterion -
random-search random-sampling stochastic, until a stop criterion -

Dispatching rule

Builds one schedule from a fixed priority rule.

Earliest due date

Decodes tasks by increasing due date, inherited from the task's group when the task has none.

Input order

Decodes tasks by release time, then in their listed order, a first-come first-served baseline.

  • Id: input-order; implemented by InputOrder
  • Runs: deterministic, to completion
  • Parameters: none
  • Models: every feature
  • Sources: Kolisch (1996)

Least slack

Decodes tasks by increasing slack, the due date minus the longest remaining path, which approximates the latest start time.

Longest processing time

Decodes tasks in decreasing order of their shortest duration, which balances load on parallel resources.

Longest remaining path

Decodes tasks by decreasing length of the longest dependency path from their start to the end of the problem, the critical-path rule.

Most work remaining

Decodes tasks by decreasing work left in their group from the task on.

Shortest processing time

Decodes tasks in increasing order of their shortest duration.

List scheduling

Ranks tasks, then maps each to the resource that finishes it first.

Heterogeneous earliest finish time

Ranks tasks by upward rank, the mean duration plus the longest mean-communication path to the end, then places each on the mode that finishes it earliest, filling idle gaps.

  • Id: heft; implemented by Heft
  • Runs: deterministic, to completion
  • Parameters: none
  • Models: every feature
  • Sources: Topcuoglu et al. (2002)

Max-min

Repeatedly places, among the eligible tasks, the one whose earliest completion time over its modes is largest, in the mode that achieves it.

Min-min

Repeatedly places, among the eligible tasks, the one whose earliest completion time over its modes is smallest, in the mode that achieves it.

Sufferage

Maps tasks in passes where each resource goes to the claiming task that would lose the most, second-best minus best completion time, without its best mode.

Constructive

Builds a schedule step by step with look-ahead or insertion.

Keeps the best partial schedules, extends each by its highest-priority eligible items, and ranks the extensions by the score of their completion under the upward-rank rule.

Grows a tree of sequence prefixes by UCB1 selection and expansion of one eligible task per playout, completes each playout with random eligible tasks, and backs up rank-normalised rewards.

NEH insertion

Takes tasks, or whole jobs, in decreasing order of total work and inserts each at the position of the growing sequence whose partial schedule scores best.

  • Id: neh; implemented by Neh
  • Runs: deterministic, to completion
  • Parameters: none
  • Models: every feature
  • Sources: Nawaz et al. (1983)

Squeaky wheel optimization

Repeatedly decodes a priority sequence, blames each task for its cost beyond the least it could incur, and moves blamed tasks forward by distances that grow with their blame.

  • Id: squeaky-wheel-optimization; implemented by SqueakyWheel
  • Runs: stochastic, until a stop criterion
  • Parameters: step = 0.5, jitter = 1.0, restart_after = 50
  • Models: every feature
  • Sources: Joslin and Clements (1999)

Improves one solution through neighbourhood moves.

Adaptive large neighbourhood search

Removes and greedily reinserts groups of tasks with destroy and repair operators drawn by adaptive roulette weights, accepting results by simulated annealing.

  • Id: alns; implemented by Alns
  • Runs: stochastic, until a stop criterion
  • Parameters: min_removed = 1, max_removed = 4, segment = 100, reaction = 0.1, sigma1 = 33.0, sigma2 = 9.0, sigma3 = 13.0, start_worsening = 0.05, cooling = 0.99975, determinism = 6.0
  • Models: every feature
  • Sources: Ropke and Pisinger (2006); Shaw (1998)

GRASP

Builds schedules by drawing each next task from those whose earliest completion time is within a fraction of the best, then improves each by a first-improvement climb.

  • Id: grasp; implemented by Grasp
  • Runs: stochastic, until a stop criterion
  • Parameters: alpha = 0.3, max_failures = 100
  • Models: every feature
  • Sources: Feo and Resende (1995)

Great deluge

Accepts any random neighbour whose cost is below a water level that drops by a fixed amount at each accepted move.

  • Id: great-deluge; implemented by GreatDeluge
  • Runs: stochastic, until a stop criterion
  • Parameters: initial_margin = 1.0, rain_speed = 0.01
  • Models: every feature
  • Sources: Dueck (1993)

Descends on the objective plus penalties on solution features, items at positions and tasks in modes, and at each local optimum penalises the features whose cost over one plus their penalty is highest.

Hill climbing

Moves to each sampled insert, swap, or mode neighbour that improves the current solution and restarts from a random sequence after a run of non-improving samples.

Iterated greedy

Removes a few random tasks or jobs from the current sequence, reinserts each at its best position, and accepts the result at a constant temperature, starting from NEH.

Perturbs the current local optimum with a few random moves, climbs to a new local optimum by first improvement, and keeps it when it is no worse.

Late acceptance hill climbing

Accepts a random neighbour that is no worse than the current solution or than the current solution a fixed number of iterations earlier.

Mode-assignment tabu search

Moves each iteration to the best admissible mode vector that changes one task's mode, decoding a fixed priority list, with a tabu list of recently vacated modes, aspiration by objective, and frequency-based diversification.

Record-to-record travel

Accepts any random neighbour whose cost is below the best cost the walk has reached plus a fixed deviation.

  • Id: record-to-record-travel; implemented by RecordToRecordTravel
  • Runs: stochastic, until a stop criterion
  • Parameters: deviation = 0.2
  • Models: every feature
  • Sources: Dueck (1993)

Simulated annealing

Accepts a worse random neighbour with probability exp(-Δ/T), where T starts at a target acceptance rate of sampled worsening moves and cools geometrically.

Moves to the best of a sample of neighbours while forbidding, for a fixed tenure, moves that restore recently removed item positions or task modes, unless they beat the best solution found.

  • Id: tabu-search; implemented by TabuSearch
  • Runs: stochastic, until a stop criterion
  • Parameters: tenure = 7, candidates = 20
  • Models: every feature
  • Sources: Glover (1986); Glover (1989)

Threshold accepting

Accepts any random neighbour less than a threshold worse than the current solution and lowers the threshold geometrically.

  • Id: threshold-accepting; implemented by ThresholdAccepting
  • Runs: stochastic, until a stop criterion
  • Parameters: initial_threshold = 1.0, cooling = 0.95, epoch = None
  • Models: every feature
  • Sources: Dueck and Scheuer (1990)

Shakes the current local optimum by k random moves, climbs by first improvement, and moves on improvement with k reset to 1, otherwise tries the next larger k.

Population

Evolves a population of solutions through variation and selection.

MAX-MIN Ant System

Builds task sequences position by position from bounded pheromone trails on (task, position) pairs and a priority-rule desirability, and lets the best solution reinforce its trails.

Biased random-key genetic algorithm

Keeps the elite random-key chromosomes, adds random mutants, and fills the population with crossings of an elite and a non-elite parent that favour the elite parent's keys.

  • Id: brkga; implemented by Brkga
  • Runs: stochastic, until a stop criterion
  • Parameters: seeded = False, modes = 'keys', population_size = None, elite_fraction = 0.2, mutant_fraction = 0.15, inheritance = 0.7
  • Models: every feature
  • Sources: Gonçalves and Resende (2011); Bean (1994)

CMA-ES

Samples random-key vectors from a multivariate normal distribution, moves its mean to the weighted mean of the best samples, and adapts its step size and covariance matrix from evolution paths and the selected steps.

Differential evolution

Adds a scaled difference of two random members to a third, crosses the result with each member coordinate by coordinate, and keeps the trial when it is no worse, over random-key vectors.

Genetic algorithm

Evolves task sequences and mode settings by tournament selection, order crossover, uniform mode crossover, and insert, swap, or mode mutation, keeping the best members from one generation to the next.

L-SHADE

Evolves random-key vectors by current-to-pbest differential mutation with an archive, draws each trial's crossover rate and scale factor from a memory of successful values, and shrinks the population linearly over the budget.

Memetic algorithm

Evolves task sequences and mode settings like the genetic algorithm and improves every child by an insertion local search, so that the population holds local optima.

Keeps a reference set of good and mutually distant task sequences, combines pairs of them by averaging item positions, improves each combination by local search, and rebuilds the set from new diverse solutions when it stops changing.

  • Id: scatter-search; implemented by ScatterSearch
  • Runs: stochastic, until a stop criterion
  • Parameters: population_size = 20, reference_size = 8, quality_size = 4, max_failures = 50
  • Models: every feature
  • Sources: Glover (1998); Martí et al. (2006)

Univariate marginal distribution algorithm

Fits an independent normal distribution per random key to the best members and samples the next population from their product.

Swarm

Moves a population of real-valued priority vectors by update rules.

Arithmetic Optimization Algorithm

Resamples each vector component around the best vector by multiplying or dividing early and by adding or subtracting late, with a step that shrinks over the budget.

Artificial Bee Colony

Moves one random component of each vector towards or away from a random member, repeats this for members drawn in proportion to their quality, keeps only improvements, and restarts the vector that failed to improve longest.

Comprehensive learning particle swarm optimizer

Moves random-key vectors toward exemplars whose coordinates come from different particles' best positions, drawing new exemplars for a particle that stops improving.

  • Id: clpso; implemented by Clpso
  • Runs: stochastic, until a stop criterion
  • Parameters: seeded = False, modes = 'keys', population_size = 40, inertia_start = 0.9, inertia_end = 0.4, acceleration = 1.49445, refresh_gap = 7, velocity_limit = 0.2
  • Models: every feature
  • Sources: Liang et al. (2006); Bean (1994)

Perturbs each vector with Lévy steps scaled by its offset from the best vector, keeps every move that is not worse, and replaces a fixed fraction of the worst vectors with random ones.

Firefly Algorithm

Pulls each vector towards every better vector of the previous iteration with a strength that decays exponentially with the squared distance, adding uniform noise that shrinks geometrically.

  • Id: firefly-algorithm; implemented by FireflyAlgorithm
  • Runs: stochastic, until a stop criterion
  • Parameters: population_size = 20, rule = 'random-key', modes = 'keys', attraction = 1.0, attraction_decay = 1.0, noise = 0.25, noise_decay = 0.97
  • Models: every feature
  • Sources: Yang (2009); Yang (2014); Bean (1994)

Gravitational Search Algorithm

Accelerates each vector towards the members of highest quality, weighted by quality over distance, with a gain that decays exponentially, a number of attracting members that shrinks to one, and random momentum.

Grey Wolf Optimizer

Moves every vector to the mean of three random points drawn around the three best vectors found so far, with a spread that shrinks linearly to zero over the budget.

Harris Hawks Optimization

Moves each vector by a rule chosen with a random coefficient whose range shrinks over the budget: jumps relative to random members and the population mean while it is large, contractions towards the best vector and greedy trials with Lévy perturbations while it is small.

Jaya

Moves each vector towards the best and away from the worst member of the population by random amounts per component, keeping the move only if it improves the vector.

  • Id: jaya; implemented by Jaya
  • Runs: stochastic, until a stop criterion
  • Parameters: population_size = 20, rule = 'random-key', modes = 'keys'
  • Models: every feature
  • Sources: Rao (2016); Bean (1994)

Marine Predators Algorithm

Moves vectors relative to the best vector with Gaussian steps early, Lévy steps late and a mix of both in between, then applies masked random jumps or scaled member differences, keeping every change that is not worse.

Moth-Flame Optimization

Moves each vector along a logarithmic spiral around one of the best vectors found so far, sharing a number of those vectors that shrinks to one over the budget.

  • Id: moth-flame-optimization; implemented by MothFlameOptimization
  • Runs: stochastic, until a stop criterion
  • Parameters: population_size = 20, rule = 'random-key', modes = 'keys', spiral_shape = 1.0
  • Models: every feature
  • Sources: Mirjalili (2015); Bean (1994)

Particle swarm optimization

Moves random-key vectors with velocities that combine inertia, a pull toward each particle's best position, and a pull toward the swarm's best, with the inertia weight decreasing over the budget.

Salp Swarm Algorithm

Resamples the first vector of a chain around the best vector with a spread that shrinks over the budget, then moves every other vector halfway to the one ahead of it.

Sine Cosine Algorithm

Moves each vector component by a sine- or cosine-weighted random multiple of its distance to a random rescaling of the best vector, with an amplitude that shrinks linearly.

  • Id: sine-cosine-algorithm; implemented by SineCosineAlgorithm
  • Runs: stochastic, until a stop criterion
  • Parameters: population_size = 20, rule = 'random-key', modes = 'keys', amplitude = 2.0
  • Models: every feature
  • Sources: Mirjalili (2016); Bean (1994)

Teaching-Learning-Based Optimization

Moves each vector towards the best member and away from the population mean, then towards a better or away from a worse random member, keeping each move only if it improves the vector.

Whale Optimization Algorithm

Moves each vector by a shrinking random multiple of its distance to the best vector or to a random member, or along a logarithmic spiral around the best vector, choosing between the two by a fair coin.

Multi objective

Approximates the Pareto front of several objectives.

AGE-MOEA-II

Breeds task sequences and modes by binary tournaments on rank and survival score, fits the curvature of the first non-dominated front by Newton's method, and keeps members by their geodesic spread on the fitted surface and, in later fronts, by proximity to the ideal point.

IBEA

Breeds task sequences and modes by binary tournaments on fitness from the additive epsilon indicator between members, and removes the least fit member one at a time, updating the others' fitness, until the population fits.

MOEA/D

Decomposes the objectives into Tchebycheff subproblems along Das and Dennis weight vectors, each holding one schedule, and lets a child bred from a subproblem's neighbourhood replace every neighbour that it scalarises no worse.

NSGA-II

Breeds task sequences and modes by crowded binary tournaments, order crossover, and insert, swap, and mode mutation, then keeps the parents and children of lowest non-dominated rank and, in the last front, of largest crowding distance.

  • Id: nsga-ii; implemented by Nsga2
  • Runs: stochastic, until a stop criterion, multi-objective
  • Parameters: population_size = 40, crossover_rate = 0.9, mutation_rate = 0.2, mode_mutation = 1.0
  • Models: every feature
  • Sources: Deb et al. (2002); Davis (1985)

NSGA-III

Breeds task sequences and modes from random parents by order crossover and insert, swap, and mode mutation, then keeps whole non-dominated fronts and fills the last one by niching normalised objective vectors around Das and Dennis reference points.

RVEA

Breeds task sequences and modes from random parents and keeps, for each reference vector, the member of smallest angle-penalised distance, a penalty that shifts selection from convergence to spread as the budget is used, rescaling the vectors to the objectives' ranges at fixed budget fractions.

  • Id: rvea; implemented by Rvea
  • Runs: stochastic, until a stop criterion, multi-objective
  • Parameters: population_size = 40, crossover_rate = 0.9, mutation_rate = 0.2, mode_mutation = 1.0, alpha = 2.0, adaptation_frequency = 0.1
  • Models: every feature
  • Sources: Cheng et al. (2016); Das and Dennis (1998); Davis (1985)

SMS-EMOA

Breeds one child at a time from random parents by order crossover and insert, swap, and mode mutation, then removes the member of the last non-dominated front with the smallest exact hypervolume contribution, keeping the front's best member in each objective.

SPEA2

Breeds task sequences and modes by binary tournaments on strength fitness, the summed strengths of dominating members plus a nearest-neighbour density, and keeps an archive of the non-dominated members, truncated by distance to the nearest neighbours.

Exact

Proves optimality or infeasibility with a mathematical model.

CP-SAT interval model

States each task as optional intervals, one per mode with exactly one present, under no-overlap, cumulative, precedence, and circuit constraints, and proves optimality with the OR-Tools CP-SAT solver, which combines clause learning with linear relaxations.

Exhaustive enumeration

Decodes every precedence-feasible task order under every mode vector with the serial schedule builder, expanding each distinct partial schedule once, and returns the best schedule, which is optimal for regular objectives.

Time-indexed MILP

Formulates the problem as a 0-1 program with one binary per task, mode, and start period, capacity rows per resource and period, and precedence rows on start times, and solves it by branch and bound with CBC, HiGHS, Gurobi, or SCIP.

Matheuristic

Improves a solution by solving restricted subproblems exactly.

Frees the tasks that start in a random window of the incumbent schedule, keeps every other task's mode and resource order, solves the restricted problem exactly with the CP-SAT interval model, and keeps the result when it is no worse.

Learning

Learns a scheduling policy from experience gathered while solving.

Q-learning dispatching

Learns which of four dispatching rules should pick the next task in each coarse state of the construction by one-step Q-learning, bootstrapping from the best action value of the next state, and builds schedules with epsilon-greedy rule choices.

REINFORCE priority policy

Draws task orders from a softmax over linear priorities of five task features and moves the weights along the REINFORCE gradient of each order's log-probability, scaled by its schedule's reward minus the running mean reward.

SARSA dispatching

Learns which of four dispatching rules should pick the next task in each coarse state of the construction by SARSA, bootstrapping from the value of the rule chosen in the next state, and builds schedules with epsilon-greedy rule choices.

Hyper heuristic

Searches over heuristics rather than over schedules.

Genetic programming hyper-heuristic

Evolves priority-rule expression trees over task attributes by tournament selection, subtree crossover, and subtree mutation, evaluating only the bred rules that a nearest-neighbour surrogate over their decisions in sample situations ranks best, each by the list schedule it builds.

Selection hyper-heuristic

Applies the low-level heuristic with the highest reinforcement score, raised by one when it improves the current solution and lowered by one otherwise, and keeps its result by late acceptance.

Random sampling

Draws random solutions and keeps the best, as a baseline.

Decodes uniformly random precedence-feasible orders until the budget runs out and returns the best, the baseline any search must beat.

  • Id: random-search; implemented by RandomSearch
  • Runs: stochastic, until a stop criterion
  • Parameters: random_modes = False
  • Models: every feature
  • Sources: Kolisch (1996)