/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                           TEST SET DOCUMENT BASE                           */
/*                                                                            */
/*                                Frans Coenen                                */
/*                                                                            */
/*                         Wednesday 21 December 2005                         */
/*                                                                            */
/*                       Department of Computer Science                       */
/*                        The University of Liverpool                         */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/* Class structure

SetDocumentBase
	|
    	+-- TestSetDocumentBase		*/
	
//package lucsKDD_ARM;

/** Class containing methods to describe a set of test documents in terms of 
identified phrases (those conatined in the phrase bin tree).  
@author Frans Coenen
@version 21 December 2005.  */

public class TestSetDocumentBase extends SetDocumentBase {

    /* ------------------------------- */
    /*                                 */
    /*              FIELDS             */
    /*                                 */
    /* ------------------------------- */

    /** String array to store word content for a single test set document. */
    private String[] testSetDoc = null;
    /** Current index into testSetDoc. */
    private int currentIndex = 0;
    /** Test set data array to hold entire test set in the form of a set of
    attribute reference numbers. */
    private short[][] testDataArray = null;

    /* ------------------------------------ */
    /*                                      */
    /*              CONSTRUCTORS            */
    /*                                      */
    /* ------------------------------------ */

    /** One argument constructor.
    @param numberOfDocs the number of documents in the test set document
    base. */

    public TestSetDocumentBase(int numberOfDocs) {
	// initialise data array.
        testDataArray = new short[numberOfDocs][];
	for(int index=0;index<testDataArray.length;index++) {
	    testDataArray[index] = new short[0];
	    }
	}

    /* --------------------------------------------- */
    /*                                               */
    /*            TEST SET DOCUMENT BASE             */
    /*                                               */
    /* --------------------------------------------- */

    /** Adds given word to test set document array of strings. <P> Test set
    document array will eventually contain all the words represented in a test
    set document. 
    @param word the given word. */

    public void addWord(String word) {
        testSetDoc[currentIndex] = word;
        currentIndex++;
        }

    /* ----------------------------------------------------- */
    /*                                                       */
    /*            FIND PHRASE IN TEST DATA ARRAY             */
    /*                                                       */
    /* ----------------------------------------------------- */

    /** Finds given phrase in test set document array of strings. <P> Used to
    generate test set data (attribute number) array.
    @param phrase the given phrase.
    @param sigWord the first significant word in the phrase.
    @param indexSigWord the index of the first significant word in the phrase.
    @param docNum the current document ID number.
    @param attNum the current attribute (phrase) ID number. */

    public void findInTestSetDoc(String[] phrase, String sigWord,
    			         int indexSigWord, int docNum, short attNum) {
	// Finf all occurances (indexes) of first significant word in phrase in 
	// test set document.			 
	int[] indexesFound = findSigWordInTestSetDoc(sigWord);	
	
	// If no occurances found return.
	if (indexesFound==null) return;
	
	// Otherwise for each occurance check if rest of phrase present.
	for (int index=0;index<indexesFound.length;index++) { 
	    // Find offset from start of the test set document to the start of 
	    // the phrase using knowledge of the location in the test set 
	    // document of the first significant word in the phrase and the 
	    // location of the significant word within the phrase.
	    int offset = indexesFound[index]-indexSigWord;
	    if (checkRestOfPhrase(phrase,offset,indexSigWord)) {
                addToDataArray(docNum,attNum);
                break;
	    	}
	    }
        }
    
    /** Checks if given phrase in current test set document where first word in
    phrase has been found.
    @param phrase the given phrase.
    @param offset index marking the start of the phrase in test set document.
    @param sigWord the first significant word in the phrase.
    @return true if phrase found, false otherwise. 		*/
    
