灰色模型预测算法源码

在我们进行Web项目开发时，经常需要预测一些离散的数据，那么灰色模型预测算法是可选的方案之一，以下算法我是根据一本教材中的流程图写得，应该算是比较早期写的东东了，以下是GM（1，1）算法，稍微改造一下即可变成GM（1，N）算法，源代码如下：

public class GM1_1
{
  private int T;//样本数量
  private int M;
  private double[] X;//原始数列
  private double[] XF;//预测值
  private double[] WC;//误差值
  private double[][] B; //B矩阵
  private double[][] YN; //YN矩阵
  private double[] X1;  //AGO结果
  private double a=0,u=0;//[a,u]T向量
  protected DataSet observedData = new DataSet();
  public GM1_1()
  {

  }
   /**
   * 取预测类型
   * @return 
   */
	public String getForecastType(){
    return "longshine.epdsm.forecase.GM1_1";
  }

  /**
   * 取预测模型名称 
   * @return 
   */
	public String toString(){
    return "灰色模型GM(1,1)";
  }  

  /**
   * 取预测模型代码 
   * @return 
   */  
	public String getForecastModelNo(){
    return "mypack.GM1_1";
  }  
  
	public double forecast( IDataPoint dataPoint ){
    int x= (int)Math.round(dataPoint.getIndependentValue("x"));
    Matrix M_YN;
    Matrix M_B;
    Matrix M_Reverse;
    try{
      M_YN= new Matrix(YN);
      M_B=new Matrix(B);  
      
      Matrix tmp=M_B.transpose().multiply(M_B).inverse();
     
      //利用最小二乘法求a系数向量a~=(B'B)-1B'YN
      M_Reverse=GMUtils.getGrayModelModulus(M_B,M_YN);
      a=M_Reverse.getEntry(1,1);
      u=M_Reverse.getEntry(2,1);
    }catch(Exception e)
    {
      e.printStackTrace();
    }
    //开始预测
    try
    {
      XF[0]=X[0];
      for(int i=1;i<XF.length;i++)
      {
        XF[i]=GMUtils.getT1Time(a,u,X[0],i);
      }
      
    }catch(Exception e)
    {
      e.printStackTrace();
    }
   
    WC=GMUtils.getRelativeError(X,XF);
   if(x<T) return X[x];
    else
    {
      try
      {
        double res=GMUtils.getT1Time(a,u,X[0],x);
        return res;
      }catch(Exception e)
      {
        e.printStackTrace();
        return 0.;
      }
    }
  }
  
  public void init( DataSet dataSet )
  {
    this.observedData = dataSet;
    setT(dataSet.size());
    X=new double[T];
    initX();
    setT(X.length);
    this.M=X.length-1;
    XF=new double[X.length];
    WC=new double[X.length];
    B=new double[M][2];
    YN=new double[M][1];    
    X1=GMUtils.sumArray(X);
    a=0;u=0;    
    //初始化B,Yn
    for(int i=0;i<M;i++)
    {
      B[i][0]=-(X1[i]+X1[i+1])/2;
      B[i][1]=1;
    }
    for(int i=0;i<M;i++)
    {
      YN[i][0]=X[i+1];
    }    
  }
  
  public int getM()
  {
    return this.M;
  }
  private void initX()  //X赋值
  {
    for (int i=1 ;i<=T ;i++ ) 
    {
      IDataPoint dp = (IDataPoint)observedData.get(i-1);
      X[i-1] =  dp.getDependentValue();
    }    
  }

  public int getT()
  {
    return T;
  }

  public void setT(int T)
  {
    this.T = T;
  }
  
  public static void main(String[] args)
  {
   
    final double[] powers={
124.8,
110.7,
129.0,
155.3,
219.03
    };
    DataSet dataset = new DataSet();
    IDataPoint dp;
    int  count = 1;
    for (int i=0 ;i<powers.length ;i++ ) 
    {
      dp = new Observation( powers[i] );
      dp.setIndependentValue( "x", i+1 );
      dp.setTitle("xxx");
      dataset.add( dp );
    };    
    GM1_1  aa = new GM1_1();
    aa.init(dataset);
    dp = new Observation(0);

    dp.setIndependentValue( "x", 5);
    System.out.println("7="+aa.forecast(dp));
    
    dp.setIndependentValue( "x", 6);
    System.out.println("8="+aa.forecast(dp));
    dp.setIndependentValue( "x", 7);
    System.out.println("9="+aa.forecast(dp));
    dp.setIndependentValue( "x", 8);
    System.out.println("10="+aa.forecast(dp));
    dp.setIndependentValue( "x", 9);
    System.out.println("11="+aa.forecast(dp));
  }
  
}