/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                             TEXT MINING MODEL                              */
/*                               Frans Coenen                                 */
/*                         Tuesday 28 February 2006                           */
/*          (Revisions: 15 March 2006, 20 March 2006, 8 Novrmber 2006)        */
/*                                                                            */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/* Experimental image minining GUI model for text Mining. Algorithm is as
follows:

startTextClassification\0:
    if (batch mode) {
        startTextClassificationBM\0:
	LOOP: through batch S, C and G values 
	    startTextClassificationBM\3:
	    LOOP: through batch UNT and LNT values 
	        startTextClassificationBM\5:
		Set parameters
		startTextClassification3\0:
	    END LOOP:
	END LOOP:
	}
    else if (setOfEifghtMode) {
        LOOP: through eight significant word strategies
            startTextClassification2\0: 
	    Set parameters
	    startTextClassification3\0:
	END LOOP:
	}
    else {
        startTextClassification2\0: 
	Set parameters
	startTextClassification3\0:
	}

startTextClassification3\0:
    if (90:10 or 50:50 split) { 
	startMiningRatioSplit\2:
	Create instance of phrase/keyword mining class
	Set file specification
	Define training and test sets according to ratio (output option)
	startMining\0: (Start phrase or key word mining)
	}
    if (TCV) {
	tenCrossEvaluation\0:
	Determine TCV split
	LOOP: through tenths
	    Define training and test sets (output option)
	    startMining\0: (Start phrase or key word mining)
	END LOOP:
	output TCV parameters array
	} */
	
//package lucsKDD_ARM;

// Java packages

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.io.*;
import java.util.*;

public class TextMiningModel extends JFrame {

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

    // CONTROL CONSTANTS

    /** Availabel significant word contribution calculation  strategies. */
    private final static String[] SW_CONTRIB_CALC_STRATS = {"Word Frequency",
    					                      "Word Support"};
    /** Availabel potential significant word list generation strategies. */
    private final static String[] PSWL_GEN_STRATS = {"Unique Sig. Words",
                                                     "All Significant Words"};
    /** Availabel significant word identification strategies. */
    private final static String[] SW_ID_STRATS = {"First N (distributed)",
                                                                  "First N",};

    /** Available text mining algorithms. */
    private final static String[] TM_ALGORITHMS = {"DelSN_contGO",
                                  "DelSN_contGW","DelSO_contGN","DelSO_contGW",
                                                                   "Keywords"};
    /** Available evaluation menu options. */
    private final static String[] EVAL_OPTIONS = {"90:10","50:50","TCV"};
    /** Available ordering menu options. */
    private final static String[] SAT_STRAT_OPTIONS = {"CSA","CSA best K"};
    /** Available training set output menu options. <P> "Training set IDs"
    controlled from this class, remainder need to be set in target class. */
    private final static String[] TRAINING_SET_OUT_OPS =
                              {"Training set doc IDs","Training set doc sizes",
                                  "Training set raw","Training set raw 1st 10",
		      "Training set marked up","Training set marked up 1st 10",
	      "Train. set Phrases/K'words","Train. set Phrases/K'words 1st 10",
		     "Training set attribute #","Training set Docs. per class",
		                                         "Training Set Stats"};
    /** Available test set output menu options. <P> "Test set IDs"
    controlled from this class, remainder need to be set in target class. */
    private final static String[] TEST_SET_OUT_OPS = {"Test set doc IDs",
    			                   "Test set doc sizes","Test set raw",
                            "Test set Phrases/Keywords","Test set attribute #",
			                                     "Test Set Stats"};
    /** Available word bin tree output menu options. */
    private final static String[] WORD_BIN_TREE_OUT_OPS = {"Word Bin Tree",
    			               "Lower Noise Words","Upper Noise Words",
                                        "Ordinary Words","Word Bin Tree Stats",
				                         "Words with Count 1"};
    /** Available word bin tree output menu options. */
    private final static String[] SIG_WORD_OUT_OPS = {"Significant Words",
			   "# pot sig words per class","# sig words per class",
			  "Potential Sig. Words","Top 10 Sig. Wds. per Class"};
    /** Available phrase bin tree output menu options. */
    private final static String[] PHRASE_BIN_TREE_OUT_OPS = {"Phrase Bin Tree",
    	           "Phrase Bin Tree Stats","Phrase list","Phrase list 1st 100"};
    /** Available TFPC output menu options all controlled from this class. */
    private final static String[] TFPC_OUT_OPS = {"T-tree Stats",
		        "P & T tree Storage","Large Itemsets","Ttree","Ptree"};
    /** Available classification output menu options. <P> "Test set IDs"
    controlled from this class, remainder need to be set in target class.*/
    private final static String[] CLASSIFIER_OUT_OPS = 
                                             {"Classifier Stats.","Classifier",
				               "Rules fired","Classification"};
    
    
    // SETTINGS
    /** Array of threshold values ordered as follows: (a) Support,
    (b) Confidence, (c) Signifcance, (d) Upper Noise and (e) Lower Noise. */
    private double[] tHoldValues = {0.1,35.0,3.0,7.0,0.2};
    /** 2-D Array of batch mode parameter values. <P>First dimension ordered as
    follows: (a) Support, (b) Confidence, (c) Significance, (d) Upper Noise and
    (e) Lower Noise. Second dimension ordered as follows: (a) from, (b) to and
    (c) step. */
    private double[][] batchValues = {{0.1,0.2,0.5},{20.0,55.0,5.0},
                                   {3.0,4.0,1.0},{7.0,8.0,10.0},{0.2,0.3,1.0}};
    /** Array of training set output settings. */
    private boolean[] trainingSetOutSettings = {false,false,false,false,false,
                                          false,false,false,false,false,false};
    /** Array of test set output settings. */
    private boolean[] testSetOutSettings = {false,false,false,false,false,
                                                                        false};
    /** Array of word bin tree output settings. */
    private boolean[] wordBinTreeOutSettings = {false,false,false,false,false,
                                                                        false};
    /* Array of significant word output settings.  */						     
    private boolean[] sigWordOutSettings = {false,false,false,false,false};						     
    /** Array of phrase bin tree output settings. */
    private boolean[] phraseBinTreeOutSettings = {false,false,false,false};    
    /** Array of TFPC output settings. */
    private boolean[] tfpcOutSettings = {false,false,false,false,false};
    /** Array of classifier output settings. */
    private boolean[] classifierOutSettings = {false,false,false,false};    
    /** Maximum number of significant word allowed. */
    private int maxNumSigWords = 1500;
    
