Abstract:
A computation method based on successive difference is disclosed herein. The computation method performs computation by weighted coefficient provided by the present embodiment, and calculates ACF and CCF directly without computation on means beforehand. Further decomposing the weighted coefficient, a method being recursive and capable of updating immediately is obtained. The computation accuracy of the present embodiment is compared to StRD dataset and PROC ARIMA of SAS ver. 9.0; the result shows that the present embodiment is of a high computation accuracy and further solves problems of prior art that ACF and CCF computation requires confirmation on data number beforehand, and unable to perform updating.

Description:
BACKGROUND OF THE INVENTION 
       [0001]    1. Field of the Invention 
         [0002]    The present embodiment relates to a statistical analysis and time series application method for computation of cross-covariance function and autocovariance function, wherein related computation procedure can be applied to data analysis as described below: 
         [0003]    A. computation of autocovariance function and autocorrelation function; 
         [0004]    B. computation of partial autocorrelation function; 
         [0005]    C. computation of cross-covariance function and cross-correlation function; 
         [0006]    D. computation of autocovariance matrix and autocorrelation matrix; and 
         [0007]    E. computation related to time series analysis in the field of financial analysis and industrial engineering. 
         [0008]    2. Brief Description of the Related Art 
         [0009]    In order to effectively and briefly describing prior art of the present embodiment (hereinafter the prior art), the prior art is itemized into five descriptions listed below. 
         [0010]    1. Data can be one of two categories: cross sectional and time series. 
         [0011]    According to Anderson et al. (2006), collected data can be of two categories: cross sectional and time series, wherein cross sectional data is data collected at the same time (or approximately the same time,) and time series data is data collected with time. The two kinds of data are further described hereinafter. 
         [0012]    (i) Cross sectional data: 
         [0013]    Data collected at a specific period of time. First data collected is x 1 , second data collected is x 2 , and the rest can be defined in the same manner, wherein the n th  data collected is x n . The above-mentioned data can be shown as a set as: {x 1 , x 2 , . . . , x n }, and as vector as: 
         [0000]        x   1×n   T   =[x   1    x   2    . . . x   n ].   (1)
 
         [0014]    (ii) Time series data: 
         [0015]    Data collected in a continuous period of time. First data collected is x 1 , second data collected is x 2 , the i th  data collected is x i , the i+1 th  data collected is x i+1 , and the n th  collected is x n ; the rest can be defined in the same manner, whereas the above-mentioned data can be shown as a set as: {x 1 , x 2 , . . . , x i , x i+1 , . . . , x n , . . . } where the first n are the data collected in the continuous period of time and as vector as: 
         [0000]        x   1×n   T   =[x   1    x   2    . . . x   n ].   (2)
 
         [0016]    The vectors of equation (1) and (2) showing the foregoing data x 1 ˜x n  are of a same representation type; however, their data attributes are different. Data of equation (1) has no sequential relationship, whereas data of equation (2) are collected sequentially with time. 
         [0017]    2. Cross sectional and time series data calculations related to sums of squares of deviation from mean, and definition of autocovariance function. 
         [0018]    The mean of the data (x 1 ˜x n ) is obtained by adding up the data (1˜n) and then divide it by n; shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       _ 
                     
                     n 
                   
                   = 
                   
                     
                       1 
                       n 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                        
                       
                           
                       
                        
                       
                         
                           x 
                           i 
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0019]    The equation (3) is applicable to calculations of both (1) and (2). 
         [0020]    With regards to the different data types, computation of sums of squares of deviation from mean for the data (x 1 ˜x n ) is very important in data analysis. Descriptions of the two categories of data: cross sectional and time series data are listed as below. 
         [0021]    (i) Cross sectional data: 
         [0022]    For cross sectional data (x 1 ˜x n ) as equation (1), square of deviation, or square of deviation from mean is the square of each data value (x 1 , x 2 , . . . , x n ) minus the mean  x   n , shown as: (x 1 −  x   n ) 2 . And add up the square of deviation of each data, the sums of square of deviation from mean, or Corrected Sums of Squares (hereinafter CSS) is obtained, shown as below: 
         [0000]    
       
         
           
             
               
                 
                   
                     CSS 
                     n 
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         1 
                       
                       n 
                     
                      
                     
                         
                     
                      
                     
                       
                         
                           ( 
                           
                             
                               x 
                               i 
                             
                             - 
                             
                               
                                 x 
                                 _ 
                               
                               n 
                             
                           
                           ) 
                         
                         2 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0023]    Wherein,  x   n  is obtained from equation (3). 
         [0024]    (ii) Time series data: 
         [0025]    For time series data (x 1 ˜x n ) as equation (2), the vector representation of sequence of the 1 st  data to (n−k) th  data is as below: [x 1  x 2  . . . x n−k ] 1×(n−k) , (5) 
         [0026]    and the vector representation of sequence of the (k+1) th  data to n th  data is as below: 
         [0000]      [x k+1  x k+2  . . . x n ] 1×(n−k) .   (6)
 
         [0027]    Each element of the equation (5) and (6) then subtract the mean  x   n  defined in equation (3), wherein the vector representation is as below: 
         [0000]      [(x 1 −  x   n ) (x 2 −  x   n ) . . . (x n k −  x   n )] 1×(n−k) ,   (7)
 
         [0000]      and 
         [0000]      [(x k+1 −  x   n ) (x k+2 −  x   n ) . . . (x n −  x   n )] 1×(n−k) .   (8)
 
         [0028]    Multiplying the first element of equation (7) (x 1 −  x   n ), with the first element of equation (8), (x k+1 −  x   n ); multiplying the second element of equation (7), (x 2 −  x   n ), with the second element of equation (8), (x k+2 −  x   n ); the rest can be done in the same manner to the (n−k) th  element. Adding up all the foregoing results, and divide the sum by n, an Autocovariance Function at lag k is thereby obtained, shown as C XX (A), and equation is as below: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       C 
                       XX 
                     
                      
                     
                       ( 
                       k 
                       ) 
                     
                   
                   = 
                   
                     
                       1 
                       n 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         
                           n 
                           - 
                           k 
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ( 
                           
                             
                               x 
                               i 
                             
                             - 
                             
                               
                                 x 
                                 _ 
                               
                               n 
                             
                           
                           ) 
                         
                          
                         
                           ( 
                           
                             
                               x 
                               
                                 i 
                                 + 
                                 k 
                               
                             
                             - 
                             
                               
                                 x 
                                 _ 
                               
                               n 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0029]    Wherein, k&lt;n/2, and  x   n  is obtained from equation (3). 
         [0030]    Wherein, equation (9) is defined according to definition of Box et al. (2008). 
         [0031]    3. Sum of the product of the deviations of two variables, X and Y, from their respective means computation goes from sums of square of deviation from mean that is single variable to two variable data; Descriptions of the two categories of data: cross sectional and time series data are listed as below. 
         [0032]    (i) Cross sectional data: 
         [0033]    For the two variables data 1˜n, the first data is (x 1 , y 1 ), the second data is (x 2 , y 2 ), the i th  data is (x i , y i ), and the rest can be defined in the same manner, wherein the n th  data is (x n , y n ). Wherein,  x   n  and  y   n  are subtracted from (x i , y i ) respectively, and then multiply the difference and get the total, which is called Corrected Sums of Products, CSP; shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     CSP 
                     n 
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         1 
                       
                       n 
                     
                      
                     
                         
                     
                      
                     
                       
                         ( 
                         
                           
                             x 
                             i 
                           
                           - 
                           
                             
                               x 
                               _ 
                             
                             n 
                           
                         
                         ) 
                       
                        
                       
                         
                           ( 
                           
                             
                               y 
                               i 
                             
                             - 
                             
                               
                                 y 
                                 _ 
                               
                               n 
                             
                           
                           ) 
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0034]    Wherein, covariance of X and Y is CSP n  divided by n−1, shown as: cov(X,Y). The equation thereof is as below: 
         [0000]    
       
         
           
             
               cov 
                
               
                 ( 
                 
                   X 
                   , 
                   Y 
                 
                 ) 
               
             
             = 
             
               
                 CSP 
                 n 
               
               
                 n 
                 - 
                 1 
               
             
           
         
       
     
         [0035]    (ii) Time series data: 
         [0036]    For the two variable time series data, the first variable is x, the second variable is y. The first data collected is (x 1 , y 1 ), the second data collected is (x 2 , y 2 ), the i th  data collected is (x i , y i ), and the n th  data collected is (x n , y n ); the rest can be defined in the same manner, wherein the set thereof is shown as: 
         [0000]      {(x 1 ,y 1 ), (x 2 ,y 2 ), . . . , (x i ,y i ), (x i+1 ,y i+1 ), . . . , (x n ,y n ), . . . } 
         [0037]    With regards to the variable x, the vector of the first data to the (n−k) th  data is shown as: 
         [0000]      [x 1  x 2  . . . x n−k ] 1×(n−k) ,   (11)
 
         [0038]    with regards to the variable y, the vector of the (k+1) th  data to the n th  data is shown as: 
         [0000]      [y k+1  y k+2  . . . y n ] 1×(n−k) .   (12)
 
         [0039]    The mean  x   n  is respectively subtracted from each data in equation (11): x 1 , x 2 , . . . , x n−k  wherein the vector thereof is shown as: 
         [0000]      [(x 1 −  x   n ) (x 2 −  x   n ) . . . (x n−k −  x   n )] 1×(n−k) ,   (13)
 
         [0040]    The mean  y   n  is respectively subtracted from each data in equation (12): y k+1 , y k+2 , . . . , y n , wherein the vector thereof is shown as: 
         [0000]      [(y k+1 −  y   n ) (y k−2 −  y   n ) . . . (y n −  y   n )] 1×(n−k) ,   (14)
 
         [0041]    Multiply the first element of equation (13), (x 1 −  x   n ), with the first element of equation (14), (x 2 −  x   n ); multiply the second element of equation (13), (x 2 −  x   n ), with the second element of equation (14), (x 2 −  x   n ); the rest can be done in the same manner to the (n−k) th  data. The sum of the foregoing results divided by n is the Cross-covariance Function at lag k, shown as C XY (k), and the equation is as below: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         C 
                         XY 
                       
                        
                       
                         ( 
                         k 
                         ) 
                       
                     
                     = 
                     
                       
                         1 
                         n 
                       
                        
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           
                             n 
                             - 
                             k 
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             ( 
                             
                               
                                 x 
                                 i 
                               
                               - 
                               
                                 
                                   x 
                                   _ 
                                 
                                 n 
                               
                             
                             ) 
                           
                            
                           
                             ( 
                             
                               
                                 y 
                                 
                                   i 
                                   + 
                                   k 
                                 
                               
                               - 
                               
                                 
                                   y 
                                   _ 
                                 
                                 n 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0042]    Wherein, k&lt;n/2, and  x   n  is obtained from equation (3). 
         [0043]    Wherein, equation (15) is defined according to definition of Box et al. (2008). 
         [0044]    4. The definition of updating 
         [0045]    Updating, according to the study of Chan et al. (1979), is when a new data is collected and put into an equation, using the new data to compute a new result and update the result computed before the new data is collected. According to Higham (2004), the updating equation is shown as below: 
         [0000]      New_value=old_value+small_correction   (16)
 
         [0046]    The computation module of equation (16) is called updating. Updating helps to save the hardware resource and supports the dynamic data analysis. 
         [0047]    5. Problems and applications of Autocorrelation Function and Cross-correlation Function 
         [0048]    Many of the computations related to time series data are based on equation (9) and (15), such as Autocorrelation Function, Partial Autocorrelation Function, PACF, Autocovariance matrix or Autocorrelation matrix. Please refer to Box et al. (2008) for related definitions and applications. According to McCullough (1998), computation of PACF on data analysis software is unable to be accurate and effective at the same time. Further, McCullough (1998) also points out that there are two computation methods for ACF and PACF: direct computation method and Newton (1988) method. Further, the study of Keeling and Pavur (2007) focuses on computation accuracy of nine commonly used data analysis software such as EXCEL XP, EXCEL 2003, JMP 5.0, Minitab 14.0, R1.9.1, SAS 9.1, Splus 6.2, SPSS 12.0, Stat 8.1 and StatCrunch 3.0; wherein, the accuracy of the nine commonly used data analysis software is still requiring improvement. 
       SUMMARY OF THE INVENTION 
       [0049]    The present embodiment is based on the successive difference developed by the applicant, and the weight (w ij ) proposed by the applicant to perform the computation of ACF and CCF. The computation equations of ACF and CCF are the equation (9) and (15). The equation (9) and (15) multiply by n is the new computation method disclosed by the present embodiment. 
         [0050]    An object of the present embodiment is to first develop a method of an equation: 
         [0000]    
       
         
           
             
               1 
               n 
             
              
             
               d 
               
                 1 
                 × 
                 
                   n 
                    
                   
                     ( 
                     k 
                     ) 
                   
                 
               
               T 
             
              
             
               W 
               
                 n 
                 × 
                 n 
               
             
              
             
               e 
               
                 n 
                 × 
                 1 
               
             
           
         
       
     
         [0000]    by decomposing the n×n matrix, W n×n  wherein the method is recursive and capable of updating. Secondly, combine the foregoing method with the updating computation when there is new data collected thereto. This solves the prior problem of having to compute the mean first when performing computation of ACF and CCF. All the prior methods that require computation of mean beforehand is a two-pass method; all data to be computed needs to be read by hardware twice. However, the method of the present embodiment is a one-pass method wherein the data only has to be read once; this helps saving the hardware storage space and increases computation efficiency. The method disclosed by the present embodiment is thereby capable of solving the prior art&#39;s problem of being unable to maintain accuracy while having to perform updating. Another object of the present embodiment is to use the successive difference as a basis in order to perform recursion and update the CCF computation method. ACF is the special case of univariate thereof; for computation of ACF, replace the bivariate of the foregoing method with univariate. 
         [0051]    Further, the method of the present embodiment has high computation accuracy; this helps to improve the computation accuracy of software computation of functions related to ACF and CCF. 
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
       [0052]    The present embodiment provides a computation method for Cross-covariance Function (hereinafter C XY (k)) and Autocovariance Function (hereinafter C XX (k)); wherein the computation method is based on successive difference and a weighted coefficient w ij , thereby does not require computation of mean in advance. 
         [0053]    (i) Cross-covariance Function 
         [0054]    With regards to the Cross-covariance Function, it possesses n data of bivariate, wherein a first data of a first variable is x 1 , a second data of the first variable is x 2 , and the rest can be defined in the same manner wherein an n th  data is x n . Define sdx 1 =x 1 , an i th  successive difference of the first variable refers to the amount that an i−1 th  data value x i−1  subtracted from an i th data value x i ; equation shown as: sdx i =x i −x i−1 , wherein i=2,3, . . . , n. A first data of a second variable is y 1 , a second data of the second variable is y 2 , and the rest can be defined in the same manner wherein an n th  data is y n . Define sdy 1 =y 1 , an i th  successive difference of the second variable refers to the amount that an i−1 th  data value y i−1  subtracted from an i th  data value y i ; equation shown as: sdy i =y i −y i−1 , wherein i=2,3, . . . , n. 
         [0055]    Firstly computation of nC XY (A) is shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         nC 
                         XY 
                       
                        
                       
                         ( 
                         k 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           1 
                           n 
                         
                          
                         
                           d 
                           
                             1 
                             × 
                             
                               n 
                                
                               
                                 ( 
                                 k 
                                 ) 
                               
                             
                           
                           T 
                         
                          
                         
                           W 
                           
                             n 
                             × 
                             n 
                           
                         
                          
                         
                           e 
                           
                             n 
                             × 
                             1 
                           
                         
                       
                       + 
                       
                         A 
                         XY 
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     Wherein 
                     , 
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       W 
                       
                         n 
                         × 
                         n 
                       
                     
                     = 
                     
                       
                         ⌊ 
                         
                           w 
                           ij 
                         
                         ⌋ 
                       
                       
                         n 
                         × 
                         n 
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     
                       w 
                       ij 
                     
                     = 
                     
                       
                         
                           ( 
                           
                             n 
                             + 
                             1 
                           
                           ) 
                         
                          
                         
                           ( 
                           
                             i 
                             + 
                             j 
                             - 
                             1 
                           
                           ) 
                         
                       
                       - 
                       ij 
                       - 
                       
                         
                           n 
                           2 
                         
                          
                         
                           ( 
                           
                             i 
                             + 
                             j 
                             + 
                             
                                
                               
                                 i 
                                 - 
                                 j 
                               
                                
                             
                           
                           ) 
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     i 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   n 
                   , 
                   
                     j 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     
                       n 
                       . 
                       
                         
 
                       
                        
                       
                         e 
                         
                           n 
                           × 
                           1 
                         
                         T 
                       
                     
                     = 
                     
                       
                         [ 
                         
                           
                             
                               
                                 sdx 
                                 1 
                               
                             
                             
                               
                                 sdx 
                                 2 
                               
                             
                             
                               … 
                             
                             
                               
                                 
                                     
                                 
                                  
                                 
                                   sdx 
                                   n 
                                 
                               
                             
                           
                         
                         ] 
                       
                       
                         1 
                         × 
                         n 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         d 
                         
                           1 
                           × 
                           
                             n 
                              
                             
                               ( 
                               k 
                               ) 
                             
                           
                         
                         T 
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     0 
                                      
                                     
                                         
                                     
                                      
                                     … 
                                      
                                     
                                         
                                     
                                      
                                     0 
                                   
                                   
                                      
                                     
                                       k 
                                        
                                       
                                           
                                       
                                        
                                       items 
                                     
                                   
                                 
                               
                               
                                 
                                   sdx 
                                   1 
                                 
                               
                               
                                 
                                   … 
                                    
                                   
                                       
                                   
                                   | 
                                 
                               
                               
                                 
                                   
                                       
                                   
                                    
                                   
                                     sdx 
                                     
                                       n 
                                       - 
                                       k 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                         
                           1 
                           × 
                           n 
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     Wherein 
                     , 
                     
                       
 
                     
                      
                     
                       
                         d 
                         
                           1 
                           × 
                           
                             n 
                              
                             
                               ( 
                               0 
                               ) 
                             
                           
                         
                         T 
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   sdx 
                                   1 
                                 
                               
                               
                                 
                                   sdx 
                                   2 
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   
                                       
                                   
                                    
                                   
                                     sdx 
                                     n 
                                   
                                 
                               
                             
                           
                           ] 
                         
                         
                           1 
                           × 
                           n 
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                       
                         d 
                         
                           1 
                           × 
                           
                             n 
                              
                             
                               ( 
                               1 
                               ) 
                             
                           
                         
                         T 
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 0 
                               
                               
                                 
                                   sdx 
                                   1 
                                 
                               
                               
                                 
                                   sdx 
                                   2 
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   sdx 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                           ] 
                         
                         
                           1 
                           × 
                           n 
                         
                       
                     
                     , 
                     
                         
                     
                      
                     
                       
                         d 
                         
                           1 
                           × 
                           
                             n 
                              
                             
                               ( 
                               2 
                               ) 
                             
                           
                         
                         T 
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     0 
                                      
                                     
                                         
                                     
                                      
                                     0 
                                   
                                   
                                      
                                     
                                       2 
                                        
                                       
                                           
                                       
                                        
                                       items 
                                     
                                   
                                 
                               
                               
                                 
                                   sdx 
                                   1 
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   sdx 
                                   
                                     n 
                                     - 
                                     2 
                                   
                                 
                               
                             
                           
                           ] 
                         
                         
                           1 
                           × 
                           n 
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     … 
                   
                    
                   
                     
 
                   
                    
                   
                     
                       until 
                        
                       
                           
                       
                        
                       k 
                     
                     &lt; 
                     
                       n 
                       2 
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
         [0056]    Further, A XY  can be shown in two forms of equations: 
         [0000]    
       
         
           
             
               
                 
                   
                       
                   
                    
                   
                     
                       
                         ( 
                         a 
                         ) 
                       
                        
                       
                           
                       
                        
                       
                         A 
                         XY 
                       
                     
                     = 
                     
                       k 
                        
                       
                         
                           
                             x 
                             _ 
                           
                           n 
                         
                          
                         
                           ( 
                           
                             
                               
                                 y 
                                 _ 
                               
                               k 
                             
                             - 
                             
                               
                                 y 
                                 _ 
                               
                               n 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ( 
                       b 
                       ) 
                     
                      
                     
                         
                     
                      
                     
                       A 
                       XY 
                     
                   
                   = 
                   
                     
                       k 
                        
                       
                         ( 
                         
                           
                             x 
                             n 
                           
                           - 
                           
                             
                               1 
                               n 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   i 
                                   = 
                                   1 
                                 
                                 n 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   ( 
                                   
                                     i 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                  
                                 
                                   sdx 
                                   i 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                      
                     
                       ( 
                       
                         
                           ( 
                           
                             
                               y 
                               k 
                             
                             - 
                             
                               
                                 1 
                                 k 
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   k 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdy 
                                     i 
                                   
                                 
                               
                             
                           
                           ) 
                         
                         - 
                         
                           ( 
                           
                             
                               y 
                               n 
                             
                             - 
                             
                               
                                 1 
                                 n 
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   n 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdy 
                                     i 
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
         [0057]    The computation of Cross-covariance Function at lag k is to divide the result from the equation (17) by n. The iterative computation developing process of 
         [0000]    
       
         
           
             
               1 
               n 
             
              
             
               d 
               
                 1 
                 × 
                 
                   n 
                    
                   
                     ( 
                     k 
                     ) 
                   
                 
               
               T 
             
              
             
               W 
               
                 n 
                 × 
                 n 
               
             
              
             
               e 
               
                 n 
                 × 
                 1 
               
             
           
         
       
     
         [0000]    and A XY  are described hereinafter. 
         [0058]    (i) The iterative computation of 
         [0000]    
       
         
           
             
               1 
               n 
             
              
             
               d 
               
                 1 
                 × 
                 
                   n 
                    
                   
                     ( 
                     k 
                     ) 
                   
                 
               
               T 
             
              
             
               W 
               
                 n 
                 × 
                 n 
               
             
              
             
               e 
               
                 n 
                 × 
                 1 
               
             
           
         
       
     
         [0059]    In practice, d 1×n(k)   T W n×n e n×1  is the only consideration; divide it by n. In order to further describe elements of W n×n  matrix of different orders, redefine elements of i th  row and j th  column of n×n matrix W n×n , hereinafter w ij(n) , and shown as: 
         [0000]    
       
         
           
             
               
                 w 
                 
                   ij 
                    
                   
                     ( 
                     n 
                     ) 
                   
                 
               
               = 
               
                 
                   
                     ( 
                     
                       n 
                       + 
                       1 
                     
                     ) 
                   
                    
                   
                     ( 
                     
                       i 
                       + 
                       j 
                       - 
                       1 
                     
                     ) 
                   
                 
                 - 
                 ij 
                 - 
                 
                   
                     n 
                     2 
                   
                    
                   
                     ( 
                     
                       i 
                       + 
                       j 
                       + 
                       
                          
                         
                           i 
                           - 
                           j 
                         
                          
                       
                     
                     ) 
                   
                 
               
             
             , 
             
               
 
             
              
             
               i 
               = 
               1 
             
             , 
             2 
             , 
             … 
              
             
                 
             
             , 
             n 
             , 
             
                 
             
              
             
               j 
               = 
               1 
             
             , 
             2 
             , 
             … 
              
             
                 
             
             , 
             
               n 
               . 
             
           
         
       
     
         [0060]    Decomposition of the matrix W n×n  is of two stages. 
         [0061]    Stage 1: 
         [0062]    Decomposing the matrix W n×n  to two matrices, shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         W 
                         
                           n 
                           × 
                           n 
                         
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   w 
                                   11 
                                 
                               
                               
                                 
                                   w 
                                   12 
                                 
                               
                               
                                 
                                   w 
                                   13 
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   w 
                                   
                                     1 
                                      
                                     
                                         
                                     
                                      
                                     n 
                                   
                                 
                               
                             
                             
                               
                                 
                                   w 
                                   21 
                                 
                               
                               
                                 
                                   w 
                                   22 
                                 
                               
                               
                                 
                                   w 
                                   23 
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   w 
                                   
                                     2 
                                      
                                     
                                         
                                     
                                      
                                     n 
                                   
                                 
                               
                             
                             
                               
                                 
                                   w 
                                   31 
                                 
                               
                               
                                 
                                   w 
                                   32 
                                 
                               
                               
                                 
                                   w 
                                   33 
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   w 
                                   
                                     3 
                                      
                                     
                                         
                                     
                                      
                                     n 
                                   
                                 
                               
                             
                             
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋱ 
                               
                               
                                 ⋮ 
                               
                             
                             
                               
                                 
                                   w 
                                   
                                     n 
                                      
                                     
                                         
                                     
                                      
                                     1 
                                   
                                 
                               
                               
                                 
                                   w 
                                   
                                     n 
                                      
                                     
                                         
                                     
                                      
                                     2 
                                   
                                 
                               
                               
                                 
                                   w 
                                   
                                     n 
                                      
                                     
                                         
                                     
                                      
                                     3 
                                   
                                 
                               
                               
                                 … 
                               
                               
                                 
                                   w 
                                   nn 
                                 
                               
                             
                           
                           ] 
                         
                         = 
                         
                           
                             
                               [ 
                               
                                 
                                   
                                     
                                       W 
                                       
                                         
                                           ( 
                                           
                                             n 
                                             - 
                                             1 
                                           
                                           ) 
                                         
                                         × 
                                         
                                           ( 
                                           
                                             n 
                                             - 
                                             1 
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                   
                                     
                                       0 
                                       
                                         
                                           ( 
                                           
                                             n 
                                             - 
                                             1 
                                           
                                           ) 
                                         
                                         × 
                                         1 
                                       
                                     
                                   
                                 
                                 
                                   
                                     
                                       0 
                                       
                                         1 
                                         × 
                                         
                                           ( 
                                           
                                             n 
                                             - 
                                             1 
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                   
                                     0 
                                   
                                 
                               
                               ] 
                             
                             
                               n 
                               × 
                               n 
                             
                           
                           + 
                           
                             G 
                             
                               n 
                               × 
                               n 
                             
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                         
                     
                      
                     Wherein 
                     , 
                     
                       
 
                     
                      
                     
                         
                     
                      
                     
                       
                         W 
                         
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                       = 
                       
                         
                           ⌊ 
                           
                             w 
                             
                               ij 
                                
                               
                                 ( 
                                 
                                   n 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                           
                           ⌋ 
                         
                         
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                         
                     
                      
                     
                       
                         w 
                         
                           ij 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                       = 
                       
                         
                           n 
                            
                           
                             ( 
                             
                               i 
                               + 
                               j 
                               - 
                               1 
                             
                             ) 
                           
                         
                         - 
                         ij 
                         - 
                         
                           
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                             2 
                           
                            
                           
                             ( 
                             
                               i 
                               + 
                               j 
                               + 
                               
                                  
                                 
                                   i 
                                   - 
                                   j 
                                 
                                  
                               
                             
                             ) 
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                         
                     
                      
                     
                       i 
                       = 
                       1 
                     
                     , 
                     2 
                     , 
                     … 
                      
                     
                         
                     
                     , 
                     
                       n 
                       - 
                       1 
                     
                     , 
                     
                       j 
                       = 
                       1 
                     
                     , 
                     2 
                     , 
                     … 
                      
                     
                         
                     
                     , 
                     
                       n 
                       - 
                       1. 
                     
                   
                    
                   
                     
 
                   
                    
                   
                       
                   
                    
                   
                     
                       
                         0 
                         
                           1 
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                           
                           ] 
                         
                         
                           1 
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                         
                     
                      
                     
                       
                         0 
                         
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                           × 
                           1 
                         
                       
                       = 
                       
                         
                           
                             [ 
                             
                               
                                 
                                   0 
                                 
                               
                               
                                 
                                   0 
                                 
                               
                               
                                 
                                   ⋮ 
                                 
                               
                               
                                 
                                   0 
                                 
                               
                             
                             ] 
                           
                           
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                             × 
                             1 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0063]    Stage 2 
         [0064]    Decomposing the matrix G n×n , shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         G 
                         
                           n 
                           × 
                           n 
                         
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   G 
                                   
                                     
                                       ( 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                     × 
                                     
                                       ( 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                               
                               
                                 
                                   M 
                                   
                                     
                                       ( 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                     × 
                                     1 
                                   
                                 
                               
                             
                             
                               
                                 
                                   M 
                                   
                                     1 
                                     × 
                                     
                                       ( 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                   
                                   T 
                                 
                               
                               
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                         
                           n 
                           × 
                           n 
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     Wherein 
                     , 
                     
                       
 
                     
                      
                     
                       
                         G 
                         
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                       = 
                       
                         
                           ⌊ 
                           
                             g 
                             ij 
                           
                           ⌋ 
                         
                         
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       
                         g 
                         ij 
                       
                       = 
                       
                         
                           1 
                           2 
                         
                          
                         
                           ( 
                           
                             i 
                             + 
                             j 
                             - 
                             
                                
                               
                                 i 
                                 - 
                                 j 
                               
                                
                             
                             - 
                             2 
                           
                           ) 
                         
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                       i 
                       = 
                       1 
                     
                     , 
                     2 
                     , 
                     … 
                      
                     
                         
                     
                     , 
                     
                       n 
                       - 
                       1 
                     
                     , 
                     
                       j 
                       = 
                       1 
                     
                     , 
                     2 
                     , 
                     … 
                      
                     
                         
                     
                     , 
                     
                       n 
                       - 
                       1. 
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       M 
                       
                         1 
                         × 
                         
                           ( 
                           
                             n 
                             - 
                             1 
                           
                           ) 
                         
                       
                       T 
                     
                     = 
                     
                       
                         
                           [ 
                           
                             
                               
                                 0 
                               
                               
                                 1 
                               
                               
                                 … 
                               
                               
                                 
                                   n 
                                   - 
                                   2 
                                 
                               
                             
                           
                           ] 
                         
                         
                           1 
                           × 
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
         [0065]    The first part of the present embodiment substitute the equation (22) and (23) in d 1×n(k)   T W n×n e n×1  to develop an iterative computation by the following two steps: 
         [0066]    Step 1 Substituting the equation (22) into d 1×n(k)   T W n×n e n×1    
         [0067]    Define DWE n =d 1×n(k)   T W n×n e n×1 , and obtain: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           DWE 
                           n 
                         
                         = 
                           
                          
                         
                           
                             d 
                             
                               1 
                               × 
                               
                                 n 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                             
                             T 
                           
                            
                           
                             W 
                             
                               n 
                               × 
                               n 
                             
                           
                            
                           
                             e 
                             
                               n 
                               × 
                               1 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               d 
                               
                                 1 
                                 × 
                                 
                                   n 
                                    
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                               T 
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     [ 
                                     
                                       
                                         
                                           
                                             W 
                                             
                                               
                                                 ( 
                                                 
                                                   n 
                                                   - 
                                                   1 
                                                 
                                                 ) 
                                               
                                               × 
                                               
                                                 ( 
                                                 
                                                   n 
                                                   - 
                                                   1 
                                                 
                                                 ) 
                                               
                                             
                                           
                                         
                                         
                                           
                                             0 
                                             
                                               
                                                 ( 
                                                 
                                                   n 
                                                   - 
                                                   1 
                                                 
                                                 ) 
                                               
                                               × 
                                               1 
                                             
                                           
                                         
                                       
                                       
                                         
                                           
                                             0 
                                             
                                               1 
                                               × 
                                               
                                                 ( 
                                                 
                                                   n 
                                                   - 
                                                   1 
                                                 
                                                 ) 
                                               
                                             
                                           
                                         
                                         
                                           0 
                                         
                                       
                                     
                                     ] 
                                   
                                   
                                     n 
                                     × 
                                     n 
                                   
                                 
                                 + 
                                 
                                   G 
                                   
                                     n 
                                     × 
                                     n 
                                   
                                 
                               
                               ) 
                             
                           
                            
                           
                             e 
                             
                               n 
                               × 
                               1 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               
                                 
                                   d 
                                   
                                     1 
                                     × 
                                     
                                       n 
                                        
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                   
                                   T 
                                 
                                  
                                 
                                   [ 
                                   
                                     
                                       
                                         
                                           W 
                                           
                                             
                                               ( 
                                               
                                                 n 
                                                 - 
                                                 1 
                                               
                                               ) 
                                             
                                             × 
                                             
                                               ( 
                                               
                                                 n 
                                                 - 
                                                 1 
                                               
                                               ) 
                                             
                                           
                                         
                                       
                                       
                                         
                                           0 
                                           
                                             
                                               ( 
                                               
                                                 n 
                                                 - 
                                                 1 
                                               
                                               ) 
                                             
                                             × 
                                             1 
                                           
                                         
                                       
                                     
                                     
                                       
                                         
                                           0 
                                           
                                             1 
                                             × 
                                             
                                               ( 
                                               
                                                 n 
                                                 - 
                                                 1 
                                               
                                               ) 
                                             
                                           
                                         
                                       
                                       
                                         0 
                                       
                                     
                                   
                                   ] 
                                 
                               
                               
                                 n 
                                 × 
                                 n 
                               
                             
                              
                             
                               e 
                               
                                 n 
                                 × 
                                 1 
                               
                             
                           
                           + 
                           
                             
                               d 
                               
                                 1 
                                 × 
                                 
                                   n 
                                    
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                               T 
                             
                              
                             
                               G 
                               
                                 n 
                                 × 
                                 n 
                               
                             
                              
                             
                               e 
                               
                                 n 
                                 × 
                                 1 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             DWE 
                             
                               n 
                               - 
                               1 
                             
                           
                           + 
                           
                             
                               d 
                               
                                 1 
                                 × 
                                 
                                   n 
                                    
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                               T 
                             
                              
                             
                               G 
                               
                                 n 
                                 × 
                                 n 
                               
                             
                              
                             
                               e 
                               
                                 n 
                                 × 
                                 1 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
           
         
       
     
         [0068]    Step 2 Substituting the equation (23) into a second item on right-hand side of the equation (24) d 1×n(k)   T G n×n e n×1    
         [0069]    According to the equation (19), d 1×n(k)   T =[0 . . . 0 sdx 1  . . . sdx n−k ] 1×n , let sdx* i =0, i=1, 2, . . . , k, sdx* i+k =sdx i , i=1, 2, . . . , n−k, then 
         [0070]    Define DGE n =d 1×n(k)   T G n×n e n×1 , and obtain 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           DGE 
                           n 
                         
                         = 
                           
                          
                         
                           
                             d 
                             
                               1 
                               × 
                               
                                 n 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                             
                             T 
                           
                            
                           
                             G 
                             
                               n 
                               × 
                               n 
                             
                           
                            
                           
                             e 
                             
                               n 
                               × 
                               1 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               
                                 d 
                                 
                                   1 
                                   × 
                                   
                                     n 
                                      
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                 
                                 T 
                               
                                
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         G 
                                         
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                           × 
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                         
                                       
                                     
                                     
                                       
                                         M 
                                         
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                           × 
                                           1 
                                         
                                       
                                     
                                   
                                   
                                     
                                       
                                         M 
                                         
                                           1 
                                           × 
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                         
                                         T 
                                       
                                     
                                     
                                       
                                         ( 
                                         
                                           n 
                                           - 
                                           1 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             
                               n 
                               × 
                               n 
                             
                           
                            
                           
                             e 
                             
                               n 
                               × 
                               1 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             [ 
                             
                               
                                 
                                   
                                     sdx 
                                     1 
                                     * 
                                   
                                 
                                 
                                   … 
                                 
                                 
                                   
                                     
                                         
                                     
                                      
                                     
                                       
                                         sdx 
                                         
                                           n 
                                           - 
                                           1 
                                         
                                         * 
                                       
                                       | 
                                     
                                   
                                 
                                 
                                   
                                     sdx 
                                     n 
                                     * 
                                   
                                 
                               
                             
                             ] 
                           
                           
                             1 
                             × 
                             n 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         G 
                                         
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                           × 
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                         
                                       
                                     
                                     
                                       
                                         M 
                                         
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                           × 
                                           1 
                                         
                                       
                                     
                                   
                                   
                                     
                                       
                                         M 
                                         
                                           1 
                                           × 
                                           
                                             ( 
                                             
                                               n 
                                               - 
                                               1 
                                             
                                             ) 
                                           
                                         
                                         T 
                                       
                                     
                                     
                                       
                                         ( 
                                         
                                           n 
                                           - 
                                           1 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                 ] 
                               
                               
                                 n 
                                 × 
                                 n 
                               
                             
                              
                             
                               [ 
                               
                                 
                                   
                                     
                                       sdy 
                                       1 
                                     
                                   
                                 
                                 
                                   
                                     ⋮ 
                                   
                                 
                                 
                                   
                                     
                                       sdy 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                     
                                   
                                 
                                 
                                   
                                     
                                       sdy 
                                       n 
                                     
                                   
                                 
                               
                               ] 
                             
                           
                           
                             n 
                             × 
                             1 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               d 
                               
                                 1 
                                 × 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                               T 
                             
                              
                             
                               G 
                               
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 × 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                              
                             
                               e 
                               
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 × 
                                 1 
                               
                             
                           
                           + 
                           
                             
                               d 
                               
                                 1 
                                 × 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                               T 
                             
                              
                             
                               M 
                               
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 × 
                                 1 
                               
                             
                              
                             
                               sdy 
                               n 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               sdx 
                               n 
                               * 
                             
                              
                             
                               M 
                               
                                 1 
                                 × 
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                               T 
                             
                              
                             
                               e 
                               
                                 
                                   ( 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 × 
                                 1 
                               
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                              
                             
                               sdx 
                               n 
                               * 
                             
                              
                             
                               sdy 
                               n 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             DGE 
                             
                               n 
                               - 
                               1 
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdx 
                                     i 
                                     * 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               sdy 
                               n 
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdy 
                                     i 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               sdx 
                               n 
                               * 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                            
                           
                             sdx 
                             n 
                             * 
                           
                            
                           
                             sdy 
                             n 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
     
         [0071]    Substituting the equation (25) into equation (24) and obtain: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           DWE 
                           n 
                         
                         = 
                           
                          
                         
                           
                             DWE 
                             
                               n 
                               - 
                               1 
                             
                           
                           + 
                           
                             DGE 
                             n 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             DWE 
                             
                               n 
                               - 
                               1 
                             
                           
                           + 
                           
                             DGE 
                             
                               n 
                               - 
                               1 
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdx 
                                     i 
                                     * 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               sdy 
                               n 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   
                                     n 
                                     - 
                                     1 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdy 
                                     i 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               sdx 
                               n 
                               * 
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                              
                             
                               sdx 
                               n 
                               * 
                             
                              
                             
                               sdy 
                               n 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
         [0072]    (ii) The iterative computation of A XY    
         [0073]    With regards to A XY , the present embodiment uses successive difference computation method, as shown in equation (21), 
         [0000]    
       
         
           
             
               k 
                
               
                 ( 
                 
                   
                     x 
                     n 
                   
                   - 
                   
                     
                       1 
                       n 
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                        
                       
                           
                       
                        
                       
                         
                           ( 
                           
                             i 
                             - 
                             1 
                           
                           ) 
                         
                          
                         
                           sdx 
                           i 
                         
                       
                     
                   
                 
                 ) 
               
             
              
             
               
                 ( 
                 
                   
                     ( 
                     
                       
                         y 
                         k 
                       
                       - 
                       
                         
                           1 
                           k 
                         
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             k 
                           
                            
                           
                               
                           
                            
                           
                             
                               ( 
                               
                                 i 
                                 - 
                                 1 
                               
                               ) 
                             
                              
                             
                               sdy 
                               i 
                             
                           
                         
                       
                     
                     ) 
                   
                   - 
                   
                     ( 
                     
                       
                         y 
                         n 
                       
                       - 
                       
                         
                           1 
                           n 
                         
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             n 
                           
                            
                           
                               
                           
                            
                           
                             
                               ( 
                               
                                 i 
                                 - 
                                 1 
                               
                               ) 
                             
                              
                             
                               sdy 
                               i 
                             
                           
                         
                       
                     
                     ) 
                   
                 
                 ) 
               
               . 
             
           
         
       
     
         [0074]    Wherein, the iterative computation thereof is described with 
         [0000]    
       
         
           
             ( 
             
               
                 x 
                 n 
               
               - 
               
                 
                   1 
                   n 
                 
                  
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                       
                   
                    
                   
                     
                       ( 
                       
                         i 
                         - 
                         1 
                       
                       ) 
                     
                      
                     
                       sdx 
                       i 
                     
                   
                 
               
             
             ) 
           
         
       
     
         [0000]    as shown below: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Define 
                        
                       
                           
                       
                        
                       
                         WSUM_SDX 
                         n 
                       
                     
                     = 
                     
                       
                         x 
                         n 
                       
                       - 
                       
                         
                           1 
                           n 
                         
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             n 
                           
                            
                           
                             
                               ( 
                               
                                 i 
                                 - 
                                 1 
                               
                               ) 
                             
                              
                             
                               sdx 
                               i 
                             
                           
                         
                       
                     
                   
                   , 
                   
                     and 
                      
                     
                         
                     
                      
                     obtain 
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     
                       WSUM_SDX 
                       n 
                     
                     = 
                     
                       
                         WSUM_SDX 
                         
                           n 
                           - 
                           1 
                         
                       
                       + 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           n 
                         
                          
                         
                           sdx 
                           i 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     Since 
                      
                     
                         
                     
                      
                     
                       ( 
                       
                         
                           y 
                           k 
                         
                         - 
                         
                           
                             1 
                             k 
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               k 
                             
                              
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 sdy 
                                 i 
                               
                             
                           
                         
                       
                       ) 
                     
                      
                     
                         
                     
                      
                     of 
                   
                    
                   
                     
 
                   
                    
                   
                     
                       k 
                        
                       
                         ( 
                         
                           
                             x 
                             n 
                           
                           - 
                           
                             
                               1 
                               n 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   i 
                                   = 
                                   1 
                                 
                                 n 
                               
                                
                               
                                 
                                   ( 
                                   
                                     i 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                  
                                 
                                   sdx 
                                   i 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                      
                     
                       ( 
                       
                         
                           ( 
                           
                             
                               y 
                               k 
                             
                             - 
                             
                               
                                 1 
                                 k 
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   k 
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdy 
                                     i 
                                   
                                 
                               
                             
                           
                           ) 
                         
                         - 
                         
                           ( 
                           
                             
                               y 
                               n 
                             
                             - 
                             
                               
                                 1 
                                 n 
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   n 
                                 
                                  
                                 
                                   
                                     ( 
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                    
                                   
                                     sdy 
                                     i 
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                       ) 
                     
                      
                     
                         
                     
                      
                     and 
                      
                     
                         
                     
                      
                     
                       ( 
                       
                         
                           y 
                           k 
                         
                         - 
                         
                           
                             1 
                             k 
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               k 
                             
                              
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 sdy 
                                 i 
                               
                             
                           
                         
                       
                       ) 
                     
                      
                     
                         
                     
                      
                     and 
                      
                     
                         
                     
                      
                     
                       ( 
                       
                         
                           y 
                           n 
                         
                         - 
                         
                           
                             1 
                             n 
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               n 
                             
                              
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 sdy 
                                 i 
                               
                             
                           
                         
                       
                       ) 
                     
                      
                     
                       ( 
                       
                         
                           x 
                           n 
                         
                         - 
                         
                           
                             1 
                             n 
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               n 
                             
                              
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 sdx 
                                 i 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0000]    are of the same computation method, the present embodiment does not further describe the details hereby; according to result of equation (27), the iterative computation for A XY  can be performed. 
         [0075]    As the foregoing, the result of equation (26) and (27) is the iterative computation method for nC XY (k), wherein the method can be written as steps that can be implemented on hardware of: 
         [0076]    Step 1: defining hardware implementing variable Defining computation variables; all variable are with an initial value of 0, wherein: 
         [0077]    defining k value; 
         [0078]    defining n_cxy_k as nC XY (k); 
         [0079]    defining dwe as DWE n  of equation (26); 
         [0080]    defining dge as DGE n  of equation (26); 
         [0081]    defining corrected_term as equation (21). 
         [0082]    The successive difference value of the first variable is sdx[i]. Further, sdx is sdx i * of the equation (26), wherein i=1 at the first implementation, i=2 at the second implementation, and the rest can be defined in the same manner. 
         [0083]    The successive difference value of the second variable sdy is sdy i  of the equation (26). 
         [0084]    The successive difference iteration sum of the first variable is isum_sdx, shown as 
         [0000]    
       
         
           
             ( 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 
                   n 
                   - 
                   1 
                 
               
                
               
                 
                   ( 
                   
                     i 
                     - 
                     1 
                   
                   ) 
                 
                  
                 
                   sdx 
                   i 
                   * 
                 
               
             
             ) 
           
         
       
     
         [0000]    in equation (26). 
         [0085]    The successive difference iteration sum of the second variable is isum_sdy, shown as 
         [0000]    
       
         
           
             ( 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 
                   n 
                   - 
                   1 
                 
               
                
               
                 
                   ( 
                   
                     i 
                     - 
                     1 
                   
                   ) 
                 
                  
                 
                   sdy 
                   i 
                 
               
             
             ) 
           
         
       
     
         [0000]    in equation (26). 
         [0000]    
       
         
           
             
               define 
                
               
                   
               
                
               n_sum 
                
               _sdx 
                
               
                   
               
                
               as 
                
               
                   
               
                
               
                 ( 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     
                       ( 
                       
                         n 
                         - 
                         i 
                         + 
                         1 
                       
                       ) 
                     
                      
                     
                       sdx 
                       i 
                     
                   
                 
                 ) 
               
             
             ; 
           
         
       
       
         
           
             
               define 
                
               
                   
               
                
               k_sum 
                
               _sdy 
                
               
                   
               
                
               as 
                
               
                   
               
                
               
                 ( 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     k 
                   
                    
                   
                     
                       ( 
                       
                         k 
                         - 
                         i 
                         + 
                         1 
                       
                       ) 
                     
                      
                     
                       sdy 
                       i 
                     
                   
                 
                 ) 
               
             
             ; 
           
         
       
       
         
           
             
               define 
                
               
                   
               
                
               n_sum 
                
               _sdy 
                
               
                   
               
                
               as 
                
               
                   
               
                
               
                 ( 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     
                       ( 
                       
                         n 
                         - 
                         i 
                         + 
                         1 
                       
                       ) 
                     
                      
                     
                       sdy 
                       i 
                     
                   
                 
                 ) 
               
             
             ; 
           
         
       
       
         
           
             
               define 
                
               
                   
               
                
               sum_sdx 
                
               
                   
               
                
               as 
                
               
                   
               
                
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   n 
                 
                  
                 
                   sdx 
                   i 
                 
               
             
             ; 
           
         
       
       
         
           
             define 
              
             
                 
             
              
             sum_sdy 
              
             
                 
             
              
             as 
              
             
                 
             
              
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 n 
               
                
               
                 
                   sdy 
                   i 
                 
                 . 
               
             
           
         
       
     
         [0086]    Step 2: reading the i th  data and computation of the successive difference value of the two variables, sdx and sdy
       sdx adding sum_sdx, and saved in sum_sdx   sum_sdx adding n_sum_sdx, and saved in n_sum_sdx   sdy adding sum_sdy, and saved in sum_sdy   sum_sdy adding n_sum_sdy, and saved in n_sum_sdy       
 
         [0091]    Step 3: determining conditions
       (i) if i≦k,
           let sdx=0,
               k_sum_sdy=n_sum_sdy   
               
           (ii) if i&gt;k, then sdx=sdx[i−k]       
 
         [0096]    Step 4:
       (i) Multiplying (i−1) with sdx, and then with sdy;   (ii) Multiplying isum_sdx with sdy, and multiplying isum_sdy with sdx;   Adding sum of all values of (i) and (ii) to dge, and then saving to dge thereof.       
 
         [0100]    Step 5: Adding dge of the step 4 to wde and then saving the result to wde 
         [0101]    Step 6: Performing recursive computation for isum_sdx and isum_sdy
       (i) Multiplying (i−1) with sdx, and adding isum_sdx thereto, and then save the result to isum_sdx   (ii) Multiplying (i−1) with sdy, and adding isum_sdy thereto, and then save the result to isum_sdy       
 
         [0104]    Step 7:
       (i) Dividing k_sum_sdy by k   (ii) Dividing n_sum_sdy by n   (iii) The result of (i) subtracting the result of (ii), and then multiplying by       
 
         [0000]    
       
         
           
             
               k 
               n 
             
             ; 
           
         
       
     
         [0000]    saving the foregoing result to corrected term 
         [0108]    Step 8: dividing wde by i, adding the corrected_term thereto, and then saving to n_cxy_k; when the i+1 th data is added, go back to step 2. 
         [0109]    The foregoing steps can be written in algorithm that is capable of implementing on hardware: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 n_cxy_k:=0 
               
               
                   
                 dwe:=0 
               
               
                   
                 dge:=0 
               
               
                   
                 corrected_term:=0 
               
               
                   
                 isum_sdx:=0 
               
               
                   
                 isum_sdy:=0 
               
               
                   
                 n —  sum_sdx:=0 
               
               
                   
                 k —  sum_sdx:=0 
               
               
                   
                 n —  sum_sdy:=0 
               
               
                   
                 sum_sdx:=0 
               
               
                   
                 sum_sdy:=0 
               
               
                   
                 for i := 1 i+1 
               
               
                   
                  input X i , Y i   
               
               
                   
                  sdx[i]:=X i −X i−1   
               
               
                   
                  sdy:=Y i −Y i−1   
               
               
                   
                   sum_sdx := sum_sdx + sdx[i] 
               
               
                   
                   sum_sdy := sum_sdy + sdy 
               
               
                   
                   n —  sum_sdx := n —  sum_sdx + sum_sdx 
               
               
                   
                   n —  sum_sdy := n —  sum_sdy + sum_sdy 
               
               
                   
                   if i≦k then 
               
               
                   
                    sdx := 0, 
               
               
                   
                    k —  sum_sdy := n —  sum_sdy 
               
               
                   
                   else sdx := sdx[i−k] 
               
               
                   
                    dge := dge + isum_sdx*sdy + isum_sdy*sdx + 
               
               
                   
                  (i−1)*sdx*sdy 
               
               
                   
                    dwe := dwe + dge 
               
               
                   
                    isum_sdx := isum_sdx + (i−1)* sdx 
               
               
                   
                    isum_sdy := isum_sdy + (i−1)* sdy 
               
               
                   
                  n_cxy_k :=dwe/i + (k/n)*( n —  sum_sdx)*( k —  sum_sdy/k − 
               
               
                   
                 n —  sum_sdy/n) 
               
               
                   
                   
               
             
          
         
       
     
         [0110]    (ii) Autocovariance Function 
         [0111]    When equation (17) is of univariate, the Autocovariance Function at lag k thereof is shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       nC 
                       XX 
                     
                      
                     
                       ( 
                       k 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         1 
                         n 
                       
                        
                       
                         d 
                         
                           1 
                           × 
                           
                             n 
                              
                             
                               ( 
                               k 
                               ) 
                             
                           
                         
                         T 
                       
                        
                       
                         W 
                         
                           n 
                           × 
                           n 
                         
                       
                        
                       
                         d 
                         
                           n 
                           × 
                           1 
                         
                       
                     
                     + 
                     
                       A 
                       XX 
                     
                   
                 
               
               
                 
                   ( 
                   28 
                   ) 
                 
               
             
           
         
       
     
         [0112]    Wherein, the coefficient of W n×n  is as equation (18), and d 1×n(k)   T  as equation (19): 
         [0000]        d   1×n   T   =d   1×n(0)   T   =[sdx   1    sdx   2    . . . sdx   n ] 1×n    (29)
 
         [0113]    Further, A XX  can be shown as: 
         [0000]    
       
         
           
             
               
                 
                   ( 
                   a 
                   ) 
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     A 
                     XX 
                   
                   = 
                   
                     k 
                      
                     
                       
                         
                           x 
                           _ 
                         
                         n 
                       
                        
                       
                         ( 
                         
                           
                             
                               x 
                               _ 
                             
                             k 
                           
                           - 
                           
                             
                               x 
                               _ 
                             
                             n 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   30 
                   ) 
                 
               
             
             
               
                 
                   ( 
                   b 
                   ) 
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     A 
                     XX 
                   
                   = 
                   
                     
                       k 
                        
                       
                         ( 
                         
                           
                             x 
                             n 
                           
                           - 
                           
                             
                               1 
                               n 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   i 
                                   = 
                                   1 
                                 
                                 n 
                               
                                
                               
                                 
                                   ( 
                                   
                                     i 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                  
                                 
                                   sdx 
                                   i 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                      
                     
                       ( 
                       
                         
                           ( 
                           
                             
                               x 
                               k 
                             
                             - 
                             
                               x 
                               n 
                             
                           
                           ) 
                         
                         - 
                         
                           
                             1 
                             k 
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               k 
                             
                              
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 sdx 
                                 i 
                               
                             
                           
                         
                         + 
                         
                           
                             1 
                             n 
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               n 
                             
                              
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 sdx 
                                 i 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   31 
                   ) 
                 
               
             
           
         
       
     
         [0114]    And the computation for Autocovariance Function at lag k is to divide the result of equation (28) by n. 
         [0115]    There are three other computation methods for Cross-covariance function; the three methods are described below respectively.
       1. computation of by CSP, as shown below:       
 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       nC 
                       XY 
                     
                      
                     
                       ( 
                       k 
                       ) 
                     
                   
                   = 
                   
                     
                       CSP 
                       n 
                     
                     - 
                     
                       
                         
                           
                             [ 
                             
                               
                                 ( 
                                 
                                   
                                     x 
                                     
                                       k 
                                       + 
                                       1 
                                     
                                   
                                   - 
                                   
                                     x 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     
                                       k 
                                       + 
                                       2 
                                     
                                   
                                   - 
                                   
                                     x 
                                     2 
                                   
                                 
                                 ) 
                               
                                
                               
                                   
                               
                                
                               … 
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     n 
                                   
                                   - 
                                   
                                     x 
                                     
                                       n 
                                       - 
                                       k 
                                     
                                   
                                 
                                 ) 
                               
                             
                             ] 
                           
                           
                             1 
                             × 
                             
                               ( 
                               
                                 n 
                                 - 
                                 k 
                               
                               ) 
                             
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       
                                         k 
                                         + 
                                         1 
                                       
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       
                                         k 
                                         + 
                                         2 
                                       
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 ⋮ 
                               
                             
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       n 
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                       
                         
                           ( 
                           
                             n 
                             - 
                             k 
                           
                           ) 
                         
                         × 
                         1 
                       
                     
                     - 
                     
                       
                         
                           
                             [ 
                             
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                                
                               
                                   
                               
                                
                               … 
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     k 
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             ] 
                           
                           
                             1 
                             × 
                             k 
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       1 
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 ⋮ 
                               
                             
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       k 
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                       
                         k 
                         × 
                         1 
                       
                     
                   
                 
               
               
                 
                   ( 
                   32 
                   ) 
                 
               
             
           
         
       
     
         [0117]    Wherein, equation (32) is using CSP and k th  order difference for computation thereof. 
         [0118]    2. computation of by successive difference vector of (n−1) elements, shown as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       nC 
                       XY 
                     
                      
                     
                       ( 
                       k 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         
                           
                             [ 
                             
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     2 
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                                
                               
                                   
                               
                                
                               … 
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     
                                       n 
                                       - 
                                       k 
                                     
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             ] 
                           
                           
                             1 
                             × 
                             
                               ( 
                               
                                 n 
                                 - 
                                 k 
                               
                               ) 
                             
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       1 
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       2 
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 ⋮ 
                               
                             
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       
                                         n 
                                         - 
                                         k 
                                       
                                     
                                     - 
                                     
                                       
                                         y 
                                         _ 
                                       
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                       
                         
                           ( 
                           
                             n 
                             - 
                             k 
                           
                           ) 
                         
                         × 
                         1 
                       
                     
                     + 
                     
                       
                         
                           
                             [ 
                             
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     2 
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                                
                               
                                   
                               
                                
                               … 
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     
                                       n 
                                       - 
                                       k 
                                     
                                   
                                   - 
                                   
                                     
                                       x 
                                       _ 
                                     
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             ] 
                           
                           
                             1 
                             × 
                             
                               ( 
                               
                                 n 
                                 - 
                                 k 
                               
                               ) 
                             
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       
                                         k 
                                         + 
                                         1 
                                       
                                     
                                     - 
                                     
                                       y 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       
                                         k 
                                         + 
                                         2 
                                       
                                     
                                     - 
                                     
                                       y 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 
                                   
                                     
                                       ⋮ 
                                     
                                   
                                   
                                     
                                       
                                         ( 
                                         
                                           
                                             y 
                                             n 
                                           
                                           - 
                                           
                                             y 
                                             
                                               n 
                                               + 
                                               k 
                                             
                                           
                                         
                                         ) 
                                       
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                       
                         
                           ( 
                           
                             n 
                             - 
                             k 
                           
                           ) 
                         
                         × 
                         1 
                       
                     
                   
                 
               
               
                 
                   ( 
                   33 
                   ) 
                 
               
             
           
         
       
       
         
           
             3. subtracting h th  order difference from (h−1) th  order difference; using the foregoing result instead of the k th  order successive difference of equation (17). That is, to write the successive difference as: 
           
         
       
     
         [0000]        sdx   i =( x   i   −x   h )−( x   i−2   −x   h ),  h= 1, 2, . . . ,  n.  
       And rewrite equation (19) as:       
 
         [0000]    
       
         
           
             
               
                 
                   
                     d 
                     
                       1 
                       × 
                       
                         n 
                          
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                     T 
                   
                   = 
                   
                     
                       
                         
                           [ 
                           
                             0 
                              
                             
                                 
                             
                              
                             … 
                              
                             
                                 
                             
                              
                             0 
                           
                         
                         
                            
                           
                             k 
                              
                             
                                 
                             
                              
                             items 
                           
                         
                       
                        
                       
                           
                       
                        
                       
                         sdx 
                         1 
                       
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           
                             x 
                             2 
                           
                           - 
                           
                             x 
                             h 
                           
                         
                         ) 
                       
                     
                     - 
                     
                       
                         ( 
                         
                           
                             x 
                             1 
                           
                           - 
                           
                             x 
                             h 
                           
                         
                         ) 
                       
                        
                       
                           
                       
                        
                       … 
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           
                             x 
                             n 
                           
                           - 
                           
                             x 
                             h 
                           
                         
                         ) 
                       
                     
                     - 
                     
                       ( 
                       
                         
                           x 
                           
                             n 
                             - 
                             1 
                           
                         
                         - 
                         
                           x 
                           h 
                         
                       
                       ) 
                     
                   
                 
                 ] 
               
               
                 1 
                 × 
                 n 
               
             
             , 
           
         
       
       
         
           
             In the same manner, the i th  element of e 1×n   T  can be written as: sdy i =(y i −y h )−(y i−2 −y h ), h=1, 2, . . . , n, 
             That is, e 1×n   T  can be shown as: 
           
         
       
     
         [0000]        e   1×n   T   =[sdy   i ( y   2   −y   h )−( y   1   −y   h ) . . . ( y   n   −y   h )−( y   n−1   −y   h )] 1×n .
 
         [0123]    When the foregoing three methods are of univariate, computation of Autocovariance function can be applied. The method disclosed by the present embodiment uses the successive difference as a basis in order to perform recursion and update the CCF computation method. ACF is the special case of univariate thereof; for computation of ACF, replace the bivariate of the foregoing method with univariate. 
         [0124]    Further, the computation accuracy of the present embodiment uses the certified value of the univariate summary statistical dataset of Statistical Reference Datasets (StRD) of National Institutes of Standards and Technology (NIST). Please refer to the website: http://www.itl.nist.gov/div898/strd/ (2011/01/08) for further details. 
         [0125]    According to Altman et al. (2004), the computation accuracy refers to the dissimilary between the exact value and the result, and is represented by distance therebetween. For the dissimilary result, Altman et al. (2004) used 10 as the lowest log relative error (LRE); wherein the LRE refers to the log of 10 of the absolute value of exact value minus the result and then divided by the exact value. The LRE value represents the significant digits length of decimal data computation accuracy. Altman et al. (2004) defines LRE as: 
         [0000]    
       
         
           
             
               
                 
                   
                     L 
                      
                     
                         
                     
                      
                     R 
                      
                     
                         
                     
                      
                     E 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 - 
                                 
                                   log 
                                   10 
                                 
                               
                                
                               
                                  
                                 
                                   
                                     exact 
                                     - 
                                     output 
                                   
                                   exact 
                                 
                                  
                               
                             
                             , 
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               exact 
                             
                             ≠ 
                             0 
                           
                         
                       
                       
                         
                           
                             
                               
                                 - 
                                 
                                   log 
                                   10 
                                 
                               
                                
                               
                                  
                                 
                                   output 
                                   - 
                                   exact 
                                 
                                  
                               
                             
                             , 
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               exact 
                             
                             = 
                             0 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   34 
                   ) 
                 
               
             
           
         
       
     
         [0126]    Wherein, exact refers to the exact value, and output refers to the computation result. 
         [0127]    When the computation result equals to the exact value, the LRE is marked as “exact”. In the past, many researchers use LRE value to determine the computation accuracy of data analysis software. For example, Wampler (1980) estimating computation accuracy of least squared algorithm; Simon (1985) estimating computation accuracy of linear regression procedure of MINITAB; McCullough (1998, 1999) estimating computation accuracy of SAS, SPSS, and S-PLUS; McCullough and Wilson (1999, 2002, 2005) estimating computation accuracy of EXCEL; Altman et al. (2007) discussing computation accuracy of R and S-PLUS; and Keeling and Pavur (2007) estimating computation accuracy of nine software. The present embodiment also uses LRE value for computation accuracy experiment report. 
         [0128]    Empirical Comparison Data 
         [0129]    The present embodiment discloses a new algorithm that is recursive and capable of updating Autocovariance Function and Cross-covariance function. Besides solving the problem of prior art being unable to perform updating, the algorithm thereof is further of high accuracy. In empirical comparison, the present embodiment uses the benchmark of the univariate summary statistical dataset of Statistical Reference Datasets (StRD) of National Institutes of Standards and Technology (NIST). Please refer to the website: http://www.itl.nist.gov/div898/strd/ (2011/01/08) for further details. 
         [0130]    StRD Data 
         [0131]    StRD is a benchmark datasets of the Statistical Engineering and Mathematical and Computational Sciences Divisions of National Institutes of Standards and Technology. It is used for diagnosing computation accuracy of the five statistics calculations below: (a) univariate summary statistics; (b) Analysis of Variance (ANOVA); (c) linear regression; (d) Markov chain Monte Carlo and (e) nonlinear regression. Please refer to the website: http://www.itl.nist.gov/div898/strd/ (2011/01/08) for further details. 
         [0132]    The univariate summary statistics dataset of the present embodiment is described hereinafter. 
         [0133]    Univariate summary statistics dataset is consist of nine datasets, each dataset provides exact mean, standard deviation and lag-1 autocorrelation coefficient of 15 significant digits for certification of computation accuracy. Since the primary object of the present embodiment is to compute the computation accuracy of CCF and ACF, the present embodiment converts lag-1 autocorrelation coefficient of the 9 datasets into ACF; the certified value thereof is shown in Table 1. 
         [0000]    
       
         
               
             
               
               
               
               
             
               
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Certified value of the univariate summary statistics of StRD 
               
             
          
           
               
                   
                 Name of 
                 Number of 
                   
               
               
                   
                 datasets 
                 datasets 
                 Certified value of ACF 
               
               
                   
                   
               
             
          
           
               
                   
                 PiDidits 
                 5000 
                 −0.0291891222080000 
               
               
                   
                 Lottery 
                 218 
                 −10244.1567496751 
               
               
                   
                 Lew 
                 200 
                 −23517.5956461250 
               
               
                   
                 Mavro 
                 50 
                 0.000000169273280000000 
               
               
                   
                 Michelso 
                 100 
                 0.003307662400000 
               
               
                   
                 NumAcc1 
                 3 
                 −0.333333333333333 
               
               
                   
                 NumAcc2 
                 1001 
                 −0.009980019801980 
               
               
                   
                 NumAcc3 
                 1001 
                 −0.009980019801980 
               
               
                   
                 NumAcc4 
                 1001 
                 −0.009980019801980 
               
               
                   
                   
               
             
          
         
       
     
         [0134]    Comparison of Computation Accuracy 
         [0135]    The present embodiment is performed under the Visual Studio .NET2003 of Windows XP. Further, it is using C++ under hardware resource of Intel Pentium M processor 1.73 GHz and 2G RAM. Wherein, the performed computation program is shown in Appendix 1. 
         [0136]    In the comparison of computation accuracy, the present embodiment uses the LRE value in Altman et al. (2004). The LRE value represents the significant digits length of data computation accuracy. The present embodiment performs the program computation in Appendix 1 and converts the result into LRE value, and then round-off the 10 digit to 1 decimal place. If the output of 15 significant digits is the same as the certified value provided by StRD, which means the result is of the accuracy of 15 significant digits, it is marked as “Exact”. In the comparison of computation accuracy, the comparison of the present embodiment and the commonly used data analyzing software: PROC ARIMA of SAS ver. 9.0 is described in Table 2. 
         [0000]    
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 LRE value comparison table of univariate summary 
               
               
                 statistics datasets and ACF of SAS ver. 9.0 
               
             
          
           
               
                   
                 Name of 
                   
                   
                 This invention 
               
               
                   
                 data set 
                 SAS 
                 This invention 
                 (round) 
               
               
                   
                   
               
               
                   
                 PiDidits 
                 Exact 
                 Exact 
                 Exact 
               
               
                   
                 Lottery 
                 Exact 
                 Exact 
                 Exact 
               
               
                   
                 Lew 
                 Exact 
                 Exact 
                 Exact 
               
               
                   
                 Mavro 
                 12.8 
                 12.8 
                 14.2 
               
               
                   
                 Michelso 
                 13.2 
                 13.6 
                 13.6 
               
               
                   
                 NumAcc1 
                 Not 
                 Exact 
                 Exact 
               
               
                   
                   
                 provided 
               
               
                   
                 NumAcc2 
                 7.7 
                 7.7 
                 7.7 
               
               
                   
                 NumAcc3 
                 7.7 
                 7.7 
                 7.7 
               
               
                   
                 NumAcc4 
                 7.5 
                 7.5 
                 7.7 
               
               
                   
                   
               
             
          
         
       
     
         [0137]    Besides the computation method, the present embodiment further discloses a method comprising round-off function provided by software for increasing computation accuracy; which is also based on successive difference. In successive difference value, from estimating digits, used round-off method to reduce the error in computing the mean and Cross-covariance function. The C++ example of the present embodiment is: 
         [0000]        sdx =Math::Round ( x−x   — 1,4). 
         [0138]    The using of round-off function in steps in successive difference is also capable of increasing computation accuracy for the computation result. The column 4 of the Table 2 shows the computation result of successive difference computation using round-off function. 
         [0139]    As shown in the column 2 and 3 of Table 2, the computation method of the present embodiment is of better performance on LRE value computation of the Michelso dataset than that of the SAS ver. 9.0. It requires at least 6 data for SAS ver. 9.0 to run and therefore SAS ver. 9.0 is not capable of running NumAcc1 dataset; however, the computation method of the present embodiment is not only without the limit, but also capable of obtaining exact result. Besides, when using round-off function in successive difference computation, it is further capable of increasing LRE value of Mavro and NumAcc4 datasets more than that of SAS ver. 9.0. 
         [0000]    
       
         
               
             
               
             
           
               
                 APPENDIX 1 
               
               
                   
               
               
                 Program of the present embodiment 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 #include “stdafx.h” 
               
               
                 #using &lt;mscorlib.dll&gt; 
               
               
                 using namespace System; 
               
               
                 #include &lt;stdio.h&gt; 
               
               
                 #include &lt;float.h&gt; 
               
               
                 #include &lt;Math.h&gt; 
               
               
                 #define n 1000 
               
               
                 #define k 1 
               
               
                 /****************************************************** 
               
               
                 ****************************/ 
               
               
                 /**************  The program is performing 
               
               
                 autocorrelation function computation 
               
               
                 **************************/ 
               
               
                 /**************  Date: 2010/05/01 
               
               
                 **************************/ 
               
               
                 /**************  Authors: The Inventors 
               
               
                 **************************/ 
               
               
                 /****************************************************** 
               
               
                 ****************************/ 
               
               
                 int 
               
               
                 main(void) 
               
               
                  { 
               
               
                   FILE *in_file; 
               
               
                   FILE *out_file; 
               
               
                   double sdx=0.0, sum_sdx=0.0, nsum_sdx=0.0, 
               
               
                 dwd = 0.0, dgd = 0.0, css = 0.0; 
               
               
                   double n_cxx_k=0.0, dwd_k=0.0, dgd_k= 
               
               
                 0.0, n_w_sum_sdx = 0.0, k_w_sum_sdy = 0.0, 
               
               
                       lagk_sdx = 0.0, isum_sdx = 0.0, utocov_k = 
               
               
                 0.0, autocorr_k = 0.0, nsum_sdy = 0.0, n_w_sum_sdy=0.0; 
               
               
                   double x, x_1=0.0, lag[k], a=0.0, b=0.0; 
               
               
                   int i, index; 
               
               
                 /*..................................................... 
               
               
                 ..............................................*/ 
               
               
                     in_file = fopen (“numacc4.txt”,“r”); 
               
               
                    out_file = fopen (“out_auto_numacc4_NR.txt”,“w”); 
               
               
                    for (i=0; i&lt;= n; i++) 
               
               
                     { 
               
               
                     fscanf(in_file, “%lf”, &amp;x); 
               
               
                 /* input data    */ 
               
               
                       index = i%k;          /* 
               
               
                  compute for the remainder of the index i and k*/ 
               
               
                        sdx = x − x_1;       /* 
               
               
                 compute the input successive difference */ 
               
               
                      nsum_sdx = nsum_sdx + sdx; /* compute for the 
               
               
                  total weighted successive difference of n data */ 
               
               
                      n_w_sum_sdx = n_w_sum_sdx + nsum_sdx; 
               
               
                         if (i&gt;0) 
               
               
                         { 
               
               
                          nsum_sdy = nsum_sdy + sdx; /* compute 
               
               
                 for the total weighted successive difference of n data*/ 
               
               
                          n_w_sum_sdy = n_w_sum_sdy + nsum_sdy; 
               
               
                 /* compute for the mean of n data */ 
               
               
                         } 
               
               
                       if (i &lt; k) 
               
               
                          { 
               
               
                            lagk_sdx = 0;  /* let the 
               
               
                 successive difference of lag-k be 0 */ 
               
               
                         k_w_sum_sdy = n_w_sum_sdy; 
               
               
                          } 
               
               
                        else 
               
               
                          { 
               
               
                         lagk_sdx = lag[index];  /* 
               
               
                 define the value of lag k    */ 
               
               
                         } 
               
               
                       lag[index] = sdx;    /* put the 
               
               
                 successive difference on a temporary array */ 
               
               
                 /****************************************************** 
               
               
                 *******************************/ 
               
               
                 /*****    in the next two lines, compute for the 
               
               
                 dwd_k of lagk      *******/ 
               
               
                        dgd_k = dgd_k + isum_sdx*sdx + 
               
               
                 sum_sdx*lagk_sdx + i*sdx*lagk_sdx; 
               
               
                       dwd_k = dwd_k + dgd_k; 
               
               
                 /****************************************************** 
               
               
                 ****************************/ 
               
               
                 /*****    do a n times iterative computation of CSS 
               
               
                 in the next two lines     ******/ 
               
               
                         dgd = dgd + 2*sum_sdx*sdx + i*sdx*sdx; 
               
               
                          dwd = dwd + dgd; 
               
               
                 /****************************************************** 
               
               
                 *************************/ 
               
               
                 /*****    in the next two lines, do a separate 
               
               
                 iterative computationfor dgd_l and dgd    ******/ 
               
               
                        isum_sdx = isum_sdx + i*lagk_sdx; 
               
               
                         sum_sdx = sum_sdx + i*sdx; 
               
               
                 /****************************************************** 
               
               
                 **************************/ 
               
               
                 /****************  compute for the n times of lag-k 
               
               
                 autocovariance function, the compute for n_cxx_k 
               
               
                 **********/ 
               
               
                          a = dwd_k/(i+1); 
               
               
                         b = k*(k_w_sum_sdy/k − 
               
               
                 n_w_sum_sdy/(i+1))*n_w_sum_sdx/(i+1); 
               
               
                     n_cxx_k = dwd_k/(i+1) + k*(k_w_sum_sdy/k 
               
               
                 − n_w_sum_sdy/(i+1))*n_w_sum_sdx/(i+1); 
               
               
                        autocov_k = n_cxx_k/(i+1); 
               
               
                         css = dwd/(i+1);  /** compute 
               
               
                 for the autocovariance function  ***/ 
               
               
                 fprintf (out_file, “i=%d dwd_k=%.15le n_cxx_k=%.15e 
               
               
                 css=%.15e a=%.15e b=%.15e autocov_k=%.15e \n”, i, dwd_k, 
               
               
                 n_cxx_k, css, a, b, autocov_k); 
               
               
                 /****************************************************** 
               
               
                 ***********************/ 
               
               
                 /***************  compute for the lag-k autocorrelation 
               
               
                 coefficient    *****/ 
               
               
                        autocorr_k =autocov_k / css; 
               
               
                 /****************************************************** 
               
               
                 *******************/ 
               
               
                     x_1=x;      /** compute for 
               
               
                 the iterated variable of n data **/ 
               
               
                      } 
               
               
                         system(“PAUSE”); 
               
               
                 }