ConstructiveProblemForm (ecj 26 API)

All Known Implementing Classes:

KnapsackProblem, MasterProblem, TSPProblem
```
public interface ConstructiveProblemForm
```
Defines a combinatorial optimization problem. Combinatorial optimization differs from other kinds of optimization and search in that algorithms for solving tasks in this domain often proceed by building up partial solutions incrementally with the help of heuristic information. So while most of ECJ's algorithms can be applied to a Problem that just provides a fitness function for whole solutions, we need more than just a fitness function in order to apply ECJ's CO algorithms.

This interface in this package defines the additional information that users must provide for combinatorial optimization problems. The most important of these are
- the component set, getAllComponents(), defining the pool of components that can be used to construct solutions in your problem domain,
- a neighborhood function, getAllowedComponents(), which defines the subset of components that can be added to a given partial solution without breaking it.
The lists of Component objects returned by these methods come with their heuristic values pre-assigned. A ConstructiveProblemForm thus also implicitly implements the heuristic evaluation function, which is essential to many combinatorial optimization algorithms.
Author:

Eric O. Scott

See Also:

ec.app.tsp, ec.app.knapsack

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`List<Component>`	`getAllComponents()`
`List<Component>`	`getAllowedComponents(ConstructiveIndividual partialSolution)` Return the allowable "neighborhood" of components that
`Component`	`getArbitraryComponent(EvolutionState state, int thread)` Chooses an arbitrary component from the problem domain.
`Component`	`getComponentFromString(String s)` Decode a String representation of a solution component.
`boolean`	`isCompleteSolution(ConstructiveIndividual solution)` Determine whether a given specifies a complete solution to this problem.
`boolean`	`isViolated(ConstructiveIndividual partialSolution, Component component)`
`int`	`numComponents()`

- Method Detail
  - numComponents
```
int numComponents()
```
    Returns:
    
    The total number of components that exist in the problem.
  - isCompleteSolution
```
boolean isCompleteSolution(ConstructiveIndividual solution)
```
    Determine whether a given specifies a complete solution to this problem.
    
    Parameters:
    
    solution - A partial or complete solution to this ConstructiveProblemForm.
    
    Returns:
    
    True iff the solution is complete (as opposed to partial).
  - isViolated
```
boolean isViolated(ConstructiveIndividual partialSolution,
                   Component component)
```
    Parameters:
    
    partialSolution - A partial solution to this ConstructiveProblemForm.
    
    component - A component that we may wish to add to the partial solution.
    
    Returns:
    
    True iff the constraint allows component to be added to the given partialSolution.
  - getAllowedComponents
```
List<Component> getAllowedComponents(ConstructiveIndividual partialSolution)
```
    Return the allowable "neighborhood" of components that
    
    Parameters:
    
    partialSolution - A collection of components that represent a partial solution that we wish to add a component to.
    
    Returns:
    
    The set of all components that can be added to the given partial solution without causing a constraint violation.
  - getAllComponents
```
List<Component> getAllComponents()
```
    Returns:
    
    all components that exist in the problem definition.
  - getComponentFromString
```
Component getComponentFromString(String s)
```
    Decode a String representation of a solution component.
    
    Parameters:
    
    s - A String representing a component.
    
    Returns:
    
    A component matching the provided String.
  - getArbitraryComponent
```
Component getArbitraryComponent(EvolutionState state,
                                int thread)
```
    Chooses an arbitrary component from the problem domain. The intent here is that this gives us an efficient way to choose a component to begin a solution with (as opposed to returning all possible components so that some external method can choose one, which may have nonlinear complexity in some domains).
    
    Parameters:
    
    state - The state (used, for example, to access the simulation's PRNGs)
    
    thread - The thread the caller is operating on. If the caller is single-threaded, just set this to zero.
    
    Returns:
    
    An component selected arbitrarily from the problem domain

Interface ConstructiveProblemForm

Method Summary

Method Detail

numComponents

isCompleteSolution

isViolated

getAllowedComponents

getAllComponents

getComponentFromString

getArbitraryComponent