All Classes and Interfaces
Class
Description
Defines the structure of an optimization model solved using the
Anytime Column Search (ACS) algorithm within the
Decision Diagram Optimization (DDO) framework.
Implementation of an Anytime Column Search (ACS) solver for decision diagram-based optimization problems.
Aircraft Landing Problem (ALP) with Acs.
Aircraft Landing Problem (ALP) with AsTar.
Aircraft Landing Problem (ALP) with Ddo.
Represents a decision in the Aircraft Landing Problem (ALP).
Fast lower bound computation for the Aircraft Landing Problem (ALP).
Entry point for solving the Aircraft Landing Problem (ALP)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents the Aircraft Landing Problem (ALP).
Ranking heuristic for
ALPState objects in the Aircraft Landing Problem (ALP).Relaxation operator for
ALPState in the Aircraft Landing Problem (ALP).Represents the state of the Aircraft Landing Problem (ALP) at a given moment.
Utility class providing common array-related operations.
Defines the structure of an optimization model solved using the
Anytime Weighted A* (AWA*) algorithm within the
Decision Diagram Optimization (DDO) framework.
Implementation of an Anytime Weighted A* search (AWA*) solver for decision diagram-based optimization problems.
Class to model a Binary clause of two literals for CNF formula.
Bounded Knapsack Problem (BKS) with Acs.
Bounded Knapsack Problem (BKS) with AsTar.
Bounded Knapsack Problem (BKS) with Ddo.
Implementation of a dominance rule for the Bounded Knapsack (BKS) problem.
A fast lower bound implementation for the
BKSProblem (Bounded Knapsack Problem).Entry point for solving the Bounded Knapsack Problem (BKS)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the Bounded Knapsack Problem (BKP).
Enumeration defining possible correlation types between item
weights and profits when generating random instances.
A default state ranking implementation for the Bounded Knapsack Problem (BKP).
A relaxation strategy for the Bounded Knapsack Problem (BKP) used in
relaxed decision diagrams.
Defines the abstraction of a cache mechanism used to prune and reduce the
search space during the compilation or exploration of a Decision Diagram (DD).
Represents the configuration parameters used during the compilation
of a Multi-valued Decision Diagram (MDD) or similar decision structure.
Specifies the type of compilation to use when constructing a decision diagram (DD) for a problem.
This strategy select the nodes based on the objective value of the best path leading to them.
Cutset type for the decision diagram compilation.
Defines the interface for a Dynamic Decision Diagram Optimization (DDO) model.
Defines the different levels of debugging information and validation
that can be enabled during the execution of the solver.
Utility class providing methods useful for debugging state transitions.
Represents a single decision within an optimization problem.
Defines the abstraction of a reusable Decision Diagram (DD) used to model and solve
combinatorial optimization problems.
Default implementation of a
DominanceChecker that performs no dominance checking.Default implementation of the
FastLowerBound interface that always returns
Integer.MIN_VALUE as the lower bound estimate.A default implementation of
VariableHeuristic that selects
the next variable to branch on without applying any specific strategy.Defines a dominance relation used to compare and prune states
during the exploration of decision diagrams or search spaces.
Object that, given a dominance, will check if a state is dominated.
Defines a function that extracts a canonical dominance key from a given state.
Represents an edge in a decision diagram that connects two nodes.
Defines the interface for a Dynamic Decision Diagram Optimization (DDO) model, used by the
ExactSolverSolver that compiles a single exact decision diagram (MDD) to find the optimal solution.
Interface for the fast lower bound method
Heuristic defining a fast lower bound for states
Implements a static maximum width heuristic for decision diagram or search-based algorithms.
Defines the abstraction of a frontier (or open list) used by solvers
to manage and prioritize the remaining subproblems that must be explored.
Generalized Hyperplane Partitioning (GHP) reduction strategy for decision diagram layers.
Golomb Rule Problem (GRP) with Acs.
Represents a Graph with adjacency matrix.
Golomb Rule Problem (GRP) with AsTar.
Golomb Rule Problem (GRP) with Ddo.
Lower bound for the Golomb Ruler.
Represents an instance of the Golomb Ruler (GR) problem.
Defines a ranking strategy for states in the Golomb Ruler (GR) problem.
Relaxation operator for the Golomb Ruler (GR) problem.
Represents a state in the Golomb Ruler (GR) problem.
Hybrid reduction strategy that combines cost-based and distance-based clustering
for decision diagram layers.
Utility class to read formatted input from a file.
Exception thrown by
Problem.evaluate(int[]) method if its input solution does not
respect the problem's constraints.Knapsack Problem (KS) with Acs.
Utility class providing algorithms to solve the Knapsack Problem.
Knapsack Problem (KS) with AsTar.
Knapsack Problem (KS) with Ddo.
Knapsack Problem (KS) with Ddo.
Distance measure for states in a Knapsack (KS) problem.
Dominance relation for the Knapsack Problem (KS).
Fast lower bound heuristic for the Knapsack Problem (KS).
Entry point for solving the 0/1 Knapsack Problem (KS)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the Knapsack Problem (KS).
State ranking for the Knapsack Problem (KS).
Relaxation for the Knapsack Problem (KS).
Longest Common Subsequence (LCS) with Acs.
Longest Common Subsequence (LCS) with AsTar.
Longest Common Subsequence (LCS) with Ddo.
Naive DP solver the 2-strings longest common subsequence problem, used
to build a heuristic for the m-strings problem.
Implementation of a fast lower bound heuristic for the Longest Common Subsequence (LCS) problem.
Contains method to generate instances of the LCS
Entry point for solving the Longest Common Subsequence (LCS) problem
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Definition of the Longest Common Subsequence (LCS) problem.
Ranking strategy for
LCSState in the Longest Common Subsequence (LCS) problem.Relaxation strategy for
LCSState in the Longest Common Subsequence (LCS) problem.Represents the state of a node in the Longest Common Subsequence (LCS) problem.
This class implements a decision diagram as a linked structure (linked MDD).
Interface representing a model for Large Neighborhood Search (LNS) problems.
Utility class providing mathematical operations with saturation semantics.
Maximum 2-Satisfiability (MAX2SAT) (MAX2SAT) problem with Acs.
Maximum 2-Satisfiability (MAX2SAT) (MAX2SAT) problem with AsTar.
Maximum 2-Satisfiability (MAX2SAT) (MAX2SAT) problem with Ddo.
Implementation of a fast lower bound heuristic for the Maximum 2-Satisfiability (MAX2SAT) problem.
Methods to generate random instance of the Max2Sat problem.
Entry point for solving the Maximum 2-Satisfiability (MAX-2SAT) problem
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents a Maximum 2-Satisfiability (MAX2SAT) problem instance.
Class used to compare two states for the Max2Sat problem.
Implements a relaxation for the Maximum 2-Satisfiability (MAX2SAT) problem.
Class to contain data for the Max2Sat sate.
Maximum Coverage (MaxCover) problem with Ddo
Maximum Coverage (MaxCover) problem with Ddo
Distance function for
MaxCoverState used to measure similarity
between states in the context of the Maximum Coverage problem.Dominance rule for
MaxCoverState used in the Maximum Coverage problem.Fast lower bound computation for the Maximum Coverage problem.
Utility class for generating and measuring instances of the Maximum Coverage (MaxCover) problem.
Entry point for solving the Maximum Coverage (MaxCover) problem
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the Maximum Coverage (MaxCover) problem.
Ranking function for
MaxCoverState used in the Maximum Coverage problem.Relaxation operator for
MaxCoverState in the Maximum Coverage problem.Represents a state in the Maximum Coverage (MaxCover) problem.
Maximum Cut Problem (MCP) with Acs.
Maximum Cut Problem (MCP) with AsTar.
Main class for solving the Maximum Cut Problem (MCP) using a DDO (Decision Diagram Optimization) approach.
Implementation of fast lower bound heuristic for the MCP.
Contains methods to generates and write instances.
Entry point for solving the Maximum Cut Problem (MCP)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the Maximum Cut Problem (MCP).
Class used to compare two states for the MCP problem.
Implements a relaxation strategy for the Maximum Cut Problem (MCP).
Class to contain data for the MCP state.
The Maximum Independent Set Problem (MISP) with Acs.
The Maximum Independent Set Problem (MISP) with AsTar.
The Maximum Independent Set Problem (MISP) with Anytime Weighted A* (AWA*).
The Maximum Independent Set Problem (MISP) with Ddo.
Implementation of a dominance relation for the Maximum Independent Set Problem (MISP).
Computes a fast lower bound for the Maximum Independent Set Problem (MISP).
Contains methods to generate instances of the MISP.
Entry point for solving the Maximum Independent Set Problem (MISP)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the Maximum Independent Set Problem (MISP) as a
Problem.Implements a ranking strategy for states in the Maximum Independent Set Problem (MISP).
Implements a relaxation strategy for the Maximum Independent Set Problem (MISP)
to be used in decision diagram optimization (DDO) algorithms.
Main class to demonstrate the application of Decision Diagram Optimization (DDO)
on a Multi-dimensional Knapsack (MKS) problem instance.
Computes a normalized distance between Multi-dimensional Knapsack (MKS) states.
Implements a dominance relation for Multi-dimensional Knapsack (MKS) states.
Provides a fast lower bound estimation for Multi-dimensional Knapsack (MKS) states.
Represents a Multi-dimensional Knapsack Problem (MKS) as a
Problem for decision diagram optimization.Ranking strategy for multi-dimensional Knapsack (MKS) states.
Relaxation strategy for the multi-dimensional Knapsack problem (MKS) states.
Represents the state of a multi-dimensional Knapsack problem (MKS) in terms of
the remaining capacities of each knapsack dimension.
Defines the core model interface for describing an optimization problem to be
solved within the Decision Diagram Optimization (DDO) framework.
Minimum Sum Completion Time (MSCT) with Acs.
Minimum Sum Completion Time (MSCT) with AsTar.
Minimum Sum Completion Time (MSCT) with Ddo.
Implements the dominance relation for the Maximum Sum of Compatible Tasks (MSCT) problem.
Provides a fast lower bound computation for the Maximum Sum of Compatible Tasks (MSCT) problem.
Contains methods to generates instance of the MSCT
Entry point for solving the Minimum Sum of Completion Times (MSCT) problem
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the **Minimum Sum of Completion Times (MSCT)** problem.
Provides a ranking strategy for
MSCTState objects
used in the search process for solving the
Maximum Sum of Completion Times (MSCT) problem.Implements the relaxation operator for the
MSCTProblem
in the context of Decision Diagram Optimization (DDO) algorithms.Represents a state in the
MSCTProblem (Minimum Sum of Completion Times) scheduling problem.A naive Max2Sat solver which enumerates all the solution to find the best one.
Naive MCP solver which enumerates all the solution to find the best one.
Represents an atomic node in a decision diagram.
Encapsulates the association of a node in a decision diagram with its corresponding state
and an associated rough lower bound.
Comparator for
NodeSubProblem instances that sorts them first by their node value,
and then by the state using a provided StateRanking if the values are equal.Enum representing the different types of nodes in the decision diagram.
Single Vehicle Pick-up and Delivery Problem (PDP) with Acs.
Single Vehicle Pick-up and Delivery Problem (PDP) with AsTar.
Single Vehicle Pick-up and Delivery Problem (PDP) with Ddo.
Provides a fast lower bound estimation for the Pickup and Delivery Problem (PDP).
Utility class for generating instances of the Pickup and Delivery Problem (PDP)
with a single vehicle.
Entry point for solving the Single Vehicle Pick-up and Delivery Problem (PDP)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents a Pickup and Delivery Problem (PDP) instance with a single vehicle.
Implements a state ranking strategy for the Pickup and Delivery Problem (PDP).
Represents a solution to a Pickup and Delivery Problem (PDP) instance.
Represents the state of a Pickup and Delivery Problem (PDP) during the search process.
Collection of utility functions for formatting data for display.
Represents an optimization problem formulated as a labeled transition
system, following the semantics of dynamic programming.
The Pigment Sequencing Problem (PSP) with Acs.
The Pigment Sequencing Problem (PSP) with AsTar.
The Pigment Sequencing Problem (PSP) with Ddo.
Computes a fast lower bound for the Pigment Sequencing Problem (PSP).
Entry point for solving the Pigment Sequencing Problem (PSP)
using a Large Neighborhood Search (LNS) approach combined with
Decision Diagram Optimization (DDO).
Represents an instance of the Pigment Sequencing Problem (PSP)
used within a Decision Diagram Optimization (DDO) framework.
Provides a ranking heuristic for comparing two
PSState objects
within the Production Scheduling Problem (PSP) search framework.Implements the relaxation mechanism used in the DDO framework
for the Pigment Scheduling Problem (PSP).
Represents a state in the Production Scheduling Problem (PSP).
A simple random-based reduction strategy for decision diagram layers.
Interface defining a strategy to reduce the number of nodes in a layer of a decision diagram
by clustering nodes for restriction and relaxation.
This is the second most important abstraction that a client should provide
when using this library.
A solver that compile one relaxed MDD from the root node.
A solver that compile one relaxed MDD from the root node.
State of a runway : last landing time and last aircraft's class
A sequential implementation of a Branch-and-Bound solver based on
Multi-valued Decision Diagrams (MDDs).
A simple implementation of a
Cache for storing threshold values associated with states in a dynamic programming model.Inner class representing a synchronized cache layer for a specific depth.
The
SimpleDominanceChecker class implements a straightforward dominance
management mechanism used in search algorithms based on Multi-valued Decision Diagrams (MDDs),
such as DDO (Decision Diagram Optimization).A simple implementation of a
Frontier for a solver, based on a plain priority queue.The Single Machine with Inventory Constraint (SMIC) with Acs.
The Single Machine with Inventory Constraint (SMIC) with AsTar.
The Single Machine with Inventory Constraint (SMIC) with Ddo.
The
SMICDominance class defines the dominance relation between two
states of the SMICState in the context of the
Single Machine with Inventory Constraint (SMIC) problem.The
SMICFastLowerBound class provides a fast and simple estimation
of the lower bound of the remaining cost (or completion time) in the
Single Machine with Inventory Constraint (SMIC) scheduling problem.The
SMICGenrator class is responsible for generating random instances of the
Single Machine with Inventory Constraint (SMIC) problem.Entry point for solving the Single Machine with Inventory Constraint (SMIC) problem
using a Large Neighborhood Search (LNS) approach.
The
SMICProblem class represents an instance of the
Single Machine with Inventory Constraint (SMIC) scheduling problem.The
SMICRanking class defines a heuristic ranking criterion for
comparing two SMICState instances during search or optimization.The
SMICRelax class implements a relaxation operator for the
SMICProblem, used in Decision Diagram Optimization (DDO)-based solvers.The
SMICState record represents a state in the search space of the
Single Machine with Inventory Constraint (SMIC) scheduling problem.Wrapper defining a solution from a set of decisions
Utility class providing helper methods to display solutions found by a solver.
Interface representing a generic solver for decision diagram based optimization problems.
The
Solvers class acts as a unified entry point for running different
optimization algorithms within the Decision Diagram Optimization (DDO) framework.Contains method useful to implements solvers
The Single-Row Facility Layout Problem (SRFLP) with Acs.
The Single-Row Facility Layout Problem (SRFLP) with AsTar.
The Single-Row Facility Layout Problem (SRFLP) with Ddo.
Provides a fast lower-bound estimation for the Single-Row Facility Layout Problem (SRFLP)
based on the current state of the solution.
Entry point for solving the Single Row Facility Layout Problem (SRFLP)
using a Large Neighborhood Search (LNS) approach.
A Single-Row Facility Layout Problem (SRFLP) instance.
Implements a ranking between two
SRFLPState instances for use in
decision diagram or search-based algorithms.Implementation of a relaxation for the Single Row Facility Layout Problem (SRFLP).
Represents a state in a Single Row Facility Layout Problem (SRFLP) instance.
Class containing a state and its depth in the main search.
Interface defining a distance function between states, used to form clusters
when deciding which nodes on a layer of a decision diagram should be merged.
A state ranking is used to order the states and decides the ones that are kept
and the ones that are merged/deleted when a relaxation/restriction occurs.
Represents a residual optimization problem (subproblem) derived from the decomposition
of an original problem during the compilation or search process.
Represents a threshold value associated with a state in a dynamic programming or search model.
Represents a time window with a start and end time.
The talent scheduling problem (tsp) with Acs.
The talent scheduling problem (tsp) with AsTar.
The talent scheduling problem (tsp) with Ddo.
Implementation of a fast lower bound for the Talent Scheduling Problem (TSP).
Entry point for solving the Talent Scheduling (TalentSched) problem using a
Large Neighborhood Search (LNS) approach.
The Traveling Salesman Problem (TSP) with Acs.
The Traveling Salesman Problem (TSP) with AsTar.
Main class to solve a Traveling Salesman Problem (TSP) instance using the Decision Diagram Optimization (DDO) method.
Implementation of a fast lower bound for the Traveling Salesman Problem (TSP).
Class to generate and handle instances of the Traveling Salesman Problem (TSP).
Entry point for solving the Traveling Salesman Problem (TSP) using a
Large Neighborhood Search (LNS) approach.
Utility class to compute lower bounds for the Traveling Salesman Problem (TSP).
Class representing an instance of the Traveling Salesman Problem (TSP).
Class that defines a ranking between two
TSPState instances.Implementation of a relaxation for the Traveling Salesman Problem (TSP).
The Talent Scheduling Problem (TSP) instance.
Represents a state in the Traveling Salesman Problem (TSP).
The Traveling Salesman Problem with Time Windows (TSP with Time Windows) with Acs.
The Traveling Salesman Problem with Time Windows (TSP with Time Windows) with AsTar.
The Traveling Salesman Problem with Time Windows (TSP with Time Windows) with Anytime Weighted
A* (AWA*).
The Traveling Salesman Problem with Time Windows (TSP with Time Windows) with Ddo.
Dominance relation for the Traveling Salesman Problem with Time Windows (TSPTW).
Key used for dominance checking in the Traveling Salesman Problem with Time Windows (TSPTW).
Implementation of a fast lower bound for the Traveling Salesman Problem with Time Windows (TSPTW).
Entry point for solving the Traveling Salesman Problem with Time Windows (TSPTW)
using a Large Neighborhood Search (LNS) approach.
Class representing an instance of the Traveling Salesman Problem with Time Windows (TSPTW).
Ranking class for states in the Traveling Salesman Problem with Time Windows (TSPTW).
Relaxation class for the Traveling Salesman Problem with Time Windows (TSPTW).
Represents a state in the dynamic programming model for the Traveling Salesman Problem with Time Windows (TSPTW).
Heuristic for computing the width of a layer in the dynamic programming model
for the Traveling Salesman Problem with Time Windows (TSPTW).
Class that defines a ranking (ordering) between two
TSState instances.Implementation of a relaxation for the Talent Scheduling problem (TSP).
Represents a state in the Talent Scheduling Problem (TalentSched).
Defines a strategy for selecting the next decision variable to branch on
during the construction or exploration of a decision diagram.
Utility class for printing detailed information about the search process
based on a specified
VerbosityLevel.Defines the different verbosity levels controlling the amount of information
printed during the execution of a solver.
Interface for heuristics that determine the maximum width of a layer in a multi-valued decision diagram (MDD).