    /** File stem. */
    private String fileStem = null;
    /** File end. */
    private String fileEnd = null;
    /** Number of documents (records) in the text base. */
    private int numOfDocs = 0;
    /** List of possible classes */
    private String[] classList = null;
    /** Significance contribution calculation strategy to be used. */
    private String sigContribCalcStrat = null; 
    /** Potential significan word list generation strategy to be used. */
    private String potSWlistGenStrat = null; 
    /** Significant word ID strategy to be used. */
    private String sigWordSelectStrat = null;
    /** Text miming algorithm to be used. */
    private String tmAlgorithm = null;
    /** Text mining satisfaction strategy to be used. */
    private String tmSatStrat = null;
    /** Text mining evluation strategy to be used. */
    private String tmEvalStrat = null;
    /** String of arguments. */
    private String[] args = new String[5];

    // Instance fields
    /** Instance of class <TT>KeyWordMining</TT> where appropriate. */
    private KeyWordMining newKeyWordMining = null;
    /** Instance of class <TT>PhraseMining</TT> where appropriate. */
    private PhraseMining newPhraseMining = null;
    /** Instance of class <TT>TextMining</TT> (super class of both
    <TT>PhraseMining</TT> and <TT>KeyWordMining</TT>). */
    private TextMining newTextMining = null;
    /** Instance of class <TT>AprioriTFP_CRgen</TT> where appropriate. */
    private AprioriTFP_CRgen newAprioriTFPC = null;

    // TCV
    /** 2-D array to hold final accuracy and number of CRs values for each
    "tenth" on completion of AprioriTFP-CR algorithm. */
    private double[][] parameters = new double[10][2];
    /** Current TCV index. */
    private int tcvIndex = 0;
    
    // BATCH MODE FIELDS
    /** Batch mode counter. */
    private int batchCounter=0;

    // FLAGS
    /** Phrase mining flag. */
    private boolean phraseMiningFlag = false;
    /** Keyword mining flag. */
    private boolean keyWordMiningFlag = false;
    /** TCV flag */
    private boolean tcvFlag = false;
    /** Batch mode flag, used to run a sequence of experiemnents with a range
    of support, confidence, significance, lower noise and upper noise 
    thresholds. */
    private boolean batchModeFlag = false;
    /** Set of eight mode flag, use to run a set of eight experiments all with
    the same support, confidence, significance, lower noise and upper noise 
    thresholds, but using the eight different significant word identification
    strategies. */
    private boolean setOfEightFlag = false;

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

    /** Zero argument constructor. */

    public TextMiningModel() {
	}

    /* ---------------------------------------------- */
    /*                                                */
    /*                    METHODS                     */
    /*                                                */
    /* ---------------------------------------------- */

    /** Start classification process. <P>Simply outputs banner and determines
    whether batch mode is required or not.         */

    public void startTextClassification() throws IOException {
        System.out.println("**********************");
	System.out.println("*\n*         START TEST RUN\n*");
	System.out.println("**********************");

        // Determibne if batch mode or not
        if (batchModeFlag) startTextClassificationBM();
	else if (setOfEightFlag) startTextClasssetOf8();
        else startTextClassification2();

	System.out.println("********** END ************");
        }

    /** Continiues proces of starting classification process in single mode
    (not batch mode). <P>Contrives a sequence of input arguments and then
    continues classification. */

    public void startTextClassification2() throws IOException  {
	// Create args string
	args = new String[6];
        args[0] = "-S" + tHoldValues[0];
	args[1] = "-C" + tHoldValues[1];
	args[2] = "-G" + tHoldValues[2];
	args[3] = "-U" + tHoldValues[3];
	args[4] = "-L" + tHoldValues[4];
        args[5] = "-M" + maxNumSigWords;

        // Continue processing according to evaluation criteria.
	startTextClassification3();

	// Reset
	reset();
	}

    /** Resetsa falgs and instance references to false and null as appropriate.
    */
    
    private void reset() {
        // Reset flags
	phraseMiningFlag  = false;
	keyWordMiningFlag = false;
	tcvFlag           = false;
        batchModeFlag     = false;
	setOfEightFlag    = false;
        
	// Reset instance references
	newPhraseMining   = null;
	newKeyWordMining  = null;
	newTextMining     = null;
        newAprioriTFPC    = null;	
	}
       
    /** Continue text classification processing, both single mode and batch 
    mode, according to the indicated classification validation criteria. */

    public void startTextClassification3() throws IOException {
        double time1;

        // Loop through list of available training-test set splits
        int index=0;
        for ( ;index<EVAL_OPTIONS.length;index++) {
            if (tmEvalStrat.equals(EVAL_OPTIONS[index])) break;
            }

        // Select algorithm
        switch (index) {
            // 90:10 Training test set split
            case 0:
	        // Start timer
    	        time1 = (double) System.currentTimeMillis();
		// Start mining
                startMiningRatioSplit(time1,(numOfDocs*9)/10);
		break;
            // 50:50 Training test set split
            case 1:
	        // Start timer
    	        time1 = (double) System.currentTimeMillis();
		// Start mining
                startMiningRatioSplit(time1,numOfDocs/2);
		break;
            // TCV
            case 2:
		time1 = (double) System.currentTimeMillis();
		tcvFlag = true;
		tenCrossEvaluation();
                newTextMining.outputDuration(time1,
				(double) System.currentTimeMillis());
		break;
            // Default
            default:
                JOptionPane.showMessageDialog(this,"Unrecognised text " +
                      "mining evaluation strategy --- \"" + tmEvalStrat +
                 "\"\n","Text Mining Error: ",JOptionPane.ERROR_MESSAGE);
	    }
	}

