algorithmkf.java,v

包含了模式识别中常用的一些分类器设计算法

    *
    */
    boolean step5()
    {



	return true;
    }   

    /**
     *
     *	 first observation
     *	
     *	initialObsn = 1200;
     *	estimateObsn = 0;
     *	
     *1	 newState = stateGain * currentState;
     *
     *2	 varErrorNew = varErrorInitial * stateGain * stateGain + varStateNoise;
     *   estimateObsn = measureGain * newState;
     *
     *3	 kalmanGain = measureGain * varErrorNew ;
     *	 kalmanGain = kalmanGain / 
     *	          ( measureGain * measureGain * varErrorNew + varMeasureNoise);
     *
     *4	 newerState =
     *	          newState + kalmanGain * (obsnSequence[index] - estimateObsn);
     *
     *5	double a = 0;
     * 	 a = ( 1 - kalmanGain * measureGain) * ( 1 - kalmanGain * measureGain);
     *
     *	varErrorNewer =
     *             varErrorNew * a + varMeasureNoise * kalmanGain * kalmanGain;
     *
     *	varErrorInitial = varErrorNewer;
     *	currentState = newerState; 
     *
     * displays the predicted signal
     *
     * @@return   true
     * 
     */
    boolean step6()
    {
	//double meas_gain = 1.0;
	//double state_gain = 1.0;
	//double var_meas_noise = 100000000;
	//double var_state_noise = 100000000;
	double est_obsn = 0;
	double kalman_gain = 0;
	//	MyPoint one = new MyPoint(1200,4);

	/*
	System.out.println("mset_1_d size: " + mset_1_d.size() + " \n" +
			   "iset_1_d size: " + iset_1_d.size() + " \n" +
			   "set_1_d  size: " + set_1_d.size()  + " \n" +
			   "display_set_1_d size : " + display_set_1_d.size());

	//		iset_1_d.setElementAt(one, 0);
	//		iset_1_d.setElementAt(one, 1);

	*/



	if(set_1_d.size() > 0) {

	    y_estimate1.removeAllElements();
	    curr_state_1_d = set_1_d.elementAt(0).y;
	    curr_error_1_d = 10;

	    for (int i = 0; i < set_1_d.size(); i++) {

		//Equation 1
		//
		new_state_1_d = state_gain * curr_state_1_d;

		//Equation 2
		//
		new_error_1_d = curr_error_1_d * state_gain * state_gain + var_state_noise;
		est_obsn = meas_gain * new_state_1_d;

		//Equation 3
		//
		kalman_gain = meas_gain * new_error_1_d;
		kalman_gain = kalman_gain / (meas_gain * meas_gain * new_error_1_d + var_meas_noise);

		//Equation 4
		//
		newer_state_1_d = new_state_1_d + kalman_gain * (set_1_d.elementAt(i).y - est_obsn);

		//Equation 5
		//
		double a = (1 - kalman_gain * meas_gain) * (1 - kalman_gain * meas_gain);
		newer_error_1_d = new_error_1_d * a + var_meas_noise * kalman_gain * kalman_gain;


		MyPoint pt = new MyPoint(set_1_d.elementAt(i).x, newer_state_1_d);

		y_estimate1.addElement(pt);

		curr_error_1_d = newer_error_1_d;
		curr_state_1_d = newer_state_1_d;
	    }

	    

	}
	


	if(set_2_d.size() > 0) {

	    y_estimate2.removeAllElements();
	    curr_state_2_d = set_2_d.elementAt(0).y;
	    curr_error_2_d = 10;

	    for (int i = 0; i < set_2_d.size(); i++) {

		//Equation 1
		//
		new_state_2_d = state_gain * curr_state_2_d;

		//Equation 2
		//
		new_error_2_d = curr_error_2_d * state_gain * state_gain + var_state_noise;
		est_obsn = meas_gain * new_state_2_d;

		//Equation 3
		//
		kalman_gain = meas_gain * new_error_2_d;
		kalman_gain = kalman_gain / (meas_gain * meas_gain * new_error_2_d + var_meas_noise);

		//Equation 4
		//
		newer_state_2_d = new_state_2_d + kalman_gain * (set_2_d.elementAt(i).y - est_obsn);

		//Equation 5
		//
		double a = (1 - kalman_gain * meas_gain) * (1 - kalman_gain * meas_gain);
		newer_error_2_d = new_error_2_d * a + var_meas_noise * kalman_gain * kalman_gain;


		MyPoint pt = new MyPoint(set_2_d.elementAt(i).x, newer_state_2_d);

		y_estimate2.addElement(pt);

		curr_error_2_d = newer_error_2_d;
		curr_state_2_d = newer_state_2_d;
	    }

	    

	}
	


	if(set_3_d.size() > 0) {

	    y_estimate3.removeAllElements();
	    curr_state_3_d = set_3_d.elementAt(0).y;
	    curr_error_3_d = 10;

	    for (int i = 0; i < set_3_d.size(); i++) {

		//Equation 1
		//
		new_state_3_d = state_gain * curr_state_3_d;

		//Equation 2
		//
		new_error_3_d = curr_error_3_d * state_gain * state_gain + var_state_noise;
		est_obsn = meas_gain * new_state_3_d;

		//Equation 3
		//
		kalman_gain = meas_gain * new_error_3_d;
		kalman_gain = kalman_gain / (meas_gain * meas_gain * new_error_3_d + var_meas_noise);

		//Equation 4
		//
		newer_state_3_d = new_state_3_d + kalman_gain * (set_3_d.elementAt(i).y - est_obsn);

		//Equation 5
		//
		double a = (1 - kalman_gain * meas_gain) * (1 - kalman_gain * meas_gain);
		newer_error_3_d = new_error_3_d * a + var_meas_noise * kalman_gain * kalman_gain;


		MyPoint pt = new MyPoint(set_3_d.elementAt(i).x, newer_state_3_d);

		y_estimate3.addElement(pt);

		curr_error_3_d = newer_error_3_d;
		curr_state_3_d = newer_state_3_d;
	    }

	    

	}
	


	if(set_4_d.size() > 0) {

	    y_estimate4.removeAllElements();
	    curr_state_4_d = set_4_d.elementAt(0).y;
	    curr_error_4_d = 10;

	    for (int i = 0; i < set_4_d.size(); i++) {

		//Equation 1
		//
		new_state_4_d = state_gain * curr_state_4_d;

		//Equation 2
		//
		new_error_4_d = curr_error_4_d * state_gain * state_gain + var_state_noise;
		est_obsn = meas_gain * new_state_4_d;

		//Equation 3
		//
		kalman_gain = meas_gain * new_error_4_d;
		kalman_gain = kalman_gain / (meas_gain * meas_gain * new_error_4_d + var_meas_noise);

		//Equation 4
		//
		newer_state_4_d = new_state_4_d + kalman_gain * (set_4_d.elementAt(i).y - est_obsn);

		//Equation 5
		//
		double a = (1 - kalman_gain * meas_gain) * (1 - kalman_gain * meas_gain);
		newer_error_4_d = new_error_4_d * a + var_meas_noise * kalman_gain * kalman_gain;


		MyPoint pt = new MyPoint(set_4_d.elementAt(i).x, newer_state_4_d);

		y_estimate4.addElement(pt);

		curr_error_4_d = newer_error_4_d;
		curr_state_4_d = newer_state_4_d;
	    }

	    

	}
	




	// The display needs to be changed to draw a line between
	// the two points on the waveform.
	// The method is:
	// 1. Get the first two estimated points.
	// 2. Draw a straight line between these two points.
	// 3. Drop the first point, now take the next point.
	// 4. Continue with step 2 and 3 in the same way, 
	//    till you come to the end.
	//
	if(set_1_d.size() > 0)
	    output_panel_d.addOutput( y_estimate1, Classify.PTYPE_LINE, 
				      Color.black);
	if(set_2_d.size() > 0)
	    output_panel_d.addOutput( y_estimate2, Classify.PTYPE_LINE, 
				      Color.pink);
	if(set_3_d.size() > 0)
	    output_panel_d.addOutput( y_estimate3, Classify.PTYPE_LINE, 
				      Color.cyan);
	if(set_4_d.size() > 0)
	    output_panel_d.addOutput( y_estimate4, Classify.PTYPE_LINE, 
				      Color.magenta);

	output_panel_d.repaint();

	// displaying "Algorithm Complete" 
	//
	pro_box_d.appendMessages("Algorithm Complete " + "\n");

       	return true;
    }

 
    /**
     *
     * Calculates the interpolated points for the data inputs   
     *
     * @@param  v  input data points
     * @@param  iset  interpolated data points
     *
     */
    public void interpol(Vector<MyPoint> v , Vector<MyPoint> iset)
    {	
	// 
	//
	double sample;

	// x distance between first and last points
	//
	double d ;
	MyPoint r = new MyPoint();	
	
	double[] y2 = new double[v.size()];  
	double[] y  = new double[v.size()];
	double[] x  = new double[v.size()];
       
       for (int k = 0; k < v.size(); k++)
       {
	   x[k] = ((MyPoint)v.elementAt(k)).x;
	   y[k] = ((MyPoint)v.elementAt(k)).y;
       }

       // Reference:
       // "Numerical Recipe in C", Cambridge University Press, pp 113-116
       
       // total time interval of the data points calculated
       //
       d = ((MyPoint)v.lastElement()).x - ((MyPoint)v.firstElement()).x ; 
       
       // time step calculation
       // scale = iporder * kforder
       //
       sample = d / scale;
       spline(x, y, y2, v.size());
       
       // iset holds new data points - interpolated values
       // First value added 
       //
       iset.addElement(new MyPoint((MyPoint)v.firstElement()));
       
       // Increment to next Time value
       //
      	r.x = sample + ((MyPoint)v.firstElement()).x;

	while (r.x <=  ((MyPoint)v.lastElement()).x)
	{
	    for(int j = 1; j < v.size(); j++)
	    {
		// the New Interpolated amplitude will be calculated
		// for the two points within which the time intervals 
		// lies, Hence, the condition check
		//
		if((r.x <= ((MyPoint)v.elementAt(j)).x ) && 
		   (r.x >=  ((MyPoint)v.elementAt(j - 1)).x)) 
		{
		    r.y = 0 ;
		    splint ((MyPoint)v.elementAt(j - 1), 
			    (MyPoint)v.elementAt(j), r, y2, (j - 1));

		    // New value appended to the array
		    //
		    iset.addElement(new MyPoint(r));
		    break; 
		}
	    }	    
   	    r.x = r.x + sample;
	}
	// sometimes the last element of the user entered 
	// values is missed out hence the condition to 
	// cross-check and put it in
	//
	if (((MyPoint)iset.lastElement()).x != ((MyPoint)v.lastElement()).x )
	    iset.addElement( new MyPoint((MyPoint)v.lastElement()));
    }

    /**
     *
     * Actually interpolates the points
     *
     * @@param x    array containing the x coordinates of datapoints
     * @@param y    array containing the y coordinates of datapoints
     * @@param y2   array containing the interpolated y coordinates
     * @@param size the size of the array to be interpolated
     * 
     */
    public void spline (double[] x, double[] y, double[] y2, int size )
    { 
	double[] u = new double[size];
	double p; 
	double sig; 
	
	y2[0] = 0;
	u[0] = 0;
	 
	for( int i = 1; i < size - 1; i++ )
	{ 
	    sig = ( x[i] - x[i - 1] ) / ( x[i + 1] - x[i - 1] ) ;
	    p = sig * y2[i - 1] + 2 ;
	    y2[i] = ( sig - 1) / p ;
	    u[i] = ( y[i + 1] - y[i] ) / ( x[i + 1] - x[i] ) ;
	    u[i] = ( 6 * u[i] / ( x[i + 1] - x[i - 1] ) 
		     - sig * u[i - 1] ) / p ;
	}
	y2[size - 1] = 0 ;
	
	// This is the back substitution loop of the tridiagonal algorithm
	//
	for(int i = size - 2; i >= 0; i-- )     
	    y2[i] = y2[i] * y2[i + 1] + u[i] ;
    }

    /**
     * Interpolates for a point between the two known points
     * using Cubic Interpolation
     *
     * @@param   u1 start point for the interpolation
     * @@param   u2 end point for the interpolation
     * @@param   r  returning point, basically the interpolated point
     * @@param   y2 array used for reassigning of r
     * @@param   i  the sample number
     *
     */
    public void splint ( MyPoint u1, MyPoint u2, MyPoint r, 
			 double[] y2, int i )
    {
	double h;
	double a;
	double b;
 
	h = u2.x - u1.x ;
	a = ( u2.x - r.x ) / h ;
	b = ( r.x - u1.x ) / h ;
	r.y = a * u1.y + b * u2.y + ((a * a * a - a) * y2[i] 
	                             + ( b * b * b - b ) * y2[i + 1] ) 
	                                                 * ( h * h ) / 6 ; 
    }


    /**
     *
     * Calculates the mean and the zero-mean data points  
     *
     * @@param    v orginal datapoints
     * @@param    mv zero mean datapoints 
     *
     * @@return   The average in a double
     * 
     */
    public double mean(Vector<MyPoint> v, Vector<MyPoint> mv)
    {
        double average = 0;
	MyPoint p      = new MyPoint();

       for(int i = 0; i < v.size(); i++ )
	   average = average + ((MyPoint)v.elementAt(i)).y;
       average = average / v.size();
       
       for(int i = 0; i < v.size(); i++ )
       {
	   p.y = ((MyPoint)v.elementAt(i)).y - average;
	   p.x =  ((MyPoint)v.elementAt(i)).x; 
	   mv.addElement(new MyPoint(p));
       }        
       return average ;
    }  
   
}