    private boolean checkRestOfPhrase(String[] phrase, int offset, 
                                                            int indexSigWord) {
        final boolean PHRASE_FOUND     = true;
	final boolean PHRASE_NOT_FOUND = false;
	
	// Check if offset is negative. If so this means that the first
	// significant word found is near the start of the document and that 
	// the words preceeding the significant words in the phrase, for the 
	// phrase to exist, are located before the start of the document. As 
	// this is not possible we can conclude that the given phrase does not 
	// exist in this part of the given test set document.
	if (offset<0) return(PHRASE_NOT_FOUND);
	
	// Process phrase
        for (int index=0;index<phrase.length;index++) {
	    // No need to check first significant word as this has already been 
	    // found in test set document
	    if (index!=indexSigWord) {
	        // Check for wild card
		if (!phrase[index].equals("?")) {
		    // Check offset is not ouside document, if so phrase not
		    // found.
		    if (offset>=(testSetDoc.length-1)) return(PHRASE_NOT_FOUND);
                    // Otherwise compare phrase word with test set document
                    if (!phrase[index].equals(testSetDoc[offset])) 
	                                          return(PHRASE_NOT_FOUND);
		    }
		}
	    // Increment offset
	    offset++;
	    } 
	 
        //Rerturn
	return(PHRASE_FOUND);
	}

    /** Adds phrase attibute to data array.
    document number to obtian the array index. 
    @param docNumber the given document number.
    @param attNum the current attribute number.	*/

    public void addToDataArray(int docNumber, short attNum) {
        int length            = testDataArray[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<testDataArray[docNumber].length;index++)
	    tempDataArray[index] = testDataArray[docNumber][index];

        // Add new attribute number
	tempDataArray[index]    = attNum;
        // Reassign to data array
	testDataArray[docNumber] = tempDataArray;
	}
	
    /** Finds occurance (indexes) og given significant word in the test set
    document.
    @param sigWord the given significant word.
    @return array of indexes or null if significant word not found. */
    
    private int[] findSigWordInTestSetDoc(String sigWord) {
        int[] indexesSoFar = null;

        // Process test set document
	for (int index=0;index<testSetDoc.length;index++) {
    	    // If found sig word add to index so far
    	    if (sigWord.equals(testSetDoc[index])) {
	        if (indexesSoFar==null) {
		    indexesSoFar    = new int[1];
		    indexesSoFar[0] = index;
		    }
		else {
		    int[] newIndexesSoFar = new int[indexesSoFar.length+1];
		    int tempIndex         = 0;
		    for ( ;tempIndex<indexesSoFar.length;tempIndex++)
		          newIndexesSoFar[tempIndex] = indexesSoFar[tempIndex];
		    newIndexesSoFar[tempIndex] = index;
		    indexesSoFar               = newIndexesSoFar;
		    }
		}
	    }
	
	// Return
	return(indexesSoFar);
	}

    /* ------------------------------------------------------- */
    /*                                                         */
    /*            FIND KEY WORD IN TEST DATA ARRAY             */
    /*                                                         */
    /* ------------------------------------------------------- */

    /** Finds given phrase in test set document array of strings. <P> Used to
    generate test set data array.
    @param keyWord the given key word.
    @param docNum the current document ID number.
    @param attNum the current attribute (phrase) ID number. */

    public void findInTestSetDoc(String keyWord, int docNum, short attNum) {
        // Process test set document
	for (int index=0;index<testSetDoc.length;index++) {
    	    // If found key word return true
    	    if (keyWord.equals(testSetDoc[index])) {
	        addToDataArray(docNum,attNum);
		break;
		}
	    }
	}
	
    /* ------------------------------------------- */
    /*              GET AND SET METHODS            */
    /* ------------------------------------------- */

    /** Initilaises current test set document array of strings to the giveb 
    size. 
    @param size the given size. */

    public void setTestDocSize(int size) {
        testSetDoc = new String[size];
        currentIndex = 0;
        }

    /** Returns reference to test data array. 
    @return Reference to start of test data array. */

    public short[][] getTestDataArray() {
        return(testDataArray);
	}

    /* ----------------------------------- */
    /*              DIAGNOSTICS            */
    /* ----------------------------------- */