    /* ------------------------------------------------ */
    /*                                                  */
    /*                    BATCH MODE                    */
    /*                                                  */
    /* ------------------------------------------------ */

    /** Starts batch mode classification by considering support, confidence and
    significance thresholds. */

    private void startTextClassificationBM() throws IOException {
        batchCounter = 1;

        // Support
        for(double sIndex = batchValues[0][0];sIndex<batchValues[0][1];
                                           sIndex=sIndex+batchValues[0][2]) {
            // Confidence
            for(double cIndex = batchValues[1][0];cIndex<batchValues[1][1];
                                           cIndex=cIndex+batchValues[1][2]) {
                // Significance
                for(double gIndex = batchValues[2][0];gIndex<batchValues[2][1];
                                           gIndex=gIndex+batchValues[2][2]) {
                    startTextClassificationBM(sIndex,cIndex,gIndex);
                    }
                }
            }
        }

    /** Continues batch mode classification process by considering lower and
    upper noise thresholds.
    @param support the gievn suppoty threshold.
    @param confidence the given confidence threshold.
    @param significance the given significance threshold. */

    private void startTextClassificationBM(double support, double confidence,
                                   double significance) throws IOException  {

        // Upper noise threshold
        for(double uIndex = batchValues[3][0];uIndex<batchValues[3][1];
                                           uIndex=uIndex+batchValues[3][2]) {
            // Lower noise threshold
            for(double lIndex = batchValues[4][0];lIndex<batchValues[4][1];
                                           lIndex=lIndex+batchValues[4][2]) {
                startTextClassificationBM(support,confidence,significance,
                                                              uIndex,lIndex);
                }
            }
        }

    /** Continues batch mode classification process by creating argument
    string.
    @param support the gievn suppoty threshold.
    @param confidence the given confidence threshold.
    @param significance the given significance threshold.
    @param upperNoiseThold the given up nooise threshold.
    @param lowerNoiseThold the given up nooise threshold.*/

    private void startTextClassificationBM(double support, double confidence,
                                 double significance, double upperNoiseThold,
                                double lowerNoiseThold) throws IOException  {
	// Create args string
	args = new String[6];
        args[0] = "-S" + support;
	args[1] = "-C" + confidence;
	args[2] = "-G" + significance;
	args[3] = "-U" + upperNoiseThold;
	args[4] = "-L" + lowerNoiseThold;
        args[5] = "-M" + maxNumSigWords;

        // Continue processing according to evaluation criteria.
        System.out.println("**********************");
	System.out.println("*    BATCH NUMBER: " + batchCounter + "\n");
	System.out.println("**********************");
	startTextClassification3();
        batchCounter++;

	// Reset
	reset();
        }

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                    SET OF EIGHT MODE                    */
    /*                                                         */
    /* ------------------------------------------------------- */

    /** Starts set of eight mode classification. */

    private void startTextClasssetOf8() throws IOException {
        int counter = 1;
	
	for (int index1=0;index1<SW_CONTRIB_CALC_STRATS.length;index1++) {
	    sigContribCalcStrat=SW_CONTRIB_CALC_STRATS[index1];
	    for (int index2=0;index2<PSWL_GEN_STRATS.length;index2++) {
                potSWlistGenStrat=PSWL_GEN_STRATS[index2];
	        counter = startTextClasssetOf8cont(counter);
		}
	    }
	}
	
    /** Continues set of eight mode classification. 
    @param counter the set counter (integer from 1 to 8 inclusive).	*/ 	

    private int startTextClasssetOf8cont(int counter) throws IOException {
	for (int index3=0;index3<SW_ID_STRATS.length;index3++) {
            sigWordSelectStrat=SW_ID_STRATS[index3];
	    System.out.println("**********************");
	    System.out.println("*     SET OF EIGHT NUMBER: " + counter + "\n");
	    System.out.println("**********************");
            startTextClassification2(); 
	    counter++;
	    }
	
	// End
	return(counter);
	}

    /* ----------------------------------------------------------- */
    /*                                                             */
    /*            X:Y TRAINING TEST EVALUATION SPLIT               */
    /*                                                             */
    /* ----------------------------------------------------------- */

    /** Implements text mining with 90:10 or 50:50 traing/test set split.
    @param time1 the start time for the process (used for monitoring only).
    @param trainingSetEnd the document number of the last document in the
    training set. */

    private void startMiningRatioSplit(double time1, int trainingSetEnd)
                                                      throws IOException {
        // Create instance of phrase/keyword mining class
	createTextMiningInstance();

	// Set file specification
        setFileSpec();

	// Define training and test sets
        defineTrainAndTestSets(trainingSetEnd);

	// Start phrase or key word mining
	startMining(time1);
	}

    /** Defines nature of test and training sets where input data is split
    according to a ratio.
    @param trainingSetEnd the document number of the last document in the
    training set.	*/

    private void defineTrainAndTestSets(int trainingSetEnd) {
        newTextMining.addToTrainingSet(1,trainingSetEnd);
        if (trainingSetOutSettings[0]) newTextMining.outputTraingSetIDs();
	newTextMining.addToTestSet(trainingSetEnd+1,numOfDocs);
        if (testSetOutSettings[0]) newTextMining.outputTestSetIDs();
        }

    /* ----------------------------------------------------------------- */
    /*                                                                   */
    /*                    TEN CROSS VALIDATION (TCV)                     */
    /*                                                                   */
    /* ----------------------------------------------------------------- */

    /** Phrase mining with ten cross validation.
    @param newTextMining instance of class text mining. */
    