@


1.2
log
@changed everything from PF to KF as it is a copy of PF.
@
text
@d1 1
a1 1
/**
a9 3
 *
 **************** UNDER CONSTRUCTION*****************
 *
a12 32
/****************************************************
	// first observation
	//
	initialObsn = 1200;
	estimateObsn = 0;
	
1	 newState = stateGain * currentState;

2	 varErrorNew = varErrorInitial * stateGain * stateGain + varStateNoise;
	 estimateObsn = measureGain * newState;

3	 kalmanGain = measureGain * varErrorNew ;
	 kalmanGain = kalmanGain / 
	          ( measureGain * measureGain * varErrorNew + varMeasureNoise);

4	 newerState =
	          newState + kalmanGain * (obsnSequence[index] - estimateObsn);

5	double a = 0;
  	 a = ( 1 - kalmanGain * measureGain) * ( 1 - kalmanGain * measureGain);

	varErrorNewer =
                   varErrorNew * a + varMeasureNoise * kalmanGain * kalmanGain;
	
	varErrorNewer = varErrorInitial;
	currentState = newerState; 

*******************************************************/




d23 3
d256 1
a256 16
	    /***************
            UNDER CONSTRUCTION
	    *****************/

	   //String str = new String("   0.  Checking for the Data Validity.");

	    String str = new String("\n**** Under Construction **** \n" +
				    "\nKalman Filter implementation \n" +
				    "\nInitial Settings:" +
				    "\nMeasurement Gain: " + meas_gain +
				    "\nState Gain:       " + state_gain +
				    "\nVariance of Measurement Noise" +
				         var_meas_noise +
				    "\nVariance of State Noise" +
				         var_state_noise + "\n" +
				    "\n0.  Checking for the Data Validity\n");
