股票预测程序设计思路与实现 <持续更新>

设计构想如下图：

         通过历年上证日指数据，对未来数据进行上涨或下降的预测，尚不对成交量及成绩额进行预测。未来实现过程中采用方案2，代码编写中…

模型说明：

 

对于一由0/1组成的字符串，按照每一个字符为一个单位，统计从状态0转换到状态0 or 1的概率，以及从状态1转换到状态0/1的概率，并将其转化成矩阵，上图可转化为矩阵：

；

当考虑字符串按照两个字符为一组进行组合时，按照三个字符为一组，四个…考虑到股票交易市场，连续5天交易的情况，将分组上限划分为五个元素为一组（如000001可被划分为两组：00000 && 00001），五种划分方式分别求出状态转换间对应的概率，并对转换的矩阵求矩阵的n次方，直到矩阵收敛（前提矩阵是收敛的）。

通过以上操作得到五个模型，采用某些算法（如EM可得到多个高斯分布函数的权重）减少与实际值误差，得到拟合曲线。

 

设计草稿及简单陈述如上，持续更新中。因08年金融危机，选择从09年1月开始，到11年4月21日，共551条记录。

现阶段源码如下：

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;


public class Z_gess_stock {
/**
 * using up--related to calculate the situation, when UP appear, one UP, two UP...
 * to predict what next when this day we get a rise.
 *  
 * using down--related to calculate the situation, when DOWN happens, 
 * that is to say, to predict what will happen, when this day we get a fall.
 */
    private Vector[] points_perday;//used to pridict the quantity
    static int limit=5;//to set the biggest days after today
    double[][] UP;//the probability of A[i][j], i days up then j days down
    double[][] DOWN;//i days down then j days up
    double[] upprob;
    double[] downprob;
    
    
    public Z_gess_stock(int k) {    
        points_perday=new Vector[k];
        UP=new double[limit][limit];
        upprob=new double[limit];
        
    }
    
    public void init_up(ArrayList<Double> points){
        
        int A=0,B=0;
        double temp=points.get(0);
        
        double sum_upprob=0;
        
        for(int i=0;i<points.size();i++){

            for(;i<points.size();i++)//calculate value i
            {
                if(temp<points.get(i)){
                    temp=points.get(i);
                    A++;
                }
                else if(temp>points.get(i)){
                    temp=points.get(i);
                    B++;
                    i++;
                    break;
                }
            }
            

            for(;i<points.size();i++)//calculate value j
            {
                if(temp<points.get(i)){
                    temp=points.get(i);
                    A++;
                    i++;
                    break;
                }
                else if(temp>points.get(i)){
                    temp=points.get(i);
                    B++;
                }
            }
            if(A-1<limit&&B-1<limit)
            {
                UP[A-1][B-1]+=1;
                upprob[B-1]++;
            }
            else {
            //    UP[limit-1][limit-1]++;
            //    upprob[limit-1]++;
            }
            sum_upprob++;
            
            B=0;
            A=1;    
        }
        printMatrix(UP);
        
        for(int i=0;i<upprob.length;i++){
            for(int j=0;j<upprob.length&&upprob[i]!=0;j++)
                UP[j][i]/=upprob[i];
        upprob[i]/=sum_upprob;
        }
        
        
        
    }
    
    public void printMatrix(double[][] A){
        for(int i=0;i<A.length;i++){
            for(int j=0;j<A[0].length;j++)
                System.out.print(A[i][j]+" ");
            System.out.println();
        }
        System.out.println();
    }
        
    public void init_down(){
        
    }    
    /**
     * making matrix converges to a steady state
     * @param n to calculate A^n, the powers of the transition
     */
    public double[][] Matrix_mul(double[][] A,double[][] B){
        if(A[0].length!=B.length){
            System.out.println("wrong size");
            return A;
        }
        
        double[][] temp =new double[A.length][B[0].length];
        
        int n=A[0].length;//column
        int m=A.length;//row
        for(int i=0,x,y;i<m;i++){
            for(x=0;x<m;x++){
                double sum=0;
                for(y=0;y<n;y++)
                    sum+=A[i][y]*B[y][x];
                temp[i][x]=sum;
            }            
        }
        
        return temp;    
    }
    
