EasyLocalAPI reference iolab-uniud/easylocal

Global namespace

Namespaces

Name
easylocal

easylocal namespace

Namespaces

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

Types

NameDescription
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

NameDescription
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

NameDescription
termination_reason Why a search run ended.

Functions

NameDescription
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

NameDescription
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

NameDescription
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.

easylocal::cli namespace

Types

NameDescription
CommandLineParameters The parameters of the command line of cli::run: --instance, --seed, --runner, --start, --solution, --output, --target, --timeout, --max_evaluations, --report and --trace.
options What cli::run adds to the command line and where it writes.

Functions

NameDescription
run Runs application as a program, from the command line to the solution.

easylocal::config namespace

Types

NameDescription
binary_expression An operator applied to two expressions.
choice_domain A set of values, as the domain of a text or numeric field.
cli_diagnostic An error of the command line, with the argument that caused it.
cli_parse_result What parse_cli read: the help request, the configuration file, the overrides and the errors.
config_file_diagnostic An error of a configuration file, with the line that caused it.
config_file_parse_result The overrides of a configuration file, and its errors.
constant_expression A constant in an expression: a number, a bool or a text.
domain_info A domain at run time, whatever its type: what a parameter_set lists and a configurator exporter reads.
expression_info An expression at run time, whatever its type: what a parameter_set lists and a configurator exporter writes.
fixed_string A string literal as a template argument: the name of a field or of a group.
no_condition No condition: a field that always matters.
no_domain No domain: a field may take any value of its type.
override_diagnostic An error of an override, with its path and value.
override_result What parameter_set::apply() did: the number of blocks it changed, and the errors.
owned_text_override An override path = value that owns its text.
parameter_diagnostic A block whose validate() fails, with the reason.
parameter_field The descriptor of a field of a parameter block: its name, its member, its description, its domain and its condition, made with field().
parameter_group A member that is itself a parameter block, nested in the schema: its fields are under "Name.", and check_schema of the enclosing block runs its validate(), as in group<"temperature", &Parameters::temperature>("Temperature schedule").
parameter_info One parameter of a set: its full path, its description, whether anything has set it, its value as text (format_value), whether it can be changed, the kind of its value, its domain, and when it matters.
parameter_requirement A requirement between the fields of a block, in its schema: an expression that must hold, and the reason given when it does not.
parameter_set The parameters of one or more objects, as paths and textual values: what the command line, configuration files, TOML, the TextUI and REST read and change.
parameter_validation_result The blocks of a set whose validate() fails.
range_domain A range of numbers, closed unless open(), open_low() or open_high() says otherwise, and sampled on a logarithmic scale by a configurator after log(); its upper bound may be unlimited.
requirement_info A requirement between the parameters of a block: the path of the block, why the block is not valid when it does not hold, the expression with full paths, and whether it holds with the current values.
setup_diagnostic An error of load_and_apply, from any of its steps.
setup_result What load_and_apply did: whether help was requested, and the errors.
text_override An override path = value, as views of a text owned elsewhere.
unary_expression An operator applied to an expression.
unbounded_domain Any value: the domain of a field whose values are all valid, such as a seed, free text or a number that may be negative.
validation_result Whether a parameter block is valid, and why not.
value_reference A parameter of the block an expression belongs to, by its path relative to the block: value<"cooling_rate">, or value<"temperature.cooling_rate"> for a field of a nested group.

Type Aliases

NameDescription
config_file_reader How a program reads the file given with --config: load_config_file, or load_toml_file of the TOML adapter, or a reader of another format that gives the overrides of the file and its errors.

Enums

NameDescription
cli_error An error of the command line.
config_file_error An error of a configuration file.
expression_operator The operators of expressions.
override_error An error of an override.
parameter_kind The kind of a parameter's value, as a configurator types it.
setup_diagnostic_source The step of load_and_apply an error comes from.

Functions

