SAMPLE CODING OF APRIORI

/** Commences process of outputting T-tree structure contents to screen. */
public void outputTtree() {
int number = 1;

// Loop

for (int index=1; index < startTtreeRef.length; index++) {
if (startTtreeRef[index] !=null) {
System.out.print("[" + number + "] {" + index);
System.out.println("} = " + startTtreeRef[index].support);
outputTtree(new Integer(number).toString(),
new Integer(index).toString(),
startTtreeRef[index].childRef);
number++;
}
}
}

/** Continue process of outputting T-tree.Operates in a recursive
manner.
@param number the ID number of a particular node.
@param itemSetSofar the label for a T-tree node as generated sofar.
@param linkRef the reference to the current array level in the T-tree. */

private void outputTtree(String number, String itemSetSofar,
TtreeNode[] linkRef) {
// Set output local variables.
int num=1;
number = number + ".";
itemSetSofar = itemSetSofar + " ";

// Check for empty branch/sub-branch.
if (linkRef == null) return;

// Loop through current level of branch/sub-branch.
for (int index=1;index if (linkRef[index] != null) {
System.out.print("[" + number + num + "] {" + itemSetSofar +
index);
System.out.println("} = " + linkRef[index].support);
String newitemSet = itemSetSofar +
new Integer(index).toString();
outputTtree(number + num,newitemSet,linkRef[index].childRef);
num++;
}
}
}

/** Commences process of outputting contents of a given T-tree branch to
screen.
@param linkRef the reference to the start of the branch*/

public void outputTtreeBranch(TtreeNode[] linkRef) {
int number = 1;

// Check for empty tree

if (linkRef == null) return;

// Loop

for (int index=1; index if (linkRef[index] !=null) {
System.out.print("[" + number + "] {" + index);
System.out.println("} = " + linkRef[index].support);
outputTtree(new Integer(number).toString(),
new Integer(index).toString(),linkRef[index].childRef);
number++;
}
}
}


/** Commences the process of counting and outputing number of supported
nodes in the T-tree.A supported set is assumed to be a non null node in
the T-tree. */

public void outputNumFreqSets() {

// If empty tree (i.e. no supported sets) do nothing
if (startTtreeRef== null) System.out.println("Number of frequent " +
"sets = 0");
// Otherwise count and output
else System.out.println("Number of frequent sets = " +
countNumFreqSets());
}

/** Commences process of counting the number of frequent sets contained in the T-tree. */

protected int countNumFreqSets() {
// If empty tree return 0
if (startTtreeRef == null) return(0);

// Otherwise loop through T-tree starting with top level
int num=0;
for (int index=1; index <= numOneItemSets; index++) {
// Check for null valued top level Ttree node.
if (startTtreeRef[index] !=null) {
if (startTtreeRef[index].support >= minSupport)
num = countNumFreqSets(index,
startTtreeRef[index].childRef,num+1);
}
}

// Return
return(num);
}

/** Counts the number of supported nodes in a sub branch of the T-tree.
@param size the length/size of the current array level in the T-tree.
@param linkRef the reference to the current array level in the T-tree.
@param num the number of frequent sets sofar. */

protected int countNumFreqSets(int size, TtreeNode[] linkRef, int num) {

if (linkRef == null) return(num);

for (int index=1; index < size; index++) {
if (linkRef[index] != null) {
if (linkRef[index].support >= minSupport)
num = countNumFreqSets(index,
linkRef[index].childRef,num+1);
}
}

// Return

return(num);
}


/** Commences the process of outputting T-tree statistics */

public void outputTtreeStats() {
System.out.println("T-TREE STATISTICS\n-----------------");
System.out.println(calculateStorage() + " (Bytes) storage");
System.out.println(countNumFreqSets() + " frequent sets");


}


/** Commences the process of determining and outputting the storage
requirements (in bytes) for the T-tree. */

public void outputStorage() {

// If empty tree (i.e. no supported sets) do nothing
if (startTtreeRef == null) return;

/* Otherwise calculate storage */
System.out.println("T-tree Storage = " + calculateStorage() +
" (Bytes)");
}

/** Commences process of calculating storage requirements for T-tree. */

protected int calculateStorage() {
// If emtpy tree (i.e. no supported sets) return 0
if (startTtreeRef == null) return(0);

/* Step through top level */
int storage = 4; // For element 0
for (int index=1; index <= numOneItemSets; index++) {
if (startTtreeRef[index] !=null) storage = storage + 12 +
calculateStorage(0,startTtreeRef[index].childRef);
else storage = storage+4;
}
// Return
return(storage);
}

/** Calculate storage requirements for a sub-branch of the T-tree.
@param localStorage the storage as calculated sofar .
@param linkRef the reference to the current sub-branch of the T-tree. */

private int calculateStorage(int localStorage, TtreeNode[] linkRef) {

if (linkRef == null) return(0);

for (int index=1; index < linkRef.length; index++) {
if (linkRef[index] !=null) localStorage = localStorage + 12 +
calculateStorage(0,linkRef[index].childRef);
else localStorage = localStorage + 4;
}

/* Return */

return(localStorage+4); }