    private void tenCrossEvaluation() throws IOException {
	// Set parameters array values to zero
	for (int index2=0;index2<parameters.length;index2++) {
	    parameters[index2][0] = 0.0;
            parameters[index2][1] = 0.0;
	    }
		
        // Determine TCV split
	int testSize = numOfDocs/10;
	for (int index1=0;index1<10;index1++) {
	    System.out.println("** " + (index1+1) + " **");
	    // Create instance of class PhraseMining
    	    createTextMiningInstance();
	    setFileSpec();
	    // Determine test start
	    createTestAndTrainingSets(index1);
            // Start timer
    	    double time1 = (double) System.currentTimeMillis();
	    // Start phrase/keyword identification process
            tcvIndex = index1;
	    startMining(time1);
	    }
	
	// End
	outputParametersArray();
	}
	
	
    /** Commences process of TCV phrase mining where test set is either the
    first or last tenth.
    @patam index the current test set tenth indicator. */

    private void createTestAndTrainingSets(int index) {
        int testStart = 1 + (index*numOfDocs)/10;
	
	// Dtermine test end
	int testEnd;
	if (index==9) testEnd = numOfDocs;
	else testEnd = ((index+1)*numOfDocs)/10;;
	
	// Determine trainuing sets start(s) and end(s), test whether: (i) if
	// first tenth is test set, (ii) is last tenth is test set or (iii)
	// the default sitiation the test set is some where in the middle.
	if (testStart==1) createTestAndTrainingSets(testStart,testEnd,
	                                                testEnd+1,numOfDocs); 
	else if (testEnd==numOfDocs) createTestAndTrainingSets(testStart,
				                      testEnd,1,testStart-1); 
	else createTestAndTrainingSets(testStart,testEnd,1,testStart-1,
	                                                testEnd+1,numOfDocs);
	}
	
	
    /** Commences process of TCV phrase mining where test set is either the
    first or last tenth.
    @param testStart first document in test set.
    @param testEnd last document in test set.
    @param trainStart first document in training set.
    @param trainEnd last document in training set. */
    
    private void createTestAndTrainingSets(int testStart, int testEnd,
                                              int trainStart, int trainEnd) {
	// Create instance of class PhraseMining and set parameters
    	createTextMiningInstance();
        setFileSpec();

	// Add test and training sets
	newTextMining.addToTrainingSet(trainStart,trainEnd);
	if (trainingSetOutSettings[0]) newTextMining.outputTraingSetIDs();
        newTextMining.addToTestSet(testStart,testEnd);
        if (testSetOutSettings[0]) newTextMining.outputTestSetIDs();
    	}
    	
    /** Commences process of phrase mining where test set is in middle of
    training set.
    @param testStart first document in test set.
    @param testEnd last document in test set.
    @param trainStart1 first document in first part of training set.
    @param testEnd1 last document in first part of training set.
    @param trainStart2 first document in second part of training set.
    @param trainEnd2 last document in second part of training set. */
    
    private void createTestAndTrainingSets(int testStart, int testEnd, 
              int trainStart1, int trainEnd1, int trainStart2, int trainEnd2) {
	// Create instance of class PhraseMining and set parameters
    	createTextMiningInstance();
        setFileSpec();
	
	// Add test and training sets
	newTextMining.addToTrainingSet(trainStart1,trainEnd1);
	newTextMining.addToTrainingSet(trainStart2,trainEnd2);
	if (trainingSetOutSettings[0]) newTextMining.outputTraingSetIDs();
	newTextMining.addToTestSet(testStart,testEnd);
        if (testSetOutSettings[0]) newTextMining.outputTestSetIDs();
    	}
	
    /* ---------------------------------------------------------- */
    /*                                                            */
    /*                    TEXT CLASSIFICATION                     */
    /*                                                            */
    /* ---------------------------------------------------------- */
 
    /** Generates classifier.
    @param time1 the start time for the process (used for monitoring only). */
    
    private void startMining(double time1) throws IOException {
	// Phrase mining
	if ((phraseMiningFlag) && (newPhraseMining.findPhrasesInDB()))
	                                             textClassification(time1);
	
	// Keyword mining
	else if ((keyWordMiningFlag) && (newKeyWordMining.findKeyWordsInDB()))
	                                             textClassification(time1);
	
	// Otherwise do nothing
	}
	 
    /** Initiates text classification by creating instance of approproiate
    classifier class.
    @param time1 the start time for the process (used for monitoring only). */
    
    private void textClassification(double time1) {
        double accuracy;
	
	// Loop through list of available record (case) satisfaction 
	// strategies
        int index=0;
        for ( ;index<SAT_STRAT_OPTIONS.length;index++) {
            if (tmSatStrat.equals(SAT_STRAT_OPTIONS[index])) break;
            }
	    
	// Select strategy and create instance of desired classifier generator.
        switch (index) {
            // TFPC with CSA ordering and "first best rule"
            case 0:
                // AprioriTFP_CRgen
		newAprioriTFPC = new AprioriTFP_CRgen();
		textClassification2(); 
		accuracy = newAprioriTFPC.startClassification();
		outputResult(time1,accuracy); 
		break;
            // TFPC with CSA ordering and "first K best rules"
            case 1:
                // AprioriTFP_CRgen
                newAprioriTFPC = new AprioriTFP_CRgen();
		textClassification2();
	        accuracy = newAprioriTFPC.startClassificationBestK();
		outputResult(time1,accuracy);  
                break;
            // Default
            default:
                JOptionPane.showMessageDialog(this,"Unrecognised rule " +
                        "ordering strategy --- \"" + tmAlgorithm + "\"\n",
		        "Text Mining Error: ",JOptionPane.ERROR_MESSAGE);
            }
	}

    /** Preprocess input data to identify phrases/keyword. */