NameDescription
add_configuration The parameters of value under prefix, if it has any: those its configuration() gives, with paths relative to it.
check_schema Whether a block meets its schema, and the first reason it does not: each field that matters is set and lies in its domain, each requirement holds, and then each nested group is valid.
cli_help The help text of a program: its usage, the options --help and --config, and every parameter of the set that can be changed, with its description, the values it may take, when it matters, and its current value or that it is required.
describe_domain The run-time description of a domain.
describe_expression The run-time description of an expression, with its references under prefix, the path of the block it belongs to.
domain_contains Whether value lies in domain; for an array or a vector, whether each element does.
evaluate The value of an expression on a block: its value_references are the block's fields.
evaluate_with The value of an expression, with read(reference) giving the value of each value_reference.
field The descriptor of a field that takes any value of its type, e.g. field<&P::seed>("Seed", easylocal::unlimited): a seed, free text, a number that may be negative.
field The descriptor of a field of a parameter block, e.g. field<&MyParameters::size>("Description"), with the values it may take as the second argument: field<&P::cooling_rate>("...", range(0.0, 1.0).open()).
fields The schema of a parameter block, as parameter_schema() returns it: its field and group descriptors, and the requirements between its fields.
for_each_parameter Calls function(descriptor, parameter) on each field of a block, without its nested groups; the parameter is const when the block is.
format_value A parameter value as text, in the syntax overrides are read in: true/false, numbers, "unlimited" for an unlimited limit, [a, b]for arrays and vectors, a path in UTF-8, the name of a value of an enumeration.
group The descriptor of a member that is itself a parameter block (a parameter_group).
is_active Whether a field matters for the block, by the condition of its descriptor.
kind_of The kind of a value of type Value.
load_and_apply Applies to the parameters the overrides of an optional --config file and then those of the command line, which take precedence.
load_config_file Reads the overrides of a configuration file, as parse_config_text does.
load_toml_file The overrides of a TOML file, with its errors, as parse_toml_text reads them: a config_file_reader.
one_of The values given, as the domain of a field: `config::one_of("tabu", "random") for text, config::one_of(10, 100, 1000)` for numbers, config::one_of(Start::random, Start::initial) for some of the values of an enumeration (a field takes all of them without a domain).
operator&& left && right, when one of them is an expression.
operator* left * right, when one of them is an expression.
operator+ left + right, when one of them is an expression.
operator- -operand.
operator- left - right, when one of them is an expression.
operator/ left / right, when one of them is an expression.
operator_symbol The symbol of an operator, the same in C++ and in R.
operator|| left || right, when one of them is an expression.
overlay_overrides The overrides of lower_precedence whose path higher_precedence does not set, followed by all those of higher_precedence.
override_views Views of owned overrides, as parameter_set::apply() takes them; they refer to the strings of overrides.
parse_cli Reads the help request, the configuration file and the overrides of the arguments of a program, without its name.
parse_cli Reads the help request, the configuration file and the overrides of argv, skipping the program name.
parse_config_text Reads the overrides path = value of a configuration text, one per line.
parse_toml_text The overrides of a TOML document given as text, with its errors.
print_diagnostics Writes each error of a configuration file to output, as for a setup: one per line, after error: , with its line and column.
print_diagnostics Writes each error of a setup to output, one per line, after error: .
range The numbers from low up, with no upper bound: `config::range(0.0, easylocal::unlimited).open_low()` is the positive numbers, infinity included, range(1, unlimited) a count of at least one, or unlimited for a limit; .open_high() leaves out infinity (and unlimited, for a limit).
range The numbers from low to high, bounds included, as the domain of a numeric field: config::range(0.0, 1.0).open() is (0, 1).
require A requirement between the fields of a block, in its schema, e.g. `require(value<"final_temperature"> < value<"initial_temperature">, "final_temperature must be smaller than initial_temperature")`: the validation of the parameters checks it, and a configurator never proposes values that break it.
require_valid Throws std::invalid_argument unless every block of the set is valid; the message gives each invalid block as "<path>: <message>".
require_valid Returns block when it is valid, with its nested groups; throws std::invalid_argument otherwise, with the reason, the path of a field or group first ("temperature.cooling_rate: ...").
undeclared_domains The paths of the parameters of a set that declare no domain, but the booleans, whose domain is true and false: each should declare a range, one_of, or easylocal::unlimited for any value.
operator! !operand.
operator== left == right, when one of them is an expression.
operator!= left != right, when one of them is an expression.
operator< left < right, when one of them is an expression.
operator<= left <= right, when one of them is an expression.
operator> left > right, when one of them is an expression.
operator>= left >= right, when one of them is an expression.

Variables

NameDescription
is_domain_v Whether a type is a domain: no_domain, unbounded_domain, a range_domain or a choice_domain.
is_domain_v A range_domain is one.
is_domain_v A choice_domain is one.
is_expression_v Whether a type is an expression: a value_reference, a constant or an operator applied to expressions.
is_expression_v A constant is one.
is_expression_v A value_reference is one.
is_expression_v An operator on an expression is one.
is_expression_v An operator on two expressions is one.
is_parameter_field_v Whether a descriptor is a field: neither a group nor a requirement.
is_parameter_group_v Whether a descriptor is a parameter_group.
is_parameter_group_v A parameter_group is one.
is_parameter_requirement_v Whether a descriptor is a parameter_requirement.
is_parameter_requirement_v A parameter_requirement is one.
value The parameter at Path, relative to the block, in an expression: value<"final_temperature"> < value<"initial_temperature">.

Concepts

