/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                            PHRASE BINARY TREE                              */
/*                                                                            */
/*                                Frans Coenen                                */
/*                                                                            */
/*                         Wednesday 21 December 2005                         */
/*                             (Revised 3/2/2006)                             */
/*                                                                            */
/*                       Department of Computer Science                       */
/*                        The University of Liverpool                         */
/*                                                                            */
/* -------------------------------------------------------------------------- */

//package lucsKDD_ARM;

/** Contains methods to generate a binary tree to describe all the phrases 
representesd by a set of documents. Generated by processing the training 
document base using methods in <TT>TrainingSetDocumentBase</TT> commencing with
the method <TT>generatePhraseBinTree</TT>. Also conatins the methods to recast
the input training set in terms of a set of attributes representing phrases
and to output the training set.
@author Frans Coenen
@version 21 December 2005.  */

public class PhraseBinTree {

    /* ------------------------------- */
    /*                                 */
    /*              FIELDS             */
    /*                                 */
    /* ------------------------------- */
     
    /** Reference to start of phrase bin tree. */
    private PhraseBinTreeNode phraseBinTreeStart = null;
    /** 2D array in which to store traing set of binary valued ARM data. */
    private short[][] trainingDataArray = null;
    
    /* ------------------------------------ */
    /*                                      */
    /*              CONSTRUCTORS            */
    /*                                      */
    /* ------------------------------------ */

    // Defulat constructor only  
    
    /* ------------------------------------ */
    /*                                      */
    /*                 METHOS               */
    /*                                      */
    /* ------------------------------------ */

    /* ---------------------------------------------------- */
    /*              METHODS TO GENERATE BIN TREE            */
    /* ---------------------------------------------------- */

    /** Starts recursive process of adding phrase to bin tree.
    @param phrase to be added.
    @param docNum the ID number of the current document. 
    @param fstSigWordInPhrase the first significant word in the phrase.
    @param indexOfFstSigWordInPhrase the index of the first significant word in 
    the phrase.		*/

    public PhraseBinTreeNode addToPhraseBinTree(String[] phrase, int docNum,
    		String fstSigWordInPhrase, int indexOfFstSigWordInPhrase) {
        // Check for empty tree.
	if (phraseBinTreeStart==null) {
	    phraseBinTreeStart = new PhraseBinTreeNode(phrase,docNum,
	                         fstSigWordInPhrase,indexOfFstSigWordInPhrase);
	    return(phraseBinTreeStart);
	    }
	else return(addToPhraseBinTree(phraseBinTreeStart,phrase,docNum,
	                        fstSigWordInPhrase,indexOfFstSigWordInPhrase));
	}

    /** Continues process of adding phrase to bin tree.
    @param node the current location in the phrase bin tree.
    @param phrase to be added.
    @param docNum the ID number of the current document. 
    @param sigWord the first significant word in the phrase.
    @param indexSigWord the index of the first significant word in the 
    phrase.	 */

    private PhraseBinTreeNode addToPhraseBinTree(PhraseBinTreeNode currentNode, 
                                   String[] phrase, int docNum, String sigWord, 
                                                            int indexSigWord) {
        int selector = comparePhrase(phrase,currentNode.phrase);

	// Comparison: If selector equals 0 found identical phrase
	if (selector == 0) {
	    if (docNumberDoesNotExist(currentNode,docNum)) 
	    				   addToDocNumbers(currentNode,docNum);
	    return(currentNode);
	    }
	// Left hand branch
	else if (selector < 0) {
	    if (currentNode.beforeBranch==null) {
	        PhraseBinTreeNode newPhraseBinTreeNode = 
				           new PhraseBinTreeNode(phrase,docNum,
	                                                 sigWord,indexSigWord);
	    	currentNode.beforeBranch = newPhraseBinTreeNode;
		return(newPhraseBinTreeNode);
		}
	    else return(addToPhraseBinTree(currentNode.beforeBranch,phrase,
	                                         docNum,sigWord,indexSigWord));
	    }
	// Rught hand branch
	else {
	    if (currentNode.afterBranch==null) {
	        PhraseBinTreeNode newPhraseBinTreeNode =
		                           new PhraseBinTreeNode(phrase,docNum,
	                                                 sigWord,indexSigWord);
	        currentNode.afterBranch = newPhraseBinTreeNode;
		return(newPhraseBinTreeNode);
		}
	    else return(addToPhraseBinTree(currentNode.afterBranch,phrase,
	    				         docNum,sigWord,indexSigWord));
	    }
	}

