head	1.15;access;symbols;locks; strict;comment	@# @;1.15date	2005.06.10.18.20.43;	author rirwin;	state Exp;branches;next	1.14;1.14date	2005.05.23.19.14.44;	author rirwin;	state Exp;branches;next	1.13;1.13date	2005.03.16.23.10.03;	author patil;	state Exp;branches;next	1.12;1.12date	2005.01.19.21.24.28;	author patil;	state Exp;branches;next	1.11;1.11date	2005.01.06.22.39.22;	author patil;	state Exp;branches;next	1.10;1.10date	2005.01.06.21.41.22;	author patil;	state Exp;branches;next	1.9;1.9date	2005.01.05.19.14.31;	author patil;	state Exp;branches;next	1.8;1.8date	2004.12.31.23.51.52;	author patil;	state Exp;branches;next	1.7;1.7date	2004.12.31.17.21.52;	author patil;	state Exp;branches;next	1.6;1.6date	2004.12.30.16.37.56;	author patil;	state Exp;branches;next	1.5;1.5date	2004.12.28.23.14.54;	author patil;	state Exp;branches;next	1.4;1.4date	2004.12.28.22.48.50;	author patil;	state Exp;branches;next	1.3;1.3date	2004.12.28.01.16.56;	author patil;	state Exp;branches;next	1.2;1.2date	2004.12.28.01.07.10;	author patil;	state Exp;branches;next	1.1;1.1date	2004.12.28.00.04.32;	author patil;	state Exp;branches;next	;desc@This is the file, i am working on.@1.15log@Establishing RCS version.@text@/** * AlgorithmLP.java v6.0 Last Edited by: Ryan Irwin 05/23/2005 * Nishant Aggarwal, Jun-Won Suh Created: 12/15/04 * * Description: Linear Prediction algorithm. Determines the estimate of  * the data points based on the points given by the user.  * The appraoch is data interpolation [ based on cubic interpolation ], * Autocorrelation coefficients and Linear Predictor Coefficients [based * on Levinson Durbin Algorithm] *///----------------------// import java packages//----------------------import java.util.*;import java.awt.*; import java.awt.Graphics;import javax.swing.JApplet; // import class Algorithmpublic class AlgorithmLP extends Algorithm{    //-----------------------------------------------------------------    //    // static data members    //    //-----------------------------------------------------------------    int lporder;    int iporder;    int scale;    //-----------------------------------------------------------------    //    // primitive data members    //    //-----------------------------------------------------------------    int output_canvas_d[][];       //-----------------------------------------------------------------    //    // instance data members    //    //-----------------------------------------------------------------    String algo_id = "AlgorithmLP";     Vector<MyPoint> support_vectors_d;    Vector<MyPoint> decision_regions_d;    // for original data    //    Vector<MyPoint> set1_d = new Vector<MyPoint>(40, 20);    Vector<MyPoint> set2_d = new Vector<MyPoint>(40, 20);    Vector<MyPoint> set3_d = new Vector<MyPoint>(40, 20);    Vector<MyPoint> set4_d = new Vector<MyPoint>(40, 20);    // for interpolation function    //    Vector<MyPoint> iset1 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> iset2 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> iset3 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> iset4 = new Vector<MyPoint>(40, 20);     // vector for mean-subtracted [zero-mean] data    //    Vector<MyPoint> mset1 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> mset2 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> mset3 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> mset4 = new Vector<MyPoint>(40, 20);     // for display purpose    //    Vector<MyPoint> display_set1 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> display_set2 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> display_set3 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> display_set4 = new Vector<MyPoint>(40, 20);     // to store autoCorrelation coefficient   //    double auto_co_1[];    double auto_co_2[];    double auto_co_3[];    double auto_co_4[];    // to store the average values for each class    //    double average1;    double average2;    double average3;    double average4;    // to store LP coefficient    //    double final_lpc_1[];     double final_lpc_2[];    double final_lpc_3[];    double final_lpc_4[];    // to store residual energy     //    double estimate_err_1 = 0;	    double estimate_err_2 = 0;	    double estimate_err_3 = 0;    double estimate_err_4 = 0;     // to store actual error energy    //    double actual_err_1 = 0;    double actual_err_2 = 0;    double actual_err_3 = 0;    double actual_err_4 = 0;    // to store the reflection coefficients    //    double ref_coeff_1[];    double ref_coeff_2[];    double ref_coeff_3[];     double ref_coeff_4[];    // to store the final results    //    Vector<MyPoint> y_estimate1 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> y_estimate2 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> y_estimate3 = new Vector<MyPoint>(40, 20);     Vector<MyPoint> y_estimate4 = new Vector<MyPoint>(40, 20);     //---------------------------------------------------------------    //    // class methods    //    //---------------------------------------------------------------    /**     *      * Implements the initialize() method in the base class. Initializes     * member data and prepares for execution of first step. This method     * "resets" the algorithm.     *     * @@return   returns true if sets of data are valid     *     */    public boolean initialize()    {	DisplayArea disp_area_d = new DisplayArea();	point_means_d           = new Vector<MyPoint>();	decision_regions_d      = new Vector<MyPoint>();	support_vectors_d       = new Vector<MyPoint>();	description_d           = new Vector<String>();	step_count  = 3;	lporder    = Classify.main_menu_d.lporder;	iporder    = Classify.main_menu_d.iporder;	scale      = lporder * iporder;	// Add the process description for the LP algorithm	//	if (description_d.size() == 0)	{	    String str = new String("   0.  Checking for the Data Validity.");	    description_d.addElement(str);	    	    str = new String("   1.  Displaying the Input Data Points.");	    description_d.addElement(str);	    	    str = new String("   2.  Computing LP Parameters.");	    description_d.addElement(str);	    	    str = new String("   3.  Displaying the Linear Predicted Signal");	    description_d.addElement(str);	}	// set the data points for this algorithm	//	//	set1_d = (Vector)data_points_d.dset1.clone();	//	set2_d = (Vector)data_points_d.dset2.clone();	//	set3_d = (Vector)data_points_d.dset3.clone();	//	set4_d = (Vector)data_points_d.dset4.clone();	//	set1_d = data_points_d.dset1;	set2_d = data_points_d.dset2;	set3_d = data_points_d.dset3;	set4_d = data_points_d.dset4;		int max1 = set2_d.size();	if (set1_d.size() > set2_d.size())	    max1 = set1_d.size();	int max2 = set4_d.size();	if (set3_d.size() > set4_d.size())	    max2 = set3_d.size();	else	    max2 = set4_d.size();	if (max2 > max1)	    max1 = max2;	if (max1 > scale)	    scale = max1;	step_index_d = 0;	if((checkdata_LP(set1_d) == true) && (checkdata_LP(set2_d) == true) 	   && (checkdata_LP(set3_d) == true) && (checkdata_LP(set4_d) == true))	{	    pro_box_d.appendMessage((String)description_d.get(step_index_d));	    pro_box_d.appendMessage("         Data points valid");	    return true;		}	else        {	    pro_box_d.appendMessage("\n" + "Invalid data");	    pro_box_d.appendMessage("Clear and enter valid data" + "\n");	    return false;	}    }    /**    *     * Validates the class entered by user for Linear Prediction      *    * @@param    lp    * @@return   true if data is Vector lp is valid. It is invalid    *           if the size of lp is 1 or any element is larger than the    *           the previous element    *     */    public boolean checkdata_LP(Vector lp)    {	if ( lp.size() == 1) 	    return false;	else	   for(int i = 0; i <= lp.size() - 1 ; i++ )	       for(int j = i + 1; j <= lp.size() - 1 ; j++ )		   // amplitudes should be in time progression		   //		   if ( (((MyPoint)lp.elementAt(i)).x == 			 ((MyPoint)lp.elementAt(j)).x) || 			(((MyPoint)lp.elementAt(i)).x > 			 ((MyPoint)lp.elementAt(j)).x) )		       return false;	return true;    }    /**     *     * Implementation of the run function from the Runnable interface.     * Determines what the current step is and calls the appropriate method.     *     */    public void run()    {	if (step_index_d == 1)	{	    disableControl();	    step1();	    enableControl();	}	if (step_index_d == 2)	{	    disableControl();	    step2();	    enableControl(); 	}	if (step_index_d == 3)	{	    disableControl();	    step3(); 	    enableControl();        }		// exit gracefully	//	return;    }        /**     *     * Displays data sets from input box in output box, clears the data     * points from the Vector fro input data, zero-mean data,     * does interpolation, and then finds mean of the interpolated data     * interpolates the zero-mean data, displays the result     *     * @@return   True     *     */    boolean step1()    {	// set up progress bar	//	pro_box_d.setProgressMin(0);	pro_box_d.setProgressMax(1);	pro_box_d.setProgressCurr(0);	output_panel_d.disp_area_d.output_points_d.removeAllElements();	output_panel_d.disp_area_d.type_d.removeAllElements();	output_panel_d.disp_area_d.color_d.removeAllElements();	      	// Display original data	// size of the point made four times bigger	//        if(set1_d.size() > 0 )       {	   display_set1.removeAllElements();	   iset1.removeAllElements();	   mset1.removeAllElements();	   interpol(set1_d, display_set1);	   average1 = mean(display_set1, mset1);	   interpol(mset1, iset1);	   output_panel_d.addOutput(set1_d, (Classify.PTYPE_INPUT * 4), 				    data_points_d.color_dset1);       }       if(set2_d.size() > 0 )       {	   display_set2.removeAllElements();	   iset2.removeAllElements();  	   mset2.removeAllElements();	   interpol(set2_d, display_set2);	   average2 = mean(display_set2, mset2);	   interpol(mset2, iset2);   	  	   output_panel_d.addOutput(set2_d, (Classify.PTYPE_INPUT * 4), 				    data_points_d.color_dset2);       }              if(set3_d.size() > 0 )       {	   display_set3.removeAllElements();	   iset3.removeAllElements();	   mset3.removeAllElements();	   interpol(set3_d, display_set3);	   average3 = mean(display_set3, mset3);	   interpol(mset3, iset3);	   output_panel_d.addOutput(set3_d, (Classify.PTYPE_INPUT * 4),