    private void textClassification2() {
	// Set confidence, support, number of classes, number of one item sets,
	// number of rows in input data, number of rows in training data set
	// and minimum support; and references to testDataArray and dataArray
	// 2-D arrays.
	setFields();

	// Reorder input data according to frequency of single attributes
	// excluding classifiers. Proceed as follows: (1) create a conversion
	// array (with classifiers left at end), (2) reorder the attributes
	// according to this array. Do not throw away unsupported attributes
	// as when data set is split (if distribution is not exactly even) we
	// may have thrown away supported attributes that contribute to the
	// generation of CRs. NB Never throw away classifiers even if
	// unsupported!
	newAprioriTFPC.idInputDataOrdering();  	// AprioriTFPclass
	newAprioriTFPC.recastInputData();      	// AssocRuleMining
	newAprioriTFPC.recastTestData();	// AprioriTFPclass

        // Output
	if (trainingSetOutSettings[6] || trainingSetOutSettings[7] || 
						      testSetOutSettings[3]) {
	    newTextMining.setReconArray(newAprioriTFPC.getReconArray());
	    if (phraseMiningFlag) {
	        if (trainingSetOutSettings[6])
		                      newPhraseMining.outputTraingSetPhrases();
	        if (trainingSetOutSettings[7])
		                    newPhraseMining.outputTraingSetPhrases10();
	        if (testSetOutSettings[3]) 
		                        newPhraseMining.outputTestSetPhrases();
		}
	    else if (keyWordMiningFlag) {
		if (trainingSetOutSettings[6])
		                    newKeyWordMining.outputTraingSetKeyWords();
		if (trainingSetOutSettings[7])
		                  newKeyWordMining.outputTraingSetKeyWords10();
	        if (testSetOutSettings[3])
		                      newKeyWordMining.outputTestSetKeyWords();
		}
	    }
        }
        
    /* ------------------------------------------------------------------ */
    /*                                                                    */
    /*                    CREATE TEXT MINING INSTANCE                     */
    /*                                                                    */
    /* ------------------------------------------------------------------ */
	
    /** Creates instance of text mining class according to selected phrase/
    keyword identification strategy (TM algorithm). */

    private void createTextMiningInstance() {
	// Loop through list of avialble TM algorithms
        int index=0;
        for ( ;index<TM_ALGORITHMS.length;index++) {
            if (tmAlgorithm.equals(TM_ALGORITHMS[index])) break;
            }

        // Select algorithm
        switch (index) {
            // DelSN_contGO
            case 0:
                newPhraseMining  = new PhraseMining_DelSN_ContGO(args);
		newTextMining    = newPhraseMining;
		phraseMiningFlag = true;
		break;
            // DelSN_contGW
            case 1:
                newPhraseMining  = new PhraseMining_DelSN_ContGW(args);
		newTextMining    = newPhraseMining;
                phraseMiningFlag = true;
                break;
            // DelSO_contGN
            case 2:
                newPhraseMining  = new PhraseMining_DelSO_ContGN(args);
		newTextMining    = newPhraseMining;
                phraseMiningFlag = true;
                break;
            // DelSO_contGW
            case 3:
                newPhraseMining  = new PhraseMining_DelSO_ContGW(args);
		newTextMining    = newPhraseMining;
                phraseMiningFlag = true;
                break;
            // Keywords
            case 4:
                newKeyWordMining  = new KeyWordMining(args);
		newTextMining     = newKeyWordMining;
		keyWordMiningFlag = true;
                break;
            // Default
            default:
                JOptionPane.showMessageDialog(this,"Unrecognised text " +
                        "mining algorithm --- \"" + tmAlgorithm + "\"\n",
		        "Text Mining Error: ",JOptionPane.ERROR_MESSAGE);
            }

	// Set output flags
	setSWstrategiesFlags();
	setOutputFlags();
	}

    /** Set significant words strategies flags. */
    
    private void setSWstrategiesFlags() {
        newTextMining.setSigContribCalcStrat(sigContribCalcStrat);
        newTextMining.setPotSWlistGenStrat(potSWlistGenStrat);
        newTextMining.setSigWordSelectStrat(sigWordSelectStrat);
        }

    /** Sets output flags as appropriate. */

    private void setOutputFlags() {
        setTrainingSetOutputFlags();
	setTestSetOutputFlags();
	setWordBinTreeOutputFlags();
	setSigWordOutputFlags();
	if (newPhraseMining!=null) setPhraseBinTreeOutputFlags();
	}

    /** Sets training set output flags. */

    private void setTrainingSetOutputFlags() {
        // Set output training set document sizes flag.
        if (trainingSetOutSettings[1])
	                    newTextMining.setOutputSizeOfDocsInTrainSet(true);
	else newTextMining.setOutputSizeOfDocsInTrainSet(false);

	// Set output training set in raw form flags (all and 1st 10).
	if (trainingSetOutSettings[2])
	                    newTextMining.setOutputTrainSetRaw(true);
	else newTextMining.setOutputTrainSetRaw(false);
	if (trainingSetOutSettings[3])
	                    newTextMining.setOutputTrainSetRaw10(true);
	else newTextMining.setOutputTrainSetRaw10(false);

	// Set output training set in marked form flags (all and 1st 10).
	if (trainingSetOutSettings[4])
	                    newTextMining.setOutputTrainSetMarked(true);
	else newTextMining.setOutputTrainSetMarked(false);
	if (trainingSetOutSettings[5])
	                    newTextMining.setOutputTrainSetMarked10(true);
	else newTextMining.setOutputTrainSetMarked10(false);

        // Options 6 and 7 are to do with outputting phrases.
	
	// Set output training set in attribute number form flag.
	if (trainingSetOutSettings[8])
	                    newTextMining.setOutputTrainSetAttNum(true);
	else newTextMining.setOutputTrainSetAttNum(false);

	// set output training set class distribution flag.
        if (trainingSetOutSettings[9])
	               newTextMining.setOutputNumDocsPerClassInTrainSet(true);
	else newTextMining.setOutputNumDocsPerClassInTrainSet(false);

	// set output training set stats flag.
        if (trainingSetOutSettings[10])
	               newTextMining.setOutputTrainSetStats(true);
	else newTextMining.setOutputTrainSetStats(false);
	}

