method.java

销售预测的实现,包括移动平均,指数平滑,时间序列分解,自回归

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package forcast;

/**
 *
 * @author Administrator
 */
public class method
{

    public static void movingaverage(double[] real,double[] forcast,int number)//移动平均模型
    {
        int period;
        if(real.length==21)
        {
            period=3;
        }
        else
        {
            period=12;
        }

        for(int i=0;i<period;i++)
        {
            forcast[i]=0;
        }
//计算预测值
        for(int i=period;i<(forcast.length) ;i++)
		{
            forcast[i]=0;
			for(int j=(i-period);j<=(i-1);j++)
			{
                if(j<real.length)
                {
                   forcast[i]+=real[j];
                }
                else
                {
                   forcast[i]+=forcast[j];
                }
				
			}
            forcast[i]=forcast[i]/period;
        }
        /*for(int i=(real.length+1);i<forcast.length;i++)
        {
            forcast[i]=0;
			for(int j=(i-period);j<=(i-1);j++)
			{
				forcast[i]+=forcast[j];
			}
            forcast[i]=forcast[i]/period;
        }*/
//输出实际值
        System.out.println("移动平均模型实际值:");
        for(int i=0;i<real.length;i++)
        {
            System.out.println(real[i]);
        }
//输出预测值
        System.out.println("移动平均模型预测值:");
        for(int i=0;i<forcast.length;i++)
        {
            System.out.println(forcast[i]);
        }
    }

    public static void autoregression(double[] real,double[] forcast,int number)//自回归模型
    {
        double sum=0,sum1=0,sum1sum1=0,sumsum1=0,a,b;
       
//利用最小二乘法计算预测函数的参数
        for(int i=1;i<real.length;i++)
        {
            sum+=real[i];
            sumsum1+=real[i]*real[i-1];
            sum1sum1+=real[i-1]*real[i-1];
        }
        sum1=sum-real[real.length-1];

        a=(sum*sum1-(real.length-1)*sumsum1)/(sum1*sum1-(real.length-1)*sum1sum1);
        b=(sum1*sumsum1-sum*sum1sum1)/(sum1*sum1-(real.length-1)*sum1sum1);
//计算预测值
        forcast[0]=real[0];
        for(int i=1;i<(real.length+1);i++)
        {
            forcast[i]=a*real[i-1]+b;
        }
        for(int i=(real.length+1);i<forcast.length;i++)
        {
            forcast[i]=a*forcast[i-1]+b;
        }
/*//输出实际值
        System.out.println("自回归模型实际值:");
        for(int i=0;i<real.length;i++)
        {
            System.out.println(real[i]);
        }
//输出预测值
        System.out.println("自回归模型预测值:");
        for(int i=0;i<forcast.length;i++)
        {
            System.out.println(forcast[i]);
        }*/
    }

    public static void exponentialSmoothing(double[] real,double[] forcast,int number)//指数平滑模型
    {
        double coefficient=0.9;//平滑系数

//计算预测值
        forcast[0]=real[0];
        for(int i=1 ; i<(real.length+1); i++)
		{
			forcast[i]=forcast[i-1]+coefficient*(real[i-1]-forcast[i-1]);
		}
        for(int i=(real.length+1);i<forcast.length;i++)
        {
            forcast[i]=forcast[i-1];
        }
/*//输出实际值
         System.out.println("指数平滑模型实际值:");
        for(int i=0;i<real.length;i++)
        {
            System.out.println(real[i]);
        }
//输出预测值
        System.out.println("指数平滑模型预测值:");
        for(int i=0;i<forcast.length;i++)
        {
            System.out.println(forcast[i]);
        }*/
    }