    /** Compare phrases to determine relative lexicographical location.
    @param phrase the given phrase.
    @param newPhrase the phrase representwed by the current node. 
    @param return 0 if the same, -1 if phrase is lexicographically before the
    node phrase and 1 otherwise. */

    public static int comparePhrase(String[] phrase, String[] nodePhrase) {
         int same = 0, before = -1, after = 1;
	 
	 for (int index=0;index<phrase.length;index++) {
	     // Phrase same as start of node phrase but phrase is longer.
	     if (index==nodePhrase.length) return(after);
	     // Compare
	     int selector = phrase[index].compareTo(nodePhrase[index]);
	     if (selector<0) return(before);
	     else if (selector>0) return(after);
	     }
	     
	 // If phrases the same length then they are the same
	 if (phrase.length==nodePhrase.length) return(same);
	 // Otherwise noderPhrase same as start of phrase but node phrase is 
	 // longer.
	 return(before);
	 }
    
    /** public void setAdds a document number to the document list for the 
    current word.
    @param node the current node in the phrase bin tree.
    @param docNum the ID number of the current document.  */

    private void addToDocNumbers(PhraseBinTreeNode node, int newDocNum) {
        // Declare new document numbers array
        int length = node.docNumbers.length+1;
	int[] newDocNums = new int[length];

	// Copy existing document numbers
	int index=0;
	for (;index<node.docNumbers.length;index++) {
	    newDocNums[index] = node.docNumbers[index];
	    }

	// Add new document number and end
	newDocNums[index] = newDocNum;
	node.docNumbers = newDocNums;
	}

    /** Determines if word has alread been recordfed for a document.
    @param node the current node in the phrase bin tree.
    @param docNum the ID number of the current document.
    @return true id word has been recorded, false otherwise. */

    private boolean docNumberDoesNotExist(PhraseBinTreeNode node, int docNum) {
    	final boolean DOC_DOES_NOT_EXIST = true;

        for (int index=0;index<node.docNumbers.length;index++) {
	    if (docNum == node.docNumbers[index]) return(!DOC_DOES_NOT_EXIST);
	    }

	// End
	return(DOC_DOES_NOT_EXIST);
	}

    /* ------------------------------------------------------ */
    /*              GENERATE TRAINING DATA ARRAY (PHRASES)    */
    /* ------------------------------------------------------ */
    
    /** Commences process of recasting training set as array of attributes with 
    each phrase representing a single attribute number. 
    @param numDocs the number of documents in the training set. 
    @param docBase the training set document base comprising a set of reference
    to nodes in the phrae bin tree.
    @param return the training data array. */
    
    public short[][] genTrainingDataArray(int numDocs, 
                                             TrainingSetDocumentBase docBase) {
        // Attributes are numbered from 1
	final short START_ATT_NUM = 1;
	
	// Initialise document array.
        trainingDataArray = new short[numDocs][];
	for (int index=0;index<trainingDataArray.length;index++) 
				       trainingDataArray[index] = new short[0];
					
	// Populate data array
	short lastAttNum = generateDataArray(phraseBinTreeStart,START_ATT_NUM);
	addClassNumbers(lastAttNum,docBase);
	
	// return
	return(trainingDataArray);
	}
    
    /** Continues process of recasting training set as array of attributes
    (each attribute representing a phrase). <P> Proceeds by processing phrase
    bin tree node by node, each phrase bin tree node includes a list of the
    documents in which the phrase represented by the node are contained. Note 
    that documents are numbered from 1 onwards while the data array is indexed 
    starting from zero therefore it is necessary to subtract 1 from the 
    document number to obtian the array index. 
    @param node the current location in the phrase bin tree.
    @param attNum the current attrivute number. */

    private short generateDataArray(PhraseBinTreeNode node, short attNum) {
        if (node != null) {
	    // Left Branch
	    attNum = generateDataArray(node.beforeBranch,attNum);
            // Process node
	    addToDataArray(node.docNumbers,attNum);
	    // Right Branch		
	    attNum = generateDataArray(node.afterBranch,(short) (attNum+1));
	    }
	    
	// End
	return(attNum);
	}