    /** Sets test set output flags. */

    private void setTestSetOutputFlags() {
        // Set output test set document sizes flag.
        if (testSetOutSettings[1])
	                    newTextMining.setOutputSizeOfDocsInTestSet(true);
	else newTextMining.setOutputSizeOfDocsInTestSet(false);

	// Set output test set in raw form flag.
	if (testSetOutSettings[2])
	                    newTextMining.setOutputTestSetRaw(true);
	else newTextMining.setOutputTestSetRaw(false);

	// Set output test set in attribute number form flag.
	if (testSetOutSettings[4])
	                    newTextMining.setOutputTestSetAttNum(true);
	else newTextMining.setOutputTestSetAttNum(false);

	// set output training set stats flag.
        if (testSetOutSettings[5])
	               newTextMining.setOutputTestSetStats(true);
	else newTextMining.setOutputTestSetStats(false);
	}

    /** Sets word bin tree output flags. */

    private void setWordBinTreeOutputFlags() {
	// Set output word bin tree flag.
	if (wordBinTreeOutSettings[0])
	                    newTextMining.setOutputWordBinTree(true);
	else newTextMining.setOutputWordBinTree(false);

	// Set output word bin tree upper noise words flag
	if (wordBinTreeOutSettings[1])
	                    newTextMining.setOutputWordBinTreeUN(true);
	else newTextMining.setOutputWordBinTreeUN(false);

	// Set output word bin tree lower noise words flag
	if (wordBinTreeOutSettings[2])
	                    newTextMining.setOutputWordBinTreeLN(true);
	else newTextMining.setOutputWordBinTreeLN(false);

	// Set output word bin tree ordinary words flag
	if (wordBinTreeOutSettings[3])
	                    newTextMining.setOutputWordBinTreeOW(true);
	else newTextMining.setOutputWordBinTreeOW(false);

	// Set output word bin tree statistics flag.
	if (wordBinTreeOutSettings[4])
	                    newTextMining.setOutputWordBinTreeStats(true);
	else newTextMining.setOutputWordBinTreeStats(false);

	// Sets desired count for output words in word bin tree with count N
    	// option.
	if (wordBinTreeOutSettings[5]) newTextMining.setOutputCount1wrds(true);
	else newTextMining.setOutputCount1wrds(false);
	}


    /** Sets significant word output flags. */

    private void setSigWordOutputFlags() {
	// Set output word bin tree significant words flag
	if (sigWordOutSettings[0])
	                    newTextMining.setOutputWordBinTreeSW(true);
	else newTextMining.setOutputWordBinTreeSW(false);

	// Set output potential number of significant words per class flag.
	if (sigWordOutSettings[1])
	                    newTextMining.setOutputPotSigWdsPerClass(true);
	else newTextMining.setOutputPotSigWdsPerClass(false);

	// Set output number of significant words per class flag.
	if (sigWordOutSettings[2])
	                    newTextMining.setOutputSigWordsPerClass(true);
	else newTextMining.setOutputSigWordsPerClass(false);

	// Set output potential significant words list flag.
	if (sigWordOutSettings[3])
	                    newTextMining.setOutputPotSigWordsList(true);
	else newTextMining.setOutputPotSigWordsList(false);
		
	// Set output top 10 potential significant words list flag.
	if (sigWordOutSettings[4])
	                    newTextMining.setOutputTop10sigWordsList(true);
	else newTextMining.setOutputTop10sigWordsList(false);
	}

    /** Sets phrase bin tree output flags. */

    private void setPhraseBinTreeOutputFlags() {
	// Set output phrase bin tree flag.
	if (phraseBinTreeOutSettings[0])
	                    newPhraseMining.setOutputPhraseBinTree(true);
	else newPhraseMining.setOutputPhraseBinTree(false);

	// Set output phrase bin tree statistics flag.
	if (phraseBinTreeOutSettings[1])
	                    newPhraseMining.setOutputPhraseBinTreeStats(true);
	else newPhraseMining.setOutputPhraseBinTreeStats(false);
	
	// Set output phrase list flags.
	if (phraseBinTreeOutSettings[2])
	                    newPhraseMining.setOutputPhraseList(true);
	else newPhraseMining.setOutputPhraseList(false);
	if (phraseBinTreeOutSettings[3])
	                    newPhraseMining.setOutputPhraseList100(true);
	else newPhraseMining.setOutputPhraseList100(false);
	}

    /* ---------------------------------------------------------- */
    /*                                                            */
    /*                    SET AND GET METHODS                     */
    /*                                                            */
    /* ---------------------------------------------------------- */

    /** Sets confidence, support, number of classes, number of one item sets,
    number of rows in input data, number of rows in training data set and
    minimum support fields; and references to testDataArray and dataArray 2-D
    arrays. <P> Operates by transfering values from one instance of
    <TT>AssocRuleMinig</TT> class to another. */
    
    private void setFields() {
        // Confidence and Support
	newAprioriTFPC.setConfidence(newTextMining.getConfidence());
	newAprioriTFPC.setSupport(newTextMining.getSupport());

	// number of classes, number of one item sets, number of rows in input 
	// data and number of rows in training data set.
	newAprioriTFPC.setNumClasses(newTextMining.getNumClasses());
	newAprioriTFPC.setNumOneItemSets(newTextMining.getNumOneItemSets());
	newAprioriTFPC.setNumberOfRows(newTextMining.getNumberOfRows());
	newAprioriTFPC.setNumberOfCols(newTextMining.getNumOneItemSets());
	newAprioriTFPC.setNumRowsInTrainingSet
	                         (newTextMining.getNumRowsInTrainingSet());

	// Set minimum support (can only be done once support and num rows have
	// been set).
	newAprioriTFPC.setMinSupport();

	// references to testDataArray and dataArray
	newAprioriTFPC.setTestDataArray(newTextMining.getTestDataArray());
	newAprioriTFPC.setDataArray(newTextMining.getDataArray());
	}
	
    /** Set file specification. */
    