    private double[][] iterature(int n, double[][] A){
        if(n==1){
            return A;
        }
        
        if(n%2.0==0)
            {
            double[][] B=iterature(n/2,A);
            return Matrix_mul(B,B);
            }
        else{
            double[][] B=iterature((n-1)/2,A);
            return Matrix_mul(Matrix_mul(B,B),B);
        }
        
        
    }
    
     public static ArrayList<Double> read_data(String filename,int column){
        ArrayList<Double> list =new ArrayList<Double>();
        
        FileReader fr;
        BufferedReader bfr;
        try{
            fr =new FileReader(filename);
            bfr =new BufferedReader(fr);
            String str =bfr.readLine();

            while(str != null){
                String[] temp =str.split(" ");
                list.add(Double.valueOf(temp[column-1]));
                str =bfr.readLine();
            }
            
        }catch(Exception e){
            //System.out.println("\n??");
            e.printStackTrace();
        }
        return list;
    }
    
    public static void main(String[] args) {
        //limit=7;
        ArrayList<Double> points=read_data("stock.txt",5);//只计算收盘价格

        //For every 5 days we name it one cluster
        Z_gess_stock stock=new Z_gess_stock(points.size()-4);
        System.out.println(points.size());
//        for(int i=0;i<points.size();i++)
//            System.out.print(points.get(i)+" ");
        
        stock.init_up(points);
        
        stock.printMatrix(stock.UP);
                
        stock.UP=stock.iterature(100, stock.UP);
        stock.printMatrix(stock.UP);
                    
        for(int j=0;j<stock.UP.length;j++)
            System.out.print(stock.upprob[j]+" ");
        
        
        System.out.println("\n  ");

        double test[][]={
                {0.1, 0.2, 0.3, 0.4},
                {0.9, 0.0, 0.0, 0.0},
                {0.0, 0.8, 0.0, 0.0},
                {0.0, 0.0, 0.7, 0.6}};
        test=stock.iterature(1000, test);
        System.out.print("\n");
        //System.out.println("\n"+test[0].length+" "+test.length);
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++)
                System.out.print(test[i][j]+" ");
            System.out.println();
        }
        

    }

}

运行结果为：

Ps：源码采用“看涨”方式，即今日为涨时，未来几天的情况，更新中^_^

551

25.0 13.0 8.0 1.0 1.0
9.0 5.0 0.0 3.0 0.0
7.0 11.0 0.0 2.0 0.0
9.0 1.0 1.0 0.0 0.0

0.5 0.43333333333333335 0.8888888888888888 0.16666666666666666 1.0
0.18 0.16666666666666666 0.0 0.5 0.0
0.14 0.36666666666666664 0.0 0.3333333333333333 0.0
0.18 0.03333333333333333 0.1111111111111111 0.0 0.0

0.4821428571428557 0.4821428571428557 0.4821428571428557 0.4821428571428557 0.4821428571428557
0.2129464285714279 0.2129464285714279 0.2129464285714279 0.2129464285714279 0.21294642857142793
0.2651785714285706 0.26517857142857054 0.2651785714285706 0.2651785714285706 0.2651785714285706
0.03973214285714274 0.03973214285714274 0.03973214285714274 0.03973214285714274 0.03973214285714274

0.45871559633027525 0.27522935779816515 0.08256880733944955 0.05504587155963303 0.009174311926605505

0.25773195876291055 0.25773195876291055 0.25773195876291055 0.25773195876291055
0.23195876288661954 0.23195876288661954 0.23195876288661954 0.23195876288661954
0.18556701030929562 0.18556701030929562 0.18556701030929562 0.18556701030929562
0.3247422680412674 0.3247422680412674 0.3247422680412674 0.3247422680412674