All Classes and Interfaces
Class
Description
Implement this class to listen and react to the different events generated by the framework.
Recover past events
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
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 to use to instantiate the component --> which other components and config parameters are mandatory
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 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
Declares how to generate values for a primitive parameter (int, double, etc) using the same strategies as Irace.
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 algorithm components to available implementations
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
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.
Metric that stores the best objective values seen so far
Default Event listener responsible for sending framework events
via websockets and storing a copy in an EventStorage
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
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.
Configure how events are processed asynchronously
Define API endpoints related to events.
Distributes the given event to different application components.
This class is used to configure the behaviour of the webserver as specified in the application.yml
Serialize raw sheet using Excel formulas.
This class is used to configure the Excel serializer by the properties specified in the application.yml
Exports the results of each experiment.
Defines how to handle calculated values when serializing to Excel 2007+
Customize Excel file with results.
Serialize results to Excel XML format
Abstract class to provide behaviour when an uncontrolled exception reaches executor code.
DTO for requesting an execution for a given instance and algorithm.
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
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
Solving mode, can be either maximize or minimize
Runs R code inside the JVM.
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.
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
Used to detect at runtime implementing classes without forcing users to use annotations.
Determines initial simulated annealing temperature.
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 how to generate values for a primitive parameter (int, double, etc) using the same strategies 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.
Serialize raw sheet calculating all relevant data beforehand.
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.
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.
Store historical event data
Manages metrics instances.
Stores metrics of different things that are happening while solving.
Default termination criteria based on metropolis exponential function
This class is in charge of launching Mork.
Base event.
Listen for events asynchronously
Represents a change for a given solution in a given neighborhood
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
NDTreeNode defines nodes used in the NDTree.
Defines a neighbourhood.
Represents an objective function to be optimized for a given problem.
Declares how to generate values for a primitive parameter (int, double, etc) using the same strategies as Irace.
Provides parameter values at runtime
Contains methods to generate permutations
Ping everyone, does nothing.
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
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
Minimum set of available random generators.
Column types in raw sheet
Generates excel raw sheet with all data to use in pivot table and custom charts or other custom processing
Value types to use as hint when serializing to Excel cells.
Declares how to generate values for a primitive parameter (int, double, etc.) using the same strategies as Irace.
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.
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.
Retrieve results and export to disk when appropriate
Runs arbitrary R code
Processes work units sequentially
Different ways to shake a solution, RandomShake for a reference implementation
Do nothing shake
Runs R code outside the JVM using the R executable.
ShutdownService class.
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.
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?
Event triggered each time an algorithm finishes creating a solution.
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.
Stream Utils
String Utils
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.
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.
WebSocketConfig class.
Includes ONLY the given classes/interfaces and their implementations, ignores the rest.
Example movement class.
Validate that a solution is valid for the __RNAME__ problem.