    private void setFileSpec() {
        // Set file specification
        newTextMining.setFileStemAndEnd(fileStem,fileEnd);
        newTextMining.setDocClasses(classList);
        }
	
    /** Set threshold values with the given array of values.
    @param the given value array. */

    public void setTholdValues(double[] valueList) {
        // Copy values
        for (int index=0;index<valueList.length;index++) tHoldValues[index] =
                                                            valueList[index];
        }   
	
    /** Set batch mode values with the given array of values.
    @param the given value array. */

    public void setBatchValues(double[][] valueList) {
        // Copy values
        for (int index1=0;index1<valueList.length;index1++) {  
            for (int index2=0;index2<valueList[index1].length;index2++) {
                batchValues[index1][index2] = valueList[index1][index2];
                }
            }
        }

    /** Set the number of documents value.
    @param nDocs the given number of documents. */

    public void setTBspecValues(String stem, String end, int nDocs) {
        fileStem   = stem;
        fileEnd    = end;
        numOfDocs  = nDocs;
        }

    /** Set class list. */

    public void setClassList(String[] cList) {
        classList = new String[cList.length];

        // Copy list
        for (int index=0;index<cList.length;index++) {
            classList[index] = cList[index];
            }
        }
    
    /** Sets significant word contribution claculation strategy to be used.
    @param strategy the given strategy. */
    
    public void setSigContribCalcStrat(String strategy) {
        sigContribCalcStrat = strategy;
        }

    /** Sets potential significant word list generation strategy to be used.
    @param strategy the given strategy. */

    public void setPotSWlistGenStrat(String strategy) {
        potSWlistGenStrat = strategy;
        }

    /** Sets significant word selection strategy to be used.
    @param strategy the given strategy. */

    public void setSigWordSelectStrat(String strategy) {
        sigWordSelectStrat = strategy;
        }

    /** Set TM (Text Mining) algorithm to be used.
    @param the given TM algorithm.   */

    public void setTMalgorithm(String newTMalg) {
        tmAlgorithm = newTMalg;
        }

    /** Set TM (Text Mining) satisfaction sratergy to be used.
    @param newTMsatStra the given TM strategy.   */

    public void setSatStrategy(String newTMsatStrat) {
        tmSatStrat = newTMsatStrat;
        }

    /** Set TM (Text Mining) evaluation strategy to be used.
    @param the given TM strategy.   */

    public void setEvalStrat(String newTMevalStrat) {
        tmEvalStrat = newTMevalStrat;
        }

    /** Sets the batch mode flag to the given value.
    @param value the given value/  */

    public void setBatchModeFlag(boolean value) {
        batchModeFlag = value;
        }

    /** Sets the set of eight mode flag to the given value.
    @param value the given value/  */

    public void setSetOfEightFlag(boolean value) {
        setOfEightFlag = value;
        }

    /** Sets the value for the maximum number of permitted significant words
    field.
    @param the newMaxValue the desired maximum number of permitted significant
    words value. */

    public void setMaxNumSigWds(int newMaxValue) {
       maxNumSigWords=newMaxValue;
       }

    /** Gets the reference to the start of the array listing the available
    signidicant word contribution calculation  strategies.
    @return the reference to the list of SW contribution calculation 
    strategies. */

    public String[] getSWcontribCalcStrats() {
        return(SW_CONTRIB_CALC_STRATS);
        }

    /** Gets the reference to the start of the array listing the available
    potential signidicant word list generation strategies.
    @return the reference to the list of potential SW list generation 
    strategies. */

    public String[] getPotSigWordLIstGenStrats() {
        return(PSWL_GEN_STRATS);
        }

    /** Gets the reference to the start of the array listing the available
    signidicant word identification strategies.
    @return the reference to the list of significant word ID srategies. */

    public String[] getSigWordIDstrategies() {
        return(SW_ID_STRATS);
        }

    /** Gets the reference to the start of the array listing the available TM
    (Text Mining) algorirthms.
    @return the reference to the list of text mininmg algorithms. */

    public String[] getTMalgorithms() {
        return(TM_ALGORITHMS);
        }   

    /** Gets the reference to the start of the array listing the available TM
    odering options.
    @return the reference to the list of text mining ordering options. */

    public String[] getOrderingOptions() {
        return(SAT_STRAT_OPTIONS);
        }

    /** Gets the reference to the start of the array listing the available TM
    evaluation options.
    @return the reference to the list of text mining evaluation options. */

    public String[] getEvalOptions() {
        return(EVAL_OPTIONS);
        }

    /** Gets the reference to the start of the array listing the available 
    training set output options.
    @return the reference to the list of training set output options. */

    public String[] getTrainingSetOutOps() {
        return(TRAINING_SET_OUT_OPS);
        }

    /** Gets the reference to the start of the array listing the available 
    test set output options.
    @return the reference to the list of test set output options. */

    public String[] getTestSetOutOps() {
        return(TEST_SET_OUT_OPS);
        }

    /** Gets the reference to the start of the array listing the available 
    word bin tree output options.
    @return the reference to the list of test set output options. */

    public String[] getWordBinTreeOutOps() {
        return(WORD_BIN_TREE_OUT_OPS);
        }

    /** Gets the reference to the start of the array listing the available 
    significant word output options.
    @return the reference to the list of test set output options. */

    public String[] getSigWordOutOps() {
        return(SIG_WORD_OUT_OPS);
        }

    /** Gets the reference to the start of the array listing the available 
    phrase bin tree output options.
    @return the reference to the list of test set output options. */

    public String[] getPhraseBinTreeOutOps() {
        return(PHRASE_BIN_TREE_OUT_OPS);
        }

    /** Gets the reference to the start of the array listing the available 
    TFPC output options.
    @return the reference to the list of TFPC output options. */

    public String[] getTFPCoutOps() {
        return(TFPC_OUT_OPS);
        }

    /** Gets the reference to the start of the array listing the available 
    classifier output options.
    @return the reference to the list of classifier output options. */

    public String[] getClassifierOutOps() {
        return(CLASSIFIER_OUT_OPS);
        }
	
    /** Gets the reference to the start of the array listing the current
    training set output settings.
    @return the reference to the current list of training set output settings. */

    public boolean[] getTrainingSetOutSettings() {
        return(trainingSetOutSettings);
        }
	
    /** Gets the reference to the start of the array listing the current
    test set output settings.
    @return the reference to the current list of test set output settings. */

    public boolean[] getTestSetOutSettings() {
        return(testSetOutSettings);
        }
	
    /** Gets the reference to the start of the array listing the current
    word bin tree output settings.
    @return the reference to the current list of test set output settings. */

    public boolean[] getWordBinTreeOutSettings() {
        return(wordBinTreeOutSettings);
        }
	
    /** Gets the reference to the start of the array listing the current
    significant word output settings.
    @return the reference to the current list of test set output settings. */

    public boolean[] getSigWordOutSettings() {
        return(sigWordOutSettings);
        }
	
    /** Gets the reference to the start of the array listing the current
    phrase bin tree output settings.
    @return the reference to the current list of test set output settings. */

    public boolean[] getPhraseBinTreeOutSettings() {
        return(phraseBinTreeOutSettings);
        }
	
    /** Gets the reference to the start of the array listing the current
    TFPC output settings.
    @return the reference to the current list of TFPC output settings. */

    public boolean[] getTFPCoutSettings() {
        return(tfpcOutSettings);
        }
	
    /** Gets the reference to the start of the array listing the current
    classifier output settings.
    @return the reference to the current list of classifier output settings. */

    public boolean[] getClassifierOutSettings() {
        return(classifierOutSettings);
        }

    /** Gets the current threshold values array.
    @return the requested value array. */
    public double[] getTholdValues() {
        return(tHoldValues);
        }

    /** Gets the current batch mode values array.
    @return the requested value array. */
    public double[][] getBatchValues() {
        return(batchValues);
        }	
	
    /** Gets the value for the maximum number of permitted significant words
    field.
    @return the maximum number of permitted significant words value. */
    
    public int getMaxNumSigWds() {
       return(maxNumSigWords);
       }	
	
    /* -------------------------------------------------------------- */
    /*                                                                */
    /*                    OUTPUT METHODS                              */
    /*                                                                */
    /* -------------------------------------------------------------- */
    
    /* OUTPUT PARAMETERS ARRAY */
    
    /** Outputs contents of parameters array (final support, confidence and
    accuracy for each "tenth"). */
    
    private void outputParametersArray() {
        double totalAcc = 0;
	double totalCRs = 0;
	
	// Process parameterts array
	for (int index=0;index<parameters.length;index++) {
	    totalAcc = totalAcc+parameters[index][0];
	    totalCRs = totalCRs+parameters[index][1];
	    System.out.print("Accuracy = " +
	    			twoDecPlaces(parameters[index][0]));
	    System.out.print(", Num. CRs = " +
	    			twoDecPlaces(parameters[index][1]));
	    System.out.println();
	    }
	
	// Averages
	System.out.println("-------------------------------");
	System.out.println("Ave. accuracy = " + (twoDecPlaces(totalAcc/10)));
	System.out.println("Ave. # CRs    = " + (twoDecPlaces(totalCRs/10)));
	}	
    
    
    /* OUTPUT RESULT */
    
    /** Outputs result from classification exercise. 
    @prama time1
    @param accuracy the obtained classification accuracy. */
     
    private void outputResult(double time1, double accuracy) {
        // Ouput timing
	newTextMining.outputDuration(time1,
				          (double) System.currentTimeMillis());

	// TCV storage
	if (tcvFlag) {
	    parameters[tcvIndex][0] = accuracy; 
	    parameters[tcvIndex][1] = newAprioriTFPC.getNumRules();
	    }

        // Accuracy
	System.out.println("Accuracy = " + accuracy);
	
	// TFPC output
	if (tfpcOutSettings[0]) newAprioriTFPC.outputTtreeStats();
	if (tfpcOutSettings[1]) newAprioriTFPC.outputStorage();
	if (tfpcOutSettings[2]) newAprioriTFPC.outputFrequentSets();
	if (tfpcOutSettings[3]) newAprioriTFPC.outputTtree();
	if (tfpcOutSettings[4]) newAprioriTFPC.outputPtree();
	
	// Classifier Output. Note: to output classifier need to call 
	// testClassification before output. Need to transfer reference to 
	// start of rule list, and number of rules (the latter is used to
	// dimension diagnostic arrays).
	newTextMining.setStartRulelist(newAprioriTFPC.getStartRulelist());
	newTextMining.setNumRules(newAprioriTFPC.getNumRules());	
	if (classifierOutSettings[0]) newAprioriTFPC.outputClassifierStats();
	if (classifierOutSettings[1])
	                    newTextMining.outputCRsWithAttLiteralsAndDefault();
	
	// Output diagnostic results of classification by running "test
	// classification" in TextMining class.
	if (classifierOutSettings[2] || classifierOutSettings[3])
	                                     newTextMining.testClassification();
	if (classifierOutSettings[2]) newTextMining.diagRulesFired();
	if (classifierOutSettings[3]) newTextMining.diagTestSetClassification();
        }
	
    /* OUTPUT TO 1 DECIMAL PLACES */
    
    /** Outputs a given decimal number to one decimal place. 
    @param number the given decimal number. */
    
    private static double oneDecPlace(double number) {
        int intNumber = (int) ((number*10)+0.5);
	number = ((double) intNumber)/10.0;
	return(number);
        }
    
    /* OUTPUT TO 2 DECIMAL PLACES */
    
    /** Outputs a given decimal number to two decimal places. 
    @param number the given decimal number. */
    
    private static double twoDecPlaces(double number) {
        int intNumber = (int) ((number*100)+0.5);
	number = ((double) intNumber)/100.0;
	return(number);
        }
    
    }