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

View Code 
 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();
         }
         
 
     }
 
 }