NameDescription
domain_for Whether a domain can be declared for a field of type Value: a range for a number or a limit, a set of text values for text, a set of numbers for a number; for an array or a vector, the domain of its elements.
expression An expression, as only_if and require take it.
parameter_block A struct of parameters: its static parameter_schema() describes its fields, its validate() checks them and returns a validation_result.

easylocal::cost namespace

Types

NameDescription
apply_expression The node of cost::apply: a user function of its children's costs.
approximately_expression The node of cost::approximately: the cost of its child, compared within a tolerance.
hard_soft_expression The node of cost::hard_soft: a cost::hierarchical of a hard and a soft cost.
hierarchical A hierarchical cost: the hard cost has strict priority, the soft cost is compared only when the hard costs are equivalent (neither is less).
in_order_expression The node of cost::in_order: a cost::lexicographic of its children's costs.
is_expression Whether T is a node of a cost expression (sum, in_order, objectives, hard_soft, apply or approximately).
lexicographic A lexicographic cost: its values are compared in the order given, a later one only when the earlier ones are equal.
objectives_expression The node of cost::objectives: a cost::pareto of its children's costs.
pareto A multi-objective cost, every objective minimized, ordered by Pareto dominance.
sum_expression The node of cost::sum: the weighted sum of the costs of its terms.
tolerance The tolerance of an approximate comparison of costs; called on two values, whether they are approximately equal (see approximately_equal).
weighted_term A term of a cost::sum: an expression and its weight.
zero_cost The zero of a cost type: no violation, no penalty.

Functions

NameDescription
apply The value of function called with the children's costs.
apply The value of a Function built from parameters, called with the children's costs: cost::apply<Excess>({.bound = 8.0}, component<C>()).
approximate_compare The order of two costs, with floating-point values that are equal within within taken as equivalent.
approximately The cost of child, which the search compares within within: costs equal within it are equivalent, and a cost is better only by more than it (see cost::approximate_compare).
approximately_equal Whether two values are equal within within: numbers when either is floating point (integers exactly), lexicographic, hierarchical and pareto costs level by level, other values with ==.
better Whether candidate is better than reference.
better_or_equivalent Whether candidate is better than or equivalent to reference.
delta The numeric difference candidate - current of two arithmetic costs.
delta Hard-preserving numeric delta: minus infinity when the hard cost improves, infinity when it worsens, the soft delta otherwise.
equivalent Whether lhs and rhs are equivalent costs.
from_text The cost written by text: throws std::invalid_argument, with the reason, when the text does not describe a value of the type.
hard_soft A cost::hierarchical of the costs of hard and soft.
in_order A cost::lexicographic of the children's costs, compared in the order given.
objectives A cost::pareto of the costs of two or more children, compared by Pareto dominance.
operator* child * weight is cost::weighted(child, weight).
operator* weight * child is cost::weighted(child, weight).
operator- delta(candidate, current), when the soft cost has a delta.
scalar The cost as one number: a number as it is, a hierarchical cost as hard * weight + soft, a lexicographic cost of n values as the sum of each value times weight to the power of the number of values after it.
sum The weighted sum of the costs of its terms, which must be arithmetic.
to_text A cost in the text from_text reads back: numbers in their shortest exact form, [hard, soft]and [v1, v2, ...]for structured costs.
weighted The term child of a cost::sum with weight weight.
zero The zero of a cost type, zero_cost<Cost>::value(): no violation, no penalty.
operator== Whether every objective is equal.
operator== Whether the hard and the soft costs are equal.
operator<=> less: lhs dominates rhs; greater: rhs dominates lhs; equivalent: equal in every objective; unordered otherwise.
operator<=> The order of the costs: by the hard costs, then by the soft costs; each branch compares with its <=>, or else with its <.

Variables

NameDescription
is_expression_v Whether T, without cv and reference qualifiers, is a node of a cost expression.

Concepts

NameDescription
approximately_comparable A cost that approximate_compare orders: a number, a lexicographic, hierarchical or pareto cost of such costs, or a type with <=> or <.
approximately_equality_comparable Values that approximately_equal compares: two numbers, two lexicographic, hierarchical or pareto costs of the same type, or values with ==.
arithmetic An arithmetic cost: a signed integral or floating-point type other than bool.
has_better A SolutionManager whose costs have a better relation: defined by the compare of the root of its cost expression, or the cost type's <.
has_better_or_equivalent A SolutionManager whose costs have a better_or_equivalent relation: defined by the compare of the root of its cost expression, or the cost type's <=.
has_delta A cost type with a numeric difference: delta(candidate, current), convertible to long double.
has_equivalent A SolutionManager whose costs have an equivalent relation: defined by the compare of the root of its cost expression, or the cost type's ==.
has_zero A cost type with a zero: zero_cost<Cost> has a static value().
hierarchical_cost A cost::hierarchical, possibly cv- or reference-qualified.
lexicographic_cost A cost::lexicographic, possibly cv- or reference-qualified.
pareto_cost A cost::pareto, possibly cv- or reference-qualified.
scalar_convertible Costs that cost::scalar turns into one number: numbers, and hierarchical and lexicographic costs of them.
text_readable Costs that from_text reads: arithmetic ones, and hierarchical, lexicographic and pareto costs of them.