     public static void arma(double[] real,double[] forcast,int number)//自回归移动平均模型
    {
        double sumsum1=0,sum1sum1=0,sum1sum2=0,sum1sum3=0,sumsum2=0,sum2sum2=0,sum2sum3=0,sumsum3=0,sum3sum3=0,a,b,c;

//利用最小二乘法计算预测函数的参数
        for(int i=3;i<real.length;i++)
        {
            sumsum1+=real[i]*real[i-1];
            sum1sum1+=real[i-1]*real[i-1];
            sum1sum2+=real[i-1]*real[i-2];
            sum1sum3+=real[i-1]*real[i-3];
            sumsum2+=real[i]*real[i-2];
            sum2sum2+=real[i-2]*real[i-2];
            sum2sum3+=real[i-2]*real[i-3];
            sumsum3+=real[i]*real[i-3];
            sum3sum3+=real[i-3]*real[i-3];
        }

        b=(sum1sum1*sum1sum3*sum1sum3*sumsum2+sumsum1*sum1sum1*sum1sum2*sum3sum3+sum1sum1*sum1sum1*sum2sum3*sumsum3-sum1sum1*sum1sum1*sumsum2*sum3sum3-sum1sum1*sum1sum2*sum1sum3*sumsum3-sumsum1*sum1sum1*sum1sum3*sum2sum3)/(sum1sum1*sum1sum3*sum1sum3*sum2sum2+sum1sum1*sum1sum2*sumsum2*sum3sum3+sum1sum2*sum1sum2*sum1sum3*sum1sum3+sum1sum1*sum1sum1*sum2sum3*sum2sum3-sum1sum2*sum1sum3*sum1sum3*sumsum2-sum1sum1*sum1sum1*sum2sum2*sum3sum3-sum1sum1*sum1sum2*sum1sum3*sum2sum3-sum1sum1*sum1sum2*sum1sum3*sum2sum3);
        c=(sumsum1*sum1sum2-sum1sum1*sumsum2+(sum1sum1*sum2sum2-sum1sum2*sum1sum2)*b)/(sum1sum2*sum1sum3-sum1sum1*sum2sum3);
        a=(sumsum1-sum1sum2*b-sum1sum3*c)/sum1sum1;
//计算预测值
        forcast[0]=real[0];
        forcast[1]=real[1];
        forcast[2]=real[2];
        for(int i=3;i<(real.length+1);i++)
        {
            forcast[i]=a*real[i-1]+b*real[i-2]+c*real[i-3];
        }
        for(int i=(real.length+1);i<forcast.length;i++)
        {
            forcast[i]=a*forcast[i-1]+b*forcast[i-2]+c*forcast[i-3];
        }
/*//输出实际值
        System.out.println("自回归移动平均模型实际值:");
        for(int i=0;i<real.length;i++)
        {
            System.out.println(real[i]);
        }
//输出预测值
        System.out.println("自回归移动平均模型预测值:");
        for(int i=0;i<forcast.length;i++)
        {
            System.out.println(forcast[i]);
        }*/
    }

     public static void ar3(double[] real,double[] forcast,int number)//3阶自回归模型
    {
        double a,b,c,d,sum=0,sum1=0,sum2=0,sum3=0,sumsum1=0,sumsum2=0,sumsum3=0,sum1sum2=0,sum1sum3=0,sum2sum3=0,sum1sum1=0,sum2sum2=0,sum3sum3=0;
        double a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13;

//利用最小二乘法计算预测函数的参数
        for(int i=3;i<real.length;i++)
        {
            sum+=real[i];
            sum1+=real[i-1];
            sum2+=real[i-2];
            sum3+=real[i-3];
            sumsum1+=real[i]*real[i-1];
            sumsum2+=real[i]*real[i-2];
            sumsum3+=real[i]*real[i-3];
            sum1sum2+=real[i-1]*real[i-2];
            sum1sum3+=real[i-1]*real[i-3];
            sum2sum3+=real[i-2]*real[i-3];
            sum1sum1+=real[i-1]*real[i-1];
            sum2sum2+=real[i-2]*real[i-2];
            sum3sum3+=real[i-3]*real[i-3];
        }

        a1=sum;
        a2=sum1;
        a3=sum2;
        a4=sum3;
        a5=sumsum1;
        a6=sumsum2;
        a7=sumsum3;
        a8=sum1sum2;
        a9=sum1sum3;
        a10=sum2sum3;
        a11=sum1sum1;
        a12=sum2sum2;
        a13=sum3sum3;

        a=-((a7*a9+a4*a4*a5+a1*a2*a13-a5*a13-a2*a4*a7-a1*a4*a9)*(a9*a12+a2*a3*a10+a3*a4*a8-a8*a10-a2*a4*a12-a3*a3*a9)+(a8*a13+a2*a4*a9+a3*a4*a9-a9*a10-a4*a4*a8-a2*a3*a13)*(a6*a9+a3*a4*a5+a1*a2*a10-a5*a10-a2*a4*a6-a1*a3*a9))/((a11*a13+2*a2*a4*a9-a9*a9-a4*a4*a11-a2*a2*a13)*(a9*a12+a2*a3*a10+a3*a4*a8-a8*a10-a2*a4*a12-a3*a3*a9)+(a8*a13+a2*a4*a9+a3*a4*a9-a9*a10-a4*a4*a8-a2*a3*a13)*(a10*a11+a2*a3*a9+a2*a4*a8-a8*a9-a3*a4*a11-a2*a2*a10));
        b=((a6*a9+a3*a4*a5+a1*a2*a10-a5*a10-a2*a4*a6-a1*a3*a9)+a*(a10*a11+a2*a3*a9+a2*a4*a8-a8*a9-a3*a4*a11-a2*a2*a10))/(a9*a12+a2*a3*a10+a3*a4*a8-a8*a10-a2*a4*a12-a3*a3*a9);
        c=((a5-a1*a2)+a*(a2*a2-a11)+b*(a2*a3-a8))/(a9-a2*a4);
        d=a1-a*a2-b*a3-c*a4;

        //System.out.println(a);
        //System.out.println(b);
        //System.out.println(c);
        //System.out.println(d);


//计算预测值
        forcast[0]=real[0];
        forcast[1]=real[1];
        forcast[2]=real[2];
        for(int i=3;i<(real.length+1);i++)
        {
            forcast[i]=a*real[i-1]+b*real[i-2]+c*real[i-3]+d;
        }
        for(int i=(real.length+1);i<forcast.length;i++)
        {
            forcast[i]=a*forcast[i-1]+b*forcast[i-2]+c*forcast[i-3]+d;
        }
//输出实际值
        System.out.println("3阶自回归模型实际值:");
        for(int i=0;i<real.length;i++)
        {
            System.out.println(real[i]);
        }
//输出预测值
        System.out.println("3阶自回归模型预测值:");
        for(int i=0;i<forcast.length;i++)
        {
            System.out.println(forcast[i]);
        }
    }


