private bool CanTransitionsBeMerged(LtmcTransition *a, LtmcTransition *b)
{
var aToStuttering = TransitionFlags.IsToStutteringState(a->Flags);
var bToStuttering = TransitionFlags.IsToStutteringState(b->Flags);
if (aToStuttering != bToStuttering)
{
// Target states do not match
return(false);
}
if (!aToStuttering)
{
// both target states are not the stuttering state. So check if the states match
if (!MemoryBuffer.AreEqual(a->TargetStatePointer, b->TargetStatePointer, RelevantStateVectorSize))
{
return(false);
}
}
if (a->Flags != b->Flags)
{
return(false);
}
if (a->Formulas != b->Formulas)
{
return(false);
}
return(true);
}
public LtmcTestBuilderWithStatesAsNumbers()
{
_transitionBuffer.Resize(TransitionCapacity * sizeof(LtmcTransition), zeroMemory: false);
_transitions = (LtmcTransition *)_transitionBuffer.Pointer;
Ltmc = new LabeledTransitionMarkovChain(StateCapacity, TransitionCapacity);
LtmcBuilder = new LabeledTransitionMarkovChain.LtmcBuilder(Ltmc);
}
public LtmcTestBuilder()
{
_transitionBuffer.Resize(TransitionCapacity * sizeof(LtmcTransition), zeroMemory: false);
_transitions = (LtmcTransition *)_transitionBuffer.Pointer;
Ltmc = new LabeledTransitionMarkovChain(StateCapacity, TransitionCapacity);
LtmcBuilder = new LabeledTransitionMarkovChain.LtmcBuilder <SimpleExecutableModel>(Ltmc);
}
public LtmcRetraverseTransitionSetBuilder(TemporaryStateStorage temporalStateStorage, long capacity)
{
Requires.That(capacity <= (1 << 30), nameof(capacity), $"Maximum supported capacity is {1 << 30}.");
_capacity = capacity;
_transitionBuffer.Resize(capacity * sizeof(LtmcTransition), zeroMemory: false);
_transitions = (LtmcTransition *)_transitionBuffer.Pointer;
_temporalStateStorage = temporalStateStorage;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="temporalStateStorage">A storage where temporal states can be saved to.</param>
/// <param name="capacity">The maximum number of successors that can be cached.</param>
/// <param name="formulas">The formulas that should be checked for all successor states.</param>
public LtmcTransitionSetBuilder(TemporaryStateStorage temporalStateStorage, long capacity, params Func <bool>[] formulas)
{
Requires.NotNull(temporalStateStorage, nameof(temporalStateStorage));
Requires.NotNull(formulas, nameof(formulas));
Requires.That(formulas.Length < 32, "At most 32 formulas are supported.");
Requires.That(capacity <= (1 << 30), nameof(capacity), $"Maximum supported capacity is {1 << 30}.");
_temporalStateStorage = temporalStateStorage;
_formulas = formulas;
_capacity = capacity;
_transitionBuffer.Resize(capacity * sizeof(LtmcTransition), zeroMemory: false);
_transitions = (LtmcTransition *)_transitionBuffer.Pointer;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="model">The model the successors are computed for.</param>
/// <param name="capacity">The maximum number of successors that can be cached.</param>
/// <param name="formulas">The formulas that should be checked for all successor states.</param>
public LtmcTransitionSetBuilder(ExecutableModel <TExecutableModel> model, long capacity, params Func <bool>[] formulas)
{
Requires.NotNull(model, nameof(model));
Requires.NotNull(formulas, nameof(formulas));
Requires.That(formulas.Length < 32, "At most 32 formulas are supported.");
Requires.That(capacity <= (1 << 30), nameof(capacity), $"Maximum supported capacity is {1 << 30}.");
_stateVectorSize = model.StateVectorSize;
_formulas = formulas;
_capacity = capacity;
_transitionBuffer.Resize(capacity * sizeof(LtmcTransition), zeroMemory: false);
_transitions = (LtmcTransition *)_transitionBuffer.Pointer;
_targetStateBuffer.Resize(capacity * model.StateVectorSize, zeroMemory: true);
_targetStateMemory = _targetStateBuffer.Pointer;
}
private uint HashTransition(LtmcTransition *transition)
{
// hashing see FNV hash at http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
if (!TransitionFlags.IsValid(transition->Flags))
{
return(0);
}
unchecked
{
uint hash = 0;
if (!TransitionFlags.IsToStutteringState(transition->Flags))
{
hash = MemoryBuffer.Hash(transition->TargetStatePointer, RelevantStateVectorSize, 0);
}
hash = hash * 397 ^ (uint)transition->Formulas.GetHashCode();
return(hash);
}
}
private void MergeCandidateWithAllApplicableTargets(LtmcTransition *mergeInCandidate, int mergeInCandidateIndex)
{
var mergeInCandidateHash = GetCandidateHash(mergeInCandidateIndex);
var toMergeCandidateIndex = mergeInCandidateIndex + 1;
while (!CandidateIsOutOfIndexOrHasDifferentHash(mergeInCandidateHash, toMergeCandidateIndex))
{
var toMergeCandidate = GetCandidateTransition(toMergeCandidateIndex);
if (TransitionFlags.IsValid(toMergeCandidate->Flags))
{
if (CanTransitionsBeMerged(mergeInCandidate, toMergeCandidate))
{
MergeTransitions(mergeInCandidate, toMergeCandidate);
}
}
toMergeCandidateIndex++;
}
}
private void MergeTransitions(LtmcTransition *mergeInCandidate, LtmcTransition *toMergeCandidate)
{
mergeInCandidate->Probability += toMergeCandidate->Probability;
toMergeCandidate->Flags = TransitionFlags.RemoveValid(toMergeCandidate->Flags);
}
public LtmcTestBuilderWithStatesAsByteVector()
{
_transitionBuffer.Resize(TransitionCapacity * sizeof(LtmcTransition), zeroMemory: false);
_transitions = (LtmcTransition *)_transitionBuffer.Pointer;
TemporaryStateStorage = new TemporaryStateStorage(sizeof(int), StateCapacity);
}
private void CheckIfTransitionIsValid(LtmcTransition *transition)
{
Assert.That(TransitionFlags.IsValid(transition->Flags), "Attempted to add an invalid transition.");
}
private void CreateNewTransitionChainStartWithTransition(int sourceState, bool areInitialTransitions, LtmcTransition *transition)
{
var locationOfNewEntry = _markovChain.GetPlaceForNewTransitionChainElement();
if (areInitialTransitions)
{
_markovChain._indexOfFirstInitialTransition = locationOfNewEntry;
}
else
{
_markovChain.SourceStates.Add(sourceState);
_markovChain._stateStorageStateToFirstTransitionChainElementMemory[sourceState] = locationOfNewEntry;
}
_markovChain._transitionChainElementsMemory[locationOfNewEntry] =
new TransitionChainElement
{
Formulas = transition->Formulas,
NextElementIndex = -1,
Probability = transition->Probability,
TargetState = transition->GetTargetStateIndex()
};
}
private void AddTransitionToTransitionChain(int sourceState, bool areInitialTransitions, LtmcTransition *probTransition)
{
var startPositionOfTransitionChain = GetStartPositionOfTransitionChain(sourceState, areInitialTransitions);
// startPositionOfTransitionChain == -1 indicates that no transition chain for state exists
if (startPositionOfTransitionChain == -1)
{
CreateNewTransitionChainStartWithTransition(sourceState, areInitialTransitions, probTransition);
}
else
{
AddTransitionToExistingTransitionChain(startPositionOfTransitionChain, probTransition);
}
}
private void AddTransitionToExistingTransitionChain(int startPositionOfTransitionChain, LtmcTransition *transition)
{
// Search for place to append is linear in number of existing transitions of state => O(n^2)
var currentTransitionElementIndex = startPositionOfTransitionChain;
// merge or append
while (true)
{
var currentElement = GetTransitionChainElement(currentTransitionElementIndex);
if (currentElement.TargetState == transition->GetTargetStateIndex() && currentElement.Formulas == transition->Formulas)
{
//Case 1: Merge
_markovChain._transitionChainElementsMemory[currentTransitionElementIndex].Probability =
transition->Probability + currentElement.Probability;
return;
}
if (currentElement.NextElementIndex == -1)
{
//Case 2: Append
var locationOfNewEntry = _markovChain.GetPlaceForNewTransitionChainElement();
_markovChain._transitionChainElementsMemory[currentTransitionElementIndex].NextElementIndex =
locationOfNewEntry;
_markovChain._transitionChainElementsMemory[locationOfNewEntry] =
new TransitionChainElement
{
Formulas = transition->Formulas,
NextElementIndex = -1,
Probability = transition->Probability,
TargetState = transition->GetTargetStateIndex()
};
return;
}
//else continue iteration
currentTransitionElementIndex = currentElement.NextElementIndex;
}
}