easylocal::initialization namespace

Types

NameDescription
Automatic The tag of the default initialization: random when the SolutionManager builds random solutions, else its initial solution.
Initial The tag of the initial solution, from initial_solution().
Random The tag of a random initial solution, from random_solution(rng).

Variables

NameDescription
automatic Starts from a random solution when the SolutionManager builds one, else from its initial solution: the default of every solver.
initial Starts from the SolutionManager's initial_solution().
random Starts from the SolutionManager's random_solution(rng), with the solver's RNG.

easylocal::logging namespace

Types

NameDescription
record A log record, as a sink receives it.

Type Aliases

NameDescription
sink A sink is invoked synchronously.

Enums

NameDescription
level The severity of a log record, from the lowest.
origin Who emits a log record.

Functions

NameDescription
current_sink The active sink, or a null pointer when dispatch is disabled.
emit Sends a record to the active sink, if any; its location defaults to the call site.
level_name The name of a level, e.g. "warning".
set_sink Replaces the active sink, and returns the previous one; nullptr disables dispatch.
stderr_sink The default sink: writes warnings and errors to stderr, as EasyLocal <level>: <message>, one write per record, and ignores the other records.

easylocal::rest namespace

Types

NameDescription
app_blueprint A Crow blueprint that serves an app over HTTP, with its runs executed by a pool of worker threads.
blueprint_options The options of an app_blueprint: its execution pool, its run history and the bound on the time of a run.
execution_pool A fixed set of worker threads that run tasks taken from a bounded queue.
text_codec The codec of an app served through the problem's text hooks alone: it has no member, so the Input and the solutions are JSON strings in the text of read_input, read_solution and write_solution, and the costs JSON numbers or the text of cost::to_text.

Functions

NameDescription
blueprint The app_blueprint that serves the app under the prefix through the problem's text hooks, without a codec (text_codec).
blueprint The app_blueprint that serves the app with the codec under the prefix.
default_worker_count The default number of worker threads: one less than the hardware threads, and at least 1.

easylocal::runners namespace

Namespaces

NameDescription
aspiration
candidates
needs The capabilities an algorithm asks of the services it searches with.
tabu
temperature

Types