d1010 1
a1012 421
    /**
    *
    * Computes the autocorrelation coeffient from the data sets   
    *
    */
    public void autoCorrelation()
    {
	if (iset_1_d.size() > 0 )
	{
	    auto_co_1 = new double[kforder + 1];
	    autocorrelate(iset_1_d, auto_co_1);
	}	

	if (iset_2_d.size() > 0)
        {
	    auto_co_2 = new double[kforder + 1];
	    autocorrelate(iset_2_d, auto_co_2);
	}	

	if (iset_3_d.size() > 0)
        {
	    auto_co_3 = new double[kforder + 1];
	    autocorrelate(iset_3_d, auto_co_3);
	}	

	if (iset_4_d.size() > 0)
        {
	    auto_co_4 = new double[kforder + 1];
	    autocorrelate(iset_4_d, auto_co_4);
	}	
    }

    /**
     *
     * Actaully computes the autocorrelation coefficients
     *
     * @@param  v Vector of datapoints
     * @@param  autoCoeff_co array of autocorrelation coefficients
     *
     */
    public void autocorrelate ( Vector<MyPoint> v, double[] autoCoeff_co) 
    {
	int size;
	size                 = v.size();
      	double[] amplitude_y = new double[size];

      	// to store the amplitude for calculation autocoefficient
      	//
    	for (int i = 0; i < size; i++)
	    amplitude_y[i] = ((MyPoint)v.elementAt(i)).y;

      	for (int j = 0; j <= kforder; j++)
      	{
      	    autoCoeff_co[j] = 0;
      	    if ( j < size)
      		for (int k = 0; k < size - j; k++)