     public static void timeseries(double[] real,double ftrend[],double seasonindexc[],double[] forcast,int number)//时间序列
     {
         
         int speriod=12;
         double reala[]=new double[real.length];//speriod期中心移动平均后的数据
         double realt[]=new double[real.length];//去掉趋势后的数据
         double trend[]=new double[real.length];//去掉季节趋势后的趋势项
         double seasonindex[]=new double[speriod];//季节指数
        

         int p=speriod/2;
         double indexsum=0;//季节指数的和
         double a,b;//去掉季节趋势后的数据应用最小二乘法得到的趋势拟合函数的参数
         double sumft=0,sumtt=0,sumt=0,sumf=0,af,at;//应用最小二乘法时的计算中间值

         for(int i=0;i<real.length;i++)
         {
             reala[i]=0;
             realt[i]=0;
         }

         for(int i=0;i<speriod;i++)
         {
             seasonindex[i]=0;
             seasonindexc[i]=0;
         }

//计算实际值的speriod期中心移动平均后的数据
         for(int i=p;i<real.length-p;i++)
         {
              for(int j=p;j>0;j--)
             {
                 reala[i]+=real[i-j];
                 reala[i]+=real[i+j];
             }
              reala[i]+=real[i]-0.5*real[i-p]-0.5*real[i+p];
              reala[i]=reala[i]/speriod;
         }
//计算去掉趋势项后的数据
         for(int i=p;i<real.length-p;i++)
         {
             realt[i]=real[i]/reala[i];
         }
//计算季节指数
         for(int i=0;i<speriod;i++)
         {
             int count=0;
             for(int j=p;j<real.length-p;j++)
             {
                 if(((j+1)%speriod)==((i+1)%speriod))
                 {
                     seasonindex[i]+=realt[j];
                     count++;
                 }
             }
             seasonindex[i]/=count;
         }
//计算规范化季节指数
         for(int i=0;i<speriod;i++)
         {
             indexsum+=seasonindex[i];
         }
         for(int i=0;i<speriod;i++)
         {
             seasonindexc[i]=seasonindex[i]*speriod/indexsum;
         }
//计算去掉季节趋势后的趋势项数据
         for(int i=0;i<real.length;i++)
         {
             trend[i]=real[i]/seasonindexc[i%speriod];
         }
//应用最小二乘法计算趋势拟合函数的参数
         for(int i=0;i<real.length;i++)
         {
             sumt+=(i+1);
             sumf+=trend[i];
             sumft+=((i+1)*trend[i]);
             sumtt+=((i+1)*(i+1));
         }
         at=sumt/real.length;
         af=sumf/real.length;
         b=(sumft-real.length*at*af)/(sumtt-real.length*at*at);
         a=af-b*at;
//利用得到的趋势函数计算趋势项的预测值
         for(int i=0;i<ftrend.length;i++)
         {
             ftrend[i]=a+b*(i+1);
         }
//利用趋势项的预测值计算实际值的预测值
         for(int i=0;i<forcast.length;i++)
         {
             forcast[i]=ftrend[i]*seasonindexc[i%speriod];
         }
/*//输出实际值
         System.out.println("实际值:");
         for(int i=0;i<real.length;i++)
         {
            System.out.println(real[i]);
         }
//输出中心滑动平均值
         System.out.println("中心滑动平均值:");
         for(int i=0;i<reala.length;i++)
         {
            System.out.println(reala[i]);
         }
//输出去掉趋势后的数据
         System.out.println("去掉趋势后的数据:");
         for(int i=0;i<realt.length;i++)
         {
            System.out.println(realt[i]);
         }
//输出季节指数
         System.out.println("季节指数:");
         for(int i=0;i<speriod;i++)
         {
            System.out.println(seasonindex[i]);
         }
//输出规范化季节指数
         System.out.println("规范化季节指数:");
         for(int i=0;i<speriod;i++)
         {
            System.out.println(seasonindexc[i]);
         }
//输出趋势项
         System.out.println("趋势项:");
         for(int i=0;i<trend.length;i++)
         {
            System.out.println(trend[i]);
         }
//输出预测趋势项
         System.out.println("预测趋势项:");
         for(int i=0;i<ftrend.length;i++)
         {
            System.out.println(ftrend[i]);
         }
//输出预测值
         System.out.println("预测值:");
         for(int i=0;i<forcast.length;i++)
         {
            System.out.println(forcast[i]);
         }*/
     }

    

}