NameDescription
AspirationPlusTabuSearch Tabu Search with Glover's aspiration plus candidate strategy: each scan examines admissible moves until plus more after the first one whose cost is under the aspiration level, but at least min_moves and at most max_moves of them, and applies the best of those examined (the group candidates, candidates::AspirationPlusParameters).
BestImprovement Best Improvement (steepest descent): at each iteration the best move of the whole neighborhood is applied, while it strictly improves the cost.
BestImprovementParameters The parameters of BestImprovement.
EliteCandidateTabuSearch Tabu Search with Glover's elite candidate list: a full scan applies the best admissible move and keeps the elite_size best other admissible moves; the following iterations evaluate only the kept moves still valid, and apply the best admissible one while its cost is not above the quality level (the group candidates, candidates::EliteListParameters).
FirstImprovement First Improvement: at each iteration the moves of the neighborhood are scanned in order and the first one that strictly improves the cost is applied.
FirstImprovementParameters The parameters of FirstImprovement.
FirstImprovementTabuSearch Tabu Search stopping the scan at the first admissible move that improves the current cost or, with improve_on_best (the group candidates, candidates::FirstImprovementParameters), the best cost; without one, the best admissible move of the whole neighborhood is applied, as in TabuSearch.
GreatDeluge Great Deluge (Dueck): a random move is accepted if it improves the current cost or if its cost does not exceed the water level.
GreatDelugeParameters The parameters of GreatDeluge.
HillClimbing Hill Climbing: at each iteration a random move is proposed and accepted if it does not worsen the current cost, so the search can drift across plateaus.
HillClimbingParameters The parameters of HillClimbing.
LateAcceptanceHillClimbing Late Acceptance Hill Climbing (Burke and Bykov): a random move is accepted if its cost is better than or equivalent to the current cost, or to the cost the current solution had history_length iterations earlier.
LateAcceptanceHillClimbingParameters The parameters of LateAcceptanceHillClimbing.
MetropolisAcceptance The Metropolis criterion: a move that does not worsen the cost is accepted, a worsening one with probability exp(-delta / temperature).
ParetoLateAcceptanceHillClimbing Pareto Late Acceptance Hill Climbing (Da Ros and Di Gaspero), for a cost::pareto cost: a history of solutions, the initial one and history_length - 1 random ones, is visited in a circle.
ParetoLateAcceptanceHillClimbingParameters The parameters of ParetoLateAcceptanceHillClimbing.
SimulatedAnnealing Simulated Annealing: at each iteration a random move is proposed and accepted by the acceptance policy at the temperature of the schedule (by default, the Metropolis criterion on the classic geometric schedule).
SimulatedAnnealingParameters The parameters of Simulated Annealing: its temperature policy's, as the group "temperature" (paths temperature.*), and its evaluation budget.
TabuSearch Tabu Search exploring the whole neighborhood: the best admissible move is applied, ties broken uniformly at random.
TabuSearchParameters The parameters of the tabu searches: the limits of the run, those of the tabu list as the group tabu_list and those of the candidate strategy as the group candidates.
requirements The capabilities an algorithm asks of the services it searches with.
tabu_candidate A candidate move, as a tabu list sees it: forbidden_by(tabu_move), whether a move the list holds forbids it (the neighborhood's inverse), its attribute() when the neighborhood has one, and, WithCost, its cost() and equivalent_cost(other), for the lists whose state declares needs_cost = true.
tabu_step What a tabu list learns after each iteration: the move applied, the solution and its cost after it, the iteration (counted from 1), whether the move improved the best cost, the move's attribute() and the solution_hash() when the problem has them.

Concepts

NameDescription
acceptance_policy_for An acceptance criterion of Simulated Annealing: accept(candidate, current, temperature, rng) tells whether a move of cost candidate is accepted from a solution of cost current at temperature, drawing from rng if it needs to.
aspiration_for An aspiration criterion of Tabu Search: overrides(run, candidate, best) tells whether a tabu move of cost candidate is admitted, when the best cost found is best; needs_cost tells whether the search must evaluate the tabu moves for it (false: never admitted, as aspiration::None).
calibrating_temperature_policy A temperature policy that can estimate its initial temperature: before the run Simulated Annealing evaluates calibration_samples() random moves at the initial solution, without applying them, and passes their deltas to calibrate(), then calls reset().
tabu_list_for A tabu list policy: a value holding its parameters, from which each run makes the list's state with make_state<Run>().
temperature_policy A temperature schedule of Simulated Annealing.

easylocal::runners::aspiration namespace

Types

NameDescription
ByObjective A tabu move is admitted when it would improve the best cost found.
None Tabu moves are never admitted, and need not be evaluated.

easylocal::runners::candidates namespace

Types

NameDescription
AspirationPlusParameters The parameters of Glover's aspiration plus candidate strategy, the scan of AspirationPlusTabuSearch.
EliteListParameters The parameters of Glover's elite candidate list, the scan of EliteCandidateTabuSearch.
FirstImprovementParameters The parameters of the scan of FirstImprovementTabuSearch.
FullParameters The parameters of the full scan of TabuSearch: none.

easylocal::runners::needs namespace

The capabilities an algorithm asks of the services it searches with.

Types

NameDescription
enumerated_moves The neighborhood explorer enumerates the moves of a solution.
non_worsening The cost tells whether a cost is better than or equivalent to another.
random_moves The neighborhood explorer draws a random move of a solution.
random_solutions The SolutionManager builds a random solution.
strict_improvement The cost tells whether a cost is better than another.

easylocal::runners::tabu namespace

Types

NameDescription
Cyclic TS3 (Taillard): the tenure of the moves changes every period iterations, taking the given tenures in turn.
CyclicParameters The parameters of the Cyclic tabu list.
FixedLength TS1: a list of the last tenure moves, overwritten in a circle: each move stays tabu for tenure iterations.
FixedLengthParameters The parameters of the FixedLength tabu list.
Foo FOO, the Fluctuation Of the Objective scheme of Blöchliger and Zufferey's reactive tabu search for graph coloring: a tenure that grows by increment when the costs reached in the last window spread less than fluctuation (the search is stuck), and shrinks by one otherwise.
FooParameters The parameters of the Foo (Fluctuation Of the Objective) tabu list.
Frequency TS5, frequency-based long-term memory (Glover and Laguna's transition measure): a move is tabu while the attribute of its moves (tabu_attribute) has been applied in more than threshold of the iterations so far.
FrequencyParameters The parameters of the Frequency tabu list.
LimDynamic LimDynamic, a limited dynamic tenure: it grows by one at each iteration after idle_threshold iterations without improving the best cost, and falls back to min_tenure when the best improves or the tenure reaches max_tenure.
LimDynamicParameters The parameters of the LimDynamic (limited dynamic tenure) tabu list.
ObjectiveBased Tabu on cost values (Gendreau and Potvin): a move is tabu when it would reach a cost equivalent to one reached in the last tenure iterations, by the semantics of the cost (equivalent()).
ObjectiveBasedParameters The parameters of the ObjectiveBased tabu list.
RandomFoo RandomFoo, a randomized Fluctuation Of the Objective: Foo with its window, increment and fluctuation drawn uniformly in their ranges at the start and again at the end of each window.
RandomFooParameters The parameters of the RandomFoo (randomized Fluctuation Of the Objective) tabu list.
RandomTenure TS2 (Gendreau, Hertz and Laporte): each move stays tabu for a tenure drawn uniformly in [min_tenure, max_tenure].
RandomTenureParameters The parameters of the RandomTenure tabu list.
Reactive TS4, Reactive Tabu Search (Battiti and Tecchiolli): the tenure starts at 1 and reacts to the solutions visited, recognized by their hash.
ReactiveParameters The parameters of the Reactive tabu list.

easylocal::runners::temperature namespace

Types

NameDescription
BasicTimeBased The cooling schedule spread over a running time instead of an iteration budget: the allowed time is divided evenly among the temperature levels, and the temperature cools when the time of its level is over or, with accepted_per_temperature, after that many acceptances; the time an early cooling saves is redistributed over the remaining levels.
Classic The classic geometric schedule: samples_per_temperature proposals at each temperature, which is then multiplied by cooling_rate.
ClassicParameters The parameters of the Classic schedule.
Cutoff A schedule with a budget of allowed_iterations proposals that cools on acceptances only: after accepted_ratio times a level's share of the budget (allowed_iterations over the temperature levels) has been accepted.
CutoffParameters The parameters of the Cutoff and Hybrid schedules.
FixedLength A geometric schedule with a budget of allowed_iterations proposals, spread evenly over the temperature levels from initial_temperature to final_temperature.
FixedLengthParameters The parameters of the FixedLength schedule.
FixedTemperature A constant temperature: the search ends after allowed_iterations proposals, or earlier once max_accepted of them have been accepted.
FixedTemperatureParameters The parameters of the FixedTemperature schedule.
Hybrid The schedule of EasyLocal 3: a level ends after its share of allowed_iterations proposals or, earlier, after accepted_ratio of them have been accepted; the proposals an early cooling saves are spread over the remaining levels.
Reheating Reheats any schedule with an initial temperature: a first descent, then up to allowed_reheats descents restarting from reheat_ratio times the initial temperature.
ReheatingParameters The parameters of Reheating: those of its schedule, as the group descent, and of the reheats.
TimeBasedParameters The parameters of the TimeBased schedule.

Type Aliases

NameDescription
HybridParameters The parameters of the Hybrid schedule, those of Cutoff.
TimeBased The TimeBased schedule, timed by std::chrono::steady_clock.

easylocal::solvers namespace

Types

NameDescription
LocalSearch The simplest Solver: binds one Runner to an Input, builds an initial solution, then runs the search once and returns its result.
MultiStart Repeatedly initializes and runs the same bound Runner, and returns the best result according to the bound runner's cost semantics.
MultiStartParameters The parameters of MultiStart.
Pipeline Runners in sequence over the same Input and Solution: each stage starts from the solution of the previous one, the first from an initial solution.
StageParameters The parameters of a pipeline stage.
algorithm_stage A stage of a pipeline registered in an app, which runs Algorithm on the app's recipes: its SolutionManager, with the app's cost, and the app's neighborhood or its own.
algorithm_stage A stage of a pipeline registered in an app, which runs Algorithm on the app's recipes: its SolutionManager, with the app's cost, and the app's neighborhood or its own.
pipeline_result The result of a pipeline: the last stage's result, with the effort of every stage, and what each stage did.
pipeline_stage A stage of a pipeline: a named runner, with an optional target cost, a number of attempts, and an optional time limit and evaluation budget.
stage_attempts A stage modifier: up to count runs while the stage does not reach its target.
stage_report What one stage of a pipeline did.
stage_restart A stage modifier: the attempts after the first start from a new solution.
stage_target A stage modifier: the stage stops as soon as its best cost reaches cost.
stage_until_feasible A stage modifier: the stage runs on the hard cost until it is zero.

Functions

NameDescription
attempts The stage runs up to count times while it does not reach its target, and keeps its best run: stage(...) & attempts(10), as with_attempts(10).
operator& The stage on the hard cost until it is zero: stage.until_feasible().
operator& The stage with a number of attempts: stage.with_attempts(attempts.count).
operator& The stage with a time limit or an evaluation budget: stage & timeout(10s), as stage.with_timeout(10s), and stage & max_evaluations(5000), as stage.with_max_evaluations(5000).
operator& The stage with a target: stage.with_target(target.cost).
operator& The stage whose attempts after the first start from a new solution: stage.with_restart(restart.initialization).
operator& The algorithm stage with a number of attempts, as a stage of a runner.
operator& The algorithm stage with a time limit or an evaluation budget, as a stage of a runner: stage("a") & timeout(10s).
operator& The algorithm stage with a target, until_feasible() or a restart, applied when the stage is built on the app's recipes, in the order they are given.
operator| The pipeline of two stages: pipeline(first, second).
operator| The pipeline with one more stage: pipeline.then(stage).
pipeline A pipeline of stages, in order: pipeline(a, b, c) is a | b | c, and pipeline(a) the pipeline of one stage, which then() extends.
restart The attempts of the stage after the first start from a new solution built as initialization says, rather than from the solution the stage received: stage(...) & attempts(10) & restart(initialization::random), as with_restart(initialization::random).
stage The stage name of a pipeline, running runner.
stage The stage name of a pipeline registered in an app, running Algorithm with parameters on the app's recipes: stage<FirstImprovement>("descent").
stage The stage name of a pipeline registered in an app, running Algorithm with parameters on its own neighborhood, built from the recipe neighborhood over the app's SolutionManager: `stage<SA>("anneal", {...}, neighborhood<Swap>())`.
target The stage stops as soon as its best cost reaches cost, written in the stage's own cost: stage(...) & target(0), as with_target(0).
two_stage A pipeline of two stages for hierarchical costs with the same runner: on the hard cost until it reaches zero, then on the whole cost.
two_stage A pipeline of two stages for hierarchical costs: first on the hard cost until it reaches zero, then second on the whole cost from its solution.
until_feasible The stage runs on the hard cost only, until it is zero: stage(...) & until_feasible(), as .until_feasible().

Using Declarations

NameDescription
max_evaluations The evaluation budget of a run, max_evaluations(n), here for a stage: stage & max_evaluations(5000).
timeout The time limit of a run, timeout(10s) or timeout(2.5) seconds, here for a stage: stage & timeout(10s).

easylocal::testing namespace

Types

NameDescription
check_failure A failed check: its name and what went wrong.
check_options The options of the contract checks: how many moves and solutions they try, the seed of their random draws and the tolerance of their comparisons.
check_report The outcome of the checks on a subject: how many ran and which failed.
deterministic_rng A random bit generator that cycles through a fixed list of values, for unit tests that script the random draws.
fixture The data every component check runs on: an Input, a valid Solution and the SolutionManager built on the Input.

Type Aliases

NameDescription
approximately The comparison of the checks: values equal within a relative and an absolute tolerance, approximately{.relative = 1e-6, .absolute = 1e-9} (see cost::tolerance).

Functions

NameDescription
check_cost_component The same, with the component built from the fixture Input.
check_cost_component A cost component evaluates the fixture Solution, and evaluating it twice gives equivalent values; an exception of evaluate() is a failure.
check_delta_cost_component The same, with every object built from the fixture; omit Delta for a co-located delta.
check_delta_cost_component Checks the component's own delta_evaluate (co-located): for the valid moves of the fixture Solution and of the random solutions of the options, value + delta equals the component's value after the move.
check_delta_cost_component Checks a separate delta cost component: for the valid moves of the fixture Solution and of the random solutions of the options (enumerated, or sampled when the neighborhood cannot enumerate), value + delta equals the component's value after the move.
check_neighborhood The same, with the NeighborhoodExplorer built on the fixture's SolutionManager.
check_neighborhood Enumerated and sampled moves of the fixture Solution and of random solutions are valid, and applying them keeps the Solution valid.
check_solution_manager The fixture's SolutionManager: bound to the fixture Input, and the fixture, initial and random solutions are valid.
print_report Prints report to out: the number of checks passed, or the failures grouped by check, in the order of their first failure, each with its count and the messages of its first three.
run_checks Prints the reports to std::cerr and returns EXIT_SUCCESS when all passed, EXIT_FAILURE otherwise.
run_checks Prints the reports to out, separated by blank lines, and returns EXIT_SUCCESS when all passed, EXIT_FAILURE otherwise.

Concepts

NameDescription
check_fixture A testing::fixture, whatever its SolutionManager and comparison.
printable_report A report of checks: a check_report, or the report of check(app) (an app_check_report), which print_report() writes and passed() sums up.

easylocal::trace namespace

Namespaces

Name
event

Types

NameDescription
async_binary_recorder A tracer that writes the events as an ELTR binary stream from a background writer thread, a block at a time.
binary_event_schema The name and fields of the records of one tag.
binary_field A field of an ELTR record: its name and type.
binary_record_writer Appends the fields of an ELTR record to a byte buffer, in their ELTR representation: little-endian integers, IEEE floats, size-prefixed strings.
binary_recorder A tracer that writes the events as an ELTR binary stream, a block of encoded records at a time.
binary_recorder_options The options of a binary recorder: its buffering and the metadata of its header.
default_binary_cost_writer The cost writer of the recorders by default: an arithmetic cost as i64, u64 or f64; a cost::lexicographic or a cost::pareto as its levels ("0", "1", ...) and a cost::hierarchical as "hard" and "soft", nested as the types are.
default_json_cost_writer The JSON cost writer of the JSONL recorder by default: a number as the shortest text that reads back to it (null for NaN and the infinities), a cost::lexicographic or a cost::pareto as the array of its levels, a cost::hierarchical as {"hard": ..., "soft": ...}, nested as the types are; the shape of the costs eltr.py decodes from ELTR.
jsonl_options The options of a jsonl_recorder: the metadata of its header line, and whether its events carry a timestamp.
jsonl_recorder A tracer that writes each event to a stream as it is emitted, one JSON object per line with an "event" field naming it.
memory_recorder A tracer that keeps a copy of every event in memory, in order, for tests, short traces and in-process analysis.
neighborhood_route_node A level of the route of a move through nested neighborhood unions, linked to the level above.
null_tracer The tracer of a run without tracing: it observes no event, so the search builds none.
without_event_types Forwards to tracer the events it observes, except those of the Excluded event types, such as event::neighborhood_selection.
without_events Forwards to tracer the events it observes, except those of the Excluded event templates.

Enums

NameDescription
binary_type The types of the fields of an ELTR record.

Functions

NameDescription
copy_route The child indices of the route ending at node, from the outermost union inward; empty for a null node.
emit Sends value to tracer when it observes the event type, and does nothing, at compile time, otherwise.
user_binary_event_tag The ELTR tag of the application event of index Index, 0 to 127: tag 128 + Index.
with_move_route Calls callback with the route of move through nested neighborhood unions, null for a move outside a union.
without without<event::neighborhood_selection>(recorder): recorder without the events of the given types, the core events without a cost (event::neighborhood_selection, event::tabu_escape, ...) or application events.
without without<event::solution_visited>(recorder): recorder without the visited solutions, for a run that does not build trajectory or local optima networks.
write_jsonl Writes the events of a memory_recorder as JSONL, with the default cost writer, after the header line.
write_jsonl Writes the events of a memory_recorder as JSONL, after the header line, one line per event as jsonl_recorder writes them during a run.

Concepts

NameDescription
binary_cost_writer_for A cost writer writes a cost and describes what it writes: fields() gives the fields in order, a scalar cost one field with an empty name.
described_binary_event An application event that describes its records with an ADL function describe_binary_event(std::type_identity<Event>) returning its binary_event_schema: the recorder writes the schema before the first record of its tag, and decoders name its fields.
json_cost_writer_for A writer of costs as JSON: writer(out, cost) writes cost to the stream out.
observes A tracer that receives Event.
tracer_for A tracer that says, with observes<Event>, whether it receives Event, and that has emit(event) when it does.

easylocal::trace::event namespace

Types

NameDescription
aspiration_applied The move just applied was tabu, admitted by the aspiration criterion.
incumbent_updated A new best solution, emitted by search_run::incumbent_updated() in the algorithms that keep the best solution found.
local_optimum A run ended in a local optimum, emitted by search_run::finish() before run_finished.
move_accepted A move applied to the current solution, emitted by search_run::commit().
move_evaluated A move evaluated, emitted by search_run::evaluate_move().
neighborhood_selection A child chosen by a neighborhood union drawing a random move, emitted once the child has tried to produce one.
run_context The place of the next run in a solve, emitted by the solvers before each run they start: its pipeline stage and its attempt.
run_finished The end of a run, emitted by search_run::finish().
run_started The start of a run, emitted by search_run::start() once the initial solution is evaluated.
solution_visited A solution reached: at the start of a run, after each applied move, and when an algorithm evaluates another solution (a sample of its population), identified by its hash (solution_hash): the nodes of search trajectory and local optima networks, whose edges go from previous_hash to hash.
tabu_escape A reactive tabu list's escape, after its random moves: moves were applied, fewer than asked when the run had to stop.
tabu_tenure_changed The tenure of a tabu list with one tenure for all its moves changed, from previous_tenure (0 at the start of a run) to tenure.
temperature_changed The temperature of Simulated Annealing changed, from previous_temperature (0 at the start of a run) to temperature.

easylocal::tui namespace

Types

NameDescription
launcher_options The options of the launcher, the TextUI that lists several apps and opens the tester of the one selected.
options The options of the interactive tester.

Enums

NameDescription
path_display_mode How the tester shows a path.

Functions

NameDescription
run Runs the interactive tester on an app: an interactive session on it, with options.seed for its RNG, and the Input loaded from options.input_path when it is set (through the read_input hook).
run_launcher Opens a menu of the apps, which share the Input (loaded from options.tester.input_path when it is set) and the current solution.