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; }