public IPermutationsCollection Successors(Permutation permutation, ExtensionMap extensionMap,
IPermutationsCollection avoidedPermutations)
{
if (permutation.Length < avoidedPermutations.LengthLongestPermutation)
{
return(CreatePermutationsChecked(permutation, extensionMap, avoidedPermutations));
}
else
{
return(CreatePermutationsUnChecked(permutation, extensionMap));
}
}
public List <PermutationContainerPPA> GetSuccessors(IPermutationDictionary <ExtensionMap> collection,
IPermutationsCollection avoidedPermutations)
{
if (Permutation.Length <= lengthLongestPermutationAvoided)
{
return(ComputeSuccessors(collection, avoidedPermutations, true));
}
else
{
return(ComputeSuccessors(collection, avoidedPermutations, false));
}
}
protected override PatternNodePPA ComputeMaximalDepth(PatternNodePPA node,
IPermutationsCollection avoidedPermutations,
int depthComputed, ResultPPA result)
{
List <PatternNodePPA> nodes = Compute(node, avoidedPermutations, depthComputed - 1, result);
foreach (var nodeProcessed in nodes)
{
result.TryProcessNodeChildren(nodeProcessed);
}
return(node);
}
public List <PatternNodePPA> ComputeChildren(IPermutationDictionary <ExtensionMap> extensionMaps,
IPermutationsCollection permutationsAvoided)
{
List <PermutationContainerPPA> childrenUnfolded =
containerPPA.GetSuccessors(extensionMaps, permutationsAvoided);
List <PatternNodePPA> childrenNodes;
childrenNodes = ComputeChildren(childrenUnfolded);
SetChildren(childrenNodes);
return(childrenNodes);
}
public MinimumLettersChecked(IPermutationsCollection permutationsAvoided)
{
permutationsUpfixes = new IPermutationsCollection[permutationsAvoided.LengthLongestPermutation];
for (int i = 0; i < permutationsAvoided.LengthLongestPermutation; i++)
{
permutationsUpfixes[i] = new PermutationCollection();
}
foreach (var permutation in permutationsAvoided)
{
ComputeUpfixes(permutation, permutation.ComputeInversion());
}
}
protected void CorrectExtensionMap(Permutation newPermutation, ExtensionMap extensionMap,
IPermutationsCollection avoidedPermutations)
{
for (int i = 0; i < extensionMap.Length; i++)
{
if (extensionMap.Get(i))
{
if (avoidedPermutations.Contains(newPermutation.InsertPosition(i)))
{
extensionMap.SetMutable(i, false);
}
}
}
}
protected override PatternNodePPA ComputeMaximalDepth(PatternNodePPA node,
IPermutationsCollection avoidedPermutations,
int depthComputed, ResultPPA result)
{
List <PatternNodePPA> nodes = Compute(node, avoidedPermutations, depthComputed - 1, result);
foreach (var nodeProcessed in nodes)
{
result.ProcessPermutations(
successorsComputation.Successors(nodeProcessed.Permutation,
node.ExtensionMap, avoidedPermutations));
}
return(node);
}
public virtual PatternNodePPA Compute(IPermutationsCollection avoidedPermutations,
int maximalLengthAvoiders, int maximalDepthComputed, ResultPPA result)
{
PatternNodePPA node = GetStartingNode(avoidedPermutations, maximalLengthAvoiders);
int depth = Math.Min(maximalLengthAvoiders, maximalDepthComputed);
if (depth == maximalLengthAvoiders)
{
return(ComputeMaximalDepth(node, avoidedPermutations, depth, result));
}
else
{
return(ComputeNotMaximalDepth(node, avoidedPermutations, depth, result));
}
}
protected List <PermutationContainerPPA> ComputeSuccessors(IPermutationDictionary <ExtensionMap> collection,
IPermutationsCollection avoidedPermutations,
bool checkAvoidedPermutations)
{
Permutation newPermutation;
PatternBasic newPermutationPositions;
ExtensionMap newExtensionMap;
int newMinimumLettersConsidered;
List <PermutationContainerPPA> containers = new List <PermutationContainerPPA>();
PermutationContainerPPA permutationContainerPPA;
int maximumLettersConsidered = Math.Min(lengthLongestPermutationAvoided, Permutation.Length + 1);
foreach (var position in extensionMap.Ctz())
{
newPermutation = Permutation.InsertPosition(position);
if (checkAvoidedPermutations && avoidedPermutations.Contains(newPermutation))
{
continue;
}
newPermutationPositions = PermutationPositions.InsertLetter(position);
newPermutationPositions = CorrectPositionsTop(newPermutationPositions);
newMinimumLettersConsidered = minimumLettersBeChecked.
GetMinimumLettersConsidered(collection, newPermutation,
newPermutationPositions, maximumLettersConsidered);
newExtensionMap = exMapComputationUnsorted.Compute(collection, newPermutation,
newPermutationPositions, newMinimumLettersConsidered);
if (checkAvoidedPermutations)
{
CorrectExtensionMap(newPermutation, newExtensionMap, avoidedPermutations);
}
permutationContainerPPA = new PermutationContainerPPA(newPermutation, newPermutationPositions,
minimumLettersBeChecked, exMapComputationUnsorted,
newExtensionMap, lengthLongestPermutationAvoided,
newMinimumLettersConsidered);
containers.Add(permutationContainerPPA);
}
return(containers);
}
private IPermutationsCollection CreatePermutationsChecked(Permutation permutation, ExtensionMap extensionMap,
IPermutationsCollection avoidedPermutations)
{
PermutationCollection permutationCollection = new PermutationCollection();
Permutation newPermutation;
foreach (var position in extensionMap.Ctz())
{
newPermutation = permutation.InsertPosition(position);
if (!avoidedPermutations.Contains(newPermutation))
{
permutationCollection.Add(newPermutation);
}
}
return(permutationCollection);
}
protected abstract PatternNodePPA ComputeMaximalDepth(PatternNodePPA node,
IPermutationsCollection avoidedPermutations,
int depthComputed, ResultPPA result);
public void UnionWith(IPermutationsCollection permutationCollection)
{
hashSet.UnionWith(permutationCollection);
}
public PermutationContainerPPAFactory(IPermutationsCollection avoidedPermutations)
{
this.avoidedPermutations = avoidedPermutations;
}
