private void Traversal(PatternTree xPattern, int yIndex, IList <PatternTree> group, Depth depth)
{
var pX = xPattern;
var pY = group[yIndex];
var childPreStr = pX.CombinePreorderRepresentation(pY).ToPreorderString(MiningParams.Separator);
PatternTree child = null;
if (PatternsExtended.AlreadyExtended(childPreStr))
{
child = PatternsFrequent.GetPatternAtDepth(childPreStr, depth);
}
else if (pX.HasNewCombineOccurrenceAtDepth(pY, depth))
{
child = Combine2Patterns(pX, pY, depth);
}
if (child == null)
{
return;
}
for (var i = 0; i < group.Count; i++)
{
Traversal(child, i, group, depth);
}
}
private void CheckSuperPatternAfterCombination(Depth depth)
{
var toBeTested = PatternsFrequent.GetClosedAndMaximalUnknownAtDepth(depth);
var groups = DevideToRelatedGroups(toBeTested);
foreach (var group in groups)
{
for (var x = 0; x < group.Count; x++)
{
if (group[x].HasOccurrenceMatch != YesNoUnknown.Unknown)
{
continue;
}
for (var y = 0; y < group.Count; y++)
{
if (x == y || group[x].Size >= group[y].Size)
{
continue;
}
group[x].CheckSuperPatternAfterCombination(group[y], depth, MiningParams.MineClosed);
if (group[x].HasOccurrenceMatch != YesNoUnknown.Unknown)
{
break;
}
}
}
}
}
private PatternTree Combine2Patterns(PatternTree px, PatternTree py, Depth depth)
{
var preList = px.CombinePreorderRepresentation(py);
var child = PatternTree.Create(preList, false, MiningParams);
PatternsExtended.AddPattern(child);
var curDepth = depth + 1;
while (--curDepth >= 0)
{
if (!px.ContainsDepth(curDepth) || !py.ContainsDepth(curDepth))
{
continue;
}
foreach (TreeOccSet tSet in px[curDepth].GetTreeSet())
{
if (!py.ContainsTreeAtDepth(curDepth, tSet.TreeId))
{
continue;
}
foreach (RootOcc root in tSet.GetRootSet())
{
if (!py.ContainsRootIndex(curDepth, tSet.TreeId, root.RootIndex))
{
continue;
}
var xOcc = px.GetOccurrence(curDepth, tSet.TreeId, root.RootIndex);
var yOcc = py.GetFirstOccAfterSpecifiedIndex(xOcc.Depth, xOcc.TreeId, xOcc.RootIndex, xOcc.RightMostIndex);
if (yOcc == null)
{
continue;
}
child.AddOccurrence(xOcc.Combine(yOcc));
}
}
}
if (!child.IsFrequent)
{
return(null);
}
PatternsFrequent.AddFrequentPattern(child);
child.Father = px;
child.Mother = py;
px.CheckMatch(child);
py.CheckMatch(child);
return(child);
}
protected override void Combine(Depth depth)
{
var rDi = PatternsFrequent.GetCombinableAtDepth(depth);
StartTraversal(rDi, depth);
if (MiningParams.MineClosed || MiningParams.MineMaximal)
{
CheckSuperPatternAfterCombination(depth);
}
}
private void DetermineClosed(Depth depth)
{
var fdi = PatternsFrequent.GetFrequentsAtDepth(depth + 1);
foreach (var pt in fdi)
{
pt.DetermineClosed(depth + 1);
if (pt.IsClosed == YesNoUnknown.Yes)
{
PatternsFrequent.AddClosed(pt);
}
}
}
private void DetermineMaximal(Depth depth)
{
var couldBeMaximal = PatternsFrequent.GetPotentialMaximalAtDepth(depth + 1);
foreach (var pt in couldBeMaximal)
{
pt.DetermineMaximal(depth + 1);
if (pt.IsMaximal == YesNoUnknown.Yes)
{
PatternsFrequent.AddMaximal(pt);
}
}
}
protected override int GenerateF1F2(IEnumerable <ITextTree> treeSet)
{
Depth maxDepth = -1;
foreach (var tree in treeSet)
{
ScanP1P2(tree.Root, ref maxDepth);
}
PatternsFrequent.SetDepth(maxDepth);
EvaluateFrequency();
return(maxDepth);
}
/// <summary>
/// For closed and maximal property if required.
/// </summary>
private void EvaluateF1()
{
if (!MiningParams.MineClosed && !MiningParams.MineMaximal)
{
return;
}
var f1Set = PatternsFrequent.Frequent1Pts;
var f2Set = PatternsFrequent.Frequent2Pts;
foreach (OnePatternTree f1 in f1Set.Values)
{
foreach (var f2 in f2Set.Values)
{
if (!f1.IsSuperPattern(f2))
{
continue;
}
f1.CheckMatch(f2);
if (f1.HasOccurrenceMatch != YesNoUnknown.Unknown &&
f1.HasTransactionMatch != YesNoUnknown.Unknown)
{
break;
}
}
if (MiningParams.MineClosed)
{
f1.DetermineClosed();
if (f1.IsClosed == YesNoUnknown.Yes)
{
PatternsFrequent.AddClosed(f1);
}
}
if (MiningParams.MineMaximal)
{
f1.DetermineMaximal();
if (f1.IsMaximal == YesNoUnknown.Yes)
{
PatternsFrequent.AddMaximal(f1);
}
}
}
}
/// <summary>
/// Frequency evaluation of each pattern (either 1-pattern or 2-pattern)
/// generated after scanning the input transaction data set.
/// </summary>
private void EvaluateFrequency()
{
foreach (var pt in OnePatterns.Values.Where(pt => pt.IsFrequent))
{
PatternsFrequent.AddFrequentPattern(pt);
}
foreach (var pt in TwoPatterns.Values.Where(pt => pt.IsFrequent))
{
PatternsFrequent.AddFrequentPattern(pt);
}
if (MiningParams.MineClosed || MiningParams.MineMaximal)
{
EvaluateF1();
}
}
protected override void Connect(Depth depth)
{
var f2Di = PatternsFrequent.GetConnectableAtDepth(depth);
var fDj = PatternsFrequent.GetToBeConnectableAtDepth(depth + 1);
foreach (var f2 in f2Di)
{
var toBeConnected = SelectPatternsOfSameRoot(f2.SecondSymbol, fDj, depth + 1);
foreach (var fpt in toBeConnected)
{
var childPreStr = f2.ConnectPreorderRepresentation(fpt).ToPreorderString(MiningParams.Separator);
if (PatternsExtended.AlreadyExtended(childPreStr))
{
continue;
}
if (!f2.HasNewConnectOccurrenceAtDepth(fpt, depth))
{
continue;
}
ConnectTwoPatterns(f2, fpt, depth);
}
}
if (MiningParams.MineClosed)
{
DetermineClosed(depth);
}
if (MiningParams.MineMaximal)
{
DetermineMaximal(depth);
}
Pruner.PruneAfterConnection(PatternsFrequent, MiningParams, depth);
}
private void ConnectTwoPatterns(PatternTree f2, PatternTree fpt, Depth depth)
{
if (f2.Size != 2)
{
throw new InvalidOperationException("The connect pattern must be 2-pattern.");
}
var preList = f2.ConnectPreorderRepresentation(fpt);
var child = PatternTree.Create(preList, true, MiningParams);
PatternsExtended.AddPattern(child);
var depthC = depth + 1; // Depth of connect
while (--depthC >= 0)
{
if (!f2.ContainsDepth(depthC))
{
continue;
}
var depthTbc = depthC + 1; // Depth of to be connected
if (!fpt.ContainsDepth(depthTbc))
{
continue;
}
foreach (TreeOccSet tSet in f2[depthC].GetTreeSet())
{
if (!fpt.ContainsTreeAtDepth(depthTbc, tSet.TreeId))
{
continue;
}
foreach (RootOcc root in tSet.GetRootSet())
{
foreach (IOccurrence f2Occ in root.GetRightMostSet())
{
if (!fpt[depthTbc][tSet.TreeId].RootSet.ContainsKey(f2Occ.SecondIndex))
{
continue;
}
var newOcc = f2Occ.Connect(fpt[depthTbc][tSet.TreeId][f2Occ.SecondIndex].FirstOcc);
child.AddOccurrence(newOcc);
}
}
}
}
if (!child.IsFrequent)
{
return;
}
PatternsFrequent.AddFrequentPattern(child);
child.Father = f2;
child.Mother = fpt;
f2.CheckMatch(child);
fpt.CheckMatch(child);
}