    /** Adds phrase attibute to appropriate locations in data array. Note 
    that documents are numbered from 1 onwards while the data array is indexed 
    starting from zero therefore it is necessary to subtract 1 from the 
    document number to obtian the array index. 
    @param docNumbers the list of documents in which the attribute appears. 
    @param attNum the current attrivute number.	*/
    
    private void addToDataArray(int[] docNumbers, short attNum) {
        // Process document numbers array
        for(int docNumIndex=0;docNumIndex<docNumbers.length;docNumIndex++) {
	    int docNumber         = docNumbers[docNumIndex];
	    int length            = trainingDataArray[docNumber].length;
	    short[] tempDataArray = new short[length+1];
	    int index             = 0;
	    // Add attribute number to records in data array, first copy
	    // record, then add attribute number, and then reassign.
	    for (;index<trainingDataArray[docNumber].length;index++) 
	    	  tempDataArray[index] = trainingDataArray[docNumber][index]; 
	    // Add new attribute number
	    tempDataArray[index]    = attNum;
	    // Reassign to data array
	    trainingDataArray[docNumber] = tempDataArray;
	    }
	}

    /** Adds class numbers to training data array
    @param lastAttNum the attribute number for the first class label.
    @param docBase reference to the TrainingSetDocumentBase object. */
    
    private void addClassNumbers(short lastAttNum, 
                                        TrainingSetDocumentBase docBase) {
        for (short docIndex=0;docIndex<trainingDataArray.length;docIndex++) {
	    short classNum = (short)
	    	                   (docBase.getClassLabel(docIndex)+lastAttNum);
	    int length            = trainingDataArray[docIndex].length;
	    short[] tempDataArray = new short[length+1];
	    int index             = 0;
	    // Add class number to record, first copy record, then add 
	    // class number, and then reassign.
	    for (;index<trainingDataArray[docIndex].length;index++) 
	    	 tempDataArray[index] = trainingDataArray[docIndex][index]; 
	    // Add new attribute number
	    tempDataArray[index]    = classNum;
	    // Reassign to data array
	    trainingDataArray[docIndex] = tempDataArray;
	    }
        }

    /* ----------------------------------------- */
    /*              GENERATE TEST DATA ARRAY     */
    /* ----------------------------------------- */

    /** Commences process of recasting a single test set document into an array 
    of attributes with each phrase contained in the test set document
    represented by a single attribute number 
    @param testDocBase the given instance of the class TestSetDocBase contining
    a list (String array) of all the words represented in the test set document
    @param dovNum the current document number. 
    @param classNum the class ID number for the current document. */

    public void convertTestDocToAtts(TestSetDocumentBase testDocBase,
                                                int docNum, short classNum) {
        final short START_ATT_NUM = 1;

        // Generate attributes
	short lastAttNum = generateTestDataArray(testDocBase,
                                phraseBinTreeStart,docNum,START_ATT_NUM);

	// Add class number
	testDocBase.addToDataArray(docNum,(short) (classNum+lastAttNum));
	}


    /** Continues process of recasting test set as array of attributes. <P>
    Proceeds in a recursive manner by processing the phrase bin tree.
    @param testDocBase the given instance of the class TestSetDocBase.
    @param node the current location in the phrase bin tree.
    @param docNum the current document number.
    @param attNum the current attribute number. */

    private short generateTestDataArray(TestSetDocumentBase testDocBase,
                PhraseBinTreeNode node, int docNum, short attNum) {
        if (node != null) {
	    // Left Branch
	    attNum = generateTestDataArray(testDocBase,node.beforeBranch,
                                                                docNum,attNum);
            // Process phrase at node (method in TestSetDocumentBase class).
            testDocBase.findInTestSetDoc(node.phrase,node.sigWord,
	                                      node.indexSigWord,docNum,attNum);
	    // Right Branch
	    attNum = generateTestDataArray(testDocBase,node.afterBranch,
                                                    docNum,(short) (attNum+1));
	    // Return
	    return(attNum);
	    }
	else return(attNum);
	}
	
    /* ---------------------------------------------------------- */
    /*                                                            */
    /*                       GET METHODS                          */
    /*                                                            */
    /* ---------------------------------------------------------- */

    /* NUMBER OF NODES IN PHRASE BIN TREE */
    
    /** Commences process of counting number of nodes in phrase bin tree.
    @return the number of unpruned nodes.	*/
    
    public int getNumNodesInPhraseBinTree() {
        final int COUNTER=0;
	
    	return(getNumNodesInPhraseBinTree(phraseBinTreeStart,COUNTER));
	}
    
