ai.libs.jaicore.basic.algorithm

Interface IAlgorithm<I,O>

Type Parameters:

I - class of which inputs stems from

O - class of which solution candidates and the eventually returned result stem from

All Superinterfaces:

java.util.concurrent.Callable<O>, Cancelable, java.lang.Iterable<AlgorithmEvent>, java.util.Iterator<AlgorithmEvent>

All Known Subinterfaces:

IOptimizationAlgorithm<I,O,V>, ISolutionCandidateIterator<I,O>

All Known Implementing Classes:

AAlgorithm, AOptimizer, ASolutionCandidateIterator, LDSRelationComputer

public interface IAlgorithm<I,O>
extends java.lang.Iterable<AlgorithmEvent>, java.util.Iterator<AlgorithmEvent>, java.util.concurrent.Callable<O>, Cancelable

The algorithms should actually also be interruptible, but since this is often not the case, we require the cancel method to ensure that the authors of the algorithms provide a mechanism to stop the algorithm and free the used resources. Implementation of both Iterable and Iterator: We envision that an object of an algorithm really only represents one run, so there is really no reason to have an additional object only to hold the state.

Method Summary

Modifier and Type	Method and Description
O	call() Overrides the call of Callable to restrict the set of allowed exceptions
IAlgorithmConfig	getConfig()
java.lang.String	getId() globally unique identifier for the algorithm run
I	getInput()
int	getNumCPUs()
TimeOut	getTimeout()
AlgorithmEvent	nextWithException() Continues the execution of the algorithm until the next event is emitted.
void	registerListener(java.lang.Object listener) Registers a listener to the algorithm's event bus.
void	setMaxNumThreads(int maxNumberOfThreads) While setNumCPUs aims at telling the algorithm how many CPUs *should* be used for parallelization, this method can be used to define a strict constraint on the number of threads that must be spawned by the algorithm itself at most.
void	setNumCPUs(int numberOfCPUs)
void	setTimeout(long timeout, java.util.concurrent.TimeUnit timeUnit) Sets the timeout for the algorithm to the given value in the given time unit.
void	setTimeout(TimeOut timeout)

Methods inherited from interface java.lang.Iterable

forEach, iterator, spliterator

Methods inherited from interface java.util.Iterator

forEachRemaining, hasNext, next, remove

Methods inherited from interface ai.libs.jaicore.basic.Cancelable

cancel

Method Detail

getInput

I getInput()

Returns:

The input that has been given to the algorithm.

registerListener

void registerListener(java.lang.Object listener)

Registers a listener to the algorithm's event bus.

Parameters:

listener - The listener to register.

getNumCPUs

int getNumCPUs()

Returns:

The number of cpus (the amount of parallelization) that is allowed to be used by the algorithm.

setNumCPUs

void setNumCPUs(int numberOfCPUs)

Parameters:

numberOfCPUs - The numer of cpus that is allowed to be used by the algorithm.

setMaxNumThreads

void setMaxNumThreads(int maxNumberOfThreads)

While setNumCPUs aims at telling the algorithm how many CPUs *should* be used for parallelization, this method can be used to define a strict constraint on the number of threads that must be spawned by the algorithm itself at most. The motivation for this functionality is that, on some systems, processes get killed if they consume too much CPU resources. This can usually be avoided if the number of threads is limited (e.g. to the number of cores that may be used). setNumCPUs does not put such a restriction, because this is unnecessarily limiting in environment where such constraints do not exist. If the value is set to 0, no own threads must be used at all. Note that this may not be possible for some algorithms that need observers in the background. If the value is set to -1, any restriction on the number of threads is removed. Note that different algorithms may have different default behaviors if this number is not set.

Parameters:

maxNumberOfThreads - The maximum number of threads that may be spawned by the algorithm itself.

setTimeout

void setTimeout(long timeout,
                java.util.concurrent.TimeUnit timeUnit)

Sets the timeout for the algorithm to the given value in the given time unit.

Parameters:

timeout - The number of e.g. ms, seconds, minutes according to the given time unit.

timeUnit - The time unit for which the timeout variable will be interpreted.

setTimeout

void setTimeout(TimeOut timeout)

Parameters:

timeout - The timeout for the algorithm.

getTimeout

TimeOut getTimeout()

Returns:

The timeout for the algorithm.

nextWithException

AlgorithmEvent nextWithException()
                          throws java.lang.InterruptedException,
                                 AlgorithmExecutionCanceledException,
                                 AlgorithmTimeoutedException,
                                 AlgorithmException

Continues the execution of the algorithm until the next event is emitted.

Returns:

The next event occuring during the execution of the algorithm.

Throws:

java.lang.Exception

java.lang.InterruptedException

AlgorithmExecutionCanceledException

AlgorithmTimeoutedException

AlgorithmException

getConfig

IAlgorithmConfig getConfig()

Returns:

The config interface to store parameters to the algorithm in.

call

O call()
throws java.lang.InterruptedException,
       AlgorithmExecutionCanceledException,
       AlgorithmTimeoutedException,
       AlgorithmException

Overrides the call of Callable to restrict the set of allowed exceptions

Specified by:

call in interface java.util.concurrent.Callable<O>

Throws:

java.lang.InterruptedException

AlgorithmExecutionCanceledException

AlgorithmTimeoutedException

AlgorithmException

getId

java.lang.String getId()

globally unique identifier for the algorithm run

Returns: