private static bool IsInducedMatch(ReadOnlyCollection <NodeSymbol> large,
int currentIndex,
int currentDepth,
int upperBound,
int lowerBound,
ReadOnlyCollection <NodeSymbol> small,
int matchIndex, NodeSymbol backTrack)
{
var curDepth = currentDepth;
for (var l = currentIndex; l < large.Count; l++)
{
if (large.Count - l < small.Count - matchIndex)
{
break; // Cannot contain a subtree in this branch
}
if (large[l] == backTrack)
{
if (--curDepth < upperBound)
{
return(false); // End of this branch, no match
}
continue; // Continue this branch
}
curDepth++; // Reach to a deep depth
if (large[l] != small[matchIndex] || curDepth > lowerBound)
{
continue; // this is induced subtree, so cannot over go a node
}
// Got an identical and the virtual matched sequent list is increased by one.
// Try to find a next match in the larger tree with the next node in the smaller tree.
var offset = 0; // Here 'offset' records the change of depth.
for (var s = matchIndex + 1; s < small.Count; s++)
{
if (small[s] == backTrack)
{
if (s == small.Count - 1)
{
return(true); // It is subtree.
}
offset--;
continue;
}
offset++;
var lowerBoundNext = curDepth + offset;// Lower bound is used when induced subtree is the case
var upperBoundNext = lowerBoundNext - 1;
// Recursively to try to match the next node
if (IsInducedMatch(large, l + 1, curDepth, upperBoundNext, lowerBoundNext, small, s, backTrack))
{
return(true);
}
break; // Not match, break and try to match in an other branch in the larger tree
}
}
return(false); // Not match found.
}
private IEnumerable <PatternTree> SelectPatternsOfSameRoot(NodeSymbol symbol, ICollection <PatternTree> fDi, Depth depth)
{
var pts = new List <PatternTree>();
if (fDi == null || fDi.Count <= 0)
{
return(pts);
}
pts.AddRange(fDi.Where(pt => pt.FirstSymbol == symbol && pt.AbleToBeConnected && pt.ContainsDepth(depth)));
return(pts);
}
static string ToPreorderStringWithIndex(this ITreeNode node, NodeSymbol backTrack)
{
//if (node == null) throw new ArgumentNullException("node");
//if (string.IsNullOrEmpty(backTrack)) throw new ArgumentNullException("backTrack");
var str = string.Format("{0}[{1}]", node.Symbol, node.PreorderIndex);
if (node.Children != null && node.Children.Count > 0)
{
str = node.Children.Aggregate(str, (current, child) => current + child.ToPreorderStringWithIndex(backTrack));
}
return(str + backTrack);
}
public static string ToPreorderString(this ITreeNode itn, char separator, NodeSymbol backTrack)
{
//if (itn == null) throw new ArgumentNullException("itn");
//if (string.IsNullOrEmpty(seperator)) throw new ArgumentNullException("separator");
//if (string.IsNullOrEmpty(backTrack)) throw new ArgumentNullException("backTrack");
var str = itn.Symbol + separator.ToString(CultureInfo.InvariantCulture);
if (itn.Children != null && itn.Children.Count > 0)
{
str = itn.Children.Aggregate(str, (current, c) => current + c.ToPreorderString(separator, backTrack));
}
return(str + backTrack + separator.ToString(CultureInfo.InvariantCulture));
}
protected MiningParams(MiningParams another)
{
subtreeType = another.SubtreeType;
mineOrdered = another.MineOrdered;
mineFrequent = another.MineFrequent;
mineClosed = another.MineClosed;
mineMaximal = another.MineMaximal;
supportType = another.SupportType;
thresholdRoot = another.ThresholdRoot;
thresholdTransaction = another.ThresholdTransaction;
separator = another.separator;
backTrackSymbol = string.Copy(another.backTrackSymbol);
}
static internal List <string> ToPreorderStringArray(this ITreeNode itn, NodeSymbol backTrack)
{
var array = new List <string> {
itn.Symbol
};
if (itn.Children != null && itn.Children.Count > 0)
{
foreach (var child in itn.Children)
{
array.AddRange(ToPreorderStringArray(child, backTrack));
}
}
array.Add(backTrack);
return(array);
}
public static T ConvertToTextTree(string treeInString, char separator, NodeSymbol backTrack)
{
if (string.IsNullOrEmpty(treeInString))
{
throw new ArgumentNullException("treeInString");
}
if (string.IsNullOrEmpty(backTrack))
{
throw new ArgumentNullException("backTrack");
}
var treeInStringArr = treeInString.Split(new[] { separator, ' ' }, StringSplitOptions.RemoveEmptyEntries);
var tree = new T {
BackTrack = backTrack, Separator = separator
};
DoConvert(treeInStringArr, tree);
return(tree);
}
public MiningParams(
SubtreeType subtreeType,
bool mineOrdered,
bool mineFrequent,
bool mineClosed,
bool mineMaximal,
SupportType supportType,
int thresholdRoot,
int thresholdTransaction,
char separator,
string backTrackSymbol)
{
switch (subtreeType)
{
case SubtreeType.Induced:
this.subtreeType = subtreeType;
break;
default:
throw new NotSupportedException("subtreeType");
}
if (string.IsNullOrEmpty(backTrackSymbol))
{
throw new ArgumentNullException("backTrackSymbol");
}
this.mineOrdered = mineOrdered;
this.mineFrequent = mineFrequent;
this.mineClosed = mineClosed;
this.mineMaximal = mineMaximal;
this.supportType = supportType;
this.thresholdRoot = thresholdRoot;
this.thresholdTransaction = thresholdTransaction;
this.separator = separator;
this.backTrackSymbol = string.Copy(backTrackSymbol);
}
public bool Equals(NodeSymbol other)
{
return(string.Equals(symbol, other.symbol));
}
public static bool IsInducedSuperPattern(this PatternTree pt, PatternTree largerPt, NodeSymbol backTrack)
{
if (pt.Size > largerPt.Size)
{
return(false);
}
var largeList = largerPt.PreorderRepresentation;
var smallList = pt.PreorderRepresentation;
const int upperBound = 1;
const int lowerBound = int.MaxValue;
return(IsInducedMatch(largeList, 0, 0, upperBound, lowerBound, smallList, 0, backTrack));
}
public TreeComparer(NodeSymbol backTracking)
{
BackTracking = backTracking;
}