    /** Continues process of counting number of nodes in phrase bin tree. 
    @param node the current location in the bin tree. 
    @param countSoFar the number of unpruned nodes counted so far.
    @return the number of unpruned nodes.	*/
    
    public int getNumNodesInPhraseBinTree(PhraseBinTreeNode node, 
                                                          int countSofar) {

	if (node != null) {
	    countSofar = countSofar+1;
	    // Process before branch
	    countSofar = getNumNodesInPhraseBinTree(node.beforeBranch,
	    							countSofar);
	    // Process after branch
	    countSofar = getNumNodesInPhraseBinTree(node.afterBranch,
	    							countSofar);
	    }
	
	// Return
	return(countSofar);
	}
	
    /* NUMBER OF PROPPER PHRASES IN BIN TREE */
    
    /** Commences process of counting number of proper phrases in the
    phrase bin tree.
    @return the number of proper phrase.	*/
    
    private int getNumProperPhrasesInBinTree() {
        final int COUNTER=0;
	
    	return(getNumProperPhrasesInBinTree(phraseBinTreeStart,COUNTER));
	}
    
    /** Continues process of counting number of proper phrases in the
    phrase bin tree. 
    @param node the current location in the bin tree. 
    @param countSoFar the number of unpruned nodes counted so far.
    @return the number of unpruned nodes.	*/
    
    public int getNumProperPhrasesInBinTree(PhraseBinTreeNode node, 
                                                          int countSofar) {
	if (node != null) {
	    if (node.phrase.length>1) countSofar = countSofar+1;
	    // Process before branch
	    countSofar = getNumProperPhrasesInBinTree(node.beforeBranch,
	    							countSofar);
	    // Process after branch
	    countSofar = getNumProperPhrasesInBinTree(node.afterBranch,
	    							countSofar);
	    }
	
	// Return
	return(countSofar);
	}
	
    /* ------------------------------------------------------------------- */
    /*                                                                     */
    /*                       BOOLEAN TEST METHODS                          */
    /*                                                                     */
    /* ------------------------------------------------------------------- */
	
    /* NONE */
	
    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                       DIAGNOSTIC OUTPUT                          */
    /*                                                                  */
    /* ---------------------------------------------------------------- */
    
    /* OUTPUTS TRAINING DATA ARRAY STATISTICS */
 
    /** Output trainimng set statistics: average number of attributes per 
    record and number of empty records (except class attribute); and average 
    number of attributes per record per class and number of empty records per
    class.
    @param numOneItemSets the number of one item sets in the data set.
    @param numClasses the number of classes represented in the data set. */
    
    /*public void outputTrainingSetStats(int numOneItemSets, int numClasses) {
        System.out.println("TRAINING SET STATS:\n===================");
        int offset    = numClasses-numOneItemSets-1;
	int numAtts   = 0;
	int numDocs   = 0;
	int numMTrecs = 0;
	
	// Initilise array to hold class data
	int[] numAttsPerClass   = new int[numClasses];
	int[] numDocsPerClass   = new int[numClasses];
	int[] numMTrecsPerClass = new int[numClasses];
	   
        // Process training data array
	for (int docIndex=0;docIndex<trainingDataArray.length;docIndex++) {
	    // Determine number of attributes (excluding class attribute) and 
	    // class index
	    int lastIndex  = trainingDataArray[docIndex].length-1;
	    int classIndex = 
	                 (int) trainingDataArray[docIndex][lastIndex]+offset;
	    // Update number of attributes; first check for empty record 
	    // (except class)
	    if (lastIndex==0) {
	        numMTrecs++;
		numMTrecsPerClass[classIndex]++;
	        }
	    else {
	        numAttsPerClass[classIndex] = 
		                       numAttsPerClass[classIndex]+lastIndex; 
	        numAtts = numAtts + lastIndex;
		}
	    // Update number of documents
	    numDocsPerClass[classIndex]++;
	    numDocs++;
	    }
	    
	// Output
	System.out.println("\t|# docs. \t| MT recs \t| Ave. Atts.");
	System.out.println("Total: \t| " + numDocs + "\t| " + numMTrecs + 
		     "\t| " + twoDecPlaces((double) numAtts/(double) numDocs));
	for (int index=0;index<numAttsPerClass.length;index++) {
	    System.out.print("Class " + (index+1) + "\t| " + 
	                                      numDocsPerClass[index] + "\t| " + 
					    numMTrecsPerClass[index] + "\t| "); 
	    if (numDocsPerClass[index] != 0) 
	       System.out.println(twoDecPlaces((double) numAttsPerClass[index]/
	                                     (double) numDocsPerClass[index]));
	    else System.out.println("0");
	    }
	System.out.println();
	} */
	    
