easylocal

Namespaces

Name
cli
config
cost
initialization
logging
rest
runners
solvers
testing
trace
tui

Types

Name	Description
App	A problem's components under a name: a SolutionManager recipe (with its cost), a neighborhood recipe and the runners and pipelines registered by name, which tools list, configure and run.
BoundApp	An app bound to an Input: the services built for it once (the SolutionManager, the app's neighborhood explorer, those of the runners that have their own) and the registrations, run by name on them.
BoundApp	An app bound to an Input: the services built for it once (the SolutionManager, the app's neighborhood explorer, those of the runners that have their own) and the registrations, run by name on them.
BoundRunner	A runner bound to an Input: the services built for it (a SolutionManager and a neighborhood explorer) and the algorithm, which run(solution, ...) runs on them, each run from a new copy of it.
BoundRunner	A runner bound to an Input: the services built for it (a SolutionManager and a neighborhood explorer) and the algorithm, which run(solution, ...) runs on them, each run from a new copy of it.
NeighborhoodUnionParameters	The parameters of a neighborhood union of Count children.
RunParameters	The limits of a run that a program reads with its configuration, for example under "run": --run.target=0, --run.timeout=10, --run.max_evaluations=5000.
Runner	A search algorithm with the recipes of the services it runs on: a SolutionManager (with its cost expression) and a neighborhood explorer.
Session	The state of an interactive session on an app, and the commands that change it: an owned Input, the app bound to it, a current solution, a selected move and an RNG.
TuningParameters	The parameters of a program for automatic configurators, under "tuning": --tuning.irace=DIR, --tuning.print=cost and --tuning.hard_weight.
app_check_composition	The composition of an app that check(app, input, solution) ran on: how many parts of each kind it composes.
app_check_report	The report of check(app, input, solution): the checks that passed and failed, and the composition they ran on.
best_so_far	The best solution of a run and its cost, for the algorithms that return the best solution they visited rather than the last one:
enumeration	The names of the values of an enumeration, which a specialization declares: a values of easylocal::enumerator, in the order a configurator sees them.
enumerator	One value of an enumeration and the name it takes in a configuration.
input_base	A base for a class built from the Input, which gives it input_type and input().
irace_stub	What write_irace_stub writes: the program, its parameters and the values to try.
irace_stub_result	The outcome of write_irace_stub: the files written and kept, and the errors.
limit	A count that may be unlimited.
named_run_result	The result of a runner chosen by name.
neighborhood_explorer_base	A base for an explorer, which gives it the associated types, the SolutionManager it is built from and input().
no_target	The target of run options without a target cost.
parameter	The value of one field of a parameter block: a Value named Name, which may not have been set.
parameter_not_set	Reading a parameter that nothing has set and that has no default.
parameters_base	A base for a class configured by a parameter block, which gives it parameters_type and parameters().
pareto_archive	The non-dominated solutions reached by a search with a cost::pareto cost: a solution enters unless an archived one is better or, by default, has an equivalent cost, and removes the archived solutions it is better than.
pareto_archive_parameters	The parameters of a pareto_archive: what it keeps of solutions of equivalent cost, and how many points.
pareto_point	A solution of a Pareto front, with its cost.
pareto_search_result	The result of a search with a cost::pareto cost: a search_result, a solution of the front with its cost and the effort, and the whole front (the non-dominated solutions reached, ordered by their objectives).
run_control	What the caller of a run controls while it runs: a std::stop_token that cancels it, an observer of its progress, and an observer of the best costs it finds.
run_effort	The effort of a run, with the fields of search_result: what a Session keeps of its last run.
run_options	Caller-side run options: optional cancellation/progress control, an optional semantic tracer and an optional target cost, passed as the trailing argument of Runner::run() and Solver::solve().
run_progress	The progress of a run, as reported to the observer of its run_control.
search_result	The result of a search: the solution it returns, its cost, the effort it took and why it ended.
search_run	One execution of a search algorithm.
shared_best_cost	The best cost of a run, shared with another thread: the run's observer of the best costs stores each one, a frontend loads a copy while the run goes on.
shared_run_progress	The progress of a run, shared with another thread: the run's observer stores it, a frontend loads a copy while the run goes on.
solution_manager_base	A base for a SolutionManager, which gives it the associated types, the Input it is built from and input().
tuning_range	The values worth trying for a parameter: a domain, narrower than the one its schema declares, given by a program for tuning, e.g. `{"runners.sa.temperature.initial_temperature", config::range(1.0, 1000.0).log()}`.
unlimited_t	The type of easylocal::unlimited: no limit for a count, and any value as the domain of a parameter.

Type Aliases

Name	Description
generator	A coroutine that yields values of type T, lazily, as an input range: std::generator<T>, which the standard library provides.
run_services_t	The services of a run of SM, which declares them.
tabu_attribute_t	The type of the tabu attribute of the moves of Explorer.

Enums

Name	Description
termination_reason	Why a search run ended.

Functions

Name	Description
app	Starts an app named name, without components: a SolutionManager recipe, a neighborhood recipe and runners are added to it with |.
check	Runs check(app, input, solution, options) from the SolutionManager's initial_solution(), binding the app once.
check	Runs the contract checks of easylocal::testing on the components of an app bound to input, from solution and from random solutions, with the options of the checks, and returns their report.
component	A cost component, a leaf of a cost expression, constructed from the Input and args (or from args alone).
cursor_moves	The moves of an explorer with the cursor of EasyLocal 3, as a lazy input range.
delta	The delta cost component co-located in Component, its delta_evaluate, bound to a neighborhood recipe with neighborhood<NHE>() | delta<C>().
delta	The delta cost component Delta of Component, constructed from the Input and args (or from args alone), bound to a neighborhood recipe with neighborhood<NHE>() | delta<C, D>(args...).
hash_combine	Folds the hash of value into the running hash seed, and returns the result.
hash_range	Folds the hash of every element of range, in order, into seed (0 by default), and returns the result.
inverse	Whether move, proposed at solution, is forbidden by tabu_move, applied earlier, as the explorer's inverse decides.
load_input	Reads an Input from a file, as read_input does from a stream.
load_solution	Reads a Solution of input from a file, as read_solution does from a stream.
make_runner	A runner for a parameterized algorithm, from its parameters: make_runner<FirstImprovement>({.max_evaluations = 1000}).
make_runner	A runner for any other algorithm, built from its arguments.
make_solver	Constructs a Solver from its arguments, e.g. make_solver<solvers::MultiStart>(runner, parameters).
max_evaluations	Run options with only an evaluation budget: easylocal::max_evaluations(10000).
moves	The moves of an explorer at solution, as an input range: its cursor, when it has one, else its moves().
neighborhood	The recipe of a NeighborhoodExplorer constructed from the SolutionManager and args.
neighborhood_union	The recipe of the union of two or more neighborhoods, whose move is a std::variant of theirs.
operator|	Registers a pipeline in the app: app | pipeline(name, ...).
operator|	Adds a SolutionManager recipe to the app: app | spec.
operator|	Adds the neighborhood recipe to the app: app | spec.
operator|	Registers a runner in the app: app | runner<Algorithm>(name, ...).
operator|	runner | nhe_recipe: the runner with its neighborhood recipe.
operator|	runner | sm_recipe: the runner with its SolutionManager recipe.
pipeline	A pipeline registration for an app, run by name from the current solution like a runner: `app("tsp") | sm | nhe | pipeline("cascade", stage<FirstImprovement>("descent") & until_feasible(), stage<SimulatedAnnealing<Classic>>("anneal", {...}))`.
pipeline	A pipeline registration for an app, of the stages of a pipeline already built: `pipeline("cascade", (stage("a", runner) & until_feasible()) | stage("b", runner))`.
print_report	Writes the checks of a report to out, then a line with the composition they ran on.
random_biases	The random biases of a neighborhood union, one per child, as in neighborhood_union(a, b) | random_biases(2, 1).
random_move	A move of an explorer drawn at solution with rng, by its random_move(); empty when it has none.
read_cost	A cost written as text, such as a target: by the problem's read_cost(input, text) when it has one, else as cost::from_text reads it.
read_input	Reads an Input from a stream with the first hook of readable_input.
read_solution	Reads a Solution of input from a stream with the first hook of readable_solution.
runner	A runner registration for an app, on the app's neighborhood: `app("tsp") | sm | nhe | runner<runners::FirstImprovement>("fi", {...})`.
runner	A runner registration for an app, on its own neighborhood: `runner<SA>("sa", {...}, neighborhood<Swap>() | delta<...>())`.
save_solution	Writes a Solution of input to a file, as write_solution does to a stream.
scalar_cost	A cost as one number, as automatic configurators compare runs: by the problem's scalar_cost(input, cost) when it has one, else as cost::scalar with hard_weight.
solution_hash	The hash of solution: the SolutionManager's hash(solution), or else the solution type's std::hash.
solution_manager	The recipe of a SolutionManager constructed from the Input and args.
solutions_equal	Whether lhs and rhs are the same solution: the SolutionManager's equal(lhs, rhs), or else lhs == rhs.
stop_at	Run options with only a target cost: run(solution, easylocal::stop_at(0)).
tabu_attribute	The attribute of move that frequency-based memory counts: the explorer's tabu_attribute(move), or else a copy of the move.
timeout	Run options with only a time limit in seconds: easylocal::timeout(2.5).
timeout	Run options with only a time limit: run(solution, easylocal::timeout(5s)).
to_string	A readable name of the reason, e.g. "evaluation budget exhausted".
with	Run options with a run_control: run(solution, with(control)).
with [deleted]	Deleted: the options would refer to a temporary run_control.
with	Run options with a tracer: run(solution, with(tracer)).
with	Run options with a run_control and a tracer.
with [deleted]	Deleted: the options would refer to a temporary run_control.
write_irace_stub	Writes the files of an irace scenario for a program to stub.directory, which it creates: parameters.txt (the parameters to tune and, commented out, the others with a range to start from), fixed.conf (the values every run starts from), target-runner (the script irace calls), scenario.txt, instances.txt and configurations.txt.

Variables

Name	Description
describe	The text of a value for people, with the first hook of describable: describe(value).
unlimited	No limit, what a default-constructed limit is, for a count; any value, as the domain of a parameter.
write_solution	Writes a Solution of input to a stream with the first hook of writable_solution: write_solution(input, solution, out).

Concepts

Name	Description
base_solution_manager	A SolutionManager: it declares input_type and solution_type, and has input() and is_valid(solution).
cursor_neighborhood_for	An explorer that enumerates its moves with the cursor of EasyLocal 3.
describable	A value with a text for people: a member value.describe(), a free describe(value) found by ADL, or operator<<, in this order; a std::variant of such values, and the move of a neighborhood union, are described by what they hold.
deterministic_neighborhood_for	An explorer that enumerates its moves, with the cursor or with moves().
enumerated	An enum whose values are named: an easylocal::enumeration declares them.
has_describe	A value with a describe hook of its own: a member value.describe(), or a free describe(value) found by ADL; operator<< does not count.
has_initial_solution	A SolutionManager with initial_solution(), which builds a solution without randomness.
has_random_solution	A SolutionManager with random_solution(rng), which draws a solution with the generator rng.
has_run_services	A SolutionManager that declares the services of a run: the state its cost components, delta cost components and explorers share while they search.
has_solution_equality	A SolutionManager whose solutions can be compared: its equal(lhs, rhs) member, or the solution type's ==.
has_solution_equality_member	A SolutionManager with an equal(lhs, rhs) member that compares solutions.
has_solution_hash	A SolutionManager whose solutions have a hash: its hash(solution) member, or the solution type's std::hash.
has_solution_hash_member	A SolutionManager with a hash(solution) member, the solution identity that algorithms and tools use to recognize a solution met before (reactive tabu search, search trajectories).
has_tabu_attribute	An explorer whose moves have a tabu attribute: its tabu_attribute(move) member, or the move itself when it has std::hash and ==.
has_tabu_attribute_member	An explorer with a tabu_attribute(move) member, the attribute of a move that frequency-based memory counts: a value with std::hash and ==.
inverse_neighborhood_for	An explorer with the inverse(solution, move, tabu_move) Tabu Search needs.
move_input_range_for	An input range whose elements construct a Move.
move_optional_for	A std::optional whose value constructs a Move.
native_moves_neighborhood_for	An explorer whose moves(solution) returns an input range of moves, such as a generator.
neighborhood_explorer_for	A NeighborhoodExplorer for the SolutionManager SM: it declares input_type, solution_type (those of SM) and move_type, and has input(), is_valid(solution, move) and make_move(solution, move).
random_neighborhood_for	An explorer that draws moves: random_move(solution, rng) returns a std::optional whose value constructs a move, empty when it has none.
readable_cost	Costs of a problem that can be read as text: by its read_cost, or because cost::from_text reads them.
readable_input	An Input that can be read from a stream: by a static Input::read(in), by a free read_input(std::type_identity<Input>, in) found by ADL, or by operator>> on a default-constructed Input, in this order.
readable_solution	A Solution that can be read from a stream, given its Input: by a static Solution::read(input, in), by a free read_solution(input, in) found by ADL, or by operator>> on Solution{input}, in this order.
scalar_cost_available	Costs of a problem that can be turned into one number: by its scalar_cost(input, cost), or because cost::scalar converts them.
search_result_for	What solvers, runs by name (app.run) and the adapters read of a result: the final solution and its cost.
std_hashable	A type that std::hash can hash.
writable_solution	A Solution that can be written to a stream, given its Input: by a member solution.write(input, out), by a free write_solution(input, solution, out) found by ADL, or by operator<<, in this order.