All Classes and Interfaces
Class
Description
Example movement class.
Validate that a solution is valid for the __RNAME__ problem.
Defines an experiment to execute.
Base class to represent metrics
Base orchestrator, contains common code.
This class is used to configure the serializer by the properties specified in the application.yml
This class is used to configure common serializer properties.
This class is used to configure the serializer by the properties specified in the application.yml
Simulated annealing acceptance criteria.
Load a test instance used to validate the autoconfig behaviour, instance data consists on several lines with random words
Test solution to validate autoconfig behaviour, each component will add or remove some arbitrary quantity from its score
Base algorithm class, all algorithms should extend this class or any of its subclasses.
Provides the necessary methods to generate an algorithm from the proposed Irace configuration.
Magic (based on reflection) util methods to create instances of algorithm components at runtime
Annotation to mark any given class as an algorithm component.
Create an algorithm component from a given set of parameters
Algorithm configuration via pairs of key values
Manage algorithm components at runtime.
This class provides an empty implementation of
AlgorithmParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
AlgorithmParser.Triggered after ending an experiment
Triggered when starting an experiment before any other action occurs
Calculate alpha value in a GRASP like constructive
Util methods to manipulate collections and arrays that are not part of the standard java API
Assertion utils
Reference
Assigns a point to a cluster
This annotation has two effects on any algorithm component:
Marks that a component should be considered when automatically proposing configurations.
Tells the autoconfig engine which constructor describes the tunable parameters and component dependencies.
Note that algorithm components can still be built dynamically at runtime from their string representation even if they do not have this annotation,
as the correct constructor to call can be detected from the given set of parameters.
Banner generator on startup
Benchmark helper methods
Benchmark cache
System info
Fast integer set implementation based on the JDK
BitSet class.Includes ALL algorithm components by default, ignores components that implement or extend any element in the blacklist.
Block Java API methods configuration
Validate that a solution is valid for the BMSSC problem.
Declares a categorical tunable parameter using the same categorical parameter type as irace.
CMSA (Construct, Merge, Solve and Adapt) is a hybrid metaheuristic that combines a probabilistic
constructive heuristic with an exact method.
CMSA algorithm builder based on the Java Builder Pattern.
Constructive method used by
CMSA to probabilistically build complete solutions.Solves, exactly or as close to exactly as possible, the sub-instance of the problem induced by restricting
it to a given set of solution components.
Util methods to manipulate collections and arrays that are not part of the standard java API
Contains methods to generate permutations
Specifies additional restrictions when resolving a constructor parameter whose type is another algorithm component.
Helper methods to deal with concurrent tasks
Concurrent executor, execute multiple runs in parallel for a given instance-algorithm pair
Fallback configuration service for when it is not viable to use a Config DTO.
Constant initial temperature calculator.
Builds a new solution for the current problem.
No operation constructive method
Returns the solution immediately without executing any operation
Not included by default as an autoconfig component because most
problems require a constructive method or solutions will not be valid
AutoCloseable objective tracking suspension scope.
Specify how the temperature changes in each simulated annealing iteration.
This class is used to configure the CSV serializer by the properties specified in the application.yml
CSV serializer.
A matrix of objective vectors and the set identifier of each row.
Metric that stores the best objective values seen so far
Default exception handler.
This class converts solution objects into their JSON equivalent by mapping the solution object variable names and value to JSON properties
UserExperimentOrchestrator class.
Default VNSNeighChange implementation that increments K one by one until it reaches maxK.
Represents a derivation rule in the autoconfig grammar
Method that destroys a solution, in part or completely.
Do nothing destructive method
Dinic's algorithm for the maxflow problem.
UnionFind/Disjoint sets implementation
Helper methods to perform comparisons between doubles (or floats)
DANGER: DoubleComparator VIOLATES COMPARISON CONTRACT, DO NOT USE IN SORTS
Generate random solutions for validation purposes
Output representation for empirical-attainment-function differences.
This class is used to configure the behaviour on error using the properties specified in the application.yml
Triggers when an unhandled exception or throwable reaches the default Mork exception handler.
Define API endpoints related to events.
Public representation of a published event.
This class is used to configure the behaviour of the webserver as specified in the application.yml
This class is used to configure the Excel serializer by the properties specified in the application.yml
Exports the results of each experiment.
Customize Excel file with results.
Serialize results to Excel XML format
Value types to use as hint when serializing to Excel cells.
Abstract class to provide behaviour when an uncontrolled exception reaches executor code.
DTO for answering an execution request for a given instance and algorithm.
API endpoints related to experiment and run execution.
Triggered when solver execution ends
Coordinates the terminal execution event, event-bus draining, and application shutdown.
Triggered when the solver starts.
Processes work units
Declared experiment DTO.
Triggered after ending an experiment
Manages and configures all experiments to execute
Triggered when starting an experiment before any other action occurs
Optionally calculate how big the neighborhood is for a given solution.
Exponential coolDown strategy
Test constructive method used to validate the behaviour of the autoconfig mode
Test improver used to validate the autoconfig mode
Move one element A from its position I to another position J, displacing all elements between those positions
Serialize solutions using a custom format
Each row represents a facility row, with positive numbers being the facility id, and negative numbers a fake facility and its width.
Custom configuration for FLPSolutionExporter, so it can be configured in the application.yml file
Solving mode, can be either maximize or minimize
Util methods to manipulate graphs
Creates GRASP constructive instances using with different configurations, allowing to easily configure them and reuse the configurations.
Creates and updates the candidate list when a movement is performed
Do nothing GRASPListManager
GRASP Constructive method using the greedy random strategy.
Sampling distributions supported by HYPE weighted hypervolume.
Reusable exact hypervolume indicator.
Algorithms available for approximate hypervolume computation.
Decides which branches of the tree should be explored, and which ones rejected
Allows the user to filter algorithm components without having to comment or modify the components.
Thrown by any algorithm component when the combination of parameters given is not valid
Any method that improves a given solution is called an Improver.
Do nothing local search
Marks an extension point whose implementations should be discovered as Spring components.
Determines initial simulated annealing temperature.
Append-only in-memory event replay log.
Base instance class.
Configuration properties related to intances
This class is used to generate an instance for the problem.
Exception thrown when there is any problem loading an instance
Class to manage instances during the solving lifecycle
Triggered after ending an experiment
Triggered when starting an experiment before any other action occurs
Declares an integer tunable parameter using the same integer parameter type as irace.
Thrown when an invalid random usage is detected, which would affect experiment reproducibility, and suggests alternatives to use.
Thrown if the solution is not valid at different solving stages
IO Service to export solutions, errors and load instances
Util methods for managing input/output
This class is used to configure irace by the properties specified in the application.yml
section irace
IraceIntegration class.
IraceOrchestrator class.
Irace run configuration.
Iterated greedy is a search method that iterates through applications of construction
heuristics using the repeated execution of two main phases, the partial
destruction of a complete candidate solution and a subsequent reconstruction of
a complete candidate solution.
Pair of datasets with the largest EAF difference and its value.
Local search procedures start from a given feasible solution and explore a determined neighborhood
in each iteration, replacing the current solution if a neighbor solution improves the objective
function of the current one.
Local search procedures start from a given feasible solution and explore a determined neighborhood
in each iteration, replacing the current solution if a neighbor solution improves the objective
function of the current one.
Cached best improvement local search.
Local search procedures start from a given feasible solution and explore a determined neighborhood
in each iteration, replacing the current solution if a neighbor solution improves the objective
function of the current one.
Calculate initial temperature as maximum difference between movements in neighborhood.
Manages metrics instances.
Stores metrics of different things that are happening while solving.
Default termination criteria based on metropolis exponential function
Minimum Vertex Cover (MVC), solved with CMSA (Construct, Merge, Solve & Adapt).
Static facade for multi-objective mathematical operations.
This class is in charge of launching Mork.
Marker interface for event payloads published through the Mork event bus.
Listen for Mork events.
Single async boundary between solver threads and event consumers.
AutoCloseable mute scope.
Represents a change for a given solution in a given neighborhood
Validate that a solution is valid for the MST problem.
DTO for requesting an execution for a given instance and algorithm.
Example multistart algorithm, executes a user-defined algorithm until N iterations are reached, return best found.
Multi-start algorithm builder based on Java Builder Pattern
Probabilistic constructive method for the Minimum Vertex Cover (MVC) problem, used as the
"Construct" step of the CMSA demo in this project.
Exact solver for the CMSA "Solve" step of the Minimum Vertex Cover demo: given a restricted set
of candidate vertices, finds the smallest subset of those candidates that covers every edge of
the original instance.
NDTreeNode defines nodes used in the NDTree.
Defines a neighbourhood.
Shapes supported by random nondominated-set generation.
Represents an objective function to be optimized for a given problem.
Declares an ordinal tunable parameter using the same ordinal parameter type as irace.
Provides parameter values at runtime
Contains methods to generate permutations
Ping everyone, does nothing.
Logback console appender that preserves the active progress bar line.
Progress bar consumer that cooperates with Logback console output.
Declares that this parameter is provided automatically by the solving engine or any extension of it.
Executes random movements from the given neighborhood until there are no moves left to execute
Seeded random generators aligned with Mork's default provider.
GRASP Constructive method
Neighborhood that is able to generate random movements under demand
Multi-thread aware random manager
Shake a solution by executing a sequence of random moves
Partially destroys a DRFP solution by removing part of its facilities.
Minimum set of available random generators.
Column types in raw sheet
Declares a real-valued tunable parameter using the same real parameter type as irace.
Removes a point from a cluster and adds it to another cluster
Represents a constructive method that can rebuild solutions after they have been partially destroyed,
or any solution in general that it is not fully constructed.
Reference result for an instance
If implemented, used when comparing experiment results
ReflectiveSolutionBuilder class.
Move that can rebuild itself for the current solution state.
Hypervolume deviation relative to a reference front; lower values are better.
Thrown when the maximum allocated resources are consumed,
or when even if they are not consumed,
it is estimated with high confidence that we cannot complete the operation.
Defines results export frequency.
This class handles the transformation of the results of the experiments to a file in a specific format.
Synchronously retrieves results and exports them to disk when requested by
the execution workflow.
In-memory generated-result store.
Parameters for one R script execution.
Result of a completed R script process.
Executes an R script.
Default R runner configuration.
Executes R scripts using the system
Rscript command.Processes work units sequentially
Raised when a result serializer fails while exporting experiment results.
Different ways to shake a solution, RandomShake for a reference implementation
Do nothing shake
Example simple algorithm, executes:
Constructive → (Optional, if present) Local Searches → (Optional, if present) Shake → If did not improve end
^_________________________________________| else repeat
This class can be used to test all the pieces if they are working properly, or as a base for more complex algorithms
Simulated annealing (SA) is a metaheuristic whose name comes from annealing in metallurgy.
Create instances of the simulated annealing algorithm.
DTO for requesting an execution for a given instance and algorithm.
Test constructive method used to validate the behaviour of the autoconfig mode
Abstract Solution class.
How to generate empty solutions from a given instance.
Calculate the distance (for example, the minimum number of moves to apply to transform solution A in solution B)
between any two given solutions for the current problem.
Should we export each (instance, algorithm, iteration),
only the best solution for each (algorithm, instance),
or only the best solution for each instance?
Lightweight event triggered each time an algorithm finishes creating a result.
Subclass to provide a custom implementation to export solutions to file.
Solution validator: If implemented, validates the generated solutions from different algorithms
during the execution, in order to detect bugs as soon as possible.
Configuration file based on application.yml file.
Configuration for warming up the JVM before running measured experiments.
Stream Utils
String Utils
Swap this point with another one in a different cluster.
Telegram configuration, see event.telegram section inside the application.yml file.
Sends telegram messages on certain MorkEvents
This class create a Bot for Mork framework.
Determines when the Simulated Annealing stops.
Tracks time usage across different threads.
Time limit
Common time operations
Pairs of (instant, value)
Tracks the exploration of the autoconfig grammar.
2D coordinate
This class represents a solution of the problem.
Example movement class.
Validate that a solution is valid for the TSPTW problem.
Result of validating a solution
Validation Util methods.
VND class.
Variable neighborhood search (VNS) is a metaheuristic for solving combinatorial
and global optimization problems.
Calculates K value for each VNS step.
Vorob'ev threshold, expectation, and average hypervolume.
Adaptation of GRASPConstructor in original VRPOD project, the rest of constructive methods are ignored as this is the only one that was not commented
Validate that a solution is valid for the VRPOD problem.
WebSocketConfig class.
Includes ONLY the given classes/interfaces and their implementations, ignores the rest.
Result of executing one work unit.