    /* OUTPUT TRAINING DATA ARRAY (ATTRIBUTE NUMBERS) */
    
    /** Outputs training data array as sequence of attribute numbers. <P> data
    array is a 2-D array, first index represenmts the record/document number 
    and the second the phrase index. Each cell cintains an attribute number
    describing a phrase. Used for local testing only.	 */
    
    /*private void outputDataArrayAttributes() {
        System.out.println("TRAINING ATTRIBUTE SET (ATTRIBUTES)");
	System.out.println("===================================");
	
	// Process training data array
	for (int docIndex=0;docIndex<trainingDataArray.length;docIndex++) {
	    System.out.println("DOCUMENT " +  docIndex + ": ");
	    for (int index=0;index<trainingDataArray[docIndex].length;index++) {
	        System.out.print(trainingDataArray[docIndex][index] + " ");
		}
	    System.out.println("\n");
	    }
	
	// End
        System.out.println("\n");
        } */
    
    /* OUTPUT TRAINING DATA ARRAY (ATTRIBUTE PHRASES) */
    
    /** Outputs training data array as sequence of phrases. <P> data array is a 
    2-D array, first index represenmts the record/document number and the 
    second the phrase index. Each cell cintains an attribute number describing 
    a phrase.	 	 
    @param phraseMiningObj the current instance of the class
    <TT>PhraseMining</TT> (required to get the class label).	 */
    	
    /* public void outputDataArrayPhrases(PhraseMining phraseMiningObj) {
        System.out.println("TRAINING ATTRIBUTE SET (PHRASES)");
	System.out.println("================================");
	for (int docIndex=0;docIndex<trainingDataArray.length;docIndex++) {
	    System.out.print("DOCUMENT " +  docIndex + ": ");
	    int length = trainingDataArray[docIndex].length-1;
	    // Output attributes
	    for (int index=0;index<length;index++) {
	        outputPhraseN(trainingDataArray[docIndex][index]);
		}
	    // Add class
	    String ClassLiteral = phraseMiningObj.
	               getClassLiteral(trainingDataArray[docIndex][length]);
	    System.out.println(ClassLiteral + "\n");
	    }
	
	// End
        System.out.println("\n");
        } */
	
    /* OUTPUT PHRASES */
    
    /** Outputs a list of identified phrases. */
    
    public void outputPhrases() {
        System.out.println("IDENTIFIED PHRASES");
	System.out.println("==================");
	int phraseNumber = 1;
        outputPhrases(phraseBinTreeStart,phraseNumber);
	System.out.println("\n");
	}
	
    /** Continues process of outputting list of identified phrases.
    @param node the current location in the bin tree.	 
    @param phraseNum the node number (identifier). 
    @return the current phrase number as incremented so far. */
    
    private int outputPhrases(PhraseBinTreeNode node, int phraseNum) {
        if (node != null) {
	    // Process before branch
	    phraseNum = outputPhrases(node.beforeBranch,phraseNum);
	    // Output phrase at node
	    System.out.println("{[" + phraseNum + "] " + node);
	    phraseNum++;
	    // Process after branch
	    phraseNum = outputPhrases(node.afterBranch,phraseNum);
	    }
	    
	// End
        return(phraseNum);
	}
	
    /* OUTPUT PHRASES (1st 100) */
    
    /** Outputs a firsdt 100 items in the list of identified phrases. */
    
    public void outputPhrases100() {
        System.out.println("1st 100 IDENTIFIED PHRASES");
	System.out.println("==========================");
	int phraseNumber       = 1;
	int numPhrasesToOutput = 100;
        outputPhrasesN(phraseBinTreeStart,phraseNumber,numPhrasesToOutput);
	System.out.println("\n");
	}
	
    /** Continues process of outputting list of first N identified phrases.
    @param node the current location in the bin tree.	 
    @param phraseNum the node number (identifier). 
    @param nPhrases the number of phrases to output. 
    @return the current phrase number as incremented so far. */
    
