Abstract:
The present invention, generally speaking, accelerates convergence of a fast RLS adaptation algorithm by, following processing of a burst of data, performing postprocessing to remove the effects of prewindowing, fictitious data initialization, or both. This postprocessing is part of a burst mode adaptation strategy in which data (signals) get processed in chunks (bursts). Such a burst mode processing approach is applicable whenever the continuous adaptation of the filter is not possible (algorithmic complexity too high to run in real time) or not required (optimal filter setting varies only slowly with time). Postprocessing consists of a series of “downdating” operations (as opposed to updating) that in effect advance the beginning point of the data window. The beginning point is advanced beyond fictitious data used for initialization and beyond a prewindowing region. In other variations, downdating is applied to data within a prewindowing region only. The forgetting factor of conventional algorithms can be eliminated entirely. Performance equivalent to that of GWC RLS algorithms is achieved at substantially lower computational cost. In particular, a postprocessing Fast Kalman Algorithm in effect transforms an initialized/prewindowed least squares estimate into a Covariance Window least squares estimate. Various further refinements are possible. Initialization may be cancelled completely or only partially. For example, in order to reduce the dynamic range of algorithmic quantities, it may be advantageous to, in a subsequent initialization, add an increment to a forward error energy quantity calculated during a previous burst. Postprocessing may then be performed to cancel only the added increment. Also, to reduce the usual large startup error transient, the desired response data can be modified in a way that dampens the error transient. The modified desired response data are saved for use in later postprocessing. Furthermore, to allow for more rapid adaptation without the use of an exponential forgetting factor, a weighting factor less than one may be applied to the forward error energy quantity during initialization from one burst to the next. This allows for the most efficient use of data but limited adaptation within a burst, but more rapid adaptation from one burst to the next.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to adaptive filters and more particularly to fast recursive least squares (fast RLS) adaptive filters. 
     2. State of the Art 
     Adaptive filters find widespread use in communications. A known class of adaptive filter is the fast RLS adaptive filter. This class of adaptive filter, or more accurately, this class of filter adaptation algorithm, is recognized for its properties of fast convergence and reduced computational complexity compared to earlier RLS algorithms (although the computational complexity is still very considerable). 
     In one aspect, the attractiveness of RLS algorithms lies in the ability to compute updated filter settings using a new data input together with the old filter settings. This “recursion” is performed differently in different variations of the algorithm. In one variation, designated by the term “growing window covariance” (GWC), the adaptation algorithm takes into account a growing window of data that begins at time zero, for example, and is incrementally extended at each sample time until the adaptation has concluded. In another variation, designated by the term “sliding window covariance” (SWC), the adaptation algorithm takes into account a window of data that at a particular point in the algorithm becomes fixed in size. In the SWC algorithm, once the size of the data window has been fixed, as updates are computed, they incorporate knowledge from a new sample and “disincorporate” knowledge from an oldest sample. 
     In general, various different methods of windowing the input data of an adaptive filter are known. In order to achieve a favorable mathematical structure for computational efficiency, the most common implementations of the fast RLS algorithm use prewindowing. The prewindowing method makes the assumption that the input data prior to time zero are zero. This assumption results in a “prewindowing transient” during which the error quantity is unusually large. In other words, prewindowing perturbs the algorithm, delaying convergence. The GWC version of RLS does not require prewindowing. Without prewindowing, however, the RLS algorithm becomes computationally more burdensome and more implementation-sensitive. 
     Initialization also perturbs the algorithm. As described in J. M. Cioffi and T. Kailath, “Fast, recursive least squares transversal filters for adaptive filtering”, IEEE Trans. on ASSP, ASSP-32(2):304-337, April 1984, more rapid convergence may be obtained by initializing the input data matrix with a sparse “fictitious” data submatrix located within a region corresponding to negative time. A sample covariance matrix is then initialized so as to be in agreement with the fictitious data. A desired response data vector (or matrix) may also be initialized with some fictitious data to reflect prior information on the filter settings. These initialization techniques may be referred to as “soft constraint initialization”. As compared to initializing the same quantities with zeros, the foregoing technique may significantly reduce the amount of perturbation experienced by the algorithm if the prior information is correct. Substantial perturbation remains, however, if the assumed prior information is incorrect, as is usually the case. 
     In order to overcome the deleterious effects of prewindowing and initialization, an exponential “forgetting factor” is commonly used. As more and more data is processed, the influence of old data becomes exponentially more attenuated. Besides forgetting “incorrect” data, however, the same forgetting also gets applied to actual data, with the result that the total amount of data available is used less than efficiently. If this forgetting factor could be eliminated entirely, the result would be better estimation performance and fewer numerical problems. 
     Further background information concerning RLS adaptation algorithms may be found in the following references, incorporated herein by reference: 
     T. Kailath, Lectures on Wiener and Kalman Filtering, Springer-Verlag, Wien—New York, 1981. 
     S. Haykin, Adaptive Filter Theory, Prentice-Hall, Englewood Cliffs, N.J., 1995, third edition. 
     B. Widrow and S. D. Stearns, Adaptive Signal Processing, Prentice-Hall, Englewood Cliffs, N.J., 1985. 
     B. Widrow and E. Walach, “On the Statistical Efficiency of the LMS Algorithm with Nonstationary Inputs”, IEEE Trans. on Information Theory, IT-30(2):211-221, March 1984, Special Issue on Adaptive Filtering. 
     D. T. M. Slock, “On the Convergence Behavior of the LMS and the Normalized LMS Algorithms”, IEEE Trans. on Signal Processing, 41(9):2811-2825, September 1993. 
     S. M. Kay, Fundamentals of Statistical Signal Processing: Estimation Theory, Prentice Hall 1993. 
     E. Eleftheriou and D. Falconer, “Tracking Properties and Steady-State Performance of RLS Adaptive Filter Algorithms”, IEEE Trans. ASSP, ASSP-34(5): 1097-1110, October 1986. 
     D. D. Falconer and L. Ljung, “Application of Fast Kalman Estimation to Adaptive Equalization”, IEEE Trans. Com., COM-26(10):1439-1446, October 1978. 
     J. M. Cioffi and T. Kailath, “Fast, recursive least squares transversal filters for adaptive filtering”, IEEE Trans. on ASSP, ASSP-32(2):304-337, April 1984. 
     D. T. M. Slock and T. Kailath, “Numerically Stable Fast Transversal Filters for Recursive Least Squares Adaptive Filtering”, IEEE Trans. Signal Proc., ASSP-39(1):92-114, January 1991. 
     D. T. M. Slock, “Backward Consistency Concept and Round-Off Error Propagation Dynamics in Recursive Least Squares Algorithms”, Optical Engineering, 31(6): 1153-1169, June 1992. 
     J. M. Cioffi and T. Kailath, “Windowed Fast Transversal Filters Adaptive Algorithms with Normalization”, IEEE Trans. on ASSP, ASSP-33(3):607-625, June 1985. 
     J. M. Cioffi, “The Block-Processing FTF Adaptive Algorithm”, IEEE Trans. on ASSP, ASSP 34(1):77-90, February 1986. 
     SUMMARY OF THE INVENTION 
     The present invention, generally speaking, accelerates convergence of a fast RLS adaptation algorithm by, following processing of a burst of data, performing postprocessing to remove the effects of prewindowing, fictitious data initialization, or both. This postprocessing is part of a burst mode adaptation strategy in which data (signals) get processed in chunks (bursts). Such a burst mode processing approach is applicable whenever the continuous adaptation of the filter is not possible (algorithmic complexity too high to run in real time) or not required (optimal filter setting varies only slowly with time). Postprocessing consists of a series of “downdating” operations (as opposed to updating) that in effect advance the beginning point of the data window. The beginning point is advanced beyond fictitious data used for initialization and beyond a prewindowing region. In other variations, downdating is applied to data within a prewindowing region only. The forgetting factor of conventional algorithms can be eliminated entirely. Performance equivalent to that of GWC RLS algorithms is achieved at substantially lower computational cost. In particular, a postprocessing Fast Kalman Algorithm in effect transforms an initialized/prewindowed least squares estimate into a Covariance Window least squares estimate. Various further refinements are possible. Initialization may be cancelled completely or only partially. For example, in order to reduce the dynamic range of algorithmic quantities, it may be advantageous to, in a subsequent initialization, add an increment to a forward error energy quantity calculated during a previous burst. Postprocessing may then be performed to cancel only the added increment. Also, to reduce the usual large startup error transient, the desired response data can be modified in a way that dampens the error transient. The modified desired response data are saved for use in later postprocessing. Furthermore, to allow for more rapid adaptation without the use of an exponential forgetting factor, a weighting factor less than one may be applied to the forward error energy quantity during initialization from one burst to the next. This allows for the most efficient use of data but limited adaptation within a burst, but more rapid adaptation from one burst to the next. 
    
    
     BRIEF DESCRIPTION OF THE DRAWING 
     The present invention may be further understood from the following description in conjunction with the appended drawing. In the drawing: 
     FIG. 1 is a block diagram of an equalizer with which the present invention may be used; and 
     FIG. 2 is a diagram illustrating initialization of the adaptive filters of the equalizer of FIG.  1 . 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     In the following description, details are described of an advantageous postprocessing algorithm that may be used to remove the effects of prewindowing and/or initialization and hence accelerate convergence of a fast RLS adaptation algorithm. For purposes of illustration only, the example of a fractionally-spaced (FS) decision feedback equalizer (DFE) is considered. Such an FS DFE finds particular application in xDSL modems; however, the technique described is broadly applicable to filter adaptation in all fields of application. In a concrete embodiment, an example is given of a fast RLS algorithm that can be used in conjunction with the postprocessing procedure. Many of the algorithmic details of the fast RLS algorithm and the postprocessing procedure are themselves familiar from the published literature. Different internal variables and recursive relations can be used to implement the same strategies. To explain the initialization removal operation, the interpretation of initialization as the result of processing fictitious data is explained in detail. 
     Fractionally-Spaced Decision Feedback Equalization 
     Consider the channel equalization application depicted in FIG.  1 . Bits get mapped into (scalar valued) symbols a k  belonging to some finite alphabet (e.g. {−1,+1}), which then modulate (linearly) a certain pulse shape. The resulting signal gets transmitted over a channel that is assumed to be linear and time-invariant and hence can be represented by a certain channel impulse response. Noise and interference get added during the transmission. At the receiver, the signal gets lowpass filtered and sampled. Assume the sampling rate to be twice the symbol rate. Then the even and odd received samples can be considered as two symbol rate sequences, which together constitute one vector valued symbol rate sequence:          y   k     =     [           y        (       t   0     +   kT     )                 y        (       t   0     +       (     k   +     1   2       )        T       )             ]                            
     where T is the symbol period and the time offset to determines the phase of the sampling operation. The whole system taking the symbols a k  as input and producing the 2×1 vector samples y k  as output is a discrete-time system operating at the symbol rate. The 2×1 transfer function H(z) indicated in FIG. 1 represents the even and odd samples of the convolution of a transmission filter (pulse shape), channel transfer function and receiver filter. Consider now a Decision-Feedback Equalizer (DFE) with feedforward filter F(z) (1×2) and feedback filter 1−B(z). In FIG. 1, F(z) is assumed to be potentially non-causal and hence leads the DFE to produce undelayed symbol estimates â k . However, in practice and in the equations below, the filter F(z) is assumed to be causal so that the DFE produces symbol estimates â k−d  with a certain delay d. Then the DFE output becomes:            a   ^       k   -   d       =           (     1   -     B        (   z   )         )          a     k   -   d         +       F        (   z   )            y   k         =       -       ∑     i   =   1       n   B                         b        (   i   )            a     k   -   d   -   i             +       ∑     i   =   0         n   F     -   1                         f        (   i   )              y     k   -   i       .                                    
     where the symbol estimate is delayed with respect to the received signal. An equalization error ã k−d  can be formed by subtracting the equalizer output â k−d  (symbol estimate) from the true symbol a k−d . The equalization error can be written as:                  a   ~       k   -   d       =                  a     k   -   d       -       a   ^       k   -   d                     =                    B        (   z   )            a     k   -   d         -       F        (   z   )            y   k                     =                    ∑     i   =   0       n   B                         b        (   i   )            a     k   -   d   -   i           -       ∑     i   =   0       n     F   -   1                           f        (   i   )            y     k   -   i                           =                  B                   A     k   -   d         -     F                   Y   k           ,                  b        (   0   )       =   1                                  
     where the b(i) are scalars and the f(i) are 1×2 vectors. 
     The true symbols a k−d  are available during the so-called training period of the equalizer. After the training period, when processing actual data, the true symbol a k−d  can be replaced by a decision â′ k−d  based on the equalizer output â k−d . The decision is obtained (in the absence of channel coding) by passing the equalizer output through a slicer, as indicated in FIG.  1 . The slicer takes the element from the symbol constellation that is closest to the equalizer output. Unless a decision error occurs, â′ k−d =a k−d . The equalization error is used by adaptive filtering algorithms to adapt the equalizer filter settings. The adaptation of the equalizer with actual data through the use of â′ k−d  is called the decision-directed mode. Define the following: 
     
       
         
           d 
           k 
           =a 
           k−d 
           , S 
           k 
           =a 
           k−d−1 
         
       
     
     where d k  denotes the desired-response signal for the equalizer and s k  is the input signal to the feedback filter. Note that s k =d k−1 : the input to the feedback filter consists of past symbols/decisions. 
     With the T/2 feedforward filter spacing considered here, there results, in fast RLS terminology, 3 channels (symbol rate filter input streams): past symbols (s k ) and even and odd received samples (the two components of y k ). The filtering (equalization) error can be rewritten as:            ε   k          (   W   )       =         d   k     -     W                   U   k         =       d   k     -       ∑     i   =   1     N                       w        (   i   )              U   k          (   i   )                                      
     where W=[−b(1) . . . −b(n B ) f(0) . . . f(n F −1)], U k =[s k  . . . s k−n     B     +1  Y k   T  . . . Y k−n     F     +1   T ] T  and super-script T  denotes matrix transposition. The input data vector U k  is a column vector, whereas filter coefficient vectors such as W will be denoted by row vectors. This allows filter outputs to be written as W U k  without tranposes. N=n B +2n F =N fb +N ff  is the total filter order (total number of filter coefficients). 
     Prewindowed Least-squares Data Structure 
     To understand the origins of fast RLS algorithms, it is essential to pay particular attention to the structure of the data in the least-squares criterion used to determine the filter settings. The structure of the data for the prewindowed least-squares criterion applicable to the DFE filter coefficients is shown in FIG.  2 . The top line indicates (discrete) time, progressing to the left, with variable time index i. Assume that the LS problem is formulated with the data available at time i=k. In the prewindowing formulation, it is assumed that the signals are zero before time i=0. So the signals are assumed to start at time i=0. For the equalizer application, if the filter adaptation is to start as soon as training data are available, then the time origin should be chosen such that s 0 =a 31 d−1  is the first available training sequence symbol. 
     The second line in FIG. 2 contains the desired-response signal in the row vector {overscore (d)} k . The structure of {overscore (d)} k  reflects the prewindowing. Also indicated in {overscore (d)} k  is an exponential forgetting/weighting factor λε(0, 1]. Actually, the data are weighted by {square root over (λ)} so that the squared errors in the least-squares criterion to be considered below will be weighted by ({square root over (λ)}) 2 =λ. The exponential weighting reduces the influence of past data exponentially fast so that the LS filter solution will be reflecting the characteristics of the most recent data, in case these characteristics vary with time. A corresponding time constant        1     1   -   λ                            
     is implied by the exponential weighting. 
     The matrix {overscore (U)} N+3,k  in FIG. 2 is the extended input data matrix. {overscore (U)} N+3,k  is a structured matrix. For the DFE problem at hand, it consists of two structured submatrices. The top submatrix is filled with the signal s i  and has a Hankel structure (if λ=1): elements along any anti-diagonal are constant. This Hankel structure is perturbed by the exponential weighting, which weighs consecutive columns more and more. The bottom submatrix of {overscore (U)} N+3,k  is block Hankel (if λ=1) and is filled with the 2×1 vector signal (blocks) y i . The data matrix {overscore (U)} N+3,k  is called extended because it contains n B +1 rows of signal s i  and n F +1 (block) rows of signal y i  so it has in fact n B +1+2(n F +1)=N+3 rows (one extra row per input channel). The extended data matrix will be required for the fast RLS algorithms. If the bottom row with signal {overscore (s)} k−n     B    and the bottom (block) row with signal {overscore (y)} k−n     F    are removed from {overscore (U)} N+3,k , then there results the regular input data matrix {overscore (U)} N,k ={overscore (U)} k  with N rows. The columns of the matrix {overscore (U)} k  are the weighted input data vectors          λ       k   -   i     2            U   i                            
     which upon multiplication with the filter coefficient vector W gives the weighted DFE output          λ       k   -   i     2            WU   i                            
     at time i. 
     The n that is indicated in FIG. 2 denotes n=max{n B , n F } (though the figure is drawn assuming that n B =n F =n). The extended data vectors U N+3,i  with time in the range i ε[0,n−1] contain some samples of signal s i  and/or y i  situated at negative time. Those samples are not available if sampling occurs beginning from time i=0 onwards. In the prewindowing assumption, those samples are set equal to zero. This means that the data vectors U N+3,i  contain zeros over the indicated time range, which can be called the prewindowing transient period. Hence, within this period of n discrete-time instants, the extended data vectors U N+3,i  do not fully contain genuine data. 
     In order to make an RLS algorithm start from well-defined quantities, some initialization needs to be provided. Such an initialization can be provided by introducing fictitious data at negative time as long as the prewindowing (data is zero before the fictitious data) and the particular structure of the (extended) input data matrix remain preserved. The structure of the fictitious data should preferably be such that the filter coefficients and all other quantities to be initialized at time k=−1 can be determined without computation. The simplest structure for such fictitious input data consists of one non-zero sample per input channel, positioned in such a way that there is no overlap between channels in the extended data matrix. The only non-zero input samples at negative time i&lt;0 are:            s       -     n   B       -   1       =       μ   B         ,       y       -     n   B       -     n   F     -   2       =         μ   F            [         0           1         ]         ,                  y       -     n   B       -     2        n   F       -   3       =             μ   F       λ       n   F     +   1                [         1           0         ]       .                              
     This results in the following diagonal initial sample covariance matrix: 
     
       
           R   −1   ={overscore (U)}   −1   {overscore (U)}   −1   T =blockdiag{μ B Λ n     B   ,λ n     B     +1 μ F Λ n     F     {circumflex over (x)}I   2 },Λ n =diag{λ n , . . . ,λ} 
       
     
     where {circumflex over (x)} denotes the Kronecker product (A{circumflex over (x)}B=[A ij B]). FIG. 2 is simplified by defining          μ   FF     1   2       =       λ     -         n   F     +   1     2                μ   F     1   2       .                              
     Also, whenever        λ       k   -   i     2                            
     with variable i appears, the value for i is actually the value indicated in the top row of the figure, in the same column. 
     If the DFE filter coefficients are to be initialized to a nonzero value, W −1 ≠0, then the portion of the desired-response signal at negative time should reflect this: {overscore (d)} −1 =W −1 {overscore (U)} −1 . 
     The Least-Squares Filtering Problem 
     An optimal (Wiener filtering) design of the filter W corresponds to minimizing the expected value (i.e., mean value or statistical average) of the squared filtering error (Minimum Mean Squared Error (MMSE) design):          W   o     =     arg                     min   W          E                       ε   k   2          (   W   )       .                                  
     The optimization of the MSE criterion however requires knowledge of the joint second-order statistics of the desired-response and input signals. In practice, these statistics are usually not available. However, (portions of) the desired-response and input signals are usually available. So in practice the statistical averaging operation in the MSE criterion must be dropped or replaced by another averaging operation. 
     In the Least-Mean-Square (LMS) algorithm, the instantaneous squared error is taken as the criterion, and a simple steepest-descent optimization strategy with one iteration per sample period is applied. The LMS algorithm uses data quite inefficiently and hence requires quite a bit of data to converge to (approximately) the optimal filter setting W 0 . 
     In the Least-Squares (LS) approach, the statistical averaging is replaced by a temporal averaging. So in the LS approach, the filter settings are determined by minimizing the temporally averaged squared filtering error or, equivalently, the sum of squared errors. If signals have been accumulated from time i=0 to time i=k, then genuine data vectors are available in the time window [n−1, k] (also called covariance window), and hence the filter coefficients W can be determined from the LS cost function:          W   k     =       arg                     min   W            ∑     i   =     n   -   1       k                       ε   i   2          (   W   )             =     arg                     min   W            ∑     i   =     n   -   1       k                         (       d   i     -     WU   i       )     2     .                                    
     Note that for the actual data vectors U i , the prewindowing transient period lasts one instant less than for the extended data vectors U n+3,i . 
     The LS criterion is often solved recursively, meaning that as a new signal sample becomes available, the new filter solution is determined from the old one instead of solving the new LS criterion all over again. The resulting algorithm is called the Recursive LS (RLS) algorithm. In the context of the RLS algorithm, it is important to note that the solution of the LS criterion only becomes well-defined when the number of terms in the sum of squared errors becomes at least equal to the number of coefficients N to be determined. To make the criterion well-defined even with only one or even zero terms in the sum of squared errors, an initialization term gets added to the sum of squared errors to yield the augmented LS criterion          W   k     =     arg                     min   W          (         ∑     i   =     n   -   1       k                       ε   i   2          (   W   )         +       (     W   -     W     -   1         )          (         R     -   1            (     W   -     W     -   1         )       T     )                                      
     where R −1  is some positive definite symmetric matrix. Note that with zero terms in the sum of squares, the solution of this criterion yields W=W −1 . The augmented LS cost function has an optimality property from the point of view of estimation theory, applied to the estimation of the filter coefficients W. Indeed, this LS criterion leads to the so-called Bayesian estimate of W if the optimal error signal ε i (W 0 ) is white Gaussian noise (with variance ξ 0 ) that is independent of the input signal(s) and prior information exists on the filter settings W in the form of a Gaussian distribution with mean W −1  and covariance matrix ξ 0 R −1   −1 . So, the larger R −1 , the closer W −1  should be to the optimal filter W 0 . In practice however, often little information is available on W 0  and hence W −1  is often chosen arbitrarily (e.g. W −1 =0) and R −1  is taken as small as possible (typically as small as the numerical implementation of the algorithm safely permits). In general, regardless of the initialization, the solution W k  of the augmented LS cost function converges to the optimal solution W 0  as the amount of data k tends to infinity. This is because time averages converge to statistical averages for most signals. 
     In order to dampen even further the influence of the initialization (or in general, to permit the RLS algorithm to track possible changes with time in the joint statistics of input and desired-response signals), exponential weighting can be introduced. The effect of this is that the past gets forgotten exponentially fast. With an exponential weighting factor λε(0, 1], the LS criterion becomes          W   k     =     arg                     min   W          (         ∑     i   =     n   -   1       k                       λ     k   -   i              ε   i   2          (   W   )           +         λ     k   +   1            (     W   -     W     -   1         )              (         R     -   1            (     W   -     W     -   1         )       T     )     .                                      
     With λ&lt;1 however, the filter solution W k  will never exactly converge to the optimal filter W 0  because even as k tends to infinity, the total effective amount of data in the cost function becomes constant, commensurate with the time constant 1/1−λ of the exponential window. This is the price to be paid to be able to forget the past quickly. So if the goal is to optimize the filter setting W k  at a certain finite time instant k, the forgetting factor λ should be carefully designed, taking both estimation quality and numerical effects into account. 
     Finally, in order to more easily allow the derivation of a so-called fast RLS algorithm, the prewindowing transient period may be incorporated into the LS cost function, leading to:                      W   k     =                arg                     min   W          (         ∑     i   =   0     k                       λ     k   -   i              ε   i   2          (   W   )           +         λ     k   +   1            (     W   -     W     -   1         )                R     -   1            (     W   -     W     -   1         )       T         )                     =                  arg                     min   W            ∑     i   =       -   N     -   3       k                       λ     k   -   i              ε   i   2          (   W   )               =     arg                     min   W            ∑     i   =     -   ∞       k                       λ     k   -   i              ε   i   2          (   W   )                             =                  arg                     min   W                     ε   _     k          (   W   )            2         =     arg                     min   W                     d   _     k     -     W          U   _     k              2                         (   1   )                                
     The optimal error signal in this case is:            ε   _     k     =           ε   _     k          (     W   k     )       =         [     1   -     W   k       ]          [             d   _     k                 U   _     k           ]       =       [             ε   k            =       ε   k          (     W   k     )                       λ                ε     k   -   1            (     W   k     )                           =       ε     k   -   1       =       ε     k   -   1            (     W     k   -   1       )                             …                        ]     .                                
     The orthogonality principle of LS leads to:              ε   _     k            U   _     k   T       =       0   ⇒         ε   _     k            ε   _     k   T         =             ε   _     k            d   _     k   T       -             ε   _     k            U   _     k   T              =   0                         W   k   T         =         ε   _     k              d   _     k   T     .                                  
     The normal equations are hence:                [     1   -     W   k       ]          [             d   _     k                 U   _     k           ]              =       ε   _     k                      [         d   _     k   T            U   _     k   T       ]     =         [     1   -     W   k       ]                       [               d   _     k            d   _     k   T                 d   _     k            U   _     k   T                     U   _     k            d   _     k   T                 U   _     k            U   _     k   T             ]            R   k   e           =       [                   ε   _     k            ε   _     k   T              ξ   k                       0           ]                                
     where R k   e  is an extended sample covariance matrix (as compared to the regular sample covariance matrix R k ={overscore (U)} k {overscore (U)} k   T ), and ξ k  is the minimum value of the LS criterion. The solution to the normal equations is: 
     
       
         
           W 
           k 
           R 
           k 
           ={overscore (d)} 
           k 
           {overscore (U)} 
           k 
           T 
         
       
     
     
       
         ξ k   ={overscore (d)}   k   {overscore (d)}   k   T   −W   k   {overscore (U)}   k   d   k   T   ={overscore (d)}   k   d   k   T   −{overscore (d)}   k   {overscore (U)}   k   T ( {overscore (U)}   k   {overscore (U)}   k   T ) −1   {overscore (U)}   k   {overscore (d)}   k   T . 
       
     
     Recursive Least-squares (RLS) Algorithm 
     From the recursive relations:        {                 d   _     k            U   _     k   T       =       λ                     d   _       k   -   1              U   _       k   -   1     T       +       d   k          U   k   T                       R   k     =       λ                   R     k   -   1         +       U   k          U   k   T                                           
     the following recursion is obtained for W k :          W   k     =         W     k   -   1       +         (       d   k     -       W     k   -   1            U   k         )              ε   k   p     =       ε   k          (     W     k   -   1       )                                 U   k   T          R   k     -   1                C   k             =       W     k   -   1       +       ε   k   p          C   k                                  
     where ε k   p  is the “predicted” (or a priori) error signal (predicted using the previous filter setting W k−1 ) and C k  is the Kalman gain. Note that C k  is like W k  with {overscore (d)} k  replaced by a {overscore (σ)}=[1 0 . . . ]: C k ={overscore (σ)}{overscore (U)} k   T R k   −1 =U k   T R k   −1 . The quantity {overscore (σ)} is called the pinning vector—it pins down the most recent sample, e.g., {overscore (U)} k {overscore (σ)} T =U k . The Kalman gain C k  is the filter for estimating {overscore (σ)} from {overscore (U)} k  with error signal given by {overscore (σ)}−C k {overscore (U)} k  and error energy given by ({overscore (σ)}−C k {overscore (U)} k ){overscore (σ)} T =1−C k U k =1−U k   T R k   −1 U k =γ k , which equals the last component of the corresponding error signal. The quantity γ k ε(0, 1] is often called the likelihood variable. It can be considered to be the RLS adaptation gain. Indeed, we get for the a posteriori (after updating W k ) error signal:                  ε   k     =         ε   k          (     W   k     )       =                    d   k     -       W   k          U   k         =         d   k     -       W     k   -   1            U   k                ε   k   p                         =                    ε   k   p          (     1   -       C   k          U   k         )       =       ε   k   p          γ   k                 -       ε   k   p          C   k          U   k                              
     To find a recursion for R k   −1  the Matrix Inversion Lemma is applied on R k =λR k−1 +U k U k   T , which leads naturally to the introduction of 
     
       
           {tilde over (C)}   k   =U   k   T λ −1   R   k−1   −1 =γ k   −1   C   k =overnormalized Kalman gain. 
       
     
     The RLS algorithm can then be formulated, which is a recursion for W k−1 , R k−1   −1 →W k , R k   −1  with initialization W −1 ,R −1   −1 :        {             ε   k   p     =       d   k     -       W     k   -   1            U   k                         C   ~     k     =       U   k   T          λ     -   1            R     k   -   1       -   1                       γ   k     =       (     1   +         C   ~     k          U   k         )       -   1                     W   k     =       W     k   -   1       +       ε   k   p          γ   k            C   ~     k                       R   k     -   1       =         λ     -   1            R     k   -   1       -   1         -         C   ~     k   T          γ   k            C   ~     k                   Riccati                   equation   .                                           
     The algorithm described above leads to the lowest complexity, but some algorithmic variations involving C k  instead of {tilde over (C)} k  are possible by exploiting the relations 
     
       
         ε k   p γ k   {tilde over (C)}   k =ε k   p   C   k =ε k   {tilde over (C)}   k , 
       
     
     
       
           {tilde over (C)}   k   T γ k   {tilde over (C)}   k   =C   k   T γ k   −1   C   k . 
       
     
     An update equation for the LS error energy can also be obtained (if desired): 
     
       
         ξ k =λξ k−1 +ε k ε k   pT   
       
     
     where the latter transposition operation is required only if ε k   p  would have been a vector signal (not the case for a DFE). 
     Fast RLS Algorithms 
     Study of the input data structure reveals that permutation matrices P A , P D (P A   −1 =P A   T , P D   −1 D =P D   T ) can be introduced to isolate the latest data {overscore (u)} k =           u   _     k     =     [               s   _       k                   y   _       k           ]                            
     or the oldest data {overscore (u)}′ k =           u   _     k   ′     =     [               s   _         k   -     n   B                     y   _       k   -     n   F               ]                            
     in the extended data matrix {overscore (U)} N+3,k  , with a regular data matrix {overscore (U)} k  or {overscore (U)} k−1  the complementary part:              P   A            U   _         N   +   3     ,   k         =       [               u   _       k                   U   _         k   -   1             ]     =     [           [               s   _       k                 y   _     k           ]                   U   _         k   -   1             ]         ,     
              P   D            U   _         N   +   3     ,   k         =       [               u   _       k   ′                 U   _     k           ]     =       [           [           s     k   -     n   B                   y     k   -     n   F               ]                   U   _       k           ]     .                                
     This leads to the following “shift time update” structure:          [               u   _       k   ′                 U   _     k           ]     =         P   D            U   _         N   +   3     ,   k         =       P   D            P   A   T          [               u   _       k                   U   _         k   -   1             ]                                  
     which means that going from the old data {overscore (U)} k−1 , to the new data {overscore (U)} k  can be accomplished by shifting in new data {overscore (u)} k  (temporarily leading to an extended data matrix {overscore (U)} N+3,k ) and shifting out old data {overscore (u)}′ k . This shift time update structure allows for the derivation of fast RLS algorithms. These algorithms require the introduction of forward and backward prediction quantities to account for the introduction of new and the discarding of old data, as follows: 
     Forward Prediction Backward Prediction 
     Error Signal 
     
       
         
           {overscore (e)} 
           k 
           ={overscore (u)} 
           k 
           − A   
           k 
           {overscore (U)} 
           k−1 k 
           {overscore (r)} 
           k 
           ={overscore (u)}′ 
           k 
           
             D 
           
           k 
           {overscore (U)} 
           k 
         
       
     
     
       
           e   k   ={overscore (e)}   k {overscore (σ)} T   r   k   ={overscore (r)}   k {overscore (σ)} T   
       
     
     Filter 
     
       
         
           
             A 
           
           k 
           ={overscore (u)} 
           k 
           {overscore (U)} 
           k−1 
           T 
           R 
           k−1 
           −1 
           
             D 
           
           k 
           ={overscore (u)}′ 
           k 
           {overscore (U)} 
           k 
           T 
           R 
           k 
           −1 
         
       
     
     
       
         
           A 
           k 
           =[I 
           3 
           − A   
           k 
           ]P 
           A 
           D 
           k 
           =[I 
           3 
           − D   
           k 
           ]P 
           D 
         
       
     
     Error Energy 
     
       
         α k   ={overscore (e)}   k   {overscore (e)}   k   T   ={overscore (e)}   k   {overscore (u)}   k   T β k   ={overscore (r)}   k   {overscore (r)}   k   T   ={overscore (r)}   k   {overscore (u)}′   k   T   
       
     
     The introduction of these prediction quantities allows for an alternative update of the Kalman gain and the likelihood variable that does not involve the Riccati equation. The update of the prediction quantities themselves can then be done in the same fashion as the update for the filter W k  and the error energy ξ k . The update of the Kalman gain and likelihood variable requires the introduction of an extended Kalman gain and likelihood variable            C       N   +   3     ,   k       =         U       N   +   3     ,   k     T          R       N   +   3     ,   k       -   1         =       γ       N   +   3     ,   k              C   ~         N   +   3     ,   k             ,     
              C   ~         N   +   3     ,   k       =       U       N   +   3     ,   k     T          λ     -   1            R       N   +   3     ,     k   -   1         -   1           ,     
            γ       N   +   3     ,   k       =       1   -       C       N   +   3     ,   k            U       N   +   3     ,   k           =     1     1   +         C   ~         N   +   3     ,   k            U       N   +   3     ,   k                                        
     where U N+3,k ={overscore (U)} N+3,k {overscore (σ)} T  is the extended input data vector at time k. 
     Fast Kalman Algorithm 
     The first Fast RLS algorithm (introduced in 1976) was the Fast Kalman algorithm, shown in Table 1. The Fast Kalman algorithm works with C k , the entries of which have a lower dynamic range than the entries of {tilde over (C)} k , a desirable property for fixed-point implementation. In the table, the quantity C k   P     D    denotes the entries in C N+3,k  that are in the same (column) positions as the entries of I 3  in D k=[I   3 − D   k ]P D . Similarly, the quantity C k   P     A    will be used, which are the entries in C N+3,k  that are in the same (column) positions as the entries of I 3  in A k =[I 3 − A   k ]P A . The table shows the computational complexity of the algorithm, measured by the number of multiplications or additions (or approximately the number of multiply-accumulates) that need to be performed. These complexities are indicated for the general case of q channels. In the FS DFE example, q=3. 
     Fast Transversal Filter (FTF) Algorithm 
     The Fast Transversal Filter algorithm (see Table 2) works with {tilde over (C)} k  (just like the RLS algorithm), which results in the lowest computational complexity. Whereas the FKA computes the backward prediction error r k   p  as the output of the backward prediction filter D k−1 , the FTF algorithm avoids this inner product and finds r k   p  by the manipulation of scalar (in the single channel case) quantities. 
     
       
         
               
             
               
               
               
               
             
               
             
               
               
               
               
               
             
               
             
               
               
               
               
               
             
               
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 The Fast Kalman Algorithm (FKA). 
               
             
          
           
               
                 T1 
                 Fast Kalman Algorithm 
                 x, + 
               
               
                   
               
             
          
           
               
                 prediction part 
               
             
          
           
               
                 1 
                 e k   p  = 
                 A k−1  U N+q,k   
                 qN 
                   
               
               
                 2 
                 A k  = 
                 A k−1  − e k   p  [0 C k−1 ] 
                 qN 
               
               
                 3 
                 e k  = 
                 A k U N+q,k   
                 qN 
               
               
                 4 
                 α k  = 
                 λα k−1  + e k e k   pT   
                 2q 2   
               
               
                 5 
                 C N+q,k  = 
                 [0 C k−1 ]P A  + e k   T α k   −1 A k   
                 qN + O(q 3 ) 
               
               
                 6 
                 r k   p  = 
                 D k−1 U N+q,k   
                 qN 
               
               
                 7 
                 D k  = 
                 (I q  − r k   p C k   P     D   ) −1 (D k−1  − r k   p C N+q,k ) 
                 (3q − 1)N + O(q 2 ) 
               
               
                 8 
                 [0 C k ] = 
                 C N+q,k P D   T  − C k   P     D   D k   
                 qN 
               
             
          
           
               
                 filtering part 
               
             
          
           
               
                 9 
                 ε k   p  = 
                 d k  − W k−1 U k   
                 N 
                   
               
               
                 10 
                 W k  = 
                 W k−1  + ε k   p C k   
                 N 
               
             
          
           
               
                   
                 total complexity 
                 (9q + 1)N + O(q 3 ) 
               
               
                   
                   
               
             
          
         
       
     
     as a result, however, the FTF algorithm is numerically less stable than the FKA in the sense that round-off errors grow faster. It is possible to combine the two ways of computing the signal r k   p  to create a measurement of the round-off error subsystem associated with the algorithm, and to feed measurement to stabilize the unstable error propagation subsystem of the algorithm. 
     Initialization of Fast RLS 
     In the foregoing Fast RLS algorithm, the following initialization is performed. Filtering part: 
     1. W k=−1 =W −1  corresponding to {overscore (d)} −1 =W −1 {overscore (U)} −1  (implicitly). 
     2. Usually, {overscore (d)} −1 =0 and W −1 =0. 
     Prediction part: 
     
       
         
               
             
               
               
               
             
               
             
               
               
               
               
             
               
             
               
               
               
               
             
               
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 The Fast Transversal Filter (FTF) algorithm. 
               
             
          
           
               
                 T2 
                 Fast Transversal Filter (FTF) Algorithm 
                 x, + 
               
               
                   
               
             
          
           
               
                 prediction part 
               
             
          
           
               
                 1 
                 e k   p  = 
                 u k  −  A   k−1 U k−1   
                 qN 
               
               
                 2 
                 {tilde over (C)} k   P     A    = 
                 e k   pT λ −1 α k−1   −1   
                 2q 2   
               
               
                 3 
                 {tilde over (C)} N+q,k P A   T  = 
                 [0 {tilde over (C)} k−1 ] + {tilde over (C)} k   P     A    [I q  −  A   k−1 ] 
                 qN 
               
               
                 4 
                 γ N+q,k   −1  = 
                 γ k−1   −1  + {tilde over (C)} k   P     A   e k   p   
                 q 
               
               
                 5 
                 r k   p  = 
                 λβ k−1 {tilde over (C)} k   P     D     T   
                 2q 2   
               
               
                 6 
                 [0 {tilde over (C)} k ] = 
                 ({tilde over (C)} N+q,k P A   T ) (P A P D   T ) − {tilde over (C)} k   P     D    [I q  − 
                 qN 
               
               
                   
                   
                   D   k−1 ] 
               
               
                 7 
                 γ k   −1  = 
                 γ N+q,k   −1  − {tilde over (C)} k   P     D   r k   p   
                 q 
               
               
                 8 
                 e k  = 
                 e k   p γ k-1   
                 q 
               
               
                 9 
                   A   k  = 
                   A   k−1  + e k {tilde over (C)} k−1   
                 qN 
               
               
                 10 
                 α k   −1  = 
                 λ −1 α k−1   −1  − {tilde over (C)} k   P     A     T γ N+q,k {tilde over (C)} k   P     A     
                 (1 ÷) q 2  + q 
               
               
                 11 
                 r k  = 
                 r k   p γ k   
                 (1 ÷) q 
               
               
                 12 
                   D   k  = 
                   D   k−1  + r k  {tilde over (C)} k   
                 qN 
               
               
                 13 
                 β k  = 
                 λβ k−1  + r k   p r k   T   
                 q 2   
               
             
          
           
               
                 filtering part 
               
             
          
           
               
                 14 
                 ε k   p  = 
                 d k  − W k−1 U k   
                 N 
               
               
                 15 
                 ε k  = 
                 ε k   p γ k   
                 1 
               
               
                 16 
                 W k  = 
                 W k−1  + ε k {tilde over (C)} k   
                 N 
               
             
          
           
               
                   
                  total complexity 
                 (2 ÷) (5q + 2)N + 6q 2  + 5q + 1 
               
               
                   
                   
               
             
          
         
       
     
     1.          U       N   +   q     ,     -   1                                        or              [             σ   _                   U   _       -   1             ]                            
     are permutations of diagonal matrices. 
     2. Hence the LS estimate of any row from any other row(s) is 0. 
     3. For the filters, 
     
       
             A     −1   = D     −1   ={tilde over (C)}   −1   =C   −1 =0. 
       
     
     4. For the error energies (the energy of the signal that is being estimated):          β     -   1       =           r   _       -   1              r   _       -   1     T       =           u   _       -   1     ′            u   _       -   1       ′   T         =     [           μ   B         0           0           λ       n   B     +   1            μ   F          I   2             ]                   α     -   1       =           e   _       -   1              e   _       -   1     T       =           u   _       -   1              u   _       -   1     T       =       [             λ     n   B            μ   B           0           0           λ       n   B     +     n   F     +   1            μ   F          I   2             ]     =       β     -   1            [           λ     n   B           0           0           λ     n   F            I   2             ]                       γ   -   1     =         σσ   _     T     =   1                            
     Lowest Complexity Fast Kalman Algorithm 
     The FTF algorithm works with {tilde over (C)} k  whereas the FKA works with C k . For {tilde over (C)} k =U k   T λ −1 R k−1   −1  in the prewindowing transient phase, the last non-zero coefficients for the different channels put together give            [       s   0          y   o   T       ]          [             λ       n   B     +   1            μ   B           0           0           λ       n   B     +     n   F     +   2            μ   F          I   2             ]         -   1                            
     which shows that for small initialization constants μ B , μ F , the overnormalized Kalman gain {tilde over (C)} k  will take on large values during the transient phase. The unnormalized Kalman gain C k =U k   T R k   −1  suffers much less from this problem since the “denominator” R k  contains the latest data U k . This problem of larger dynamic range for {tilde over (C)} k  compared to C k  manifests itself more generally whenever a sudden increase in the input signal level occurs. This motivates (with an eye toward fixed-point implementation) the use of C k  over {tilde over (C)} k . The algorithm shown in Table 3 uses C k  as in the FKA. It also computes the backward prediction error by straightforward filtering as in the FKA (as opposed to avoiding this inner product after the manner of the FTF algorithm). This leads to a less unstable algorithm. Finally, note that as a result the algorithm does not require β k  (required in the FTF algorithm). These are the most important characteristics of the FKA, and hence the resulting fast RLS algorithm can appropriately be called an FKA, albeit the fastest version of the FKA. 
     
       
         
               
             
               
               
               
             
               
             
               
               
               
               
             
               
             
               
               
               
               
             
               
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 Lowest complexity Fast Kalman Algorithm. 
               
             
          
           
               
                 T3 
                 Lowest Complexity FKA 
                 x, + 
               
               
                   
               
             
          
           
               
                 prediction part 
               
             
          
           
               
                 1 
                 e k   p  = 
                 u k  −  A   k−1 U k−1   
                 qN 
               
               
                 2 
                 {tilde over (C)} k   P     A    = 
                 e k   pT λ −1 α k−1   −1   
                 2q 2   
               
               
                 3 
                 γ N+q,k  = 
                 γ k−1 /(1 + γ k−1 {tilde over (C)} k   P     A   e k   p ) 
                 (1 ÷)  q +1 
               
               
                 4 
                 α k   −1  = 
                 λ −1 α k−1   −1  − {tilde over (C)} k   P     A     T  γ N+q,k {tilde over (C)} k   P     A     
                 q 2  + q 
               
               
                 5 
                   A   k  = 
                   A   k−1  + e k   p C k−1   
                 qN 
               
               
                 6 
                 C N+q,k P A   T  = 
                 [0  C k−1 ] + γ N+q,k {tilde over (C)} k   P     A    [I q  −  A   k ] 
                 qN 
               
               
                 7 
                 r k   p  = 
                 u k ′ −  D   k−1 U k   
                 qN 
               
               
                 8 
                 γ k γ N+q,k   −1  = 
                 1/(1 − C k   P     D   r k   p ) 
                 (1 ÷) q 
               
               
                 9 
                 γ k  = 
                 (γ k γ N+q,k   −1 )γ N+q,k   
                 1 
               
               
                 10 
                 [0 C k ] = 
                 (γ k γ N+q,k   −1 ) [(C N+q,k P A   T ) (P A P D   T ) − 
                 (q + 1)N 
               
               
                   
                   
                 C k   P     D    [I q  −  D   k−1 ]] 
               
               
                 11 
                   D   k  = 
                   D   k−1  + r k   p C k   
                 qN 
               
             
          
           
               
                 filtering part 
               
             
          
           
               
                 14 
                 ε k   p  = 
                 d k  − W k−1 U k   
                  N 
               
               
                 15 
                 W k  = 
                 W k−1  + ε k   p  C k   
                 N 
               
             
          
           
               
                   
                 total complexity 
                 (2 ÷) (6q + 3)N + 3q 2  + 3q + 2 
               
               
                   
                   
               
             
          
         
       
     
     In Matlab notation (for portions of vectors): C k   P     D   =C N+q,k [N fb +1, N+2, N +3], whereby line 10 in Table 3 can be rewritten as 
     
       
           C   k =(γ k γ N+q,k   −1 )[( C   N+q,k   P   A   T )[1,4: N   fb +2,2,3, N   fb +4 :N− 2] +C   k   P     D       D     k−1 ]. 
       
     
     Since γ k γ N+q,k   −1 &gt;1, the implementation of the multiplication with this number on a fixed-point processor may take more than one cycle. 
     The least complex computation of the LS filter estimate would be to solve the normal equations with the generalized Levinson algorithm. However, this may be more sensitive in a fixed-point 
     Prewindowing/Initialization Removal Postprocessing 
     It is clear that avoiding the prewindowing assumption and the initialization (when W −1  is not particularly close to W 0 ) would lead to much faster and better convergence. (The influence of the initialization can be made small by choosing μ B , μ F  small, but a fixed-point implementation, specially, will pose constraints on how small these quantities can be made.) With initialization and prewindowing, exponential weighting needs to be applied, not so much to adapt to changing statistics, but simply to forget the initialization and the prewindowing. Without the perturbation of initialization or prewindowing, no exponential weighting would need to be applied. This would lead to better estimation performance and fewer numerical problems. 
     To be robust against changing statistics later on in time, tracking performance could still be obtained without exponential forgetting by processing the data in bursts and at each burst incorporating as initialization the filter setting resulting from processing the previous burst with appropriate weighting. (In this case, the initialization would not have to be gotten rid off, only the prewindowing.) 
     A straightforward way to avoid prewindowing is to use the Growing Window Covariance (GWC) version of the FKA. In this fast RLS algorithm: the LS problem corresponding to the covariance window in FIG. 2 is solved at each time instant k. This algorithm is more complex than the prewindowed version. Indeed, it requires the introduction of an additional filter G, the dual Kalman gain, which needs to be updated also at every time instant. The GWC FKA may also be more sensitive for a fixed-point implementation (due to larger dynamics of quantities). 
     As mentioned earlier, in many applications it may not be possible to run a fast RLS algorithm in real-time to get initial convergence, due to complexity considerations. On the other hand, it may also be overkill to keep a fast RLS algorithm running to adapt to slow variations in the optimal filter settings. In this case: data should initially be acquired and stored. Then a fast RLS algorithm can be run off-line to converge on these data. The amount of data to be stored and processed should be such that it allows the LS filter estimate to have close to optimal performance (small excess MSE). For instance, an amount of data corresponding to k=10N should be largely sufficient for equalization applications. If a covariance window is used, less data can be used if that leads to a more favorable memory/complexity/performance trade-off. If an FKA with initialization and prewindowing is used, however, much more data would normally be required to get comparable performance. 
     Now, given (as described above) that fast RLS algorithms with prewindowing have the lowest complexity, an effective strategy is to simply run the prewindowed FKA, possibly with relatively large initialization constants μ to dampen the dynamics of the (fixed-point) quantities. This will be done over a burst of data such that the corresponding covariance window LS problem gives acceptable performance (so the data length is relatively short). At the end of the burst, a postprocessing FKA algorithm is run which will now remove the initial data vectors (hence the initialization constants in R −1  and the prewindowing). This will have a lower overall complexity than running a GWC version of the FKA. 
     Downdating RLS Algorithm 
     To formulate the postprocessing algorithm, data matrices are needed which not only have an end time k but also a starting time j (j=−∞ in principle in the prewindowed case). With the initialization of FIG. 2, a starting time j=−∞ is in fact equivalent to j=−N−q since all data prior to that instant are zero. So the filter becomes the solution of the following LS problem                W     j   ,   k       =     arg                     min   W            ∑     i   =   j     k                       λ     k   -   i              ε   i   2          (   W   )                           =       arg                     min   W                     ε   _       j   ,   k            (   W   )            2         =     arg                     min   W                                d   _       j   ,   k       -     W                     U   _       j   ,   k                2                                        
     To obtain an RLS algorithm, the problem then is to find recursions to move j forward in time, until the prewindowing period is passed, so from about j=−N−q to j=n−1 where n=max{n B , n F } if both initialization and prewindowing need to be removed, or from 0 to n−1 if only prewindowing needs to be removed. Since the postprocessing consists of making the data window shorter by removing data at the beginning of the window, the resulting processing can be called downdating (as opposed to the usual updating). 
     From the recursive relations:        {                      d   _         j   +   1     ,   k              U   _         j   +   1     ,   k     T       =           d   _       j   ,   k              U   _       j   ,   k     T       -       λ     k   -   j            d   j          U   j   T                       R       j   +   1     ,   k       =       R     j   ,   k       -       λ     k   -   j            U   j          U   j   T                                          
     the following recursion is obtained for W j,k :          W       j   +   1     ,   k       =         W     j   ,   k       -       λ     k   -   j                                      (       d   j     -       W     j   ,   k            U   j         )                           ε     j   ,   k       =                  ε   j          (     W     j   ,   k       )                                   U   j   T          R       j   +   1     ,   k       -   1                  G   ~       j   ,   k             =       W     j   ,   k       -       λ     k   -   j            ε     j   ,   k            G     j   ,   k                                    
     where {tilde over (G)} j,k  is a (overnormalized) dual Kalman gain, this time not to reflect the effect of adding a data point at the end, but of removing a data point at the beginning. Furthermore, the (unnormalized) dual Kalman gain is G j,k =U j   T R j,k   −1 . Note that λ k−j G j,k  is like W j,k  with {overscore (d)} j,k  replaced by {overscore (π)}=           [     0                 …                 0        λ       k   -   j     2         ]     :       λ     k   -   j            G     j   ,   k           =         π   _            U   _       j   ,   k     T          R     j   ,   k       -   1         =       λ     k   -   j            U   j   T            R     j   ,   k       -   1       .                                
     The quantity {overscore (π)} is called the dual pinning vector. it pins down (and weighs) the oldest sample. The dual Kalman gain G j,k  is the filter for estimating {overscore (π)} from {overscore (U)} j,k  with error signal ={overscore (π)}−λ k−j G j,k {overscore (U)} j,k  and error energy=({overscore (π)}−λ k−j G j,k {overscore (U)} j,k ){overscore (π)} T =λ k−j δ j,k  where          δ     j   ,   k       =       1   -       λ     k   -   j            G     j   ,   k            U   j         =       1   -       λ     k   -   j            U   j   T          R     j   ,   k       -   1            U   j         =       1     1   +       λ     k   -   j              G   ~       j   ,   k            U   j           =       1     1   +       λ     k   -   j            U   j   T          R       j   +   1     ,   k       -   1            U   j                    ε        (     0   ,   1         ]     .                                    
     Again, a relation of the form G j,k =δ j,k {tilde over (G)} j,k  is obtained. To find a recursion for R j,k   −1 , the Matrix Inversion Lemma is again applied on R j+1,k =R j,k −λ k−j U j U j   T . The downdating RLS algorithm, which is a recursion for W j,k , R j,k   −1 →W j+1,k , R j+1,k   −1  with initialization W −N−q,k =W k , R −N−q,k   −1 =R k   −1  can then be formulated as follows:        {             ε     j   ,   k       =       d   j     -       W     j   ,   k            U   j                       G     j   ,   k       =       U   j   T          R     j   ,   k       -   1                       δ     j   ,   k       =     1   -       λ     k   -   j            G     j   ,   k            U   j                       W       j   +   1     ,   k       =       W     j   ,   k       -       ε     j   ,   k            λ     k   -   j            δ     j   ,   k       -   1            G     j   ,   k                         R       j   +   1     ,   k       -   1       =       R     j   ,   k       -   1       +       G     j   ,   k     T          λ     k   -   j            δ     j   ,   k       -   1            G     j   ,   k                     Riccati                   equation   .                                           
     The corresponding downdate equation for the LS error energy (if desired)is given by: 
     
       
         ξ j+1,k =ξ j,k −ε j,k λ k−j δ j,k   −1 ε j,k   T   
       
     
     where the latter transposition operation is required only if ε j,k  is a vector signal (not the case for a DFE). 
     Downdating Fast Kalman Algorithm 
     To find a downdating fast RLS algorithm, the shift structure in the data can again be exploited, of which the details are now:            [               u   _         j   ,   k     ′                 U   _       j   ,   k             ]     =         P   D            U   _         N   +   3     ,   j   ,   k         =       P   D            P   A   T          [               u   _       j   ,   k                     U   _         j   -   1     ,     k   -   1               ]                                               
     which means that going from the old data {overscore (U)} j−1,k−1  to the new data {overscore (U)} j,k  can be accomplished by shifting in new data {overscore (u)} j,k  (temporarily leading to an extended data matrix {overscore (U)} N+3,j,k ) and shifting out old data {overscore (u)}′ j,k . To get a complete downdating strategy which will be used to downdate G j−1,k  to G j,k , the regular time updating strategy (involving the regular Kalman gain C j,k ) is first used to downdate G j−1,k  to G j−1,k−1  and then the shift structure is used (involving foward and backward prediction filters) to update G j−1,k−1 , to G j,k . The derivations are along the same lines as for the FKA/FTF algorithms. The resulting algorithm is shown in Table 4. 
     Just as the updating algorithm requires initialization, so also the downdating algorithm requires initialization. The following initialization (at j=−1, if the desired is to get rid of prewindowing only) may be used: W,A,D,C,α −1 , γ are initialized by their values obtained from the prewindowed algorithm, and G −1,k =0, δ −1,k =1. The initialization can be placed earlier to get rid of the soft constraint initialization (W −1 , R −1 ) also. (This is done using the same initialization values, only the signal values to be processed during the downdating become more numerous). When downdating the soft constraint initialization, the complexity can be reduced by 3N−3 if the fact that the U j  contain only one non-zero entry gets exploited. 
     Prewindowing Suppression for the Filtering Section 
     The filtering (equalization) error signal shows large values during the initial convergence of the algorithms. One would expect, however, that this would not be the case when the filter W is initialized to some setting W −1  that is relatively close to the optimal setting (as a result of previous adaptation). However, things are perturbed due to the prewindowing, which will lead good filter settings to produce a large error signal during the prewindowing transient. The prior art (Eleftheriou and Falconer) describes a solution to this problem. The solution consists of still using the prewindowed input data vector U k  for the prediction part of the fast RLS algorithm, so that a fast algorithm is possible, but to introduce a different data vector, U′ k , for the filtering section. U′ k  is the same as U k  except that it&#39;s not prewindowed. So U′ k  differs from U k  only during the prewindowing transient, in which period U′ k  contains some actual data from before time zero (assuniing this data is available but was simply not used due to the algorithmic constraints of prewindowed fast RLS algorithms). So in this case, the filtering error signal is actually computed as                ε   k   p     =       d   k     -       W     k   -   1            U   k   ′                     =       (       d   k     -       W     k   -   1            (       U   k   ′     -     U   k       )         )     -       W     k   -   1            U   k                     =       d   k   ′     -       W     k   -   1            U   k                                      
     where U′ k −U k  is non-zero, and d′ k  is different from d k , only during the prewindowing transient. So things happen as if the prewindowinig assumption is still used, but with a (temporarily) modified desired-response signal d′ k  which compensates as well as it can for the prewindowing assumption (since before updating at time k, W k−1  is our best estimate for W). The filtering error thus computed does not get perturbed by prewindowing and hence does not show particularly large values during the prewindowing (not larger than what W −1  can deliver). 
     To incorporate this modification in the postprocessing, it suffices to use d′ k  instead of d k  (U′ k  does not need to be used). Indeed, the filter estimate would have been exactly the same if prewindowing (U k ) in the filtering section was used, with d′ k  as desired response signal. 
     Partial Cancellation of the Initialization 
     It is trivially possible to cancel the initialization only partially. This may be desirable if the initialization constants were chosen oil the basis of numerical considerations, whereas after cancellation, the objective is for the constants to take on (smaller) values that correspond to certain statistical estimation considerations (Bayesian point of view). 
     Indeed, if for the postprocessing purposes, μ F , μ B  are set to values μ′ F &lt;μ F , μ′ B &lt;μ B , then after postprocessing the initialization will still influence the filter estimate, but now according to the constants μ F −μ′ F , μ B −μ′ B . 
     Updating and Tracking by Processing Data in Bursts 
     To make up for the fact that the available processing power may be insufficient to run fast RLS algorithms in real time, data can he stored and processed in bursts of length and frequency such that the processing of a burst is finished before the next burst of data arrives. To incorporate the results from processing previous data bursts, when processing the next burst, the (soft constraint) initialization mechanism can be used. To have an appropriate weighting of the previous results, the following initialization values can be used: put  A ,  D , C, U to 0, γ to 1, and leave α −1  and W unchanged. This corresponds to a pre- and postwindowed data matrix {overscore (U)} −1  with block-diagonal (3×3 blocks) R −1 . The advantage of such a simple initialization is that the numerical errors associated with critical (unstable) quantities are flushed out. The appropriate weighting is provided by leaving α −1  unchanged. If λ=1 is used, then the filter estimate is the result of all the data bursts processed (not in the usual LS sense though, but in some weighted version of it). Forgetting, to track possible changes in the environment, can be introduced by taking λ&lt;1. Alternatively, one can take λ=1 but weigh α −1 : α −1 ←λ 1   −1 α −1  at initialization, where λ 1  is some burst-level forgetting factor. Or one can use a combination of both weighting mechanisms. 
     Obviously, when incorporating information from previous bursts, the initialization should not be removed by postprocessing (postprocessing should then only be applied to the prewindowing transient). 
     
       
         
               
             
               
               
               
             
               
             
               
               
               
               
             
               
             
               
               
               
               
             
               
               
               
             
           
               
                 TABLE 4 
               
             
             
               
                   
               
               
                 Postprocessing Fast Kalman Algorithm to transform the 
               
               
                 initialized/prewindowed LS estimate into a 
               
               
                 Covariance Window LS estimate. 
               
             
          
           
               
                 T4 
                 Downdating FKA 
                 x + 
               
               
                   
               
             
          
           
               
                 prediction part 
               
             
          
           
               
                 1 
                 η j−1,k  = 
                 C j−1,k U j−1   
                 N 
               
               
                 2 
                 γ j,k γ j−1,k   −1  = 
                 1 − λ k−j+1 γ j−1,k   −1 δ j−1,k   −1 η j−1,k   2   
                 4 
               
               
                 3 
                 γ j,k   −1  = 
                 (γ j,k γ j−1,k   −1 ) −1 γ j−1,k   −1   
                 (1 ÷) 1 
               
               
                 4 
                 C j,k  = 
                 C j−1,k  + λ k−j+1 δ j−1,k   −1 η j−1,k G j−1,k   
                 N 
               
               
                 5 
                 δ j−1,k−1   −1  = 
                 (γ j,k γ j−1,k   −1 ) −1 δ j−1,k   −1   
                 1 
               
               
                 6 
                 G j−1,k−1  = 
                 λγ j,k γ j−1,k   −1 G j−1,k  + λγ j−1,k   −1 η j−1,k C j,k   
                 2N + 2 
               
               
                 7 
                 e j,k  = 
                 u j  −  A   j,k U j−1   
                 qN 
               
               
                 8 
                 G j,k   P     A    = 
                 e j,k   T α j,k   −1   
                 q 2   
               
               
                 9 
                 δ N+q,j,k   −1  = 
                 δ j−1,k−1   −1 /(1 − λ k−j δ j−1,k−1   −1 G j,k   P     A   e j,k ) 
                 (1 ÷) q + 3 
               
               
                 10 
                 α j+1,k   −1  = 
                 α j,k   −1  + λ k−j δ N+q,j,k   −1 G j,k   P     A     T G j,k   P     A     
                 q 2  + q + 1 
               
               
                 11 
                 G N+q,j,k P A   T  = 
                 [0 G j−1,k−1 ] + G j,k   P     A    [I q  −  A   j,k ] 
                 qN 
               
               
                 12 
                   A   j+1,k  = 
                   A   j,k  − λ k−j δ j−1,k−1   −1 e j,k G j−1,k−1   
                 qN + q 
               
               
                 13 
                 r j,k  = 
                 u j ′ −  D   j,k U j   
                 qN 
               
               
                 14 
                 δ j,k   −1  = 
                 δ N+q,j,k   −1 /(1 + λ k−j δ N+q,j,k   −1 G j,k   P     D   r j,k ) 
                 (1 ÷) q + 2 
               
               
                 15 
                 [0 G j,k ] = 
                 (G N+q,j,k P A   T ) (P A P D   T ) − G j,k   P     D    [I q  − 
                 qN 
               
               
                   
                   D   j,k ] 
               
               
                 16 
                   D   j+1,k  = 
                   D   j,k  − λ k−j δ j,k   −1 r j,k G j,k   
                 qN + q + 1 
               
             
          
           
               
                 filtering part 
               
             
          
           
               
                 17 
                 ε j,k  = 
                 d j  − W j,k U j   
                 N 
               
               
                 18 
                 W j+1,k  = 
                 W j,k  − λ k−j δ j,k   −1 ε j,k G j,k   
                 N + 1 
               
             
          
           
               
                   
                 total complexity 
                 (3 ÷) (6q + 6)N + 2q 2  + 5q + 16 
               
               
                   
                   
               
             
          
         
       
     
     Use of the described postprocessing fast Kalman algorithm shows that equivalent results as conventional algorithms can be obtained using from six to sixteen times less data than conventional algorithms. 
     It will be appreciated by those of ordinary skill in the art that the invention can be embodied in other specific forms without departing from the spirit or essential character thereof. The presently disclosed embodiments are therefore considered in all respects to be illustrative and not restrictive. The scope of the invention is indicated by the appended claims rather than the foregoing description, and all changes which come within the meaning and range of equivalents thereof are intended to be embraced therein.