org.processmining.plugins.astar.petrinet.impl

Class PILPTail

java.lang.Object

org.processmining.plugins.astar.petrinet.impl.PILPTail

All Implemented Interfaces:

nl.tue.astar.FastLowerBoundTail, nl.tue.astar.Tail

public class PILPTail
extends java.lang.Object
implements nl.tue.astar.FastLowerBoundTail

Field Summary

Fields

Modifier and Type	Field and Description
protected int	estimate
protected boolean	isExact
protected short[]	variables

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	PILPTail(int estimate, short[] variables, boolean isExact)
	PILPTail(PILPDelegate delegate, PHead h, int minCost)

Method Summary

Methods

Modifier and Type	Method and Description
boolean	canComplete() returns true if and only if the replay can finish according to this tail, i.e.
void	computeEstimate(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d, nl.tue.astar.Head head, int lastEstimate) Starts the computation of the exact estimate on the first call.
int	getEstimate()
int	getEstimatedCosts(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d, nl.tue.astar.Head head) get an estimate of the remaining distance to the target state in the search.
PILPTail	getNextTail(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d, nl.tue.astar.Head newHead, int modelMove, int logMove, int activity) constructs the new tail based on the two operations from the old head.
<S> nl.tue.astar.Tail	getNextTailFromStorage(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d, nl.tue.storage.CompressedStore<S> store, long index, int modelMove, int logMove, int activity) constructs the new tail based on the two operations from the old state, which is stored in the given store at the given index.
static int	getSizeFor(int variables)
short[]	getVariables()
boolean	isExactEstimateKnown() This method should return true if the exact estimate is known.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

estimate

protected int estimate

variables

protected final short[] variables

isExact

protected boolean isExact

Constructor Detail

PILPTail

public PILPTail(PILPDelegate delegate,
        PHead h,
        int minCost)

PILPTail

protected PILPTail(int estimate,
        short[] variables,
        boolean isExact)

Method Detail

getSizeFor

public static int getSizeFor(int variables)

getNextTail

public PILPTail getNextTail(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d,
                   nl.tue.astar.Head newHead,
                   int modelMove,
                   int logMove,
                   int activity)

Description copied from interface: nl.tue.astar.Tail

constructs the new tail based on the two operations from the old head. Preferably, the code to compute the new tail is kept as lightweight as possible.

Specified by:

getNextTail in interface nl.tue.astar.Tail

Returns:

getNextTailFromStorage

public <S> nl.tue.astar.Tail getNextTailFromStorage(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d,
                                           nl.tue.storage.CompressedStore<S> store,
                                           long index,
                                           int modelMove,
                                           int logMove,
                                           int activity)
                                         throws java.io.IOException

Description copied from interface: nl.tue.astar.Tail

constructs the new tail based on the two operations from the old state, which is stored in the given store at the given index. Preferably, the code to compute the new tail is kept as lightweight as possible.

Specified by:

getNextTailFromStorage in interface nl.tue.astar.Tail

Returns:

Throws:

java.io.IOException

getEstimatedCosts

public int getEstimatedCosts(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d,
                    nl.tue.astar.Head head)

Description copied from interface: nl.tue.astar.FastLowerBoundTail

get an estimate of the remaining distance to the target state in the search. This method should return a fast lower bound, until the computeEstimate() method has been called. After that, the exact estimate should be returned

Specified by:

getEstimatedCosts in interface nl.tue.astar.FastLowerBoundTail

Specified by:

getEstimatedCosts in interface nl.tue.astar.Tail

Returns:

canComplete

public boolean canComplete()

Description copied from interface: nl.tue.astar.Tail

returns true if and only if the replay can finish according to this tail, i.e. for the case

Specified by:

canComplete in interface nl.tue.astar.Tail

Returns:

getEstimate

public int getEstimate()

getVariables

public short[] getVariables()

computeEstimate

public void computeEstimate(nl.tue.astar.Delegate<? extends nl.tue.astar.Head,? extends nl.tue.astar.Tail> d,
                   nl.tue.astar.Head head,
                   int lastEstimate)

Description copied from interface: nl.tue.astar.FastLowerBoundTail

Starts the computation of the exact estimate on the first call. The method should not return before the exact estimate is known. The exact estimate should never become lower than the previously computed lowerbound. Every additional call to computeEstimate should be ignored.

Specified by:

computeEstimate in interface nl.tue.astar.FastLowerBoundTail

isExactEstimateKnown

public boolean isExactEstimateKnown()

Description copied from interface: nl.tue.astar.FastLowerBoundTail

This method should return true if the exact estimate is known. It should return true after the first call to ComputeEstimate, but may return true ealier.

Specified by:

isExactEstimateKnown in interface nl.tue.astar.FastLowerBoundTail

Returns: