/* -------------------------------------------------------------------------- */
/*                                                                            */
/*               LUCS-KDD DATA DISCRETISATION/NORMALISATION                   */
/*                 (DATA PREPARATION GUI FOR DATA MINING)                     */
/*                                                                            */
/*                              Frans Coenen                                  */
/*                                                                            */
/*                          Monday 15 June 2003                               */
/*           (Revised 17 Feb 2004, 14 October 2004, 17 February 2006,         */
/*                        28 February 2006, 1 May 2006)                       */
/*                                                                            */
/*                    Department of Computer Science                          */
/*                     The University of Liverpool                            */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/** The LUCS-KDD (Liverpool University Computer Science - Knowledge Discocery in
Data) DN (discretization/normalisation) software has been developed to convert
data files available in the UCI data repository (http://www.ics.uci.edu/~mlearn/
MLRepository.html) into a binary format suitable for use with Association Rule
Mining (ARM) and Classigication Association Rule Mining (CARM) software. The
software can, of course, equally well be used to convert data files obtained
from other sources. */

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

// Other packages

public class LUCS_KDD_DN extends JFrame implements ActionListener {

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

    /* Data Structures */

    /* ------ SCHEMA CLASS ------ */

    /** Inner class defining a linked list of records describing the input
    schema. */

    private class InputSchema {
        /** Label for schema item. */
        String name;
        /** Tye of schema item: 'int', 'double', 'nominal', 'unused'. */
        String typeName;
        /** Minimum value for numeric ('int' or 'double') schema items. */
        double min=0;
        /** Maximum value for numeric ('int' or 'double') schema items. */
        double max=0;
        /** Range (maximum-minimum) value for numeric ('int' or 'double')
        schema items. */
        double range=0;
        /** list of nominal values in the case nominal schema items, set to
        null otherwise. */
        String [] nominalData;
	/** Number of divisions. */
	int numDivisions;
	/** Array of numerical divisions for output. */
	double [] divisionMarkers;
	/** Array of array of nominal values for output. */
	int [][] nominalDivs;

        /* DEFAULT CONSTRUCTOR */
        /** Default construcor. */
        private InputSchema() {
            }

        /* COPY CONSTRUCTOR */
        /** Creates a copy of the given schema item.
        @param oldInputSchema the given schema item. */

        private InputSchema(InputSchema oldInputSchema) {
            name     = oldInputSchema.name;
            typeName = oldInputSchema.typeName;
            min      = oldInputSchema.min;
            max      = oldInputSchema.max;
            range    = oldInputSchema.range;

            if (oldInputSchema.nominalData!=null) {
                nominalData = new String[oldInputSchema.nominalData.length];
                for (int index=0;index<nominalData.length;index++) {
                    nominalData[index] = oldInputSchema.nominalData[index];
                    }
                }
            else nominalData=null;
            }
        }

    /* ------ DIVISIONS CLASS ------ */

    /** Class defining details of a schema numeric divisons. <P> A numeric
    division is a subrange. */

    private class Division {
        /** Start Index */
	int startIndex;
	/** End Index */
	int endIndex;
	/** Number of elements in division */
	int length;
	/** Dominant class */
	int dominantClass;
	/** Number of sample records per class. */
	int numRecords[];
	/** Total number of records */
	int totalNumRecords;
	/** Probability per class */
	double probability[];
	/** Next link */
	Division linkRef = null;
	/** Back link */
	Division backRef = null;

	/* CONSTRUCTOR */
	/** Four argument constructor
	@param sIndex the start index.
	@param eIndex the end index.
	@param domClass the dominant class
	@param temp temporary array containing number of records per class. */

	private Division(int sIndex, int eIndex, int domClass, int[] temp) {
	    startIndex    = sIndex;
	    endIndex      = eIndex;
	    length        = eIndex-sIndex+1;
	    dominantClass = domClass;

	    // Assign to number of records field and determine total number
	    // of records
	    numRecords = new int[numClasses];
	    int total = 0;
	    for (int i=0;i<temp.length;i++) {
	        numRecords[i]=temp[i];
		total = total + temp[i];
	        }
	    totalNumRecords = total;

	    // Determine probabilities
	    probability = new double[numClasses];
	    for (int i=0;i<temp.length;i++) probability[i] =
	    				(double) temp[i]/ (double) total;
	    }
	}

    /* ------ NOMINAL DIVISION CLASS ------ */

    /** Class defining details of a schema nominal divisons. */

    private class NominalDiv {
    	/** List of vlaues */
	int [] listOfValues = new int[1];
	/** Dominant class */
	int dominantClass;
	/** Number of sample records per class. */
	int numRecords[];
	/** Total number of records */
	int totalNumRecords;
	/** Probability per class */
	double probability[];
	/** Next link */
	NominalDiv linkRef = null;
	/** Back link */
	NominalDiv backRef = null;

        /* CONSTRUCTOR */

        /** Two argument constructor
	@param start value for the division
	@param domClass the dominant class
	@param temp temporary array containing number of records per class. */

	private NominalDiv(int value, int domClass, int[] temp) {
	    dominantClass = domClass;

	    // Create list of values array
	    listOfValues[0] = value;

	    // Assign to number of records field and determine total number
	    // of records
	    numRecords = new int[numClasses];
	    int total = 0;
	    for (int i=0;i<temp.length;i++) {
	        numRecords[i]=temp[i];
		total = total + temp[i];
	        }
	    totalNumRecords = total;

	    // Determine probabilities
	    probability = new double[numClasses];
	    for (int i=0;i<temp.length;i++) probability[i] =
	    				(double) temp[i]/ (double) total;
	    }
	}

    /* GUI features  */

    // BUTTONS
    // Input buttons
    /** Input data button (space seperated). */
    private JButton inputSpaceDataButton;
    /** Input data button (comma seperated). */
    private JButton inputCommaDataButton;
    /** Input schema. */
    private JButton inputSchemaButton ;
    /** Input max range. */
    private JButton inputNumDivsButton;

    // Output Input Buutons
    /** List input data */
    private JButton listInputDataButton;
    /** List schema */
    private JButton listInputSchemaButton;
    /** List Min Max data */
    private JButton listMinMaxDataButton;

    // Edit Buttons
    /** Remove column N */
    private JButton removeColNbutton;
    /** Move column N to end */
    private JButton moveNtoEndButton;
    /** Move column N to before col M */
    private JButton moveNtoMbutton;
    /** Randomise */
    private JButton randomizeRowsButton;

    // Normalisation Buttons
    /** Normalisation */
    private JButton normaliseButton;
    /** List output data */
    private JButton listOutputDataButton;
    /** Distribute classes */
    private JButton distributeButton;
    /** List output schema */
    private JButton listOutputSchemaButton;
    /** List parameters */
    private JButton listParametersButton;
    /** Save normalisation button */
    private JButton saveNormButton;
    /** Save output schema button */
    private JButton saveOutputSchemaButton;

    // Panels
    /** Input buttons panel */
    private JPanel inputPanel;
    /** Input output buttons panel */
    private JPanel inputOutputPanel;
    /** Edit buttoms panel */
    private JPanel editPanel;
    /** Nor,alisation buttoms panel */
    private JPanel normalisationPanel;
    /** Credits panel */
    private JPanel creditsPanel;

    // Other components
    /** Text Area */
    private JTextArea textArea;

    // Data structures
    /** 2-D aray to hold input data from data file */
    private double[][] inputDataArray = null;
    /** 2-D aray to hold (normalised) output data  */
    private int[][] outputDataArray = null;
    /** Holds schema as contaioned in schema file */
    private InputSchema[] schema = null;
    /** Holds classes and the number of records per class */
    private int[][] classesArray = null;
    /** Holds linked list of numerical divisions */
    private Division startDivisions = null;
    /** Holds linked list of nominal divisions */
    private NominalDiv startNominalDivs = null;

    // Instance fields
    /** Instance of BufferedReader class */
    private BufferedReader fileInput;
    /** Instance of PrintWriter class */
    private PrintWriter fileOutput;

    // Flags
    /** Flag to indicate whether system has data or not. */
    private boolean hasDataFlag = false;
    /** Flag to indicate whether system has data schema or not. */
    private boolean hasInputSchemaFlag = false;
    /** Flag to indicate whether system has max num. divisions value or not. */
    private boolean hasMaxRangeFlag = false;
    /** Flag to indicare whether system has normalisation results. */
    private boolean hasNormalisationFlag = false;
    /** Unrecognised nominal value. */
    private boolean unrecognisedNominalValue = false;
    /** Oupit scheam flag. */
    private boolean outputSchemaFlag = false;

    // Constants
    /** Missing term value 100,000,001. */
    private final double MISSING_ITEM = 100000001.0;
    /** Term against which missing term value is tested 100,000,000 (the
    assumption is that we will not have a dataset that includes this value). */
    private final double TEST_TERM    = 100000000.0;
    /** Minomim number of divisiosns. */
    private final int MIN_NUM_DIVS    = 3;

    // Other fields
    /** Input data file name. */
    private File inputFileName;
    /** Output data file name. */
    private File outputFileName;
    /** Output schema file name. */
    //private File outputInputSchemaFileName;
    /** Number of rows. */
    private int numRows  = 0;
    /** Number of Columns in input data. */
    private int numColsInInputData  = 0;
    /** Number of Columns in input schema. */
    private int numColsInInputSchema  = 0;
    /** Number of Columns in normalisation data. */
    private int numColsInNormalisationData  = 0;
    /** The maximum number of integers that can be defined discretly */
    private int maxRange = 5;
    /** Number of attributes in output data set (set during normalisation). */
    private int numAttributes = 0;
    /** Number of classes in output data (assuming last label of each record
    is a class identifier) */
    private int numClasses =0;
    /** Number of missing items */
    private int numMissingItems = 0;

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

    /** One argument constructor.
    @param s The window name. */

    public LUCS_KDD_DN(String s) {
        super(s);

	// Content pane
        getContentPane().setBackground(Color.pink);
        getContentPane().setLayout(new BorderLayout(5,5)); // 5 pixel gaps

        // Creata panels
        createInputPanel();
        createInputOutputPanel();
        createEditPanel();
        createNormalisationPanel();

        // Credits Panel
	createCreditsPanel();

	// Add button Panel
	JPanel buttonPanel = new JPanel();
	buttonPanel.setLayout(new GridLayout(1,4));
	buttonPanel.add(inputPanel);
	buttonPanel.add(inputOutputPanel);
	buttonPanel.add(editPanel);
	buttonPanel.add(normalisationPanel);
	getContentPane().add(buttonPanel,BorderLayout.NORTH);

	// Add text area
	textArea = new JTextArea(40, 15);
	textArea.setEditable(false);
        getContentPane().add(new JScrollPane(textArea),BorderLayout.CENTER);
        instructions();

	// Add credits pabnel
	getContentPane().add(creditsPanel,BorderLayout.SOUTH);
	}

    /* CREATE CREDITS PANEL */
    /** Create credits panel. */

    private void createCreditsPanel() {
	// Swet up panel
	creditsPanel = new JPanel();
	creditsPanel.setBackground(Color.pink);
	creditsPanel.setLayout(new GridLayout(5,1));

	// Create labels
	Label creditLabel1 = new Label("LUCS-KDD (Liverpool University " +
				"Computer Science - Knowledge Discovery");
	Label creditLabel2 = new Label("in Data) group DN software (CARM data).");
	Label creditLabel3 = new Label(" ");
	Label creditLabel4 = new Label("Version 1 Created by Frans Coenen " +
			"(15 July 2003)");
	Label creditLabel5 = new Label("Version 2 Created by Frans Coenen " +
			"(18 January 2005)");
	// Add labels
	creditsPanel.add(creditLabel1);
	creditsPanel.add(creditLabel2);
	creditsPanel.add(creditLabel3);
	creditsPanel.add(creditLabel4);
	creditsPanel.add(creditLabel5);
	}

    /* CREAT INPUT PANEL */
    /** Sets upinput panel for interface. */

    private void createInputPanel() {
	// Set Up panel
	inputPanel = new JPanel();
	inputPanel.setBackground(Color.pink);
	inputPanel.setLayout(new GridLayout(4,1));

	// Create buttons
    	inputSchemaButton = new JButton("Input InputSchema");
     	inputSchemaButton.addActionListener(this);
  	inputCommaDataButton = new JButton("Input Data (',' Sep.)");
   	inputCommaDataButton.setEnabled(false);
   	inputCommaDataButton.addActionListener(this);
	inputSpaceDataButton = new JButton("Input Data (' ' Sep.)");
 	inputSpaceDataButton.setEnabled(false);
 	inputSpaceDataButton.addActionListener(this);
        inputNumDivsButton = new JButton("Input Num. Divs"); ;
        inputNumDivsButton.setEnabled(false);
        inputNumDivsButton.addActionListener(this);

      	// Add to panel
        inputPanel.add(inputSchemaButton);
       	inputPanel.add(inputSpaceDataButton);
        inputPanel.add(inputCommaDataButton);
	inputPanel.add(inputNumDivsButton);
	}

    /* CREATE INPUT OUTPUT PANEL */
    /** Sets up input output panel. */

    private void createInputOutputPanel() {
	// Set Up panel
	inputOutputPanel = new JPanel();
	inputOutputPanel.setBackground(Color.pink);
	inputOutputPanel.setLayout(new GridLayout(3,1));

	// Create buttons
	listInputDataButton = new JButton("List Input Data");
        listInputDataButton.addActionListener(this);
	listInputDataButton.setEnabled(false);
        listInputSchemaButton = new JButton("List InputSchema");
        listInputSchemaButton.addActionListener(this);
	listInputSchemaButton.setEnabled(false);
	listMinMaxDataButton = new JButton("List Min Max Data");
	listMinMaxDataButton.addActionListener(this);
	listMinMaxDataButton.setEnabled(false);

        // Add to panel
       	inputOutputPanel.add(listInputDataButton);
       	inputOutputPanel.add(listInputSchemaButton);
       	inputOutputPanel.add(listMinMaxDataButton);
	}

    /* CREATE EDIT PANEL */
    /** Sets up outpu panel. */

    private void createEditPanel() {
	// Set Up panel
	editPanel = new JPanel();
	editPanel.setBackground(Color.pink);
	editPanel.setLayout(new GridLayout(4,1));

	// Create buttons
        moveNtoEndButton = new JButton("Move N to End");
	moveNtoEndButton.addActionListener(this);
	moveNtoEndButton.setEnabled(false);
        moveNtoMbutton = new JButton("Move N to Before M");
	moveNtoMbutton.addActionListener(this);
	moveNtoMbutton.setEnabled(false);
        removeColNbutton = new JButton("Remove Col N");
	removeColNbutton.addActionListener(this);
	removeColNbutton.setEnabled(false);
        randomizeRowsButton = new JButton("Randomize Rows");
	randomizeRowsButton.addActionListener(this);
	randomizeRowsButton.setEnabled(false);

	// Add to panel
	editPanel.add(moveNtoEndButton);
	editPanel.add(moveNtoMbutton);
	editPanel.add(removeColNbutton);
	editPanel.add(randomizeRowsButton);
        }

    /* CREATE NORMALISATION PANEL */
    /** Sets up normalisation tools panel. */

    private void createNormalisationPanel() {
	// Set Up panel
	normalisationPanel = new JPanel();
	normalisationPanel.setBackground(Color.pink);
	normalisationPanel.setLayout(new GridLayout(7,1));

	// Create buttons
	normaliseButton = new JButton("Normalise");
	normaliseButton.addActionListener(this);
	normaliseButton.setEnabled(false);
	distributeButton = new JButton("Distribute Classes");
        distributeButton.addActionListener(this);
	distributeButton.setEnabled(false);
	listOutputSchemaButton = new JButton("List Output Scema");
	listOutputSchemaButton.addActionListener(this);
	listOutputSchemaButton.setEnabled(false);
	listParametersButton = new JButton("List Parameters");
	listParametersButton.addActionListener(this);
	listParametersButton.setEnabled(false);
        listOutputDataButton = new JButton("List Output Data");
        listOutputDataButton.addActionListener(this);
	listOutputDataButton.setEnabled(false);
	saveNormButton = new JButton("Save Normalization");
	saveNormButton.addActionListener(this);
	saveNormButton.setEnabled(false);
        saveOutputSchemaButton = new JButton("Save Output Schema");
	saveOutputSchemaButton.addActionListener(this);
	saveOutputSchemaButton.setEnabled(false);

        // Add to panel
       	normalisationPanel.add(normaliseButton);
	normalisationPanel.add(distributeButton);
	normalisationPanel.add(listParametersButton);
	normalisationPanel.add(listOutputSchemaButton);
	normalisationPanel.add(listOutputDataButton);
	normalisationPanel.add(saveNormButton);
	normalisationPanel.add(saveOutputSchemaButton);
	}

    /* ATION PERFORMED */

    /** Action listeners
    @param event The triggered event. */

    public void actionPerformed(ActionEvent event) {
        if (event.getActionCommand().equals("Input Data (' ' Sep.)"))
			inputSpaceData();
        if (event.getActionCommand().equals("Input Data (',' Sep.)"))
			inputCommaData();
	if (event.getActionCommand().equals("Input InputSchema"))
			inputInputSchema();
	if (event.getActionCommand().equals("Input Num. Divs"))
			inputNumDivs();
        if (event.getActionCommand().equals("Normalise"))
			normalise();
        if (event.getActionCommand().equals("List Input Data"))
			listInputData();
        if (event.getActionCommand().equals("List InputSchema"))
			listInputSchema();
        if (event.getActionCommand().equals("List Output Data"))
			listOutputData();
        if (event.getActionCommand().equals("Distribute Classes"))
			distributeClasses();
        if (event.getActionCommand().equals("List Min Max Data"))
			listMinMaxData();
        if (event.getActionCommand().equals("List Parameters"))
			listParameters();
        if (event.getActionCommand().equals("List Output Scema"))
			listOutputSchema();
        if (event.getActionCommand().equals("Save Normalization"))
			saveNormalisation(); 
        if (event.getActionCommand().equals("Save Output Schema"))
			saveOutputSchema();
        if (event.getActionCommand().equals("Move N to End"))
			moveColNtoEnd();
        if (event.getActionCommand().equals("Move N to Before M"))
			moveColNtoBeforeColM();
        if (event.getActionCommand().equals("Remove Col N"))
			removeColN();
        if (event.getActionCommand().equals("Randomize Rows"))
			randomizeRows();

        // Reset buttonn enabling
	resetButtonEnabling();
	}

    /* RESET BUTTON ENABLING */
    /* Resets the functionality of the GUI by enabling/disabling buttons. */

    private void resetButtonEnabling() {
        if (hasNormalisationFlag) setNormalisationButtonsToTrue();
	else if (hasMaxRangeFlag) {
	    normaliseButton.setEnabled(true);
	    }
	else if (hasDataFlag) {
            inputNumDivsButton.setEnabled(true);
	    listInputDataButton.setEnabled(true);
	    listMinMaxDataButton.setEnabled(true);
            setEditButtonsEnableToTrue();
	    determinMaxMinDataArray();
	    }
        else if (hasInputSchemaFlag) {
            listInputSchemaButton.setEnabled(true);
            inputCommaDataButton.setEnabled(true);
 	    inputSpaceDataButton.setEnabled(true);
            inputNumDivsButton.setEnabled(false);
	    listInputDataButton.setEnabled(false);
	    listMinMaxDataButton.setEnabled(false);
	    setEditButtonsEnableToFalse();
	    setNormalisationButtonsToFalse();
	    numMissingItems=0;
	    }
        // Tried to load schema but failed
	else {
	    inputCommaDataButton.setEnabled(false);
 	    inputSpaceDataButton.setEnabled(false);
            inputNumDivsButton.setEnabled(false);
	    setOutputButtonsEnableToFalse();
	    setEditButtonsEnableToFalse();
	    setNormalisationButtonsToFalse();
	    numMissingItems=0;
	    }
	}

    /** Enables edit buttons. */
    private void setEditButtonsEnableToTrue() {
        removeColNbutton.setEnabled(true);
     	moveNtoEndButton.setEnabled(true);
	moveNtoMbutton.setEnabled(true);
	randomizeRowsButton.setEnabled(true);
	}

    /** Enables normalisation output buttons. */
    private void setNormalisationButtonsToTrue() {
    	listOutputDataButton.setEnabled(true);
	distributeButton.setEnabled(true);
	listOutputSchemaButton.setEnabled(true);
	listParametersButton.setEnabled(true);
	saveNormButton.setEnabled(true);
        saveOutputSchemaButton.setEnabled(true);
	}

    /** Disables output buttons. */
    private void setOutputButtonsEnableToFalse() {
        listInputSchemaButton.setEnabled(false);
	listInputDataButton.setEnabled(false);
	listMinMaxDataButton.setEnabled(false);
	}

    /** Disables edit buttons. */
    private void setEditButtonsEnableToFalse() {
        removeColNbutton.setEnabled(false);
     	moveNtoEndButton.setEnabled(false);
	moveNtoMbutton.setEnabled(false);
	randomizeRowsButton.setEnabled(false);
	}

    /** Disables normalisation buttons. */
    private void setNormalisationButtonsToFalse() {
    	normaliseButton.setEnabled(false);
	listOutputDataButton.setEnabled(false);
	distributeButton.setEnabled(false);
	listOutputSchemaButton.setEnabled(false);
	listParametersButton.setEnabled(false);
	saveNormButton.setEnabled(false);
	}

    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                           INPUT DATA                             */
    /*                                                                  */
    /* ---------------------------------------------------------------- */

    /* Commence reading data from file */

    /* INPUT SPACE DATA */
    /** Commences process of reading inpu file of space seperated numbers:
    (1) dispalys file dialog box, (2) checks the selected file is readable
    and if so (3) reads the file.*/
    private void inputSpaceData() {
        textArea.append("READING INPUT FILE:\n-------------------\n");
	textArea.append("Space separated attributes\n" );

	inputData(" ");
	}

    /* INPUT COMMA DATA */
    /** Commences process of reading inpu file of comma seperated numbers:
    (1) dispalys file dialog box, (2) checks the selected file is readable
    and if so (3) reads the file.*/
    private void inputCommaData() {
        textArea.append("READING INPUT FILE:\n-------------------\n");
	textArea.append("Comma separated attributes\n" );

        inputData(",");
        }

    /* Input DATA */
    /** Commences process of reading inpu file: (1) dispalys file dialog box,
    (2) checks the selected file is readable and if so (3) reads the file and
    determines ranges.
    @param discriminator the separater between numbers, e.g. spaxce or comma. */

    private void inputData(String discriminator) {
	// Display file dialog so user can select file to open
	JFileChooser fileChooser = new JFileChooser();
	fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
	int result = fileChooser.showOpenDialog(this);

	// If cancel button selected return
	if (result == JFileChooser.CANCEL_OPTION) return;

	// Obtain selected file
	numMissingItems = 0;
	inputFileName   = fileChooser.getSelectedFile();
	textArea.append("inputFileName = " +  inputFileName + "\n");
	// Read file if readabale (i.e not a direcrory etc.).
	if (checkFileName()) readDataFile(discriminator);
	}

    /* READ DATA FILE */
    /** Reads the selected input file: (1) checks file foramt and if OK
    determines the number of records in the file,  and then (if OK) (2)
    dimensions the data array in which the file is to be stored, (3) causes
    the data to be loaded into the data array and (4) sets the
    <TT>hasDataFlag</TT> to "true".
    @param discriminator the separater between numbers, e.g. spaxce or comma. */

    private void readDataFile(String discriminator) {

	try {
	    // Set appropriate flags to false
	    hasMaxRangeFlag      = false;
	    hasNormalisationFlag = false;
	    // If file OK
	    if (countNumRecordsAndCols(discriminator)) {
	        // Dimension input data array
	        inputDataArray  = new double[numRows][];
	        // Read file
	        if (inputDataSet(discriminator)) {
  	            // Set have data flag to true
	            hasDataFlag = true;
	            listParameters2();
	            }
		}
	    else {
	        hasDataFlag = false;
		return;
		}
	    }
	catch(IOException ioException) {
	    JOptionPane.showMessageDialog(this,"Error reading File",
			 "Error: ",JOptionPane.ERROR_MESSAGE);
	    closeInputFile();
	    System.exit(1);
	    }
	}

    /* COUNT NUMBER OF RECORDS AND COLUMNS */
    /** Reads the input file and dertermines the number of records and columns
    @param discriminator the separater between numbers, e.g. spaxce or comma.
    @return false if file is not in correct format or not of correct size. */

    private boolean countNumRecordsAndCols(String discriminator)
    							throws IOException {
        int counter = 0;
        int localNumCols =0 ;
	boolean firstLine = true;

	// Open the file
	openInputFile();

	// Get first row and check discriminator, if not of correct type
	// rerturn false
	String line = fileInput.readLine();
	if (line.indexOf(discriminator.charAt(0)) < 0) {
	    if (discriminator.equals(" ")) JOptionPane.showMessageDialog(null,
	    		"File is not space separated\n\n" );
	    if (discriminator.equals(",")) JOptionPane.showMessageDialog(null,
	    		"File is not Comma separated\n\n" );
            closeInputFile();
	    return(false);
	    }

	// Loop through file incrementing record counter.
	while (line != null) {
	    StringTokenizer dataLine = new StringTokenizer(line,discriminator);
            int numberOfTokens = dataLine.countTokens();
	    if (firstLine) {
	        localNumCols=numberOfTokens;
	        firstLine=false;
	        }
	    if (numberOfTokens == 0) break;
	    counter++;
            line = fileInput.readLine();
	    }

	// Check number of columns with that in schema file (if it exists)
	if (numColsInInputSchema != localNumCols) {
	    JOptionPane.showMessageDialog(null,
	            	"ERROR: Number of columns in input data \n(" +
	            	localNumCols + ") is not the same as in the schema " +
	            	                  "file (" + numColsInInputSchema + ")\n");
            numRows = counter;
	    numColsInInputData = localNumCols;
	    closeInputFile();
            return(false);
	    }

	// Set number of rows and columns and close file
	numRows = counter;
	numColsInInputData = localNumCols;
        closeInputFile();
        return(true);
	}

    /* INPUT DATA SET */
    /** Reads input data from file specified in command line argument and
    places data in inputDataArray.
    @param discriminator the separater between numbers, e.g. spaxce or comma.
    @return true if data successfully loaded, false otherwise. */

    public boolean inputDataSet(String discriminator) throws IOException {
        int rowIndex=0;

	// Open the file
	openInputFile();

	// get first row.
	String line = fileInput.readLine();

	// Loop until empty line found
	while (line != null) {
	    // Create a StringTokienizer instance
	    StringTokenizer dataLine = new StringTokenizer(line,discriminator);
            // Get number of tokens
            int numberOfTokens = dataLine.countTokens();
	    // If no tokens jump out of loop
	    if (numberOfTokens == 0) break;
	    // If number of tokens greater than that in schema file error
	    if (numColsInInputSchema != numberOfTokens) {
	         textArea.append("ERROR: in line " + (rowIndex+1) +
		                    " Number of columns (" + numberOfTokens +
		                         ") not the same as in the schema " +
	            	                 "file (" + numColsInInputSchema + ")\n");
		 return(false);
		 }
	    // Otherwise convert input string to a sequence of doubles
	    double[] code = doubleConversion(rowIndex+1,dataLine,
	    			numberOfTokens);
	    // Check for unrecognised nominal value error
	    if (unrecognisedNominalValue) {
	    	textArea.append("ABORTING READ OPERATION!");
		unrecognisedNominalValue=false;
		closeInputFile();
		return(false);
		}
            // Check for "null" input
	    if (code!=null) {
	    	// Dimension rows in 2-D inputDataArray
		int codeLength = code.length;
		inputDataArray[rowIndex] = new double[codeLength];
		// Assign to elements in row
		for (int colIndex=0;colIndex<codeLength;colIndex++)
			inputDataArray[rowIndex][colIndex] = code[colIndex];
		}
	    else inputDataArray[rowIndex]=null;
	    // Increment first index in 2-D data array
	    rowIndex++;
	    // get next line
            line = fileInput.readLine();
	    }

	// Close file
	closeInputFile();
	return(true);
	}

    /* DOUBLE CONVERSION. */
    /** Produce an array of doubles from the input line.
    @param lineNum line number in input data file
    @param dataLine row from the input data file
    @param numberOfTokens number of items in row
    @return 1-D array of doubles representing attributes in input row */

    private double[] doubleConversion(int lineNum, StringTokenizer dataLine,
    							int numberOfTokens) {
        double[] newItemSet = null;

	// Loop through input line and add contents to data array
	for (int tokenCounter=0;tokenCounter < numberOfTokens;tokenCounter++) {
	    String s1 = dataLine.nextToken();
	    double number = 0.0;
	    // Test for missing term
	    if (s1.equals("?")) {
	    	numMissingItems++;
	    	number = MISSING_ITEM;
	    	}
	    else {
	        // Test for unused value
		if (schema[tokenCounter].typeName.equals("unused")) number=0;
	        // Test for nominal value if so determine value
	        else if (schema[tokenCounter].typeName.equals("nominal")) {
	            number = getNominalValue(lineNum,s1,tokenCounter);
	            if (unrecognisedNominalValue) return(null);
		    }
	        // Otherwise number
	        else {
		    try {
		        number = Double.parseDouble(s1);
			}
		    catch (NumberFormatException e) {
		        textArea.append("ERROR in line " + lineNum + ", " +
			   "column number " + tokenCounter + ", of input " +
			   "data not of type " + schema[tokenCounter].typeName +
			   " as expected!\n");
			number = 0.0;
			}
		    }
		}
	    // Enter value into data array
	    newItemSet = realloc1(newItemSet,number);
	    }

	// Return itemSet
	return(newItemSet);
	}

    /* GET NOMINAL VALUE */
    /** Get nominal value.
    @param lineNum line number in input data file
    @param s1 the string read from the input stream
    @param colNum the column number
    @return an integer returned as a double representing the nominal value. */

    private double getNominalValue(int lineNum, String s1, int colNum) {
        unrecognisedNominalValue=false;

        // Loop through possible values for this column looking for a match
        for(int index=0;index<schema[colNum].nominalData.length;index++) {
            if (schema[colNum].nominalData[index].equals(s1)) return(index);
            }

        // Check for missing value
	if (s1.equals("?")) return(MISSING_ITEM);

	// End, if process gets this far no comparable value has been found
        // in which case there is something wrong with either the schema or
        // the data.
        textArea.append("ERROR in line " + lineNum + " of input data: data " +
		"item \"" + s1 + "\" not found in schema entry for column " +
		(colNum+1) + ", options are: { ");
        for (int index=0;index<schema[colNum].nominalData.length;index++) {
            textArea.append(schema[colNum].nominalData[index] + " ");
            }
        textArea.append("}\n");
	unrecognisedNominalValue=true;
        return(MISSING_ITEM); 	// Error value
        }

    /* DETERMINE RANGES */
    /** Determine range of vlaues for each column. */

    private void determineRanges() {

	// process min/max array
	for (int colIndex=0;colIndex<schema.length;colIndex++) {
	    schema[colIndex].range = schema[colIndex].max -
	    					schema[colIndex].min;
	    }
	}

    /* REDETERMINE MIN, MAX AND RANGE VALUES */
    /** Determines minimum, maximum and range array values. <P> Operates
    only when bith scema and data exist. Also called when a column is
    moved or deleted. */

    private void determinMaxMinDataArray() {
        if (!hasInputSchemaFlag) return;

        // Initialise min amd max fields in scheam array to missing
	// term value
	for(int index=0;index<schema.length;index++) {
	    schema[index].min = MISSING_ITEM;
	    schema[index].max = MISSING_ITEM;
	    }

        // Loop through input data array
        for (int rowN=0;rowN<inputDataArray.length;rowN++) {
            for (int colN=0;colN<inputDataArray[rowN].length;colN++) {
	        // If nominal value add values from schema file
		if (schema[colN].typeName.equals("nominal")) {
		    schema[colN].min = 0;
		    schema[colN].max = schema[colN].nominalData.length-1;
		    schema[colN].range = schema[colN].nominalData.length-1;
		    }
		// Otherwise process
		else {
		    // Update min anmd max fields if data item is not a
		    // "missing item" otherwise leave min and max entries with
		    // current values
	            if (inputDataArray[rowN][colN]<TEST_TERM) {
	                // First item
	                if (schema[colN].min > TEST_TERM) {
	                    schema[colN].min = inputDataArray[rowN][colN];
		            schema[colN].max = inputDataArray[rowN][colN];
		            }
	                else {
	                    if (inputDataArray[rowN][colN] < schema[colN].min)
				  schema[colN].min = inputDataArray[rowN][colN];
		            if (inputDataArray[rowN][colN] > schema[colN].max)
			    	  schema[colN].max = inputDataArray[rowN][colN];
		            }
			}
		    }
		}
	    }

	// Determine ranges
	determineRanges();
	}

    /* RECALCULATE NUMBER OF MISSING ITEMS */
    /** Recalculates the number of missing items in the input data set (used
    when a column has been removed. */

    private void recalculateMissingItems() {
        numMissingItems=0;

        // Loop through data array
        for(int index1=0;index1<inputDataArray.length;index1++) {
            for (int index2=0;index2<inputDataArray[index1].length;index2++) {
                if (inputDataArray[index1][index2]>TEST_TERM) numMissingItems++;
                }
            }
        }

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                    INPUT INPUT SCHEMA                   */
    /*                                                         */
    /* ------------------------------------------------------- */

    /* INPUT INPUT SCHEMA */
    /** Commences process of inputting inpurt data schema, if schema not read (for
    whatever reason) sets hasInputSchemaFlag value to false. */

    private void inputInputSchema() {
        textArea.append("READING INPUT SCHEMA:\n-----------------------\n");

	// Display file dialog so user can select file to open
	JFileChooser fileChooser = new JFileChooser();
	fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
	int result = fileChooser.showOpenDialog(this);

	// If cancel button selected return
	if (result == JFileChooser.CANCEL_OPTION) return;

	// Obtain selected file
	inputFileName = fileChooser.getSelectedFile();
	textArea.append("InputSchema inputFileName = " +  inputFileName + "\n\n");
	// Read file if readabale (i.e not a direcrory etc.).
	if (checkFileName()) readInputSchemaFile();
	else  hasInputSchemaFlag=false;

	// Set all other flags to false
	hasDataFlag          = false;
	hasMaxRangeFlag      = false;
	hasNormalisationFlag = false;
	}

    /* READ INPUT SCHEMA DILE  */
    /** Reads input schema file and stores in array of schema items.
    First row is "unused", "nominal", "int" or "double". */

    private void readInputSchemaFile() {
	try {
	    // Open the file
	    openInputFile();
	    // Read first line and tokenise
	    String lineFromFile = fileInput.readLine();
	    StringTokenizer dataLine = new StringTokenizer(lineFromFile);
	    // Get numberof columns in schema file
	    numColsInInputSchema =  dataLine.countTokens();
	    // Diemsion and initialise schema array
            schema = new InputSchema[numColsInInputSchema];
            for (int index=0;index<schema.length;index++)
	                                          schema[index] = new InputSchema();
	    // Store first line in schema array
	    for (int colIndex=0;colIndex<schema.length;colIndex++)
	                      schema[colIndex].typeName = dataLine.nextToken();
	    // Read reast of schema file
	    if (readRestOfInputSchemaFileOK()) hasInputSchemaFlag=true;
	    else hasInputSchemaFlag=false;
	    // Close file
	    closeInputFile();
	    }
	catch (IOException ioException) {
	    JOptionPane.showMessageDialog(this,"Error reading File",
			 "Error: ",JOptionPane.ERROR_MESSAGE);
	    closeInputFile();
	    System.exit(1);
	    }
	}

    /* READ REST OF INOUT SCEMA FILE OK */
    /** Reads second and third lines from schaema file. If OK returns
    tree, otherwise returns false.
    @return True if schema is OK anf false otherwise. */

    private boolean readRestOfInputSchemaFileOK() throws IOException {
        // Read second line and tokenise
        String lineFromFile = fileInput.readLine();
	StringTokenizer dataLine = new StringTokenizer(lineFromFile);

	// If not same length as first line in schema return false.
	if (!sameLengthAsFirstLineInScema(dataLine,"second")) return(false);

	// If OK store in schema array data structure
	for (int colIndex=0;colIndex<schema.length;colIndex++)
	                	schema[colIndex].name = dataLine.nextToken();

	// Check contents of first line of schema
	if (!checkInputSchemaContents()) return(false);

	// If OK read third line from schema
	lineFromFile = fileInput.readLine();
	dataLine = new StringTokenizer(lineFromFile);

	// If not same length as first line in schema return false.
	if (!sameLengthAsFirstLineInScema(dataLine,"third")) return(false);

	// Load nominal data array
	loadNominalDataArray(dataLine);

	// Check contents of third line of schema
	return(checkNominalData());
        }

    /* LOAD NOMINAL DATA ARRAY */
    /** Loads nominal data array with possible values for nominal data
    attributes, "null" for other attributes. */

    private void loadNominalDataArray(StringTokenizer dataLine) {
        numColsInNormalisationData = numColsInInputSchema;

        // Loop through second line of scema data array to identify nominal
	// attributes
        for (int colN=0;colN<schema.length;colN++) {
            // get item from third line of schema file
            String itemList = dataLine.nextToken();
            // Check schema type value
            if (schema[colN].typeName.equals("nominal")) {
                StringTokenizer itemListTokens =
		                             new StringTokenizer(itemList,"/");
                // Determine number of values in item list
                int numValues = itemListTokens.countTokens();
                // Dimension line in nominal data array
                schema[colN].nominalData = new String[numValues];
                // loop through item list of nominal values seperated by
		// '/' charactor.
                for (int tknCntr=0;tknCntr<numValues;tknCntr++)
                			    schema[colN].nominalData[tknCntr] =
		 		                    itemListTokens.nextToken();
                }
    	    else schema[colN].nominalData=null;
    	    }
        }

    /* SAME LENGTH AS FIRST LINE IN SCHEMA */
    /** Checks that second line in schema has same number of tokens as first
    line
    @param dataLine The input line from the schema file
    @return type is same number of tokens, and false otherwise. */

    private boolean sameLengthAsFirstLineInScema(StringTokenizer dataLine,
    							   String lineNumber) {
        int localLength =  dataLine.countTokens();

        if (localLength != numColsInInputSchema)  {
	    JOptionPane.showMessageDialog(null,"ERROR: Number of columns in " +
	            	lineNumber + " line\nof schema (" + localLength +
	            	") is not the\nsame as in first line (" +
	            	numColsInInputSchema + ")\n");
	    return(false);
	    }

	// End
	return(true);
        }

    /* CHECK SCHEMA CONTENTS. */
    /** Checks first line of schema file and outputs error message if an entry
    is found that is not "int", "double", "nominal" or "unused".
    @return true if OK, false otherwise. */

    private boolean checkInputSchemaContents() {
         boolean errorFlag = false;
         int colIndex=0;

         // Loop through schema file and checj types
         for ( ;colIndex<schema.length;colIndex++) {
	    if (!schema[colIndex].typeName.equals("int") &&
	    		!schema[colIndex].typeName.equals("double") &&
	    		!schema[colIndex].typeName.equals("nominal") &&
	    		!schema[colIndex].typeName.equals("unused")) {
		errorFlag=true;
		break;
		}
	    }

	// Default
	if (errorFlag) {
	    JOptionPane.showMessageDialog(null,"ERROR: unrecognised first " +
	    	     "line schema label, found\n\"" + schema[colIndex].typeName +
		     "\" when expecting \"int\", \"double\", \"nominal\" or\n" +
		     "\"unused\"\n");
	    return(false);
	    }
	return(true);
	}

    /* CHECK NOMINAL DATA */
    /** Checks third line of schema matches second line of schema and
    vice versa.
    @returm true oi third line of schema matches second line, false
    otherwise. */

    private boolean checkNominalData() {
        boolean returnValue=true;

        // Loop through third line of schema data to make sure that
        // each nominal attribute has a value list associated with it.
        for (int colIndex=0;colIndex<schema.length;colIndex++) {
            if (schema[colIndex].typeName.equals("nominal") &&
            				schema[colIndex].nominalData==null) {
            	 JOptionPane.showMessageDialog(null,"ERROR: Attribute " +
		                      colIndex + ", nominal data items\nmust " +
            	 		    "have a value list associated with them\n");
            	 returnValue=false;
            	 }
            }

        // Loop through nominal data structure to make sure that
        // each nominal attribute has a value list associated with it.

        for (int colIndex=0;colIndex<schema.length;colIndex++) {
            if (schema[colIndex].nominalData!=null &&
                                   !schema[colIndex].typeName.equals("nominal"))
                JOptionPane.showMessageDialog(null,"WARNING: Attribute " +
			          colIndex + ", list of values supplied\nbut " +
            	 	         "type is " + schema[colIndex].typeName + "\n");
            }

        // Return
        return(returnValue);
        }


    /* NUMBER OF CLASSES */
    /** Determines number of classes.
    @return true if number of classes can be calculated and false otherwise. */

    private boolean calcNumberOfClasses() {
        if (schema[schema.length-1].nominalData != null) {
	    numClasses = schema[schema.length-1].nominalData.length;
	    return(true);
	    }
	else {
	    JOptionPane.showMessageDialog(null,"NUMBER OF CLASSES " +
	    		"CALCULATION ERROR:\nThe class attribute is assumed " +
			"to be represented\nby the last column in the input " +
			"data and must be\nof type \"nominal\". Currently " +
			"the last column is\n of type \"" +
			schema[schema.length-1].typeName + "\". Either:\n(i) " +
			"Adjust schema, or\n(ii) If the class attribute is " +
			"reprersented by some\n    other column use the " +
			"\"move N to end\" button\n    so that it becomes " +
			"the last column.\n");
	    return(false);
	    }
        }

    /* --------------------------------------------------------- */
    /*                                                           */
    /*                     INPUT MAX DIVISIONS                   */
    /*                                                           */
    /* --------------------------------------------------------- */

    /* INPUT NUMBER OF DIVISIONS */
    /** Commences process of inputting max number of divisions --- the maximum
    number of divisions for a single attribute. */

    private void inputNumDivs() {
        textArea.append("INPUT MAXIMUM NUM DIVISIONS VALUE:\n"+
	                            "-------------------------------------\n");

        try{
           while (true) {
               String stNum1 = JOptionPane.showInputDialog("Input maximum " +
               		"number of divisions for numeric\nattributes. Should " +
			"be a positive integer\n equal to or greater than " +
               		MIN_NUM_DIVS + "\n\n" );
	       maxRange = Integer.parseInt(stNum1);
	       if (maxRange >= MIN_NUM_DIVS) break;
               JOptionPane.showMessageDialog(null,"MAXIMUM NUMBER OF " +
	       		"DIVISIONS VALUE INPUT ERROR:\ninput = " + maxRange +
	       		"\nmaximum number of divisions input must be an " +
	       		"integer\ngreater or equal to " + MIN_NUM_DIVS + "\n");
	       }
	    textArea.append("Maximum number of divisions = " + maxRange +
	    							      "\n\n");
	    hasMaxRangeFlag=true;
	    }
        catch(NumberFormatException e) {
	    }
	}

    /* ---------------------------------------------- */
    /*                                                */
    /*                       EDIT PANEL               */
    /*                                                */
    /* ---------------------------------------------- */

    /* MOVE COLUMN N TO END */
    /** Moves a column in the input file to the end of the input data (user
    prompted for column number to be moved). */
    private void moveColNtoEnd() {
        int newColIndex;
        // Input column number to be removed
        textArea.append("MOVE COLUMN TO END:\n--------------------\n");
        int colNumToBeMovedToEnd = inputColNumber("Input column number " +
							        "to be moved");
        if (colNumToBeMovedToEnd == -1) {
	    textArea.append("Operation cancelled\n");
	    return;
	    }
	textArea.append("Column number to be moved to end = " +
					      (colNumToBeMovedToEnd+1) + "\n");

	// Move
        moveColInInputData(colNumToBeMovedToEnd,numColsInInputData);
        moveColInInputSchema(colNumToBeMovedToEnd,numColsInInputData);

        // Calculate new min and max values for ranges, and number of missing
	// items
	determinMaxMinDataArray();
	recalculateMissingItems();

        // End
        textArea.append("Column number " + (colNumToBeMovedToEnd+1) +
	                                                  " moved to end\n\n");
        }

    /* MOVE COLUMN N TO BEFORE COLUMN M */
    /** Moves a column in the input file to another position in the input data
    (user prompted for column number to be moved and column number to be moved
    to). */
    private void moveColNtoBeforeColM() {
        int newColIndex;

        // Input column number to be removed
        textArea.append("MOVE COLUMN:\n-------------\n");
        int colNumToBeMoved = inputColNumber("Input column number to be moved");
        if (colNumToBeMoved == -1) {
	    textArea.append("Operation cancelled\n");
	    return;
	    }
	int toColumnNumber  = inputColNumber("Input column number for colum " +
        		(colNumToBeMoved+1) + " to be moved to");
        if (toColumnNumber == -1) {
	    textArea.append("Operation cancelled\n");
	    return;
	    }
	textArea.append("Column number " + (colNumToBeMoved+1) +
	                       " to be moved to " + (toColumnNumber+1) + "\n");

        // Move
        int toNumber=toColumnNumber;
        if (toColumnNumber>colNumToBeMoved) toNumber--;
        moveColInInputData(colNumToBeMoved,toNumber);
        moveColInInputSchema(colNumToBeMoved,toNumber);;

        // Calculate new min and max values for ranges, and number of missing
	// items
	determinMaxMinDataArray();
	recalculateMissingItems();

        // End
        textArea.append("Column number " + (colNumToBeMoved+1) + " moved to " +
        		(toColumnNumber+1) + "\n\n");
        }

    /* MOVE COLUMN IN INPUT DATA */
    /** Moves column in input data structure.
    @param colToBeMoved The column number identifier for the column to be moved.
    @param toColumnNumber The column number identifier for the column before
    which the column to be moved is tombe inswerted.  */

    private void moveColInInputData(int colToBeMoved, int toColumnNumber) {
        int localNumRows = inputDataArray.length;

        // Store input for column to be moved}
        double[] inputToBeMoved = new double[localNumRows];
        for (int rowN=0;rowN<localNumRows;rowN++)
        	inputToBeMoved[rowN]=inputDataArray[rowN][colToBeMoved];

        // Remove column to be moved from input data structure
        removeColNfromInput(colToBeMoved);

        // Increment input data column counter, and create new input data
	// structure
        numColsInInputData++;
        double[][] newInputDataArray =
	                          new double[localNumRows][numColsInInputData];

        // Loop through current data and create new data structure
        for (int rowN=0;rowN<localNumRows;rowN++) {
            int newcolN=0;
            boolean columnMoved=false;
            // Loop through row column ny column
            for (int colN=0;colN<inputDataArray[rowN].length;colN++) {
	        if (colN==toColumnNumber) {
		    newInputDataArray[rowN][newcolN] = inputToBeMoved[rowN];
	            newcolN++;
	            columnMoved=true;
	            }
	        newInputDataArray[rowN][newcolN] = inputDataArray[rowN][colN];
	        newcolN++;
	        }
	    // Add to end
	    if (!columnMoved) newInputDataArray[rowN][newcolN] =
	    						inputToBeMoved[rowN];
	    }

	// Assign new data structure identifier to current data field
	inputDataArray = newInputDataArray;
        }

    /* MOVE COLUMN IN SCHEMA */
    /** Moves column in schema structure.
    @param colToBeMoved The column number identifier for the column to be moved.
    @param toColumnNumber The column number identifier for the column before
    which the column to be moved is tombe inswerted.  */

    private void moveColInInputSchema(int colToBeMoved, int toColumnNumber) {
        // Store schema attributes for column to be moved
        InputSchema attributeToBeMoved = new InputSchema(schema[colToBeMoved]);

        // Remove column to be moved from schema data structure
        removeColNfromInputSchema(colToBeMoved);

        // Increment number of columns in schema, and create new schema data
        // structure
        numColsInInputSchema++;
        InputSchema[] newInputSchema  = new InputSchema[numColsInInputSchema];

	// Loop through current schema and create new scheam data srtructure
        int newColIndex=0;
	boolean columnMoved=false;
        for (int colIndex=0;colIndex<(numColsInInputSchema-1);colIndex++) {
            if (colIndex==toColumnNumber) {
	        newInputSchema[newColIndex] = attributeToBeMoved;
	        newColIndex++;
	        newInputSchema[newColIndex] = schema[colIndex];
	        columnMoved=true;
	        }
	    else newInputSchema[newColIndex] = schema[colIndex];
	    newColIndex++;
	    }

	// Add to end?
	if (!columnMoved) newInputSchema[newColIndex] = attributeToBeMoved;

	// Assign new schema structure identifier to current schema field
	schema = newInputSchema;
	}

    /* REMOVE COLUMN N */
    /** Removes a column from the input file (user prompted for column number
    to be moved). */
    private void removeColN() {
        // Input column number to be removed
        textArea.append("REMOVED COLUMN:\n-------------------\n");
        int colNumToBeRemoved = inputColNumber("Input column number to be " +
						                     "removed");
        if (colNumToBeRemoved == -1) {
	    textArea.append("Operation cancelled\n");
	    return;
	    }
	textArea.append("Column number to be removed = " +
	                                          (colNumToBeRemoved+1) + "\n");

        // Are you sure?
        if (confirmColRemoval(colNumToBeRemoved)) {
            // Remoce column from input data structure
            removeColNfromInput(colNumToBeRemoved);
            // Remove column from schema structure
            removeColNfromInputSchema(colNumToBeRemoved);
	    // Calculate new min and max values for ranges, and number of
	    // missing items
	    determinMaxMinDataArray();
	    recalculateMissingItems();
	    // End
	    textArea.append("Column number " + (colNumToBeRemoved+1) +
	                                                        " removed\n\n");
	    listParameters2();
	    }
        }

    /* REMOVE COLUMN FROM INPUT  */
    /** Removes given column number from input data structure.
    @param colNumToBeRemoved The column identifier of the column to be removed
    from the input data structure. */

    private void removeColNfromInput(int colNumToBeRemoved) {
        // Decrement number of columns in data
        numColsInInputData--;

        // Create new data structure
        double[][] newInputDataArray  = new double[numRows][numColsInInputData];

        // Loop through current data and create new data structure
        for (int rowN=0;rowN<inputDataArray.length;rowN++) {
            for (int colN=0, newColN=0;colN<inputDataArray[rowN].length;
                					colN++) {
	        if (colN!=colNumToBeRemoved) {
	            newInputDataArray[rowN][newColN] =
	                			     inputDataArray[rowN][colN];
	            newColN++;
	            }
	        }
	    }

	// Assign new data structure identifier to current data field
	inputDataArray = newInputDataArray;
	}

    /* REMOVE COLUMN FROM SCHEMA */
    /** Removes given column number from schema data structure.
    @param colNumToBeRemoved The column identifier of the column to be removed
    from the schema structure. */

    private void removeColNfromInputSchema(int colNumToBeRemoved) {
        // Decrement number of columns in schema
        numColsInInputSchema--;

        // Create new schema file
        InputSchema[] newInputSchema  = new InputSchema[numColsInInputSchema];

        // Loop through current schema and create new schema data structure
        for (int colIndex=0, newColIndex=0;colIndex<=numColsInInputSchema;
                					          colIndex++) {
	    if (colIndex!=colNumToBeRemoved) {
	        newInputSchema[newColIndex]=schema[colIndex];
	        newColIndex++;
	        }
	    }

	// Assign new schema structure identifier to current schema field
	schema = newInputSchema;
	}

    /* INPUT COLUMN NUMBER TO BE REMOVED */
    /** Creates message window into which user can enter a colum number (used
    in conjunction with edit methods such as <TT>moveColNtoEnd</TT>,
    <TT>moveColNtoBeforeColM</TT> and <TT>removeColN</TT>).
    @param s1 The input string to be output in message window
    @return the column number input by the user. */
    private int inputColNumber(String s1) {
        int colNumber=0;

        try{
           while (true) {
               String stNum1 = JOptionPane.showInputDialog(s1 + " (integer\n" +
	       	     "within the range 1 and " + numColsInInputData + ")\n\n");
	       // Check for operation cancelled
	       if (stNum1 == null) return(-1);
	       colNumber = Integer.parseInt(stNum1);
               if (colNumber >= 1 && colNumber <= numColsInInputData) break;
               JOptionPane.showMessageDialog(null,
	       		"INVALID COLUMN NUMBER INPUT ERROR:\n" +
	       		"input = " + colNumber +
	       		"\ncolumn number number must be within the\n" +
	       		"range 1 and " + numColsInInputData + "\n\n");
	       }
	    }
        catch(NumberFormatException e) {
	    }

	// Return
	return(colNumber-1);
	}

    /* CONFIRM */
    /** Creates a message window to allow user to confirm a given colum number
    (used with <TT>removeColN</TT> edit method).
    @param colNumber The column number to be confirmed
    @return true of OK, false otherwise. */
    private boolean confirmColRemoval(int  colNumber) {
        int result = JOptionPane.showConfirmDialog(null,
	       	"CONFIRM COLUMN NUMBER TO BE REMOVED:\nAre you sure you " +
	       	"wish to remove column " + (colNumber+1) + "\nfrom the " +
	       	"input data set? (THIS OPERATION IS\nNOT REVERSABLE!)\n\n",
	       	"Confirm",JOptionPane.YES_NO_OPTION);
        if (result==0) return(true);
        else return(false);
        }

    /* ----------------------------------------------- */
    /*                                                 */
    /*                    DISTRIBUTE                   */
    /*                                                 */
    /* ----------------------------------------------- */

    /* DISTRIBUTE CLASSES */
    /* Distributes records through data set so that classes are equally
    distributed. */

    private void distributeClasses() {
    	int[][] localDataArray = new int[outputDataArray.length][];
    	for (int index=0;index<localDataArray.length;index++)
						     localDataArray[index]=null;
     	double numRowsAvail = numRows;

        // Output
        textArea.append("DISTRIBUTE CLASSES\n----------------------------\n");

      	// Loop through classes array
      	int classI=0;
       	for ( ;classI<classesArray.length-1;classI++) {
            double spacing=
	          (double) numRowsAvail/((double) classesArray[classI][1]+1.0);
            // Variables to hold number of empty slots in local data array from
            // start to where current record is to be inserted
            double nextSlot = spacing;
            // Index for local data array
            int currentCount=1;
            // Step through output data array
            int localI=0;
            for (int index=0;index<outputDataArray.length;index++) {
                // Get last index
                int lastI = outputDataArray[index].length-1;
                // If matches class insert into local data array
                if (outputDataArray[index][lastI]==classesArray[classI][0]) {
		    // Step through empty slots in local data array from
		    // current index to nextSlot
                    while (currentCount < (int) nextSlot ||
		                                localDataArray[localI]!=null) {
			if (localDataArray[localI]==null) currentCount++;
			localI++;
			}
                    // Add record to local data array
                    localDataArray[localI]=outputDataArray[index];
                    // Increment counters
		    localI++;
		    currentCount++;
		    // Increment nextSlot
                    nextSlot=nextSlot+spacing;
                    }
                }
            // Revise number of available attributes
            numRowsAvail= numRowsAvail-classesArray[classI][1];
            }

        // Last class fitted in wherever space available, step through output
	// data array
        int localI=0;
        for (int index=0;index<outputDataArray.length;index++) {
            // Get last index
            int lastI = outputDataArray[index].length-1;
            // If matches class inswert into local data array
            if (outputDataArray[index][lastI]==
	    					classesArray[classI][0]) {
                // find empty slot in local data array and osert record
                while (true) {
	  	    if (localDataArray[localI]==null) break;
		    localI++;
      		    }
                localDataArray[localI]=outputDataArray[index];
                }
            }

        // Assign local data array variable to global variable
        outputDataArray=localDataArray;

        // End
	textArea.append("Class distribution complete\n\n");
        }

    /* ----------------------------------------------- */
    /*                                                 */
    /*                     RANDOMIZE                   */
    /*                                                 */
    /* ----------------------------------------------- */

    /* RANDOMIZE ROWS */
    /** Produces a ranmdomised data file. */

    private void randomizeRows() {
	int numRecords = numRows;
        int randomIndex=0, newIndex=0;

        // Output
        textArea.append("RANDOMIZE INPUT DATA ROWS\n" +
					"----------------------------\n");

        // Create new data file
        double[][] newInputDataArray = new double[numRows][numColsInInputData];

    	while (numRecords>1) {
            randomIndex = (int) (Math.random()*(numRecords-1));
            for (int colIndex=0;colIndex<inputDataArray[randomIndex].length;
	    							colIndex++) {
                newInputDataArray[newIndex][colIndex] =
					inputDataArray[randomIndex][colIndex];
                }
            newIndex++;
            numRecords--;
            if (randomIndex!=numRecords) {
                inputDataArray[randomIndex] =
				new double[inputDataArray[numRecords].length];
                for (int colIndex=0;colIndex<inputDataArray[numRecords].length;
								colIndex++) {
                    inputDataArray[randomIndex][colIndex] =
		    			inputDataArray[numRecords][colIndex];
                    }
                }
            }

	// Last lines
        for (int colIndex=0;colIndex<inputDataArray[randomIndex].length;
								colIndex++) {
            newInputDataArray[newIndex][colIndex] =
	    			        inputDataArray[randomIndex][colIndex];
            }

        // Assign new data file identifier to current data file field
	inputDataArray = newInputDataArray;
	// End
	textArea.append("Randomization complete\n\n");
	}

    /* --------------------------------------------------------- */
    /*                                                           */
    /*                    PROCESS INPUT SCHEMA                   */
    /*                                                           */
    /* --------------------------------------------------------- */

    /* PROCESS INPUT SCHEMA */
    /** Identify ranges in input schema according to type. <P> The 2-D count array
    used in this method (and its sub-methods) is used to store the number of
    occurances of a possible value for the current attribute with respect to
    the different possible classes. The first index is set as follows:
    <OL>
    <LI>If attribute is of type "integer" and less than 100 possible values to
    the number of values
    <LI>If attribute is of type "integer" and more than 100 possible values or
    attribute is if type "double" then to 100.   */

    private void processInputSchema() {
        // Declare count array
        int[][] countArray;

	// Step through schema up until the class attribute
        for(int colIndex=0;colIndex<(schema.length-1);colIndex++) {
            // Integer
	    if (schema[colIndex].typeName.equals("int")) {
		// Define N element count array
		int length = 1 + (int) schema[colIndex].range;
		if (length<100) countArray = new int[length][numClasses+1];
                else countArray = new int[100][numClasses+1];
		processInputSchemaNumeric(countArray,colIndex);
		}
	    // Double
	    else if (schema[colIndex].typeName.equals("double")) {
		// Define a 100 element count array such that each element
		// represents a division.
                countArray = new int[100][numClasses+1];
		processInputSchemaNumeric(countArray,colIndex);
		}
	    // Nominal
	    else if (schema[colIndex].typeName.equals("nominal")) {
		processInputSchemaNominal(colIndex);
		}
	    // Otherwise unused (ignore)
	    }
	}

    /* ---------------------------------------------------------- */
    /*                                                            */
    /*                    PROCESS SCHEMA  NUMERIC                 */
    /*                                                            */
    /* ---------------------------------------------------------- */

    /* PROCESS SCHEMA NUMERIC */

    /** Identify sub-ranges, in numeric schema items, to be used in the
    normalisation. <P> Note that count array is emty at this point.
    @param countArray the given array to hold support counts for particular
    values of the given attrivute matched to the available classes.
    @param colIndex the index in the data array of the current attribute to
    be provessed. */

    private void processInputSchemaNumeric(int[][] countArray, int colIndex) {
	// Process elements in the indicated data array column and increment
	// the count array element values so that count array contains support
	// for the different possible values (represented by the range of the
	// given attribut), with respect to the given class.
	genSupportValuesNumeric(colIndex,countArray);

	// Determine dominant classes
	determineDominantClasses(countArray);

        // Create numerical division linked list
	int numDivisions = createDivisionsLinkedList(countArray);
	// Process division linked list merging divisions until required
	// number of divisions is reached.
	while (numDivisions > maxRange) numDivisions = 
                                                 mergeDivision(numDivisions);

	// Store divisions in schema array
	storeDivisionsInInputSchemaArray(numDivisions,colIndex,
						(double) countArray.length-1);
	}

    /* GENERATE SUPPORT VALUES NUMERIC */

    /** Process elements in the indicated data array column and increment the
    count array element values so that count array contains support for the
    different possible values (represented by the range of the given attribut),
    with respect to the given class. <P> Used with numeric attributes ('int' or
    'double').
    @param colIndex the index in the data array of the current attribute.
    @param countArray the given array of support counts. */

    private void genSupportValuesNumeric(int colIndex, int countArray[][]) {
        // Calculate multiplyer
	double constantK = (double) countArray.length-1;
	// Get undex for class attribute
	int lastIndex = schema.length-1;

	// Process input data
	for (int rowIndex=0;rowIndex<inputDataArray.length;rowIndex++) {
	    // Identify class index
	    int classIndex= (int) inputDataArray[rowIndex][lastIndex];
	    // Identify value index provided attribute value does not indicate
	    // a missing vlaue
	    if (inputDataArray[rowIndex][colIndex] < TEST_TERM) {
	        int valueIndex = (int) (((inputDataArray[rowIndex][colIndex] -
		                schema[colIndex].min)/schema[colIndex].range)*
			   					   constantK);
	        // Increment support count.
	        countArray[valueIndex][classIndex]++;
		}
	    }
	}

    /* DETERMINE DOMINANT CLASSES */

    /** Processes count array and, for each value (column in the count array),
    determines the dominant class. <P> Note that for some columns there many be
    no data and therefore no immediate dominant class can be deduced. Similarly
    there may also be columns where the counts are equivalent, i.e. again no
    dominant class exits. In these cases the dominant class must be determined
    according to the dominatnt classes identified by the neigbouring columns
    (representing values) in the count array. Note also that If count array
    contains no dominant classes at all the dominant class for each value is
    set to 0.
    @param countArray the given array of support counts. */

    private void determineDominantClasses(int countArray[][]) {
        int lastDominantIndex=-1;
        int i;
	boolean atStart=true;

	// Looop through count array
	for(i=0;i<countArray.length;i++) {
	    // Test if column has a dominant class (it may not) if so set the
	    // last elemnet in the column in the 2-D array to the domuinant
	    // class value.
	    if (hasDominantClass(countArray[i])) {
                // If previous column (index-1) without a dominant class
	        if (lastDominantIndex != (i-1)) {
		    // If at start assign current dominant class to all
		    // foregoing columns
		    if (atStart) {
 		        for (int j=0;j<i;j++)
			    countArray[j][numClasses]=countArray[i][numClasses];
			}
		    // Otherwise assign last dominant class to colums nearest
		    // to last column with a dominant class, and assign current
		    // class to columns nearest to current column
		    else {
                        int newDominantIndex=i;
                        int newClass=countArray[newDominantIndex][numClasses];
		        int oldClass=countArray[lastDominantIndex][numClasses];
		        lastDominantIndex++;
		        newDominantIndex--;
		        while (lastDominantIndex <= newDominantIndex) {
			    countArray[lastDominantIndex][numClasses]=oldClass;
			    countArray[newDominantIndex][numClasses]=newClass;
		            lastDominantIndex++;
		            newDominantIndex--;
			    }
			}
		    }
	        atStart=false;
		lastDominantIndex=i;
		}
	    // Otherwise no dominant class --- continue
	    }

	// If count array contains no dominant classes at all, set entire array
	// to class 0.
	if (lastDominantIndex == -1) {
	    for (i=0;i<countArray.length;i++) countArray[i][numClasses] = 0;
	    }
	// If last dominant column is not at end set dominant class for
	// remaining columns to current class.
        else if (lastDominantIndex != (i-1)) {
	    for (int j=lastDominantIndex;j<(i-1);j++)
	                                            countArray[j][numClasses] =
				     countArray[lastDominantIndex][numClasses];
 	    }
	}

    /* HAS DOMINANT CLASS */

    /** Processes given array to determine if there is a dominant class, i.e.
    there exists a single maximum support count. <P> If so assigns this
    dominant class to the last element of the given array.
    @param array the given array.
    @return true if given array contains a dominant class and false
    otherwise. */

    private boolean hasDominantClass(int array[]) {
	// Get start max value
	int maxValue=array[0];
	int maxIndex=0;

	// Process rest of array (note that it may be that the given array
	// only has one value.
	for(int i=1;i<(array.length-1);i++) {
	    if (maxValue < array[i]) {
	        maxValue=array[i];
		maxIndex=i;
		}
	    }

	// Check that there is only one maximum value, if not return false
	int count=0;
        boolean hasDomClass = true;
	for(int i=0;i<(array.length-1);i++) {
	    if (maxValue == array[i]) count++;
	    if (count>1) return(!hasDomClass);
	    }

	// Dominant class exists therefore allocate dominant class to to last
	// row of array and return.
	array[array.length-1]=maxIndex;
	return(hasDomClass);
	}

    /* CREATE DIVISIONS LINKED LIST */

    /** Create a linked list describing the parameters for each division in
    the given count array. <P>The divisions describe sub-ranges of values in
    the count array where all the values have the same dominant class. It may
    be that the attribute in question has no dominant class ay all in which 
    case only ine division will be created.
    @param countArray the given array of support counts.
    @return the number of divisions. */

    private int createDivisionsLinkedList(int[][] countArray) {
	Division nextMarker = null;
	int numDivisions    = 0;
	// Get start value and index
	int startIndex      = 0;
	int currentValue    = countArray[0][numClasses];

	// Create temp array of copy of first entry in count array
	int temp[] = new int[numClasses];
	for(int j=0;j<numClasses;j++) temp[j] = countArray[0][j];

	// Loop through count array
	int i;
	for (i=1;i<countArray.length;i++) {
            // If dominant class is not same as previous dominant class have
	    // found a division boundary, create a Division instance and add to
	    // linked list of such divisions
	    if (countArray[i][numClasses] != currentValue) {
	        Division newDivision = new Division(startIndex,i-1,
				      countArray[startIndex][numClasses],temp);
	        numDivisions++;
	        createDivisionsLinkedList(newDivision,nextMarker);
		nextMarker   = newDivision;
		// Create new temp array, and update start value and index
		for(int j=0;j<numClasses;j++) temp[j] = countArray[i][j];
	        currentValue = countArray[i][numClasses];
		startIndex   = i;
		}
	    // Otherwise add counts in current column in count array to the
	    // temp array
	    else for(int j=0;j<numClasses;j++)
	                                  temp[j] = temp[j] + countArray[i][j];
	    }

	// Last record
	if (startIndex<countArray.length) {
	    Division newDivision = new Division(startIndex,countArray.length-1,
	                              countArray[startIndex][numClasses],temp);
	    numDivisions++;
	    createDivisionsLinkedList(newDivision,nextMarker);
	    }

	// Return
	return(numDivisions);
	}

    /** Add a divions to a divisions linked list.
    @param newDivision the reference to the new node in the linked list
    @param nextMarker the reference to the last node in the linked list so
    far. */

    private void createDivisionsLinkedList(Division newDivision,
                                                         Division nextMarker) {
	if (startDivisions == null) {
	    startDivisions      = newDivision;
	    newDivision.backRef = null;
	    }
	else {
	    nextMarker.linkRef  = newDivision;
	    newDivision.backRef = nextMarker;
	    }
	}

    /*  MERGE DIVISION */

    /** Merges the two divisions. with the highest probability with respcet to
    a shared dominant class, from within the linked list of divisions. Proceeds as follows:
    <OL>
    <LI>Create empty "dominant class" array indicating the dominant class
    shared at a division boundary. Each element represents a division boundary
    <LI>Create probabilities array indicating probability for the dominant
    class shared at division boundaries.
    <LI>Identify divison boundray with the highest probability for dominant
    class where the divisions on either side of the boundary merged.
    <LI>Merge divisions at selected division boundary (has effect of removing
    current division).
    <LI>Check that no further merges are required with divisions immediately
    before or after the merged pair. It may be that either the preceeding or
    following division of the newly merged division has the same class as the
    nelwy merged division in which case this should also be merged.
    </OL>
    @param numDivisions the current number of divisiosn. */

    private int mergeDivision(int numDivisions) {
	// Create empty "dominant class" array.
	int[] domClass = new int[numDivisions-1];

        // Create probabilities array.
	double[] probArray = calcBoundaryProbs(numDivisions,domClass);

	// Select "best" divison boundary.
	int bestIndex   = idBestDivBoundary(probArray);
	int domClassLabel = domClass[bestIndex];

	// Merge divisions at selected division boundary. Commence by finding
	// division leading up to the boundary.
	Division nextRef = startDivisions;
	for (int i=0;i<bestIndex;i++) nextRef = nextRef.linkRef;
	nextRef = mergeDivisionWithNext(nextRef,domClassLabel);
	numDivisions--;

	// Check for further merging
	if ((nextRef.linkRef != null) &&
		            (domClassLabel == nextRef.linkRef.dominantClass)) {
	    mergeDivisionWithNext(nextRef,domClassLabel);
	    numDivisions--;
	    }
	if ((nextRef.backRef != null) &&
		            (domClassLabel == nextRef.backRef.dominantClass)) {
	    mergeDivisionWithNext(nextRef.backRef,domClassLabel);
	    numDivisions--;
	    }

	// Return
	return(numDivisions);
	}

    /* ------ CALCULATE DIVISION BOUNDARIES AND PROBABILITIES ------ */

    /** Create array of probabilities indicating to what extent the records
    represented by the disvision on either side of a divisiosn boundary
    indicate a shared dominant class. <P>This is used to detremine which
    divisons to merge.
    @param numDivisions the current number of divisiosn.
    @param domClass array in which to place identified dominant class label. */

    private double[] calcBoundaryProbs(int numDivisions, int domClass[]) {
	Division nextRef = startDivisions.linkRef;
	int index        = 0;

        // Create empty probability array
	double probArray[] = new double[numDivisions-1];

	// Process linked list of divisions
	while (nextRef != null) {
	    probArray[index] = calcBoundaryProb(nextRef.backRef,nextRef,index,
	    							     domClass);
	    index++;
	    nextRef = nextRef.linkRef;
	    }

	// Return
	return(probArray);
	}

    /** Determines the dominant class and its associate probability across two
    divisions sharing a common boundary. <P>The identified dominant class is
    placed in an array of dominant classes (passed in as an argument) whose
    indexes match to division identifiers (numbers).
    @param linkRef1 the first given divisiosn to be considered.
    @param linkRef2 the second given divisiosn to be considered.
    @param index the attribute index.
    @param domClass array in which to place identified dominant class label.
    @return the calculated best probability associated with the dominant
    class.	*/

    private double calcBoundaryProb(Division linkRef1, Division linkRef2, 
                                             int index, int domClass[]) {
        // Calculate total number of records per class represented by the
	// two divisions.
	int numRecords[]  = new int[numClasses];
	int totalNumRcrds = linkRef1.totalNumRecords + linkRef2.totalNumRecords;
	for (int i=0;i<numClasses;i++) numRecords[i] =
				  linkRef1.numRecords[i]+linkRef2.numRecords[i];

	// For each class calculate pthe robability that the records 
        // represenred in the division belong to the class
	double probabilities[] = new double[numClasses];
	for (int i=0;i<numClasses;i++) probabilities[i] =
			         (double) numRecords[i]/ (double) totalNumRcrds;

	// Identify dominant class with highest probability
	double bestProb   = probabilities[0];
	int domClassLabel = 0;
	for (int i=1;i<numClasses;i++) {
	    if (bestProb < probabilities[i]) {
	        bestProb = probabilities[i];
		domClassLabel = i;
		}
	    }

	// Store identified dominant class label
	domClass[index] = domClassLabel;

	// Return best probability
	return(bestProb);
	}

    /** Identify best division boundray to merge.
    @param probArray probabilities array indicating probability for the
    dominant class shared at division boundaries.
    @reurn the index of the selected division boundary*/

    private int idBestDivBoundary(double probArray[]) {
        // Start best probability and index
	double bestProb = probArray[0];
	int bestIndex   = 0;

	// Process probabilities array
	for (int i=0;i<probArray.length;i++) {
	    if (bestProb < probArray[i]) {
	        bestProb  = probArray[i];
		bestIndex = i;
		}
	    }

	// Rerurn best index
	return(bestIndex);
	}

    /* ------ MERGE DIVISION WITH NEXT------ */

    /** Removes a division from linked list of divisions by merging with the
    next division.
    @param shortestDiv the division to be removed.
    @param domClassLabel the label for the dominant class.
    @return reference to the merged divisiosn. */

    private Division mergeDivisionWithNext(Division shortestDiv,
    							int domClassLabel) {
        Division nextRef   = shortestDiv.linkRef;
        
	// Indexes and length
	nextRef.startIndex = shortestDiv.startIndex;
	nextRef.length = nextRef.endIndex - nextRef.startIndex + 1;

	// Number of records per class and in total
	for (int i=0;i<numClasses;i++) nextRef.numRecords[i] =
			nextRef.numRecords[i]+shortestDiv.numRecords[i];
	nextRef.totalNumRecords= nextRef.totalNumRecords +
	                                            shortestDiv.totalNumRecords;

	// Probabilities
	for (int i=0;i<numClasses;i++) nextRef.probability[i] =
		(double) nextRef.numRecords[i]/(double) nextRef.totalNumRecords;

	// Dominant class
	nextRef.dominantClass = domClassLabel;

	// References
	nextRef.backRef = shortestDiv.backRef;
	if (shortestDiv.backRef != null) shortestDiv.backRef.linkRef = nextRef;
	else startDivisions = nextRef;

	// Return reference to merged division
	return(nextRef);
	}

    /* ------ STORE DIVISIONS IN SCHEMA ARRAY ------ */

    /** Stores the identified delimeters contained in the Divisions linked list
    into the schema array ready for application to the input data to genertae
    the desired output data.
    @param the number of divisions.
    @param colIndex the index in the data array of the current attribute.
    @param constantK the multiplyer used to determine division end values. */

    private void storeDivisionsInInputSchemaArray(int numDivisions, int colIndex,
    							   double constantK) {
	// Set number of divisuions field
	schema[colIndex].numDivisions = numDivisions;

	// Dimension division marker array
	schema[colIndex].divisionMarkers = new double[numDivisions];

	// Process Divisions linked list
	int index = 0;
	Division nextRef = startDivisions;
	while (nextRef != null) {
	    schema[colIndex].divisionMarkers[index] = (schema[colIndex].range *
	    	                       ((double) nextRef.endIndex)/constantK) +
		                                          schema[colIndex].min;
	    index++;
	    nextRef = nextRef.linkRef;
	    }

	// Destroy current  Divisions linked list
	startDivisions=null;
	}

    /* -------------------------------------------------------- */
    /*                                                          */
    /*                    PROCESS SCHEMA NOMINAL                */
    /*                                                          */
    /* -------------------------------------------------------- */

    /* PROCESS SCHEMA NOMINAL */

    /** Identify grupings of nominal values, associated with particular
    classes, for the given attribute (indicated by <TT>colIndex</TT>).
    @param colIndex the index in the data array of the current attribute to
    be processed. */

    private void processInputSchemaNominal(int colIndex) {
	// Define 2-D count array (array of elments representing the possible
	// nominal values).
	int countArrayLength = schema[colIndex].nominalData.length;
        int[][] countArray = new int[countArrayLength][numClasses+1];

	// Process data array and increment vount array element values
	// accordingly so that the count array contains support for each
	// nominal value with respect to each class.
	genSupportValuesNominal(colIndex,countArray);

	// Identify the dominant class fort each value (column) in the count
	// array.
	determineDominantClassesNominal(countArray);

	// Create nominal division linked list
	int numDivisions = createNominalDivsLinkedList(colIndex,countArray);

	// Process nominal division linked list to determine if any merging
	// can be undertaken
	if (numDivisions==0) {
	    textArea.append("WARNING: Attribute " + schema[colIndex].name +
	    " does not feature in any record\n");
	    }
	else numDivisions = procNominalDivLinkedList(numDivisions);

	// Store nominal divisions in schema array
	storeNominalDivsInInputSchemaArray(numDivisions,colIndex);
  	}

    /* ------ GENERATE SUPPORT VALUES NOMINAL ------ */

    /** Processes data set with respect to current nominal attribute and
    determines support counts for each element in the given count array
    @param colIndex the index in the data array of the current attribute.
    @param countArray the given array of support counts. */

    private void genSupportValuesNominal(int colIndex, int countArray[][]) {
        // Get undex for class attribute
        int lastIndex = schema.length-1;

	// Process input data
	for (int rowIndex=0;rowIndex<inputDataArray.length;rowIndex++) {
	    // Identify class index
	    int classIndex = (int) inputDataArray[rowIndex][lastIndex];
	    // Identify value index provided attribute value does not indicate
	    // a missing vlaue
	    if (inputDataArray[rowIndex][colIndex] < TEST_TERM) {
	        int valueIndex = (int) inputDataArray[rowIndex][colIndex];
	        // Increment support count
	        countArray[valueIndex][classIndex]++;
		}
	    }
	}

    /* DETERMINE DOMINANT CLASSES NOMINAL */

    /** Processes count array and, for each element (value), determines the
    dominant class. <P> Note that for some elements there many be no data and
    therefore no dominant class can be deduced (similarly there will also be
    columns where the counts are equivalent and consequently no dominant class
    can be produced also). In these cases the dominant class value is
    set to -1.
    @param countArray the given array of support counts. */

    private void determineDominantClassesNominal(int countArray[][]) {
        int lastDominantIndex=-1;
        int i;
	boolean atStart=true;

	// Loop through count array identifying dominant class in each case
	for(i=0;i<countArray.length;i++) {
	    // Test if column has a dominant class (if so assigns this class to
	    // the last element in the column in the 2-D array for each value
	    // Otherwise sets this value to -1
	    if (!hasDominantClass(countArray[i])) {
	    	int lastIndex = countArray[i].length-1;
		countArray[i][lastIndex] = -1;
		}
	    }
	}

    /* CREATE NOMINAL DIVISIONS LINKED LIST */

    /** Create a linked list describing the parameters for each division in
    the given count array ignoring a nominal values for which there are no
    records (Used for further processing).
    @param colIndex the index in the data array of the current attribute.
    @param countArray the given array of support counts.
    @return the number of divisions. */

    private int createNominalDivsLinkedList(int colIndex, int[][] countArray) {
        NominalDiv nextMarker = null;
	int numDivisions=0;

	// Loop through count array
	for (int i=0;i<countArray.length;i++) {
	    // Create temp array
	    int temp[] = new int[numClasses];
	    for(int j=0;j<numClasses;j++) temp[j] = countArray[i][j];
	    // Create nominal division record
	    NominalDiv newNominalDiv = new
	    		NominalDiv(i,countArray[i][numClasses],temp);
	    // If no records in division output warning
	    if (newNominalDiv.totalNumRecords == 0) {
	        textArea.append("WARNING: There are no records that contain " +
		       "the nominal value " + schema[colIndex].nominalData[i] +
		              " for attribute " + schema[colIndex].name +
		                    " (column number " + (colIndex+1) + ")\n");
		}
	    // Otherwise process
	    else {
	        if (startNominalDivs == null) {
	            startNominalDivs      = newNominalDiv;
	            newNominalDiv.backRef = null;
	            }
	    	else {
	            nextMarker.linkRef    = newNominalDiv;
	            newNominalDiv.backRef = nextMarker;
	            }
	    	numDivisions++;
	    	nextMarker = newNominalDiv;
		}
	    }

	// Return
	return(numDivisions);
	}

    /* ------ PROCESS NOMINAL DIVISION LINKED LIST ------ */

    /** Process nominal division linked list merging records that have the
    same dominant class with a probability above a certain threshold.
    @param numDivision the number of divisions prior to processing.
    @return the final number of divisions. */

    private int procNominalDivLinkedList(int numDivisions) {
        NominalDiv nextRef1 = startNominalDivs;

	while (nextRef1 != null) {
	    // If similar division found, decrement division count and repeat
	    if (procNominalDivLinkedList(nextRef1))
	        				 numDivisions = numDivisions-1;
            // Not found simlar division so proceed to next divisiosn
	    else nextRef1 = nextRef1.linkRef;
	    }

	// Return
	return(numDivisions);
	}

    /** Compares current nominal divisiosn with all proceeding divisions with
    the objective of identifying similar recors (using a probabibility of 0.9).
    @param nextRef1 the current nominal divisons.
    @return true if found similar record and false otherwise.		 */

    private boolean procNominalDivLinkedList(NominalDiv nextRef1) {
	NominalDiv nextRef2 = nextRef1.linkRef;

	// Compare with all remaining nominal valies
	while (nextRef2 != null) {
	    if (nextRef2.dominantClass != -1) {
	       if ((nextRef1.dominantClass == nextRef2.dominantClass) &&
			(nextRef1.probability[nextRef1.dominantClass] > 0.9) &&
			(nextRef2.probability[nextRef2.dominantClass] > 0.9)) {
		    addToFirstNominalDiv(nextRef1,nextRef2);
		    return(true);
		    }
		}
	    nextRef2 = nextRef2.linkRef;
	    }

	// Default return, no similar record found.
	return(false);
	}

    /* ------ ADD TO FIRST NOMINAL DIVISION ------ */

    /** Combines two nominal divisions by adding the second given division to
    the first.
    @param firstDiv the division which is to be added to.
    @param secondDiv the division to be deleted. */

    private void addToFirstNominalDiv(NominalDiv firstDiv,
    							NominalDiv secondDiv) {

	// add values from second division to value list for first division.
	int newLength = firstDiv.listOfValues.length +
					secondDiv.listOfValues.length;
	int newListOfVlaues[] = new int[newLength];
	int j=0;
	for (int i=0;i<firstDiv.listOfValues.length;i++,j++)
	    			newListOfVlaues[j] = firstDiv.listOfValues[i];
	for (int i=0;i<secondDiv.listOfValues.length;i++,j++)
	    			newListOfVlaues[j] = secondDiv.listOfValues[i];
	firstDiv.listOfValues = newListOfVlaues;

	// Number of records per class and in total
	for (int i=0;i<numClasses;i++) firstDiv.numRecords[i] =
			firstDiv.numRecords[i]+secondDiv.numRecords[i];
	firstDiv.totalNumRecords=firstDiv.totalNumRecords+
			secondDiv.totalNumRecords;

	// Probabilities
	for (int i=0;i<numClasses;i++) firstDiv.probability[i] =
	     (double) firstDiv.numRecords[i]/(double) firstDiv.totalNumRecords;

	// References
	secondDiv.backRef.linkRef = secondDiv.linkRef;
	if (secondDiv.linkRef != null)
				secondDiv.linkRef.backRef = secondDiv.backRef;
	}

    /* ------ STORE NOMINAL DIVISIONS IN SCHEMA ARRAY ------ */

    /** Stores the identified nominal values in the Nominal Divisions linked
    list into the schema array ready for application to the input data to
    genertae the desired output data.
    @paramcolIndex the index in the data array of the current attribute.
    @param the number of divisions. */

    private void storeNominalDivsInInputSchemaArray(int numDivisions, int colIndex) {
	// Set number of divisuions field and define nominal divisions array
	schema[colIndex].numDivisions = numDivisions;
	schema[colIndex].nominalDivs  = new int [numDivisions][];

	// Process Nominal Divisions linked list
	NominalDiv nextRef = startNominalDivs;
	int index=0;
	while (nextRef != null) {
	    schema[colIndex].nominalDivs[index] =
	    				new int[nextRef.listOfValues.length];
	    for(int i=0;i<nextRef.listOfValues.length;i++)
	        		schema[colIndex].nominalDivs[index][i] =
						nextRef.listOfValues[i];
	    index++;
	    nextRef = nextRef.linkRef;
	    }

	// Destroy current  Divisions linked list
	startNominalDivs=null;
	}

    /* ---------------------------------------------- */
    /*                                                */
    /*                    NORMALISE                   */
    /*                                                */
    /* ---------------------------------------------- */

    /* NORMALISE */
    /** Commences normalisation process, i.e. the central functionality of
    the software. <P> Operates as follows:
    1) Consider each attribute in turn and identify appropriate boundaries. */

    private void normalise() {
        textArea.append("NORMALISE DATA\n----------------\n");

	// Calculate number of classes, if possible continue processing (must
	// be a nominal field).
	if (calcNumberOfClasses()) {
	    // Process schema to identify ranges which in turn will define
	    // attribute numbering.
	    processInputSchema();
	    // Process
	    determineBinaryOutput();
            // Generate classes array (output purposes)
	    generateClassesArray();
	    // End, set flag to true (to allow further processing), and output
	    // message.
	    hasNormalisationFlag = true;
	    textArea.append("Normalisation complete\n\n");
	    }
	else textArea.append("Normalisation failed\n\n");
	}

    /* DETERMINE BINARY OUTPUT */
    /** Commence process of identifying binary output. */

    private void determineBinaryOutput() {
        int attNumber=1;

        // Dimension output data array
        outputDataArray  = new int[numRows][numColsInInputData];

	// Process rows
        for (int rowN=0;rowN<inputDataArray.length;rowN++) {
	    attNumber=1;
	    // process columns in row
	    int colN;
	    for (colN=0;colN<(inputDataArray[rowN].length-1);colN++) {
		attNumber = determineBinaryOutput(attNumber,
					 inputDataArray[rowN][colN],rowN,colN);
		}
	    // Output class
	    determineBinaryOutputClass(attNumber,
	    		                 inputDataArray[rowN][colN],rowN,colN);
	    }

	numAttributes=attNumber-1+numClasses;
        }

    /* DETERMINE BINARY OUTPUT */
    /** Determines whether value is an integer, double or boolean.
    @param attNum the current attribute (column) number.
    @param number the given value in the current row/column intersection in
        the input data structure.
    @param rowIndex the current row index in the input data structure.
    @param colIndex the current column index in the input data structure.
    @return the revised attribute number. */

    private int determineBinaryOutput(int attNum, double number,
    						int rowN, int colN) {
        // Integer
	if (schema[colN].typeName.equals("int"))
	    		    return(determineBinaryOutputInt(attNum,number,rowN,
							   colN,schema[colN]));
	// Double
	else if (schema[colN].typeName.equals("double"))
	                 return(determineBinaryOutputDouble(attNum,number,rowN,
							   colN,schema[colN]));
	// Boolean
	else if (schema[colN].typeName.equals("nominal"))
			return(determineBinaryOutputNominal(attNum,number,rowN,
			                                   colN,schema[colN]));

	// Otherwise "unused", i.e. ignore
	else return(attNum);
	}

    /* DETERMINE BINARY OUTPUT FOR CLASS ATTRIBUTE. */
    /** Output attribute number for class attribute value.
    @param attNum the current attribute (column) number.
    @param number the given value in the current row/column intersection in the
    	input data structure.
    @param rowN the current row index in the input data structure.
    @param colN the current column index in the input data structure.  */

    private void determineBinaryOutputClass(int attNum, double number,
    			int rowN, int colN) {
	outputDataArray[rowN][colN] = attNum + (int) number;
	}

    /* DETERMINE BINARY OUTPUT NOMINAL (VALUE) */
    /** Output attribute number for nominal value.
    @param attNum the current attribute (column) number.
    @param number the given value in the current row/column intersection in the
    	input data structure.
    @param rowIndex the current row index in the input data structure.
    @param colIndex the current column index in the input data structure.
    @param schema the current attribute in the schema.
    @return the revised attribute number.  */

    private int determineBinaryOutputNominal(int attNum, double number,
    			                  int rowN, int colN, InputSchema schema) {
        // Test for missing value
        if (number>TEST_TERM) outputDataArray[rowN][colN] =
							(int) MISSING_ITEM;
	// Otherwise process
	else {
	    boolean done =false;
	    for (int i=0;i<schema.nominalDivs.length;i++) {
	        for (int j=0;j<schema.nominalDivs[i].length;j++) {
	            if (number == schema.nominalDivs[i][j]) {
		        outputDataArray[rowN][colN]=attNum+i;
		        done = true;
		        break;
			}
		    }
	        if (done) break;
	        }
	    }

	// Return
	return(attNum+schema.numDivisions);
	}

    /* DETERMINE BINARY OUTPUT INTEGER (VALUE) */
    /** Output attribute number for of integer value.
    @param attNum the current attribute (column) number.
    @param number the given value in the current row/column intersection in the
    	input data structure.
    @param rowIndex the current row index in the input data structure.
    @param colIndex the current column index in the input data structure.
    @param schema the current attribute in the schema.
    @return the revised attribute number.  */

    private int determineBinaryOutputInt(int attNum, double number,
    			                   int rowN, int colN, InputSchema schema) {
        // Test for missing value
	if (number>TEST_TERM) outputDataArray[rowN][colN] = (int) MISSING_ITEM;
        // Determine value
	else{
	    boolean notDone = true;
	    int minValue    = (int) schema.min;
	    for (int i=0;i<schema.numDivisions;i++) {
	        if ((number >= minValue) &&
				 (number < (int) schema.divisionMarkers[i])) {
		    outputDataArray[rowN][colN]=attNum+i;
		    notDone = false;
		    break;
		    }
		minValue = (int) schema.divisionMarkers[i];
		}
	    if (notDone) outputDataArray[rowN][colN]=
	    					  attNum+schema.numDivisions-1;
	    }

	// Return
	return(attNum+schema.numDivisions);
	}

    /* DETERMINE BINARY OUTPUT DOUBLE (VALUE) */
    /** Output attribute number for of double value.
    @param attNum the current attribute (column) number.
    @param number the given value in the current row/column intersection in the
    	input data structure.
    @param rowIndex the current row index in the input data structure.
    @param colIndex the current column index in the input data structure.
    @param schema the current attribute in the schema.
    @return the revised attribute number.*/

    private int determineBinaryOutputDouble(int attNum, double number,
    					   int rowN, int colN, InputSchema schema) {
        // Test for missing value
	if (number>TEST_TERM) outputDataArray[rowN][colN] = (int) MISSING_ITEM;

	// Determine value
	else {
	    boolean notDone = true;
	    double minValue = schema.min;
	    // Check if contained in divisions before last.
	    for (int i=0;i<schema.numDivisions;i++) {
	        if (number <= schema.divisionMarkers[i]) {
		    outputDataArray[rowN][colN]=attNum+i;
		    notDone = false;
		    break;
		    }
		minValue = schema.divisionMarkers[i];
		}
	    // If not found then in last division
	    if (notDone) outputDataArray[rowN][colN]=
	    					  attNum+schema.numDivisions-1;
	    }

	// Return
	return(attNum+schema.numDivisions);
	}

    /* GENERATE CLASSES ARRAY */

    /** Generates class array used in output. */

    private void generateClassesArray() {
        // Determine lowest label (number) for attribute class
        int lowestLabel=numAttributes-numClasses+1;

        // Diemensiosn 2-D classes array
        classesArray = new int[numClasses][2];
        for (int index=0;index<classesArray.length;index++)
            			classesArray[index][0]=lowestLabel+index;

        // Determine number of records per class
        for (int index=0;index<outputDataArray.length;index++) {
            // get last index
            int lastIndex=outputDataArray[index].length-1;
            //  Get class
            int classLabel = outputDataArray[index][lastIndex];
            // Increment classes array.
            classesArray[classLabel-lowestLabel][1]++;
            }

        // Order classes array so that class that appears in least number of
        // records appears first.
        orderClassesArray();
        }

    /* SORT CLASSES ARRAY */

    /** Bubble sorts classes array produced by <TT>geberateClassArray</TT>
    method so that array is ordered according to frequency of classes.
    @param classesArray The 2-D array returned by the <TT>countSingles</TT>
    method. */

    private void orderClassesArray() {
        int label, quantity;
        boolean isOrdered;
        int index;

        do {
	    isOrdered = true;
            index     = 0;
            while (index < (classesArray.length-1)) {
                if (classesArray[index][1]<=classesArray[index+1][1]) index++;
	        else {
	            isOrdered=false;
                    // Swap
		    label = classesArray[index][0];
		    quantity = classesArray[index][1];
	            classesArray[index][0]   = classesArray[index+1][0];
	            classesArray[index][1]   = classesArray[index+1][1];
                    classesArray[index+1][0] = label;
	            classesArray[index+1][1] = quantity;
	            // Increment index
		    index++;
	            }
	  	}
	    } while (isOrdered==false);
    	}

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

    /* LIST INPUT DATA */
    /** Outputs stored input data set; initially read from input data file. */

    private void listInputData() {
        textArea.append("LIST DATA\n--------\n");

        for(int index=0;index<inputDataArray.length;index++) {
	    outputItemSet(inputDataArray[index]);
	    textArea.append("\n");
	    }

	// End
	textArea.append("\n");
	}

    /* OUTPUT ITEMSET */
    /** Outputs a given item set of doubles (outputs a "?" if a missing value is
    detected.
    @param itemSet the given item set. */

    private void outputItemSet(double[] itemSet) {
	String itemSetStr = null;
	
	// If empty item set return
	if (itemSet==null) return;
	
	// Output first item
	if (itemSet[0]>TEST_TERM) itemSetStr = "?";
	else itemSetStr = Double.toString(itemSet[0]);
	
	// Output rest
	for (int index=1;index<itemSet.length;index++) {
	    if (itemSet[index]>TEST_TERM) itemSetStr = itemSetStr + " ?";
	    else itemSetStr = itemSetStr + " " + itemSet[index];
	    }
	
	// Output
	textArea.append(itemSetStr);
	}
	
    /** Outputs a given item set of integers (omits missing values).
    @param itemSet the given item set. */
    private void outputItemSet(int[] itemSet) {
	String itemSetStr = null;
	boolean noItemsInItemSetStr = true;
	
	// If empty item set return
	if (itemSet==null) return;
	
	// Output rest
	for (int index=0;index<itemSet.length;index++) {
	    if (!schema[index].typeName.equals("unused")) {
		int number = itemSet[index];
	        if (number<TEST_TERM) {
		    if (noItemsInItemSetStr) {
		        itemSetStr = Integer.toString(number);
		        noItemsInItemSetStr = false;
		        }
		    else itemSetStr = itemSetStr + " " + number;		
		    }
		}
	    }
	
	// Output
	textArea.append(itemSetStr);
	}		

    /* LIST OUTPUT DATA */
    /** Outputs stored normalised output data set. */

    private void listOutputData() {
        textArea.append("LIST OUTPUT DATA\n--------\n");

        for(int index=0;index<outputDataArray.length;index++) {
	    outputItemSet(outputDataArray[index]);
	    textArea.append("\n");
	    }
	
	// End
	textArea.append("\n");
	}
	
    /* LIST SCHEMA */
    /** Outputs stored schema for input data set. */

    private void listInputSchema() {
        textArea.append("LIST SCHEMA\n------------\n");

	// Output schema
	int number=1;
	for (int colIndex=0;colIndex<schema.length;colIndex++) {
	    textArea.append("(" + number + ") " + 
	                                     schema[colIndex].typeName + ": ");
	    if (schema[colIndex].typeName.equals("nominal")) {
	        textArea.append(schema[colIndex].name + " { ");
	        for (int index=0;index<schema[colIndex].nominalData.length;
		                                                       index++)
	        	textArea.append(schema[colIndex].nominalData[index] +
				" ");
	        textArea.append("}\n");
	        }
	    else textArea.append(schema[colIndex].name + "\n");
	    number++;
	    }
	
	// End
	textArea.append("\n\n");
	}
	
    /* LIST MIN MAXDATA */
    /** Lists information in Min/Max 2D data array. */

    private void listMinMaxData() {
        textArea.append("LIST MIN-MAX DATA\n---------\n");

        // Loop through array
	for (int colIndex=0;colIndex<schema.length;colIndex++) {
	    textArea.append("Range col. " + (colIndex+1) + ": ");
	    if (schema[colIndex].typeName.equals("unused")) 
	                                           textArea.append("Unused\n");
	    else if (schema[colIndex].typeName.equals("double")) {
	        textArea.append(schema[colIndex].min + " to " + 
	                                 schema[colIndex].max + " (range of " + 
	                                        schema[colIndex].range +")\n");
		}
	    else textArea.append(((int) schema[colIndex].min) + " to " + 
	                         ((int) schema[colIndex].max) + " (range of " + 
	                                ((int) schema[colIndex].range) +")\n");
	    }
	
	// End
	textArea.append("\n");
	}
	
    /* LIST PARAMETERS */
    /** Outputs number of rows, columns, missing values, classes, divisions, 
    attributes and class distyribution to text area. */	

    private void listParameters() {
        textArea.append("LIST PARAMETERS\n---------------\n");
        textArea.append("Number of records\t= " + numRows + "\n");
	textArea.append("Number of cols (input data)\t= " + numColsInInputData +
			"\n");
	textArea.append("Number of cols (schema)\t= " + numColsInInputSchema + "\n");
	textArea.append("Num. missing values\t= " + numMissingItems + "\n");
	textArea.append("Max num. divisions\t= " + maxRange + "\n");
	textArea.append("Number of attributess\t= " + numAttributes + "\n");
	textArea.append("Density (%)\t\t= " + (twoDecPlaces(getDensity())) + 
                                                                          "\n");
        textArea.append("Number of classes\t= " + numClasses + "\n");

        // Output class distribution
        textArea.append("Number of records per class:\n");
	for (int index=0;index<classesArray.length;index++) {
            double percentage = 
	    	    ((double) classesArray[index][1]*100.0)/(double) numRows;
            textArea.append("\tClass " + classesArray[index][0] + " = " +
            			classesArray[index][1] + " records (" +
            			twoDecPlaces(percentage) + "%)\n");
            }

        // End output
        textArea.append("\n");
        }
	
    /* LIST PARAMETERS 2 */
    /** Outputs number of rows, columns, missing values and classes to text 
    area. */

    private void listParameters2() {
        textArea.append("Number of records = " + numRows +
	                      "\nNumber of columns = " + numColsInInputData +
	                      "\nNum. missing values = " + numMissingItems +
	                      "\n\n");
	}
	
    /* GET DENSITY */
    /* Calculates and returns the density of the normalised data set.
    @return the number of elements. */

    private double getDensity() {
        double counter=0.0;

        // Loop through output array
        for (int index=0;index<outputDataArray.length;index++) {
            counter = counter + (double) outputDataArray[index].length;
            }

        // Return
        double numberOfSlots = (double) (numRows*numAttributes);
        return((counter*100.0)/numberOfSlots);
        }

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

    /* -------------------------------------------------- */
    /*                                                    */
    /*			LIST OUTPUT SCHEMA                */
    /*                                                    */
    /* -------------------------------------------------- */

    /* LIST OUTPUT SCHEMA */
    /** Commences process of listing output schema (attribute labels) to
    textArea. <P> Done by processing schema array. */

    private void listOutputSchema() {
        // Start
        textArea.append("LIST OUTPUT SCHEMA\n---------------------\n");
	listOutputSchema2();

	// End
	textArea.append("\n");
        }

    /** Continues process of listing output schema (attribute labels) to
    textArea. <P> Done by processing schema array. */

    private void listOutputSchema2() {
        int attNum=1;
	int colIndex;

	for(colIndex=0;colIndex<(schema.length-1);colIndex++) {
	    // Integer
 	    if (schema[colIndex].typeName.equals("int"))
	        attNum = outputIntLabel(attNum,schema[colIndex]);
	    // Double
	    if (schema[colIndex].typeName.equals("double")) attNum =
	   		        outputDoubleLabel(attNum,schema[colIndex]);
	    // Nominal
	    if (schema[colIndex].typeName.equals("nominal"))
	        attNum = outputNominalLabel(attNum,schema[colIndex]);
	    }

	// Output class labels
	outputClassLabel(attNum,schema[colIndex]);
        }

    /* OUTPUT INTEGER LABEL */
    /** Outputs the attribute numbers and labels for an integer column.
    @param attNum The current attribute number.
    @param schema the current attribute in the schema.
    @return the new current attribite number. */