    /* OUTPUTS TEST 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 stes in the data set.
    @param numClasses the number of classes represented in the data set. */
    
    public void outputTestSetStats(int numOneItemSets, int numClasses) {
        System.out.println("TEST 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 test data array
	for (int docIndex=0;docIndex<testDataArray.length;docIndex++) {
	    // Determine number of attributes (excluding class attribute) and 
	    // class index
	    int lastIndex  = testDataArray[docIndex].length-1;
	    int classIndex = 
	                 (int) testDataArray[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();
	}

    /** Outputs data array as a sequence of attribute numbers. */

    public void outputDataArray() {
        System.out.println("TEST ATTRIBUTE SET");
	System.out.println("======================");
	for (int docIndex=1;docIndex<testDataArray.length;docIndex++) {
	    for (int index=0;index<testDataArray[docIndex].length;index++) {
	        System.out.print(testDataArray[docIndex][index] + " ");
		}
	    System.out.println();
	    }
	}
	
    /** Outputs test set document as a sequence of words. 
    @param docNumber the ID number for the test set document.  */

    public void outputTestSetDoc(short docNumber) {
        System.out.println("TEST SET DOCUMENT " + docNumber + 
	                                           "\n======================");
    	for (int index=0;index<testSetDoc.length;index++) {
	    if (testSetDoc[index] != null)
                        System.out.print(testSetDoc[index] + " ");
	    else System.out.print("# ");
            }

	//End
	System.out.println("\n");
	} 
    
    /** Outputs test data array as a sequence of phrases.
    @param phraseBinTree the tgrference to the current bin tree of phrases.	 
    @param phraseMiningObj the current instance of the class.		 */
    
    public void outputTestDataArray(PhraseBinTree phraseBinTree,
                                         PhraseMining phraseMiningObj) {
        System.out.println("TEST DATA ARRAY (PHRASES)\n" +
	                                           "=========================");
	
	// Process data array 
    	for (int docIndex=0;docIndex<testDataArray.length;docIndex++) {
	    System.out.print("Doc #" + (docIndex+1) + ": ");
	    if (testDataArray[docIndex]==null) System.out.print("Empty!");
	    else {
	        int length = testDataArray[docIndex].length-1;
		for (int index=0;index<length;index++) {
	      	    phraseBinTree.outputPhraseN(testDataArray[docIndex][index]);
		    }
	        // Add class
	        String ClassLiteral = phraseMiningObj.
	                       getClassLiteral(testDataArray[docIndex][length]);
		System.out.println(" " + ClassLiteral);
		}
	    System.out.println();	
            }

	//End
	System.out.println();
	}   
    
    /** Outputs test data array as a sequence of key words.
    @param wordBinTree the tgrference to the current bin tree of phrases.	 
    @param keyWordMiningObj the current instance of the class.		 */
    
    public void outputTestDataArray(WordBinTree wordBinTree,
                                         KeyWordMining keyWordMiningObj) {
        System.out.println("TEST DATA ARRAY (KEY WORDS)\n" +
	                                        "===========================");
	
	// Process data array 
    	for (int docIndex=0;docIndex<testDataArray.length;docIndex++) {
	    System.out.print("Doc #" + (docIndex+1) + ": ");
	    if (testDataArray[docIndex]==null) System.out.print("Empty!");
	    else {
	        int length = testDataArray[docIndex].length-1;
		for (int index=0;index<length;index++) {
	      	    wordBinTree.outputKeyWordN(testDataArray[docIndex][index]);
		    System.out.print(" ");
		    }
	        // Add class
	        String ClassLiteral = keyWordMiningObj.
	                       getClassLiteral(testDataArray[docIndex][length]);
		System.out.println(" " + ClassLiteral);
		}
	    System.out.println();	
            }

	//End
	System.out.println();
	}

    /* -------------------------------- */
    /*                                  */
    /*        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);
	}  
    }