    private int outputPhrasesN(PhraseBinTreeNode node, int phraseNum, 
    							int nPhrases) {
        // Check quota
	if (phraseNum>nPhrases) return(phraseNum); 
	
	// Process node
	if (node != null) {
	    // Process before branch
	    phraseNum = outputPhrasesN(node.beforeBranch,phraseNum,nPhrases);
	    if (phraseNum>nPhrases) return(phraseNum);
	    // Output phrase at node
	    System.out.println("{[" + phraseNum + "] " + node);
	    phraseNum++;
	    if (phraseNum>nPhrases) return(phraseNum);
	    // Process after branch
	    phraseNum = outputPhrasesN(node.afterBranch,phraseNum,nPhrases);
	    }
	    
	// End
        return(phraseNum);
	}
	
    /* OUTPUT PHRASE BIN TREE. */
    
    /** Starts recursive process of outputting phrase bin tree	 */

    public void outputPhraseBinTree() {
        System.out.println("PHRASE BIN TREE");
	System.out.println("===============");
	int attributeNumber = 1;
        outputPhraseBinTree(phraseBinTreeStart,"0",attributeNumber);
	System.out.println("\n");
	}

    /** Continues process of outputting bin tree (without pruned nodes).
    @param node the current location in the bin tree.	 
    @param num the node number (identifier). 
    @param attNum the attribute number.
    @return the attribute number sofar.	*/

    private int outputPhraseBinTree(PhraseBinTreeNode node, String num, 
    							int attNum) {
	if (node != null) {
	    // Process before branch
	    attNum = outputPhraseBinTree(node.beforeBranch,num+".0",attNum);
	    // Output phrase at node
	    System.out.println("{[" + num + "][" + attNum + "] " + node + "}");
	    attNum++;
	    // Process after branch
	    attNum = outputPhraseBinTree(node.afterBranch,num+".1",attNum);
	    }
	
	// End
	return(attNum);
	}
    
    /** Output phrase (used for diagnostic purposes only).
    @param phrase the given phrase. */
    
    private void outputPhrase(String[] phrase) {
        for (int index=0;index<phrase.length;index++) {
	    if (index==0) System.out.print("{" + phrase[index]);
	    else System.out.print(" " + phrase[index]);
	    }
	
	System.out.print("}");
	}

    /* PHASE BIN TREE STATISTICS. */
    
    /** Outputs Phrase bin tree statistsics. */
    
    public void outputPhraseBinTreeStats() {
    	int numNodes    = getNumNodesInPhraseBinTree();
    	int numPhrases  = getNumProperPhrasesInBinTree();
        int numKeywords = numNodes-numPhrases;
	
	// Output
	System.out.println("PHASE BIN TREE STATS:\n=====================" +
	                         "\nNumber of Nodes          = " + numNodes +
	                       "\nNumber of Proper Phrases = " + numPhrases + 
	               "\nNumber one word phrases  = " + numKeywords + "\n");
	}
    
    /* OUTPUT PHRASE N */
    
    /** Commences process of outputting a particular phrase (identified by a
    sequential attribute number) within the phrase bin tree.
    @param num the given phrase id number. */
    
    public void outputPhraseN(int num) {
        outputPhraseN(phraseBinTreeStart,num);
	}
    
    /** Continues process of outputting a particular phrase (identified by a
    sequential number) within the phrase bin tree.
    @param node the current location in the bin tree.     
    @param num the given phrase id number. 
    @return the phrase number so far.	*/
    
    private int outputPhraseN(PhraseBinTreeNode node, int num) {
	if (node != null) {
	    // Check if word already found
	    if (num==0) return(0);
	    // Process before branch
	    num = outputPhraseN(node.beforeBranch,num);
	    // Current node
	    if (num == 1) {	   
	        outputPhrase(node.phrase);
		return(0);
		}
	    else num = num-1;
	    // Process after branch
	    num = outputPhraseN(node.afterBranch,num);
	    // Return
	    return(num);
	    }
	else return(num);
	}

    /* -------------------------------- */
    /*                                  */
    /*        OUTPUT UTILITIES          */
    /*                                  */
    /* -------------------------------- */

    /* TWO DECIMAL PLACES */

    /** Converts given real number to real number rounded up to two decimal
    places.
    @param number the given number.
    @return the number to two decimal places. */

    protected double twoDecPlaces(double number) {
    	int numInt = (int) ((number+0.005)*100.0);
	number = ((double) numInt)/100.0;
	return(number);
	}	
    }