    private int outputIntLabel(int attNum, InputSchema schema) {
	// Only one division
	if (schema.numDivisions==1) {
	    outputLabel(attNum,schema.name);
	    attNum++;
	    // Return
	    return(attNum);
	    }

	// If more than one divisiosn output first label
	String label = (schema.name + " <= " + (int) schema.divisionMarkers[0]);
	outputLabel(attNum,label);
	attNum++;

	// Output rest of labels
	int minValue = (int) schema.divisionMarkers[0];
	for (int i=1;i<(schema.numDivisions-1);i++) {
	    label = (minValue + " < " + schema.name + " <= " +
	    			              (int) schema.divisionMarkers[i]);
	    outputLabel(attNum,label);
	    minValue = (int) schema.divisionMarkers[i];
	    attNum++;
	    }

	// Output last label
	label = (minValue + " < " + schema.name);
	outputLabel(attNum,label);
	attNum++;

	// Return
	return(attNum);
	}

    /* OUTPUT DOUBLE LABEL */
    /** Outputs the attribute numbers and labels for an double column.
    @param attNum The current attribute number.
    @param schema the current attribute in the schema.
    @return the new current attribite number. */

    private int outputDoubleLabel(int attNum, InputSchema schema) {
	// Only one division
	if (schema.numDivisions==1) {
	    outputLabel(attNum,schema.name);
	    attNum++;
	    // Return
	    return(attNum);
	    }

	// Output first label
	String label = (schema.name + " <= " +
			      outputToNdecPlaces(schema.divisionMarkers[0],3));
	outputLabel(attNum,label);
	attNum++;

	// Output rest of labels
	double minValue = schema.divisionMarkers[0];
	for (int i=1;i<(schema.numDivisions-1);i++) {
	    label = (outputToNdecPlaces(minValue,3) + " < " +
	    						schema.name + " <= " +
			      outputToNdecPlaces(schema.divisionMarkers[i],3));
	    outputLabel(attNum,label);
	    minValue = schema.divisionMarkers[i];
	    attNum++;
	    }

	// Output last label
	label = (outputToNdecPlaces(minValue,3) + " < " + schema.name);
	outputLabel(attNum,label);
	attNum++;

	// Return
	return(attNum);
	}

    /* OUTPUT NOMINAL LABEL */
    /** Produces label for nominal field.
    @param attNum The current attribute number.
    @param schema the current attribute in the schema.
    @return the new current attribite number. */

    private int outputNominalLabel(int attNum, InputSchema schema) {
        for (int i=0;i<schema.nominalDivs.length;i++) {
	    String label = (schema.name + " = {");
	    for (int j=0;j<schema.nominalDivs[i].length;j++) {
	        if (j>0) label = label + ",";
		label = label + schema.nominalData[schema.nominalDivs[i][j]];
		}
	    label = label + "}";
	    outputLabel(attNum,label);
	    attNum++;
	    }

	// Return
	return(attNum);
        }

    /* OUTPUT CLASS LABEL */
    /** Produces label for class field.
    @param attNum The current attribute number.
    @param schema the current attribute in the schema. */

    private void outputClassLabel(int attNum, InputSchema schema) {
        for (int index=0;index<schema.nominalData.length;index++) {
	    outputLabel(attNum,schema.name + "=" + schema.nominalData[index]);
	    attNum++;
	    }
        }

    /* OUTPUT LABEL */
    /** Outputs label to text area.
    @param attNum The current attribute number.
    @param label The label to be output. */

    private void outputLabel(int attNum, String label) {
        if (outputSchemaFlag) fileOutput.println(label);
        else textArea.append("(" + attNum + ") " + label + "\n");
        }

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                     SAVE NORMALISATION                  */
    /*                                                         */
    /* ------------------------------------------------------- */

    /* SAVE NORMALISATION */
    /** Outputs result of normalisation to file. */

    private void saveNormalisation() {
        textArea.append("SAVE NORMALIZATION\n--------------------\n");

        if (openOutputFile()) {
	    try {
   		outputToFile();
                }
            catch (IOException ioException) {
	    	JOptionPane.showMessageDialog(this,"Error Writing to File",
			 "Error",JOptionPane.ERROR_MESSAGE);
		}
            }
	}

    /* OUTPUT TO FILE */
    /** Commences process of oputputting to file the normalised data. */

    private void outputToFile() throws IOException {
        // Initial output
	textArea.append("File name = " + outputFileName + "\n");

	// Test if data exists
	if (outputDataArray != null) {
  	    // Step through records
	    for (int index1=0;index1<outputDataArray.length;index1++) {
	    	// Write integers in record up to last integer
	    	int index2=0;
	    	for (;index2<outputDataArray[index1].length-1;index2++) {
		    if (!schema[index2].typeName.equals("unused")) {
		        int number = outputDataArray[index1][index2];
	                if (number<TEST_TERM) fileOutput.print(number + " ");
	                }
		    }
	    	// Write last integer
		int number = outputDataArray[index1][index2];
	        if (number<TEST_TERM) fileOutput.println(number);
                else fileOutput.println();
		}
            textArea.append("File output complete\n\n");
	    }
        else textArea.append("No data\n\n");

	// End by closing file
	fileOutput.close();
	}

    /* OPEN OUTPUT FILE */
    /** Opems the output file ready to write normalised data to.
    @return true if file succesfully opened, and false otherwise. */

    private boolean openOutputFile() {
	// Display file dialog box
	JFileChooser fileChooser = new JFileChooser();
	fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
	int result = fileChooser.showSaveDialog(this);

	// If cancel button selected return
	if (result == JFileChooser.CANCEL_OPTION) return(false);

	// Obtain selected file
	outputFileName = fileChooser.getSelectedFile();

	// Dispaly error if invalid
	if (outputFileName ==  null || outputFileName.getName().equals("")) {
	    JOptionPane.showMessageDialog(this,"Invalid File name",
			"Invalid File name.",JOptionPane.ERROR_MESSAGE);
	    return(false);
	    }
	else {
   	    try {
		fileOutput = new PrintWriter(new FileWriter(outputFileName));
	 	return(true);
		}
	    catch(IOException ioException) {
	    	JOptionPane.showMessageDialog(this,"Error opening File",
			 "Error",JOptionPane.ERROR_MESSAGE);
      		return(false);
		}
	    }
	}

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                     SAVE OUTPUT SCHEMA                  */
    /*                                                         */
    /* ------------------------------------------------------- */

    /* SAVE OUTOUT SCHEMA */
    /** Saves outpit schema (ayytibute labels) to file. */

    private void saveOutputSchema() {
        textArea.append("SAVE OUTPUT SCHEMA\n--------------------\n");

        if (openOutputFile()) {
	    try {
   		outputSchemaToFile();
                }
            catch (IOException ioException) {
	    	JOptionPane.showMessageDialog(this,"Error Writing to File",
			 "Error",JOptionPane.ERROR_MESSAGE);
		}
            }
	}

    /* OUTPUT SCHEMA TO FILE */
    /** Commences process of oputputting to the output schema to file. */

    private void outputSchemaToFile() throws IOException {
        // Initial output
	textArea.append("File name = " + outputFileName + "\n");

        // Output
	outputSchemaFlag = true;
	listOutputSchema2();
	outputSchemaFlag = false;

	// End by closing file
	fileOutput.close();
	textArea.append("Operation complete\n");
	}

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                  FILE HANDLING UTILITIES                */
    /*                                                         */
    /* ------------------------------------------------------- */

    /* OPEN INPUT FILE */
    /** Opens input file. */
    private void openInputFile() {
	try {
	    // Open file
	    FileReader file = new FileReader(inputFileName);
	    fileInput = new BufferedReader(file);
	    }
	catch(IOException ioException) {
	    JOptionPane.showMessageDialog(this,"Error Opening File",
			 "Error 4: ",JOptionPane.ERROR_MESSAGE);
	    }
	}
	
    /* CLOSE INPUT FILE */
    /* Closes input file. */
    private void closeInputFile() {
        if (fileInput != null) {
	    try {
	    	fileInput.close();
		}
	    catch (IOException ioException) {
	        JOptionPane.showMessageDialog(this,"Error Opening File",
			 "Error 4: ",JOptionPane.ERROR_MESSAGE);
	        }
	    }
	}
	
    /* CHECK FILE NAME */	
    /** Checks nature of input file name selected by user.
    @return false if selected file is a directory, access is denied or is
    not a file name and true otherwise. */
	
    private boolean checkFileName() {
	if (inputFileName.exists()) {
	    if (inputFileName.canRead()) {
		if (inputFileName.isFile()) return(true);
		else JOptionPane.showMessageDialog(null,
				"FILE ERROR: File is a directory");
		}
	    else JOptionPane.showMessageDialog(null,
	    			"FILE ERROR: Access denied");
	    }
	else JOptionPane.showMessageDialog(null,
				"FILE ERROR: No such file!");
	// Return
	
	return(false);
	}
	
    /* ------------------------------------------------------- */
    /*                                                         */
    /*                       INSTRUCTIONS                      */
    /*                                                         */
    /* ------------------------------------------------------- */

    /* INSTRUCTIONS */
    /** Outputs instructions to window. */

    private void instructions() {
        textArea.append("\nNOTE: To discretise/nornmalise a data set user " +
		" should proceed as follows:\n" +
        	"(1) load schema file,\n" +
        	"(2) load data file --- either space or comma separated, " +
        	"and\n(3) set number of divisions value\n\n");
        }

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                       ARM UTILITIES                     */
    /*                                                         */
    /* ------------------------------------------------------- */	

    /* REALLOC 1 */
    
    /** Resizes given item set so that its length is increased by one
    and append new element
    @param oldItemSet the original item set
    @param newElement the new element/attribute to be appended
    @return the combined item set */
    
    private double[] realloc1(double[] oldItemSet, double newElement) {
        
	// No old item set
	
	if (oldItemSet == null) {
	    double[] newItemSet = {newElement};
	    return(newItemSet);
	    }
	
	// Otherwise create new item set with length one greater than old 
	// item set
	
	int oldItemSetLength = oldItemSet.length;
	double[] newItemSet = new double[oldItemSetLength+1];
	
	// Loop
	
	int index;
	for (index=0;index < oldItemSetLength;index++)
		newItemSet[index] = oldItemSet[index];
	newItemSet[index] = newElement;
	
	// Return new item set
	
	return(newItemSet);
	}

    /** Converts the given decimal number to one reduced to N decimal places.
    @param number the given number.
    @param numPlaces the required number of decimal places.
    @return the converted number. 	*/
    
    private double outputToNdecPlaces(double number, int numPlaces) {
        // Multiply by (10^number of places)
	double multiplier = Math.pow(10.0,numPlaces);
	number = number*multiplier;
	
	// Cast to integer
	int intNumber = (int) (number+0.5);
	
	// Cast back to doubleand divide by (10^number of places)	
	number = (double) intNumber;
	number = number/multiplier;
	
	// Return
	return(number);
	}
	
    /* -------------------------------------------------------- */
    /*                                                          */
    /*                       TEST UTILITIES                     */
    /*                                                          */
    /* -------------------------------------------------------- */
	
    /* ------ OUTPUT DIVSION LINKED LIST ------ &*/
    
    /** Outputs to screen (not window) a numeric divisions linked list for test 
    purposes. */
    
    private void outputDivisons() {
    	Division nextRef = startDivisions;
	int count = 1;
	
	while (nextRef != null) {
	    System.out.print("[ " + count + "] startIndex = " + 
	        nextRef.startIndex + ", endIndex = " + nextRef.endIndex + 
		", length = " + nextRef.length + ", domClass = " + 
		nextRef.dominantClass + "\n\tnumRecords = {" + 
		nextRef.numRecords[0]);
	    for (int i=1;i<nextRef.numRecords.length;i++) 
	    			System.out.print("," + nextRef.numRecords[i]);
	    System.out.print("}, totalNumRecords = " + 
	                     nextRef.totalNumRecords + "\n\tprobability = {" + 
	                                              nextRef.probability[0]);
	    for (int i=1;i<nextRef.probability.length;i++) 
	                       System.out.print("," + nextRef.probability[i]);
	    System.out.println("}");
	    System.out.print("\tprevious startIndex = ");
	    if (nextRef.backRef == null) System.out.print("null");
	    else System.out.print(nextRef.backRef.startIndex);
	    System.out.print(", next startIndex = ");
	    if (nextRef.linkRef == null) System.out.println("null\n");
	    else System.out.println(nextRef.linkRef.startIndex + "\n");
	    nextRef = nextRef.linkRef;
	    count++;
	    }
	}
    
    /* ------ OUTPUT DIVSION LINKED LIST ------ &*/
    
    /** Outputs to screen (not window) a nominal divisions linked list for 
    test purposes. */
    
    private void outputNominalDivs() {
    	NominalDiv nextRef = startNominalDivs;
	int count = 1;
	
	while (nextRef != null) {
	    System.out.print("[" + count + "] List of values = {");
	    for (int i=0;i<nextRef.listOfValues.length;i++) {
	        if (i>0) System.out.print(", ");
		System.out.print(nextRef.listOfValues[i]);
		}	
	    System.out.print("}, domClass = " + nextRef.dominantClass + 
		"\n\tnumRecords = {" + nextRef.numRecords[0]);
	    for (int i=1;i<nextRef.numRecords.length;i++) 
	                         System.out.print("," + nextRef.numRecords[i]);
	    System.out.print("}, totalNumRecords = " + 
	                      nextRef.totalNumRecords + "\n\tprobability = {" +
			                               nextRef.probability[0]);
	    for (int i=1;i<nextRef.probability.length;i++) 
	                        System.out.print("," + nextRef.probability[i]);
	    System.out.println("}");
	    System.out.print("\tprevious values = ");
	    if (nextRef.backRef == null) System.out.print("null");
	    else System.out.print(nextRef.backRef.listOfValues[0] + " ... ");
	    System.out.print(", next values = ");
	    if (nextRef.linkRef == null) System.out.println("null\n");
	    else System.out.println(nextRef.linkRef.listOfValues[0] + " ...\n");
	    nextRef = nextRef.linkRef;
	    count++;
	    }
	}
	
    /* ------------------------------------------------------- */
    /*                                                         */
    /*                         MAIN METHOD                     */
    /*                                                         */
    /* ------------------------------------------------------- */
    	
    /* MAIN METHOD */
    /** Main method. */
    public static void main(String[] args) throws IOException {
	// Create instance of class AprioriTgui
	LUCS_KDD_DN newFile = new LUCS_KDD_DN("Data Preparation GUI (CARM data)");

	// Make window vissible
	newFile.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
	newFile.setSize(700,810);
        newFile.setVisible(true);
        }
    }