# Patent

## Title
Self-synchronizing adaptive multistage receiver for wireless communication systems

## Abstract

The present invention discloses an adaptive near-far resistant receiver for wireless communication systems, such as, asynchronous DS-CDMA systems, without the use of prior synchronization. The only requirement is knowledge of the spreading code of the desired user. Also there is no need of a training period or of data-free observations. In one aspect the present system describes a method and system for filtering of an asynchronous wireless signal comprising the steps of receiving a data vector; of using the received data vector to update the weight coefficients of an adaptive filter without a prior knowledge of synchronization and without a need for a separate training period or data free observations.
In another aspect, the present system describes an adaptive near-far resistant receiver for an asynchronous wireless systems comprising means for receiving a data vector; means for; using the received data vector to update weight coefficients of an adaptive filter, and means for iterative multistage decomposition updating of the filter coefficients. In one embodiment the receiver uses an adaptive filter bank comprising a plurality of adaptive filters, wherein each filter corresponds to at least one different sampling time. An estimate of the timing is obtained from the maximum of a set of sequential outputs from the filter bank, The output that yields the maximum is preferably used to demodulate the information bit.

## Background
CROSS-REFERENCE TO RELATED APPLICATIONS
This patent application claims the benefit of the filing date of U.S. Provisional Patent Application Ser. No. 60/248,469, filed Nov. 14, 2000 and entitled “Adaptive Multistage Filter-Bank Receiver for Wireless Communication Systems,” the entire contents of which are hereby expressly incorporated by reference.


FIELD OF THE INVENTION
The present invention relates to a filtering system and method for wireless communication signals. More specifically, the present invention is directed to a method and system for adaptively filtering asynchronous signals in wireless communication systems.
BACKGROUND OF THE INVENTION
Direct-sequence code-division multiple-access (DS-CDMA) has become an important component of recent communication systems. This is due to its many attractive properties for wireless communications such as the one depicted in FIG. 1A. In DS-CDMA communications, users' signals are multiplexed by distinct code waveforms, rather than by orthogonal frequency bands in frequency-division multiple access (FDMA), or by orthogonal time slots in time-division multiple access (TDMA). All users can transmit at the same time with each of them being allocated the entire available, broad-band, frequency spectrum for transmission. This method of channel allocation alleviates the problems commonly associated with other forms of channel allocation such as unused resources.
In CDMA, demodulation requires the suppression of two forms of noise, ambient channel noise, which is modeled as additive white Gaussian noise, plus multiple access interference (MAI), which is highly structured. The conventional receiver, which uses a simple correlation of the received signal and its user-spreading sequence (a standard matched filter), does not take into account the existence of MAI. The MAI caused by any one user is generally small, but as the number of interferers and their total power increases, the effects of MAI can become substantial. These effects fall within, what is called, the near-far problem.
The conventional receiver is severely limited by the effects of such MAI. One way to alleviate the MAI problem is to use power control schemes. However, power control is not easy to accomplish, especially in a wireless environment, where the power levels often vary dramatically. Even if perfect power control is used, the system may still need to be implemented with a forward error-correcting code to obtain a good performance. Another way of handling the near-far problem is to use near-far resistant receivers, which, in principle, can yield a substantial improvement over the standard receiver with perfect power control.
Multiuser detection techniques were proposed many years ago to mitigate the MAI problem. For example, S. Verdú, in “Minimum probability of error for asynchronous gaussian multiple-access channels,” IEEE Trans. on Inform. Theory, vol. IT-32, pp. 85–96, January 1986, [1], the entire contents of which are hereby expressly incorporated by reference, proposed and found the optimal multiuser detection criterion and maximum-likelihood sequence detection for DS-CDMA. Unfortunately, Verdú's detection and demodulation methods were generally too complex to realize in a practical DS-CDMA system.
As a consequence, a number of simplified detector-demodulators have been proposed to obtain near optimal performance with reduced computational complexity. (For example, see R. Lupas and S. Verdú, “Linear multiuser detectors for synchronous code-division multiple-access channels,” IEEE Trans. On Inform. Theory, vol. 35, pp. 123–136, January 1989 [2]; R. Lupas and S. Verdú, “Near-far resistance of multiuser detectors in asynchronous channels,” IEEE Trans. on Commun., vol. 38, pp. 496–508, April 1990 [3]; Z. Xie, R. T. Short, and C. K. Rushforth, “A family of suboptimum detectors for coherent multiuser communications,” IEEE J. Select. Areas Commun., vol. 8, pp. 683–690, May 1990 [4]; U. Madhow and M. L. Honig, “MMSE interference suppression for direct-sequence spread spectrum CDMA,” IEEE Trans. On Commun., vol. 42, pp. 3178–31888, December 1994 [5]; M. L. Honig and J. S. Goldstein, “Adaptive reduced-rank residual correlation algorithms for DS-CDMA interference suppression,” in Conference Record of the Thirty-Second Asilomar Conference on Signals, Systems & Computers, 1998, vol. 1, pp. 551–555 [6]; and D. J. Lee, Adaptive Detection of DS/CDMA Signals Using Reduced-Rank Multistage Wiener Filter, Ph.D. thesis, University of Southern California, March 2000 [7], the contents of which are hereby expressly incorporated by reference.)
These receivers, however, deal primarily only with detectors that require a precise knowledge of the propagation delays of all users, which is usually unknown a priori. To use such an algorithm, the propagation delays need to be estimated and as a consequence, the receivers suffer from errors that occur with the estimation of the propagation delays. (See S. Parkvall, E. G. Strom, and B. Ottersten, “The impact of timing errors on the performance of linear ds-cdma receivers,” IEEE J. Select. Areas Commun., pp. 1660–1668, October 1996. [8], the contents of which are hereby expressly incorporated by reference). To obtain a better performance, the transmitters and receivers needed to be synchronized. Moreover, the transmitters and receivers, in this case, need to be synchronized in order to obtain a better performance. However, the synchronization requirement adds more complexity and cost to the system.
The conventional acquisition system that utilizes a tapped delay line with its weights being the elements of the spreading sequence also suffers from the same near-far problems. Many near-far resistant timing-acquisition algorithms have been developed. One approach is to jointly estimate the needed parameters of all users, as shown in Y. Steinberg and H. V. Poor, “On sequential delay estimation in wide-band digital communication systems,” in Proc. Intl. Symp. Information Theory, San Antonio, Tex., 1993, p. 423 [9]; and S. Y. Miller and S. C. Schwartz, “Parameter estimation for asynchronous multiuser communications,” in Proc. Conf. Information Sciences and Systems, Baltimore. Md., 1989, pp. 294–299 [10], the contents of which are hereby expressly incorporated by reference. While such techniques can provide excellent results, they are computationally complex.
Recently, maximum-likelihood synchronization of a single user is developed in S. E. Bensley and B. Aazhang. “Maximum-Likelihood synchronization of a single user for Code-Division Multiple-Access communication systems,” IEEE Trans. on Commun., pp. 392–399, March 1998 [11], the contents of which are hereby expressly incorporated by reference. However, the method in [11] requires a training period. This requirement is not feasible in certain situations. For example, whenever there is a significant change in the MAI level, during a deep fade or a turning-on of some near-in strong interferers, retraining is required, and the data transmission need to be interrupted accordingly. Similar limitations apply also to the minimum mean-square-error (MMSE) interference suppression techniques for the timing-acquisition, developed in U. Madhow, “MMSE interference suppression for timing acquisition and demodulation in Direct-Sequence CDMA systems,” IEEE Trans. on Commun., pp. 1065–1075, August 1998 [12], the contents of which are hereby expressly incorporated by reference.
By the use of a subspace decomposition technique, such as multiple signal classification (MUSIC), another type of timing estimator is developed in E. G. Ström, S. Parkvall, S. L. Miller, and B. E. Ottersten, “Propagation delay estimation in asynchronous direct-sequence code-division multiple access system,” IEEE Trans. on Commun., Vol. 44, pp. 84–93, January 1996 [13]; and S. E. Bensley and B. Aazhang, “Subspace-based channel estimation for code division multiple access communication systems,” IEEE Trans. on Commun., vol. 44, pp. 1009–1020, August 1996 [14], the contents of which are hereby expressly incorporated by reference. This type of estimator does not need a training sequence and provides good results when unknown information sequences are sent. However, this timing estimator still involves extensive computations due to the need for an eigen decomposition. Also, this technique assumes that the number of active users is fixed and needs to be known or estimated. As a result, there is a need for a system and method for a relatively simple, accurate, and cost effective filtering of an asynchronous wireless signal.
SUMMARY OF THE INVENTION
An adaptive near-far resistant receiver for wireless communication systems, such as, asynchronous DS-CDMA systems is developed without the use of prior synchronization. The only requirement is knowledge of the spreading code of the desired user. Also, there is no need of a training period or of data-free observations.
In one aspect the present system describes a method and system for filtering of an asynchronous wireless signal comprising the steps of receiving a data vector; of using the received data vector to update the weight coefficients of an adaptive filter without prior knowledge of synchronization and without a need for a separate training period or data free observations.
In another aspect, the present system describes an adaptive near-far resistant receiver for an asynchronous wireless system comprising: means for receiving an asynchronous data vector including a spreading code; using the received asynchronous data vector, means for updating weight coefficients of an adaptive filter without prior knowledge of synchronization of the spreading code of the data vector; using the updated weight coefficients, means for determining synchronization of the spreading code; and means for demodulating the output of the filter using the determined synchronization of the spreading code for obtaining a filtered data vector.
In yet another aspect, the present system discloses a method performed by a computer for filtering interference and noise of an asynchronous wireless signal comprising: receiving an asynchronous data vector including a spreading code; using the received asynchronous data vector, updating weight coefficients of an adaptive filter without prior knowledge of synchronization of the spreading code; using the updated weight coefficients information to determine synchronization of the spreading code; and demodulating the output of the filter using the determined synchronization of the spreading code for obtaining a filtered data vector.
The method further comprises the step of dividing the data vector represented by x[i] into two channels x1[i] and d1[i] using a transformation T1 on x[i], represented by T1x[i], wherein the transformed data vector x[i] does not contain information about a designated sender's spreading code s1, and d1[i] contains primarily only information about the spreading code s1 and residual data from correlation of s1 and x[i].
In yet another aspect, the present system describes an adaptive receiver for filtering interference and noise of an asynchronous wireless signal comprising: means for receiving an asynchronous data vector including information data bits; means for updating weight coefficients of an adaptive filter without prior knowledge of synchronization of the information data bits for determining the start of the information data bits; and means for demodulating the output of the adaptive filter.



BRIEF DESCRIPTION OF DRAWINGS
Other embodiments of the present invention will become readily apparent to those skilled in the art from the following detailed description. As will be realized, the invention is capable of other and different embodiments and its several details are capable of modification in various respects, all without departing from the spirit and scope of the present invention. Accordingly, the drawings and detailed description are to be regarded as illustrative in nature and not as restrictive.
FIG. 1A is an exemplary block diagram of a mobile phone channel;
FIG. 1 is an exemplary block diagram of an asynchronous DS-CDMA system;
FIGS. 2(a)–2(g) are exemplary timing diagrams of construction of a typical DS signal;
FIG. 3 is an exemplary block diagram of a receiver according to one embodiment of the present invention;
FIG. 4 is an exemplary block diagram of a structure of a test statistic;
FIG. 5 is an exemplary block diagram of a multistage decomposition of a likelihood ratio test for M=4;
FIG. 6 is an exemplary decomposition of data vectors of FIG. 7;
FIG. 7 is an exemplary conceptual block diagram of a self-synchronized detector;
FIG. 8 is an exemplary flow diagram for deriving test statistics by the iterative version of the multistage adaptive filter;
FIG. 9 is an exemplary conceptual flow diagram of block 77 of FIG. 7;
FIG. 9A is an exemplary algorithm for finding the maximum of |Re{y[i]}| over NS period;
FIG. 10 is an exemplary flow diagram for demodulation system of FIG. 7; and
FIGS. 11–20 are performance charts for various embodiments of the present invention.



DETAIL DESCRIPTION
In this invention, an adaptive near-far resistant receiver for asynchronous DS-CDMA is described which assumes no prior knowledge of synchronization. The receiver of the present invention only needs to have knowledge of the spreading code of the desired user. Also there is no need of a separate training period or of data-free observations. The receiver is composed of a near-far resistant acquisition criterion and demodulation scheme. Furthermore, a lower complexity version of the receiver is developed that is related to the concept of the multistage Wiener filter described in J. S. Goldstein, I. S. Reed, and L. L. Scharf, “A multistage representation of the Wiener filter based on orthogonal projections,” IEEE Trans. Inform. Theory, vol. 44, pp. 2943–2959, November 1998 [16], the contents of which are hereby expressly incorporated by reference. This results in a substantial reduction of the computational burden and a rapid convergence in an adaptive implementation. Finally, an iterative version of the multistage decomposition is developed.
As shown in L. E. Brennan and I. S. Reed, “A digital adaptive antenna for JTIDS,” The final report on contract F19628-88-C-0098, Adaptive Sensors, Inc., December 1989, submitted to the Electronic Systems Division AFSC, USAF [15], the contents of which are hereby expressly incorporated by reference, acquisition is an optimum signal detection problem analogous to radar-signal detection. In [15], the detector of the signal looks at each sampling interval for a new data set of N samples that occur periodically, where N is the spreading gain of the system. This is accomplished by a moving window or its physical realization, using a tapped delay line (TDL). This moving window is used to sweep through each periodic time interval of N samples. In each such time period, an estimate of the timing is obtained from the maximum of a set of optimum adaptive filter outputs. Thus, synchronization can be done sequentially over the code length by the maximum likelihood detector. For demodulation, an adaptive MMSE receiver described in [4] and [7] is implemented. One approach for implementing the receiver is the equivalent of a TDL, finite impulse response (FIR) adaptive filter bank. Such an FIR detector-demodulator adaptive filter bank is converted then to the considerably simpler bank of iterative or infinite impulse response (IIR) filters.
The authors in [16] have developed a new type of reduced-rank adaptive Wiener filter. With the concept of the reduced-rank multistage-Wiener adaptive filter a lower complexity version of the receiver is developed. As a consequence, covariance-matrix inversions or eigen decompositions are avoided, thereby making possible a substantial reduction in computational complexity. The multistage scheme not only eliminates matrix inversions, but its adaptive version which is developed in [7] can be realized directly from the raw A/D converted digital data without any need for an explicit estimation of the covariance matrix. These important features contribute to a significant reduction of the computational cost and the amount of sample support usually required to accurately estimate the covariance matrix, as shown in I. S. Reed, J. D. Mallet, and L. E. Brannan, “Rapid convergence rate in adaptive arrays,” IEEE Trans. Aerosp. Electron. Syst., AES-10, pp. 853–863, November 1974 [24], the contents of which are hereby expressly incorporated by reference.
In this invention, a new iterative method or an IIR version of the reduced-rank multistage-Wiener adaptive filter is developed. In this new method, the coefficients of each filter of a filter bank are updated every time that a data vector is received. Thus, each filter continuously keeps track of the changes of the environment. Furthermore, this new algorithm is implemented more efficiently because it obviates the necessity of matrix multiplications. This new algorithm can be realized as an iterative or IIR adaptive filter bank with each filter of the type suggested in [6], whereas the original algorithm in [16] or the training-based algorithm in [7] needs to be realized as an FIR adaptive filter.
For simplicity reasons, only binary phase-shift keying (BPSK) modulation is developed and used in this disclosure, however, it will be recognized by those skilled in the art that other modulation schemes for other embodiments of the invention are also possible. Therefore, the receiver can be applied to many other modulation schemes that utilize other symbol alphabets and spreading-sequence generators. Furthermore, the present invention is not limited by the type of modulation code or the code length of the desired user or of the other users. For example, the family of 4-phase sequence developed in P. V. Kumar, H. F. Francis Lu, T. Helleseth and D.-J. Shin, “On the Large Family of Low Correlation Quaternary Sequences S(2),” Proceedings of the IEEE Intnl. Conf. Personal Wireless Comm., (ICPWC'2000), Hyderbad, pp. 33–37, Dec. 17–20, 2000 [26], the contents of which are hereby expressly incorporated by reference, can also be used as a spreading sequence in addition to the Gold code (described in Appendix A). Synchronization and demodulation of the receiver system is derived in detail in the following sections. The reduced-rank version of the receiver that is based on the multistage representation of the Wiener adaptive filter is also described below.
Asynchronous DS-CDMA System Model
Consider an asynchronous DS-CDMA system that uses BPSK modulation with K simultaneous users on an additive white Gaussian noise (AWGN) baseband channel, as illustrated in FIG. 1. The received signal can be written in the form,




  
    
      
        
          
            r
            ⁡
            
              (
              t
              )
            
          
          =
          
            
              
                ∑
                
                  m
                  =
                  
                    -
                    ∞
                  
                
                ∞
              
              ⁢
              
                
                  ∑
                  
                    k
                    =
                    1
                  
                  K
                
                ⁢
                
                  
                    A
                    k
                  
                  ⁢
                  
                    
                      b
                      k
                    
                    ⁡
                    
                      [
                      m
                      ]
                    
                  
                  ⁢
                  
                    
                      s
                      k
                    
                    ⁡
                    
                      (
                      
                        t
                        -
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          
                            T
                            b
                          
                        
                        -
                        
                          τ
                          k
                        
                      
                      )
                    
                  
                
              
            
            +
            
              n
              ⁡
              
                (
                t
                )
              
            
          
        
        ,
      
    
    
      
        (
        1
        )
      
    
  




where the parameters and other quantities are defined as follows:

    
    
        Tb Information symbol interval.
        n(t) Additive white Gaussian noise (AWGN).
        bk[m] The m-th information symbol of the k-th user and bk[m]ε{−1, 0, 1} where symbol zero denotes the fact that the k-th user is off (has either not started or has finished transmission).
        Ak Amplitude of the k-th user.
        τk The propagation delay of the k-th user.
    
    


Here, Sk(t) is the spreading waveform of the k-th user, given by




  
    
      
        
          
            
              s
              k
            
            ⁡
            
              (
              t
              )
            
          
          =
          
            
              ∑
              
                j
                =
                0
              
              
                N
                -
                1
              
            
            ⁢
            
              
                c
                j
                
                  (
                  k
                  )
                
              
              ⁢
              
                φ
                ⁡
                
                  (
                  
                    t
                    -
                    
                      j
                      ⁢
                      
                        
                      
                      ⁢
                      
                        T
                        c
                      
                    
                  
                  )
                
              
            
          
        
        ,
      
    
    
      
        (
        2
        )
      
    
  




where Tc is the chip interval and φ(t) is the chip waveform, which is assumed to approximate a rectangular pulse of duration Tc. (Each bit in the spreading code is called a chip.) The spreading code waveforms have unit amplitude and are assumed to be periodic with the time period Tb. In one symbol period, there are N=Tb/Tc chips, modulated with the spreading code (C0(k),C1(k), . . . , CN−1(k)). Here, also N is called the spreading gain.

To understand how the asynchronous DS-CDMA signal is determined, an example for K=2 and N=31, is presented next. In the DS-CDMA system, the information-bearing sequence for each user is spread over a broader bandwidth by means of a spreading wave-form that is unique to that user. FIGS. 2(a)–2(g) depict construction of a typical DS signal. FIGS. 2(a) and 2(b) are parts of two information sequences, FIGS. 2(c) and 2(d) are two spreading waveforms, FIGS. 2(e) and 2(f) are the two modulated waveforms to be transmitted, one for the desired user 1 and the other for the interfering user (user 2). FIG. 2(g) is the combined waveform of FIGS. 2(e) and 2(f). Note that user 2 is assumed to be delayed by τ2−τ1=4Tc seconds with respect to user 1. FIG. 2(a) shows two bits of an information sequence for user 1. The spreading waveform of user 1 is shown in FIG. 2(c). It is constructed by modulating the chip waveform φ(t) by means of a spreading code. In this example, a Gold code of length 31 is employed for the spreading code of user 1, given by s1=(−1, −1, −1, 1, 1, −1, 1, 1, 1, 1, −1, 1, 1, −1, 1, −1, −1, −1, 1, 1, 1, 1, 1, 1, −1, 1, −1, −1, −1, −1, −1) (see Appendix A). Each bit in the spreading code s1 is called a chip. FIG. 2(e) shows the modulated baseband DS signal that corresponds to the multiplication (modulation) of the information sequence and the spreading waveform in FIGS. 2(a) and 2(c). The interfering information signal of user 2 that contributes to the received signal, is assumed to be offset in time from that of user 1 by 4Tc and is illustrated in FIG. 2(b). Also, FIGS. 2(d) and (f) show the spreading waveform and the modulated signal of user 2. The spreading code for user 2 is given by s2=(1, 1, 1, 1, −1, 1, −1, −1, −1, 1, −1, −1, 1, −1, −1, 1, −1, −1, 1, 1, −1, 1, −1, −1, −1, −1, −1, 1, −1, −1, −1). The baseband transmitted signal for the time interval [t, t+2Tb], shown in FIG. 2(g), is the sum of the modulated signals of both users.
To facilitate the derivation of the receiver, the communication channel is assumed to approximate a time-invariant channel over some interval of time exceeding N chips, i.e. the channel is quasi-stationary. In particular, the number, the powers, the delay profiles of the users and the interferers are assumed to be fixed (but unknown). Only the turning on-and-off of the information sequences, their bk's, and the AWGN are changing in time. In scenarios of this type, it turns out that the receiver is able to adapt quickly to any such changing environment. As a consequence such assumptions affect the usefulness of the receiver of the present invention only minimally.
An exemplary receiver structure is shown in FIG. 3. For simplicity in its realization, the proposed receiver is described using a baseband-equivalent structure. Such a baseband complex signal process is physically achieved by the combination of quadrature demodulation and a phase-locked loop (PLL). (For example, see J. G. Proakis, Digital Communications, McGraw-Hill, New York, N.Y., 3rd edition, 1995, Chapter 6 [25], the contents of which are hereby expressly incorporated by reference). This converts the received radio frequency (RF) modulated signal to a baseband complex-valued signal. This means that after converting the received signal to baseband complex-valued signals, the received signal is passed through a filter that is matched to the square-wave chip (or other type of waveform that is used to be the chip waveform). The output of this chip matched filter is




  
    
      
        
          x
          ⁡
          
            (
            t
            )
          
        
        =
        
          
            
              ∫
              t
              
                t
                +
                
                  T
                  ⁢
                  
                    
                  
                  ⁢
                  c
                
              
            
            ⁢
            
              
                r
                ⁡
                
                  (
                  
                    t
                    ′
                  
                  )
                
              
              ⁢
              
                d
                
                  t
                  ′
                
              
            
          
          =
          
            
              ∫
              0
              
                T
                ⁢
                
                  
                
                ⁢
                c
              
            
            ⁢
            
              
                r
                ⁡
                
                  (
                  
                    
                      t
                      ′
                    
                    -
                    t
                  
                  )
                
              
              ⁢
              
                
                  d
                  
                    t
                    ′
                  
                
                .
              
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




After that the output of the chip matched filter is sampled once every Ts seconds, where S=Tc/Ts is an integer and S≧1. This means, that the sampling rate is greater than or equal to the chip rate. Then the output is used as the input to the N-element tapped delay line (TDL). The signal is sampled at time iTs so that the tapped delay line can be expressed by the column vector,

x[i]=[x(iTs),x(iTs−Tc), . . . ,x(iTs−(N−1)Tc)]T,  (4)

where [.]T denotes matrix transpose. Similarly the tap-weights' vector is expressed as the column vector,

w[i]=[w0[i], w1[i], . . . , wN−1[i]]T.  (5)

The components of the weight vector w[i] are determined later in Eq. (30) of Section 3.1.

The output of the tapped delay line filter, y[i], is given by the inner product of the vectors in Eqs. (4) and (5) as follows:




  
    
      
        
          
            y
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                
                  w
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                †
              
              ⁢
              
                x
                ⁡
                
                  [
                  i
                  ]
                
              
            
            =
            
              
                ∑
                
                  n
                  =
                  0
                
                
                  N
                  -
                  1
                
              
              ⁢
              
                
                  
                    
                      ω
                      n
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  *
                
                ⁢
                
                  x
                  ⁡
                  
                    (
                    
                      
                        i
                        ⁢
                        
                          
                        
                        ⁢
                        
                          T
                          s
                        
                      
                      -
                      
                        T
                        c
                      
                      +
                      
                        m
                        ⁢
                        
                          
                        
                        ⁢
                        
                          T
                          b
                        
                      
                    
                    )
                  
                
              
            
          
        
        ,
      
    
    
      
        (
        6
        )
      
    
  




where [.]† denotes the conjugate (Hermitian) transpose of a matrix, and [.]* denotes the conjugate of a complex number. This output is passed through the time acquisition and demodulation system to obtain the information bit after synchronization. This time acquisition system can be modeled as a filter bank constructed of NS parallel receivers, each of the type shown in FIG. 3, in order to identify the time phases at which to demodulate the information symbols of the desired user.

Receiver Structure, Synchronization System

As shown in [15], the synchronization problem in communications is a signal detection problem analogous to radar detection. This problem can be modeled as a binary hypothesis problem, where hypothesis H1 corresponds to target signal presence, and hypothesis H0 corresponds to target-signal absence. Thus at each time sample of the N-vector x[i] the synchronization receiver need to distinguish between two hypotheses of some user, say user 1. The target signal under hypothesis H1 is denoted by the N-vector A1b1s1, where A1 is the amplitude of user 1, b1 is the information bit of user 1, and




  
    s
    1
  
  =
  
    
      [
      
        
          c
          0
          
            (
            1
            )
          
        
        ,
        
          c
          1
          
            (
            1
            )
          
        
        ,
        ...
        ⁢
        
          
        
        ,
        
          c
          
            N
            -
            1
          
          
            (
            1
            )
          
        
      
      ]
    
    T
  




is the signature sequence of user 1, where the observation vector at the sample time iTs is the N-vector x[i], given in Eq. (4).

The noise environment is composed of N-vectors that are due to the combined effects of the interference sources and white noise. The noise process n(t) is assumed to approximate complex Gaussian noise with zero mean by an application of the central limit theorem [11] and a covariance matrix, defined as follows:

Rn[i]=E {n[i]n†[i]}  (7)

Thus, at a particular symbol interval the two hypotheses, which the adaptive detector need to distinguish at each sampling time, are given by

H0: x [i]=n[i],

H1: x [i]=A1b1s1+n[i].

given b1 where b1=+1 or −1. Note that the condition b1=0, x[i] is equivalent to the null hypothesis H0.

For simplicity, let N=Tb/Tc and S=Tc/Ts, where both numbers are integers. If the spreading code modulation is approximately band-limited, the case S=2 would correspond with Nyquist sampling. It is easy to show that the covariance matrix of the sample vector x[i] is periodic with the integer time period NS. In other words, x[i] is a cyclostationary process with period NS.
The random vector x[i], when conditioned on the first user's information symbol b1, is approximately Gaussian under both hypotheses. The condition probability densities of x[i] are




  
    
      
        
          
            
              
                p
                ⁡
                
                  (
                  
                    
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      |
                      
                        H
                        1
                      
                    
                    ,
                    
                      b
                      1
                    
                  
                  )
                
              
              =
              
              ⁢
              
                
                  1
                  
                    
                      π
                      N
                    
                    ⁢
                    d
                    ⁢
                    
                      
                    
                    ⁢
                    e
                    ⁢
                    
                      
                    
                    ⁢
                    
                      t
                      ⁡
                      
                        (
                        
                          
                            R
                            n
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        )
                      
                    
                  
                
                ⁢
                
                  e
                  
                    
                      -
                      
                        
                          (
                          
                            
                              x
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                            -
                            
                              
                                A
                                1
                              
                              ⁢
                              
                                b
                                1
                              
                              ⁢
                              
                                s
                                1
                              
                            
                          
                          )
                        
                        †
                      
                    
                    ⁢
                    
                      
                        R
                        n
                        
                          -
                          1
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      (
                      
                        
                          x
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        -
                        
                          
                            A
                            1
                          
                          ⁢
                          
                            b
                            1
                          
                          ⁢
                          
                            s
                            1
                          
                        
                      
                      )
                    
                  
                
              
            
          
        
        
          
            
              
                
                  p
                  ⁡
                  
                    (
                    
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      |
                      
                        H
                        0
                      
                    
                    )
                  
                
                =
                
                ⁢
                
                  
                    1
                    
                      
                        π
                        N
                      
                      ⁢
                      d
                      ⁢
                      
                        
                      
                      ⁢
                      e
                      ⁢
                      
                        
                      
                      ⁢
                      
                        t
                        ⁡
                        
                          (
                          
                            
                              R
                              n
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          )
                        
                      
                    
                  
                  ⁢
                  
                    e
                    
                      
                        -
                        
                          
                            x
                            †
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                      
                      ⁢
                      
                        
                          R
                          n
                          
                            -
                            1
                          
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                    
                  
                
              
              ,
            
          
        
      
    
    
      
        (
        8
        )
      
    
  




where det(R) denotes the determinant of R. From Eq. (8), the conditional probability density of p(x [i]|H1,b1) can be expressed in terms of p(x [i]|H1,b1) for b1=±1 as follows:





  
    
      
        
          
            p
            ⁡
            
              (
              
                
                  x
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                |
                
                  H
                  1
                
              
              )
            
          
          =
          
            
              ∑
              
                b
                1
              
            
            ⁢
            
              
                p
                ⁡
                
                  (
                  
                    b
                    1
                  
                  )
                
              
              ·
              
                p
                ⁡
                
                  (
                  
                    
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      |
                      
                        H
                        1
                      
                    
                    ,
                    
                      b
                      1
                    
                  
                  )
                
              
            
          
        
        ,
      
    
    
      
        (
        9
        )
      
    
  




where p(b1=1)=p(b1=−1)=1/2. Then, the likelihood-ratio test (LRT) takes the form,





  
    
      
        
          Λ
          =
          
            
              
                p
                ⁡
                
                  (
                  
                    
                      x
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    |
                    
                      H
                      1
                    
                  
                  )
                
              
              
                p
                ⁡
                
                  (
                  
                    
                      x
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    |
                    
                      H
                      0
                    
                  
                  )
                
              
            
            ⁢
            
              
                ⋛
                H
              
              0
              
                H
                1
              
            
            ⁢
            γ
          
        
        ,
      
    
    
      
        (
        10
        )
      
    
  




where γ is the detection threshold. The substitution of the conditional probability density functions, given in Eq. (9), into Eq. (10) yields:





  
    
      
        
          
            
              Λ
              =
              
                
                  1
                  2
                
                ⁢
                
                  (
                  
                    
                      
                        p
                        ⁡
                        
                          (
                          
                            
                              
                                x
                                ⁡
                                
                                  [
                                  i
                                  ]
                                
                              
                              |
                              
                                H
                                1
                              
                            
                            ,
                            
                              
                                b
                                1
                              
                              =
                              1
                            
                          
                          )
                        
                      
                      +
                      
                        p
                        ⁡
                        
                          (
                          
                            
                              
                                x
                                ⁡
                                
                                  [
                                  i
                                  ]
                                
                              
                              |
                              
                                H
                                1
                              
                            
                            ,
                            
                              
                                b
                                1
                              
                              =
                              
                                -
                                1
                              
                            
                          
                          )
                        
                      
                    
                    
                      p
                      ⁡
                      
                        (
                        
                          
                            x
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          |
                          
                            H
                            0
                          
                        
                        )
                      
                    
                  
                  )
                
              
            
          
        
        
          
            
              =
              
                
                  
                    
                      e
                      
                        
                          -
                          
                            
                              (
                              
                                
                                  A
                                  1
                                
                                ⁢
                                
                                  s
                                  1
                                
                              
                              )
                            
                            †
                          
                        
                        ⁢
                        
                          
                            R
                            n
                            
                              -
                              1
                            
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        ⁢
                        
                          (
                          
                            
                              A
                              1
                            
                            ⁢
                            
                              s
                              1
                            
                          
                          )
                        
                      
                    
                    ⁡
                    
                      [
                      
                        
                          e
                          
                            
                              -
                              2
                            
                            ⁢
                            R
                            ⁢
                            
                              
                            
                            ⁢
                            e
                            ⁢
                            
                              {
                              
                                
                                  
                                    (
                                    
                                      
                                        A
                                        1
                                      
                                      ⁢
                                      
                                        s
                                        1
                                      
                                    
                                    )
                                  
                                  †
                                
                                ⁢
                                
                                  
                                    R
                                    n
                                    
                                      -
                                      1
                                    
                                  
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                                ⁢
                                
                                  x
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                              
                              }
                            
                          
                        
                        +
                        
                          e
                          
                            2
                            ⁢
                            Re
                            ⁢
                            
                              {
                              
                                
                                  
                                    (
                                    
                                      
                                        A
                                        1
                                      
                                      ⁢
                                      
                                        s
                                        1
                                      
                                    
                                    )
                                  
                                  †
                                
                                ⁢
                                
                                  
                                    R
                                    n
                                    
                                      -
                                      1
                                    
                                  
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                                ⁢
                                
                                  x
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                              
                              }
                            
                          
                        
                      
                      ]
                    
                  
                  2
                
                .
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




Thus, the likelihood ratio test in Eq. (10) reduces to





  
    
      
        
          Λ
          =
          
            
              cosh
              ⁡
              
                (
                
                  2
                  ⁢
                  R
                  ⁢
                  
                    
                  
                  ⁢
                  e
                  ⁢
                  
                    {
                    
                      
                        
                          (
                          
                            
                              A
                              1
                            
                            ⁢
                            
                              b
                              1
                            
                            ⁢
                            
                              s
                              1
                            
                          
                          )
                        
                        †
                      
                      ⁢
                      
                        
                          R
                          n
                          
                            -
                            1
                          
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                    
                    }
                  
                
                )
              
            
            ⁢
            
              ⋛
              
                H
                0
              
              
                H
                1
              
            
            ⁢
            
              γ
              1
            
          
        
        ,
      
    
    
      
        (
        12
        )
      
    
  




where γ1 is a new decision constant. Since the hyperbolic cosine function cosh(.) is a monotonically increasing function in the magnitude of its argument, the test in Eq. (12) is clearly equivalent to





  
    
      
        
          
            |
            
              Re
              ⁢
              
                {
                
                  q
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                }
              
              |
            
          
          =
          
            |
            
              Re
              ⁢
              
                {
                
                  
                    s
                    1
                    †
                  
                  ⁢
                  
                    
                      R
                      n
                      
                        -
                        1
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    x
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                }
              
            
            |
            
              
                ⋛
                
                  H
                  0
                
                
                  H
                  1
                
              
              ⁢
              
                γ
                2
              
            
          
        
        ,
        
          

        
        ⁢
        where
      
    
    
      
        (
        
          13a
        
        )
      
    
  
  
    
      
        
          
            q
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              s
              1
              †
            
            ⁢
            
              
                R
                n
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              x
              ⁡
              
                [
                i
                ]
              
            
          
        
        ,
      
    
    
      
        (
        
          13
          ⁢
          b
        
        )
      
    
  




and γ2 is another constant.

The test statistic in Eq. (13a) can be used at each clock time or phase within the time period NTc to test for the existence of the signal of a particular user, If

Q[i]={|Re{q[i]}|, . . . ,|Re{q[i−NS+1]}|}  (14)

is the set of such tests in increasing time sequence of the form, given in Eq. (13a) over a past spreading code period total of NS clock times, then the integer clock time î ε {i, i−1, . . . , i−NS+1}, such that





  
    
      
        
          |
          
            Re
            ⁢
            
              {
              
                q
                ⁡
                
                  [
                  
                    i
                    ^
                  
                  ]
                
              
              }
            
            |
          
        
        =
        
          
            max
            
              k
              ∈
              
                {
                
                  0
                  ,
                  1
                  ,
                  
                    
                  
                  ,
                  
                    NS
                    -
                    1
                  
                
                }
              
            
          
          ⁢
          
            |
            
              Re
              ⁢
              
                {
                
                  q
                  ⁡
                  
                    [
                    
                      i
                      -
                      k
                    
                    ]
                  
                
                }
              
              |
            
          
        
      
    
    
      
        (
        15
        )
      
    
  




is attained, is the time that synchronization is most likely to occur within the interval (i−NS+1, i). The “greatest of” sequence-in-time test in Eq. (15) detects sequentially the maximum of all likelihood tests in the filter bank of the tests in the set Q [i] in Eq. (14).

The matrix Rn[i] in Eqs. (13a) and (13b) is the covariance matrix of the signal-free observation N-vector x[i]=n[i]. In the classical adaptive-array application it is normally possible to collect signal-free observation vectors. However, in a CDMA-type system, obtaining signal-free observation vectors at the receiver is not at all a trivial task. The test in Eq. (13a) needs to be considerably modified in order to be realized with both signal-plus-noise and noise-only data vectors.
To accomplish this modification test in Eq. (13a) is expressed equivalently next in, what is called, the generalized sidelobe canceler (GSC) form. Consider an N×N nonsingular matrix T1 with the structure,




  
    
      
        
          
            T
            1
          
          =
          
            [
            
              
                
                  
                    u
                    1
                    †
                  
                
              
              
                
                  
                    B
                    1
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        16
        )
      
    
  




where B1 is, what is called, a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector





  
    u
    1
  
  =
  
    
      s
      1
    
    /
    
      
        
          
            s
            1
            †
          
          ⁢
          
            s
            1
          
        
      
      .
    
  




That is,

B1u1=B1s1=0.  (17)

The test statistic in Eq. (13a) can be re-expressed in terms of the transformation T1, defined in Eqs. (16) and (17) as the expression,





  
    
      
        
          |
          
            R
            ⁢
            
              
            
            ⁢
            e
            ⁢
            
              {
              
                
                  s
                  1
                  †
                
                ⁢
                
                  
                    R
                    n
                    
                      -
                      1
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  x
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              }
            
            |
          
        
        =
        
          |
          
            
              Re
              (
              
                
                  s
                  1
                  †
                
                ⁢
                
                  
                    
                      T
                      1
                      †
                    
                    ⁡
                    
                      (
                      
                        
                          T
                          1
                        
                        ⁢
                        
                          
                            R
                            n
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        ⁢
                        
                          T
                          1
                          †
                        
                      
                      )
                    
                  
                  
                    -
                    1
                  
                
                ⁢
                
                  T
                  1
                
                ⁢
                
                  x
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              }
            
            ⁢
            
              |
              .
            
          
        
      
    
    
      
        (
        18
        )
      
    
  




To evaluate the latter test statistic in Eq. (13a), let the transformed output vector be expressed in the form,





  
    
      
        
          
            
              T
              1
            
            ⁢
            
              x
              ⁡
              
                [
                i
                ]
              
            
          
          =
          
            
              [
              
                
                  
                    
                      
                        u
                        1
                        †
                      
                      ⁢
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                    
                  
                
                
                  
                    
                      
                        B
                        1
                      
                      ⁢
                      
                        x
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                    
                  
                
              
              ]
            
            =
            
              [
              
                
                  
                    
                      
                        d
                        1
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
                
                  
                    
                      
                        x
                        1
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              ]
            
          
        
        ,
      
    
    
      
        (
        19
        )
      
    
  




where





  
    
      d
      1
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      u
      1
      †
    
    ⁢
    
      x
      ⁡
      
        [
        i
        ]
      
    
  




is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed.

Here, the data vector x[i] is divided by the transformation T1 into two channels or paths, namely, d1[i] and x1[i], respectively, as shown in FIG. 4. The transformed data vector x1[i] does not contain any information about the signal s1 because it was obtained by a projection of the data onto the orthogonal complement of the signal subspace. Actually, in the channel of the d1[i] process, obtained when the data vector x[i] is projected onto the signal subspace, the interference has been suppressed already due to the low cross-correlation property of the other users' spreading codes. This d1[i] process is the same process that is obtained from the cross-correlation conventional detector which yields for low interference level an acceptable performance by the exploitation of this property. However, with severe MAI due to the near-far problem, it is possible that the contribution of the interference in the d1[i] channel is still significant. Thus, the other channel x1[i] which contains information only about the interference-plus-noise can be used to partially cancel the interference-plus-noise process in the d1[i] channel. Then the herein described multistage decomposition for a Wiener filter provides a natural and optimal way to accomplish such a step-by-step cancellation process.
The correlation matrix of the transformed vector T1x[i] can be expressed as the following partitioned matrix:




  
    
      
        
          
            
              T
              1
            
            ⁢
            
              
                R
                x
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              T
              1
              †
            
          
          =
          
            
              [
              
                
                  
                    
                      
                        u
                        1
                        †
                      
                      ⁢
                      
                        
                          R
                          x
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        u
                        1
                      
                    
                  
                  
                    
                      
                        u
                        1
                        †
                      
                      ⁢
                      
                        
                          R
                          x
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                        †
                      
                    
                  
                
                
                  
                    
                      
                        B
                        1
                      
                      ⁢
                      
                        
                          R
                          x
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        u
                        1
                      
                    
                  
                  
                    
                      
                        B
                        1
                      
                      ⁢
                      
                        
                          R
                          x
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                        †
                      
                    
                  
                
              
              ]
            
            =
            
              [
              
                
                  
                    
                      
                        σ
                        
                          d
                          1
                        
                        2
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  
                    
                      
                        r
                        
                          
                            x
                            1
                          
                          ⁢
                          
                            d
                            1
                          
                        
                        †
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
                
                  
                    
                      
                        r
                        
                          
                            x
                            1
                          
                          ⁢
                          
                            d
                            1
                          
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  
                    
                      
                        R
                        
                          x
                          1
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              ]
            
          
        
        ,
        
          

        
        ⁢
        where
        ,
      
    
    
      
        (
        20
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                σ
                
                  d
                  1
                
                2
              
              ⁡
              
                [
                i
                ]
              
            
            =
            
              
                
                  u
                  1
                  †
                
                ⁢
                
                  
                    R
                    x
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  u
                  1
                
              
              =
              
                E
                ⁢
                
                  {
                  
                    |
                    
                      
                        d
                        1
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      |
                      2
                    
                  
                  }
                
              
            
          
          ,
        
      
    
    
      
        (
        21
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                r
                
                  
                    x
                    1
                  
                  ⁢
                  
                    d
                    1
                  
                
              
              ⁡
              
                [
                i
                ]
              
            
            =
            
              
                
                  B
                  1
                
                ⁢
                
                  
                    R
                    x
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  u
                  1
                
              
              =
              
                E
                ⁢
                
                  {
                  
                    
                      
                        x
                        1
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        d
                        1
                        *
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  }
                
              
            
          
          ,
        
      
    
    
      
        (
        22
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                R
                
                  x
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            =
            
              
                B
                1
              
              ⁢
              
                
                  R
                  x
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                B
                1
                †
              
            
          
          ,
        
      
    
    
      
        (
        23
        )
      
    
  




with E{.} denoting the expected value operator. Next the signal-free correlation matrix Rn[i], needed in Eq. (13a), can be expressed in terms of Rx[i] by





  
    
      
        
          
            
              R
              n
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                R
                x
              
              ⁡
              
                [
                i
                ]
              
            
            -
            
              
                A
                1
                2
              
              ⁢
              
                s
                1
              
              ⁢
              
                s
                1
                †
              
            
          
        
        ,
      
    
    
      
        (
        
          23a
        
        )
      
    
  




where





  
    s
    1
  
  ⁢
  
    s
    1
    †
  




is the N×N matri outer product of vector s1 by itself. If one defines the positive number,





  
    
      δ
      1
    
    =
    
      
        
          s
          1
          †
        
        ⁢
        
          s
          1
        
      
    
  
  ,




it can be shown, using Eq. (23a), that





  
    
      
        
          
            
              T
              1
            
            ⁢
            
              
                R
                n
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              T
              1
              †
            
          
          =
          
            
              [
              
                
                  
                    
                      
                        u
                        1
                        †
                      
                      ⁢
                      
                        
                          R
                          n
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        u
                        1
                      
                    
                  
                  
                    
                      
                        u
                        1
                        †
                      
                      ⁢
                      
                        
                          R
                          n
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                        †
                      
                    
                  
                
                
                  
                    
                      
                        B
                        1
                      
                      ⁢
                      
                        
                          R
                          n
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        u
                        1
                      
                    
                  
                  
                    
                      
                        B
                        1
                      
                      ⁢
                      
                        
                          R
                          n
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                        †
                      
                    
                  
                
              
              ]
            
            =
            
              [
              
                
                  
                    
                      
                        
                          σ
                          
                            d
                            1
                          
                          2
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      +
                      
                        
                          A
                          1
                          2
                        
                        ⁢
                        
                          δ
                          1
                          2
                        
                      
                    
                  
                  
                    
                      
                        r
                        
                          
                            x
                            1
                          
                          ⁢
                          
                            d
                            1
                          
                        
                        †
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
                
                  
                    
                      
                        r
                        
                          
                            x
                            1
                          
                          ⁢
                          
                            d
                            1
                          
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  
                    
                      
                        R
                        
                          x
                          1
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              ]
            
          
        
        ,
      
    
    
      
        (
        
          23
          ⁢
          b
        
        )
      
    
  




With the aid of the matrix inversion lemma in Jerry M. Mendel, Lessons in Estimation Theory for Signal Processing, Communications, and Control, Prentice-Hall, Englewood Cliffs, N.J., 1995 [17], the contents of which are hereby expressly incorporated by reference, the inverse of




  
    T
    1
  
  ⁢
  
    
      R
      n
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    T
    1
    †
  




is computed to be





  
    
      
        
          
            (
            
              
                T
                1
              
              ⁢
              
                
                  R
                  n
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                T
                1
                †
              
            
            )
          
          
            -
            1
          
        
        ⁢
        
           
          
            =
            
               
              
                
                  
                    
                      (
                      
                        
                          
                            ξ
                            1
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        +
                        
                          
                            A
                            1
                            2
                          
                          ⁢
                          
                            δ
                            1
                            2
                          
                        
                      
                      )
                    
                    
                      -
                      1
                    
                  
                  ⁡
                  
                    [
                    
                      
                        
                          1
                        
                        
                          
                            
                              
                                r
                                
                                  
                                    x
                                    1
                                  
                                  ⁢
                                  
                                    d
                                    1
                                  
                                
                                †
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                            ⁢
                            
                              
                                R
                                
                                  x
                                  1
                                
                                
                                  -
                                  1
                                
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                          
                        
                      
                      
                        
                          
                            -
                            
                               
                              
                                
                                  
                                    R
                                    
                                      x
                                      1
                                    
                                    
                                      -
                                      1
                                    
                                  
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                                ⁢
                                
                                  
                                    r
                                    
                                      
                                        x
                                        1
                                      
                                      ⁢
                                      
                                        d
                                        1
                                      
                                    
                                  
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                              
                            
                          
                        
                        
                          
                            
                              
                            
                            ⁢
                            
                              
                                
                                  R
                                  
                                    x
                                    1
                                  
                                  
                                    -
                                    1
                                  
                                
                                ⁡
                                
                                  [
                                  i
                                  ]
                                
                              
                              ⁢
                              
                                (
                                
                                  
                                    
                                      (
                                      
                                        
                                          
                                            ξ
                                            1
                                          
                                          ⁡
                                          
                                            [
                                            i
                                            ]
                                          
                                        
                                        +
                                        
                                          
                                            A
                                            1
                                            2
                                          
                                          ⁢
                                          
                                            δ
                                            1
                                            2
                                          
                                        
                                      
                                      )
                                    
                                    ⁢
                                    I
                                  
                                  +
                                  
                                    
                                      
                                        r
                                        
                                          
                                            x
                                            1
                                          
                                          ⁢
                                          
                                            d
                                            1
                                          
                                        
                                      
                                      ⁡
                                      
                                        [
                                        i
                                        ]
                                      
                                    
                                    ⁢
                                    
                                      
                                        r
                                        
                                          
                                            x
                                            1
                                          
                                          ⁢
                                          
                                            d
                                            1
                                          
                                        
                                        †
                                      
                                      ⁡
                                      
                                        [
                                        i
                                        ]
                                      
                                    
                                    ⁢
                                    
                                      
                                        R
                                        
                                          x
                                          1
                                        
                                        
                                          -
                                          1
                                        
                                      
                                      ⁡
                                      
                                        [
                                        i
                                        ]
                                      
                                    
                                  
                                
                                )
                              
                            
                          
                        
                      
                    
                    ]
                  
                
                ,
                
                  

                
                ⁢
                where
              
            
          
        
      
    
    
      
        (
        24
        )
      
    
  
  
    
      
        
          
            ξ
            1
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              σ
              
                d
                1
              
              2
            
            ⁡
            
              [
              i
              ]
            
          
          -
          
            
              
                r
                
                  
                    x
                    1
                  
                  ⁢
                  
                    d
                    1
                  
                
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                R
                
                  x
                  1
                
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  r
                  
                    
                      x
                      1
                    
                    ⁢
                    
                      d
                      1
                    
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              .
            
          
        
      
    
    
      
        (
        25
        )
      
    
  




Then, the transformed signal T1s1 is given by the vector,





  
    
      
        
          
            
              T
              1
            
            ⁢
            
              s
              1
            
          
          =
          
            
              
                [
                
                  
                    
                      (
                      
                        
                          s
                          1
                          †
                        
                        ⁢
                        
                          s
                          1
                        
                      
                      )
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  0
                  ⁢
                  
                    
                  
                  ⁢
                  ...
                  ⁢
                  
                    
                  
                  ⁢
                  0
                
                ]
              
              †
            
            =
            
              
                
                  δ
                  1
                
                ⁡
                
                  [
                  
                    1
                    ⁢
                    
                      
                    
                    ⁢
                    0
                    ⁢
                    
                      
                    
                    ⁢
                    ...
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                  ]
                
              
              †
            
          
        
        ,
      
    
    
      
        (
        27
        )
      
    
  




Hence, the test statistic in Eq. (13a) can be re-expressed as





  
    
      
        
          
            
              
                
                  
                  
                    Re
                    ⁢
                    
                      {
                      
                        
                          s
                          1
                          †
                        
                        ⁢
                        
                          
                            R
                            n
                            
                              -
                              1
                            
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        ⁢
                        
                          x
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                      
                      }
                    
                  
                  
                
                =
                
                  
                  
                    Re
                    ⁢
                    
                      {
                      
                        
                          s
                          1
                          †
                        
                        ⁢
                        
                          
                            
                              T
                              1
                              †
                            
                            ⁡
                            
                              (
                              
                                
                                  T
                                  1
                                
                                ⁢
                                
                                  
                                    R
                                    n
                                  
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                                ⁢
                                
                                  T
                                  1
                                  †
                                
                              
                              )
                            
                          
                          
                            -
                            1
                          
                        
                        ⁢
                        
                          T
                          1
                        
                        ⁢
                        
                          x
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                      
                      }
                    
                  
                  
                
              
            
          
          
            
              
                
                  =
                  
                    
                    
                      Re
                      ⁢
                      
                        {
                        
                          
                            
                              (
                              
                                
                                  
                                    ξ
                                    1
                                  
                                  ⁡
                                  
                                    [
                                    i
                                    ]
                                  
                                
                                +
                                
                                  
                                    A
                                    1
                                    2
                                  
                                  ⁢
                                  
                                    δ
                                    1
                                    2
                                  
                                
                              
                              )
                            
                            
                              -
                              1
                            
                          
                          ⁢
                          
                            
                              δ
                              1
                              *
                            
                            ⁡
                            
                              (
                              
                                
                                  u
                                  1
                                  †
                                
                                -
                                
                                  
                                    
                                      w
                                      GSC
                                      †
                                    
                                    ⁡
                                    
                                      [
                                      i
                                      ]
                                    
                                  
                                  ⁢
                                  
                                    B
                                    1
                                  
                                
                              
                              )
                            
                          
                          ⁢
                          
                            x
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                        
                        }
                      
                    
                    
                  
                
                ,
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          where
          ,
        
      
    
    
      
        (
        28
        )
      
    
  
  
    
      
        
          
            w
            GSC
            †
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              r
              
                
                  x
                  1
                
                ⁢
                
                  d
                  1
                
              
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                R
                
                  x
                  1
                
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            .
          
        
      
    
    
      
        (
        29
        )
      
    
  




From Eq. (28) the term δ1 is a positive constant which can be moved to the other side of the test in Eq. (13a). Also the term





  
    (
    
      
        
          ξ
          1
        
        ⁡
        
          [
          i
          ]
        
      
      +
      
        
          A
          1
          2
        
        ⁢
        
          δ
          1
          2
        
      
    
    )
  
  
    -
    1
  




defined in Eq. (26), does not vary significantly over the period NS when the signal A1s1 is comparable to the interference-plus-noise power level so that





  
    (
    
      
        
          ξ
          1
        
        ⁡
        
          [
          i
          ]
        
      
      +
      
        
          A
          1
          2
        
        ⁢
        
          δ
          1
          2
        
      
    
    )
  
  
    -
    1
  




is approximately a positive constant over the same NS time period. Hence also the term





  
    (
    
      
        
          ξ
          1
        
        ⁡
        
          [
          i
          ]
        
      
      +
      
        
          A
          1
          2
        
        ⁢
        
          δ
          1
          2
        
      
    
    )
  
  
    -
    1
  




can be moved to the other side of the test in Eq. (13a). Thus the test statistic q[i] in Eq. (13a) can be modified to a new test statistic y[i] given as follows:





  
    
      
        
          
            
            
              Re
              ⁢
              
                {
                
                  y
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                }
              
            
            
          
          =
          
            
              
              
                Re
                ⁢
                
                  {
                  
                    
                      (
                      
                        
                          u
                          1
                          †
                        
                        -
                        
                          
                            
                              w
                              GSC
                              †
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            B
                            1
                          
                        
                      
                      )
                    
                    ⁢
                    
                      x
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  }
                
              
              
            
            ⁢
            
              ⋛
              
                H
                0
              
              
                H
                1
              
            
            ⁢
            
              γ
              2
            
          
        
        ,
      
    
    
      
        (
        30
        )
      
    
  




where the weight vector in Eq. (5) has been replaced by





  
    
      
        
          
            u
            1
            †
          
          -
          
            
              
                w
                GSC
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              B
              1
            
          
        
        ,
      
    
    
      
        (
        
          30a
        
        )
      
    
  




and y[i] which replaces q[i] in Eqs.(14) and (15) is defined by the modified likelihood ratio test





  
    
      
        
          y
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            (
            
              
                u
                1
                †
              
              -
              
                
                  
                    w
                    GSC
                    †
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  B
                  1
                
              
            
            )
          
          ⁢
          
            
              x
              ⁡
              
                [
                i
                ]
              
            
            .
          
        
      
    
    
      
        (
        
          30b
        
        )
      
    
  




The block-diagram structure of this new test statistic is shown in FIG. 4. Evidently, this test statistic has the form of the classical sidelobe canceler, used in the past to suppress or cancel interferers or jamming of radars and communication systems. Also note that the modified test to determine î for synchronization in Eq. (15) is given by




  
    
      
        
          
          
            Re
            ⁢
            
              {
              
                y
                ⁡
                
                  [
                  
                    i
                    ^
                  
                  ]
                
              
              }
            
          
          
        
        =
        
          
            max
            
              kε
              ⁡
              
                (
                
                  0
                  ,
                  1
                  ,
                  
                    
                  
                  ⁢
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                  
                  ⁢
                  
                    
                      N
                      ⁢
                      
                        
                      
                      ⁢
                      S
                    
                    -
                    1
                  
                
                )
              
            
          
          ⁢
          
            
            
              Re
              ⁢
              
                {
                
                  y
                  ⁡
                  
                    [
                    
                      i
                      -
                      k
                    
                    ]
                  
                
                }
              
            
            
          
        
      
    
    
      
        (
        
          30c
        
        )
      
    
  




with q[i] replaced by y[i] in Eq. (30b).

From the test statistic in Eq. (30) the expression WGSC is the only term to utilize the covariance matrix. It is easily verifiable that




  
    
      
        
          
            
              R
              
                x
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                B
                1
              
              ⁢
              
                
                  R
                  n
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                B
                1
                †
              
            
            =
            
              
                
                  
                    B
                    1
                  
                  ⁡
                  
                    (
                    
                      
                        
                          R
                          x
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      -
                      
                        
                          A
                          1
                          2
                        
                        ⁢
                        
                          s
                          1
                        
                        ⁢
                        
                          s
                          1
                          †
                        
                      
                    
                    )
                  
                
                ⁢
                
                  B
                  1
                  †
                
              
              =
              
                
                  B
                  1
                
                ⁢
                
                  
                    R
                    x
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  B
                  1
                  †
                
              
            
          
        
        ,
      
    
    
      
        (
        31
        )
      
    
  
  
    
      
        
          
            r
            
              
                x
                1
              
              ⁢
              
                d
                1
              
            
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              B
              1
            
            ⁢
            
              
                R
                n
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              s
              1
            
          
          =
          
            
              
                
                  B
                  1
                
                ⁡
                
                  (
                  
                    
                      
                        R
                        x
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    -
                    
                      
                        A
                        1
                        2
                      
                      ⁢
                      
                        s
                        1
                      
                      ⁢
                      
                        s
                        1
                        †
                      
                    
                  
                  )
                
              
              ⁢
              
                s
                1
              
            
            =
            
              
                B
                1
              
              ⁢
              
                
                  R
                  x
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  s
                  1
                
                .
              
            
          
        
      
    
    
      
        (
        32
        )
      
    
  




These relations in Eqs. (31) and (32) demonstrate that the test statistic in Eq. (30) remains invariant to the presence or absence of a signal component in the observation vector x[i].

Demodulation System

Once synchronization is established, data demodulation is accomplished by the use of a MMSE detector [4, 5]. Let x[î], where î is the time phase or clock time defined in Eq. (15) at which synchronization occurs, be the observation vector obtained upon synchronization. Then, the estimate of the information symbol b1 is obtained from the estimation statistic in Eq. (30) has the form,




  
    
      
        
          
            
              b
              ^
            
            1
          
          =
          
            sgn
            ⁡
            
              (
              
                Re
                ⁢
                
                  {
                  
                    
                      
                        (
                        
                          
                            A
                            1
                          
                          ⁢
                          
                            s
                            1
                          
                        
                        )
                      
                      †
                    
                    ⁢
                    
                      
                        R
                        x
                        
                          -
                          1
                        
                      
                      ⁡
                      
                        [
                        
                          i
                          ^
                        
                        ]
                      
                    
                    ⁢
                    
                      x
                      ⁡
                      
                        [
                        
                          i
                          ^
                        
                        ]
                      
                    
                  
                  }
                
              
              )
            
          
        
        ,
      
    
    
      
        (
        33
        )
      
    
  




where sgn denotes the sign operator. Since the amplitude A1 and the norm of the signal sequence, namely





  
    
      s
      1
      †
    
    ⁢
    
      s
      1
    
  




is positive, the estimate of b1 can be simplified to





  
    
      
        
          
            b
            ^
          
          1
        
        =
        
          
            sgn
            ⁡
            
              (
              
                Re
                ⁢
                
                  {
                  
                    
                      u
                      1
                      †
                    
                    ⁢
                    
                      
                        R
                        x
                        
                          -
                          1
                        
                      
                      ⁡
                      
                        [
                        
                          i
                          ^
                        
                        ]
                      
                    
                    ⁢
                    
                      x
                      ⁡
                      
                        [
                        
                          i
                          ^
                        
                        ]
                      
                    
                  
                  }
                
              
              )
            
          
          .
        
      
    
    
      
        (
        34
        )
      
    
  




However, for the modified test statistic in FIG. 4, the estimate of b1 is obtained by replacing the weight vector u1†Rx−1[î] in Eq. (34) by the new weight vector in Eq. (30). Thus





  
    
      
        
          
            b
            ^
          
          1
        
        =
        
          
            sgn
            ⁡
            
              (
              
                Re
                ⁢
                
                  {
                  
                    
                      (
                      
                        
                          u
                          1
                          †
                        
                        -
                        
                          
                            
                              w
                              GSC
                              †
                            
                            ⁡
                            
                              [
                              
                                i
                                ^
                              
                              ]
                            
                          
                          ⁢
                          
                            B
                            1
                          
                        
                      
                      )
                    
                    ⁢
                    
                      x
                      ⁡
                      
                        [
                        
                          i
                          ^
                        
                        ]
                      
                    
                  
                  }
                
              
              )
            
          
          .
        
      
    
    
      
        (
        35
        )
      
    
  




is the modified estimate of the information symbol to use hereafter in this invention. It should be noted that the term





  
    (
    
      
        u
        1
        †
      
      -
      
        
          
            w
            GSC
            †
          
          ⁡
          
            [
            
              i
              ^
            
            ]
          
        
        ⁢
        
          B
          1
        
      
    
    )
  
  ⁢
  
    x
    ⁡
    
      [
      
        i
        ^
      
      ]
    
  




is used in common with both the synchronization system and the demodulation system. This term can be computed and stored during the acquisition process. It does not need to be recomputed for demodulation.

An Exemplary Implementation of the Receiver

Recall that x(m)[i] is the observation vector at the sampling time iTs of the m-th symbol. Assume that L approximately independent snapshots (samples) of the observation vector x(m)[i] are available for the initial acquisition of the detector parameters. These data are given in matrix form by

X0[i]Δ[x(1)[i], . . . , x(L)[i]].

The maximum likelihood estimator for Rx[i] is computed then to be





  
    
      
        R
        ^
      
      x
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
        
        ⁢
        
          
            
              x
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              x
              
                
                  (
                  m
                  )
                
                *
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          
            X
            0
            †
          
          ⁡
          
            [
            i
            ]
          
        
        .
      
    
  




The two statistics needed to find wGSC can be computed by the following:





  
    
      
        
          
            
              R
              ^
            
            
              x
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              B
              1
            
            ⁢
            
              
                
                  R
                  ^
                
                
                  x
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              B
              1
              †
            
          
          =
          
            
              1
              L
            
            ⁢
            
              B
              1
            
            ⁢
            
              
                X
                0
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                0
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              B
              1
              †
            
          
        
      
    
  
  
    
      
        
          
            r
            ^
          
          
            
              x
              1
            
            ⁢
            
              d
              1
            
          
        
        =
        
          
            
              B
              1
            
            ⁢
            
              
                
                  R
                  ^
                
                x
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              s
              1
            
          
          =
          
            
              1
              L
            
            ⁢
            
              B
              1
            
            ⁢
            
              
                X
                0
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                0
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              s
              1
            
          
        
      
    
  




By substitution of these two estimates into Eqs.(30) and (35), an adaptive version of the proposed receiver is obtained.

Lower Complexity with the Multistage Representation

Recently, rank-reduction methods have received considerable attention in the context of a Wiener filter [16] and in J. S. Goldstein and I. S. Reed, “Reduced-rank adaptive filtering,” IEEE Trans. Signal Processing, vol. 45, pp. 492–496, February 1997 [18], the contents of which are hereby expressly incorporated by reference, in which form the detection tests in Eqs.(30) and (35) can be applied. To achieve this, the observation vector is projected onto a lower dimensional subspace, and the Wiener filter is constrained to lie in this subspace. This procedure makes possible optimal signal detection and accurate signal estimation while allowing for a lower computational complexity and a smaller sample support.
In this section a reduced-rank version of the receiver is developed which is based on a new Wiener filter structure, called “multistage representation of the Wiener filter,” [16]. This multistage structure represents a pioneering breakthrough in that it achieves near full rank detection and estimation performance with often only a small number of stages. This can result in a substantial reduction of the computational burden and a rapid convergence in an adaptive implementation without any need for matrix inversion.
To achieve the desired multistage decomposition of the likelihood ratio test in Eq. (13a), successive orthogonal decompositions are applied to the observed data. Actually, the derivation of the test in Eq. (30) from Eq. (13a) can be considered to be the first stage of the multistage decomposition. To accomplish the second stage of the decomposition, the same technique is applied to the term x1[i]=B1x[i] and wGSC defined in Eq. (29). First, define u2[i] as the vector,




  
    
      
        
          
            
              u
              2
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            =
            Δ
          
          ⁢
          
            
              
                r
                
                  
                    x
                    1
                  
                  ⁢
                  
                    d
                    1
                  
                
              
              ⁡
              
                [
                i
                ]
              
            
            
              
                
                  
                    r
                    
                      
                        x
                        1
                      
                      ⁢
                      
                        d
                        1
                      
                    
                    †
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  
                    r
                    
                      
                        x
                        1
                      
                      ⁢
                      
                        d
                        1
                      
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
            
          
        
        ,
      
    
    
      
        (
        36
        )
      
    
  




where, rx1d1[i] is the correlation defined in Eq. (22). Then, define a new nonsingular trans-formation T2[i], similar to T1 in (16), by





  
    
      
        
          
            
              T
              2
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            [
            
              
                
                  
                    
                      u
                      2
                      †
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              
                
                  
                    
                      B
                      2
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        37
        )
      
    
  




where the rows of the (N−2)×N matrix B2[i] is the null space of u2[i], i.e., B2[i]u2[i]=0. Thus, the new transformed vector under transformation T2[i] is represented by





  
    
      
        
          
            
              T
              2
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              x
              1
            
            ⁡
            
              [
              i
              ]
            
          
        
        =
        
          
            [
            
              
                
                  
                    
                      
                        u
                        2
                        †
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        x
                        1
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              
                
                  
                    
                      
                        B
                        2
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        x
                        1
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
            
            ]
          
          =
          
            [
            
              
                
                  
                    
                      d
                      2
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              
                
                  
                    
                      B
                      2
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
            ]
          
        
      
    
    
      
        (
        38
        )
      
    
  




in accordance with the definition in Eq. (19) for the first stage decomposition. The procedure for the decomposition of the likelihood ratio test in the first stage is repeated in the second stage. By following the same arguments that lead to Eqs. (28) and (29), the second stage decomposition of the likelihood ratio is calculated from Eq. (28) by the relations





  
    
      
        
          
            
              
                y
                ⁡
                
                  [
                  i
                  ]
                
              
              =
              
                
                  (
                  
                    
                      u
                      1
                      †
                    
                    -
                    
                      
                        
                          w
                          GSC
                          †
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                      
                    
                  
                  )
                
                ⁢
                
                  x
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
            
          
        
        
          
            
              =
              
                (
                
                  
                    u
                    1
                    †
                  
                  -
                  
                    
                      
                        ω
                        2
                        *
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      (
                      
                        
                          
                            u
                            2
                            †
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        -
                        
                          
                            
                              r
                              
                                
                                  x
                                  2
                                
                                ⁢
                                
                                  d
                                  2
                                
                              
                              †
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              R
                              
                                x
                                2
                              
                              
                                -
                                1
                              
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              B
                              2
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            B
                            1
                          
                        
                      
                      )
                    
                    ⁢
                    
                      x
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
                )
              
            
          
        
        
          
            
              
                =
                
                  
                    
                      d
                      1
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  -
                  
                    
                      
                        ω
                        2
                        *
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      (
                      
                        
                          
                            d
                            2
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        -
                        
                          
                            
                              r
                              
                                
                                  x
                                  2
                                
                                ⁢
                                
                                  d
                                  2
                                
                              
                              †
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              R
                              
                                x
                                2
                              
                              
                                -
                                1
                              
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              x
                              2
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                        
                      
                      )
                    
                  
                
              
              ,
            
          
        
      
    
    
      
        (
        39
        )
      
    
  




where





  
    
      ω
      2
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    =
    Δ
  
  ⁢
  
     
    
      
        
          
            δ
            2
          
          ⁡
          
            [
            i
            ]
          
        
        
          
            ξ
            2
          
          ⁡
          
            [
            i
            ]
          
        
      
      ,
      
        
          
            δ
            2
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                
                  
                    r
                    
                      
                        x
                        1
                      
                      ⁢
                      
                        d
                        1
                      
                    
                    †
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  
                    r
                    
                      
                        x
                        1
                      
                      ⁢
                      
                        d
                        1
                      
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
            
            ⁢
            
              
            
            ⁢
            and
            ⁢
            
              
            
            ⁢
            
              
                ξ
                2
              
              ⁡
              
                [
                i
                ]
              
            
          
          =
          
            
              
                σ
                
                  d
                  2
                
                2
              
              ⁡
              
                [
                i
                ]
              
            
            -
            
              
                
                  r
                  
                    
                      x
                      2
                    
                    ⁢
                    
                      d
                      2
                    
                  
                  †
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  R
                  
                    x
                    2
                  
                  
                    -
                    1
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  
                    r
                    
                      
                        x
                        2
                      
                      ⁢
                      
                        d
                        2
                      
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                .
              
            
          
        
      
    
  




Also, define an error signal ε2[i] as





  
    
      
        
          
            ε
            2
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              d
              2
            
            ⁡
            
              [
              i
              ]
            
          
          -
          
            
              
                r
                
                  
                    x
                    2
                  
                  ⁢
                  
                    d
                    2
                  
                
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                R
                
                  x
                  2
                
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  x
                  2
                
                ⁡
                
                  [
                  i
                  ]
                
              
              .
            
          
        
      
    
    
      
        (
        40
        )
      
    
  




The variance of ε2[i] in Eq. (40) is given by





  
    
      
        
          
            σ
            
              ε
              2
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          E
          ⁢
          
            
              {
              
                
                  
                    ε
                    2
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  
                    ε
                    2
                    *
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              }
            
            .
          
        
      
    
    
      
        (
        41
        )
      
    
  




Thus, the substitution of Eq. (40) into Eq. (41) yields:





  
    
      
        
          
            
              
                
                  σ
                  
                    ε
                    2
                  
                  2
                
                ⁡
                
                  [
                  i
                  ]
                
              
              =
              
                E
                ⁢
                
                  {
                  
                    
                      (
                      
                        
                          
                            d
                            2
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        -
                        
                          
                            
                              r
                              
                                
                                  x
                                  2
                                
                                ⁢
                                
                                  d
                                  2
                                
                              
                              †
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              R
                              
                                x
                                2
                              
                              
                                -
                                1
                              
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              x
                              2
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                        
                      
                      )
                    
                    ⁢
                    
                      
                        (
                        
                          
                            
                              d
                              2
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          -
                          
                            
                              
                                r
                                
                                  
                                    x
                                    2
                                  
                                  ⁢
                                  
                                    d
                                    2
                                  
                                
                                †
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                            ⁢
                            
                              
                                R
                                
                                  x
                                  2
                                
                                
                                  -
                                  1
                                
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                            ⁢
                            
                              
                                x
                                2
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                          
                        
                        )
                      
                      †
                    
                  
                  }
                
              
            
          
        
        
          
            
              =
              
                
                  
                    σ
                    
                      d
                      2
                    
                    2
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                -
                
                  2
                  ⁢
                  
                    
                      r
                      
                        
                          x
                          2
                        
                        ⁢
                        
                          d
                          2
                        
                      
                      †
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      R
                      
                        x
                        2
                      
                      
                        -
                        1
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      r
                      
                        
                          x
                          2
                        
                        ⁢
                        
                          d
                          2
                        
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                +
                
                  
                    
                      r
                      
                        
                          x
                          2
                        
                        ⁢
                        
                          d
                          2
                        
                      
                      †
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      R
                      
                        x
                        2
                      
                      
                        -
                        1
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      R
                      
                        x
                        2
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      R
                      
                        x
                        2
                      
                      
                        -
                        1
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      r
                      
                        
                          x
                          2
                        
                        ⁢
                        
                          d
                          2
                        
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  
                    
                      σ
                      
                        d
                        2
                      
                      2
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  -
                  
                    
                      
                        r
                        
                          
                            x
                            2
                          
                          ⁢
                          
                            d
                            2
                          
                        
                        †
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        R
                        
                          x
                          2
                        
                        
                          -
                          1
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        r
                        
                          
                            x
                            2
                          
                          ⁢
                          
                            d
                            2
                          
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
                =
                
                  
                    
                      ξ
                      2
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  .
                
              
            
          
        
      
    
    
      
        (
        42
        )
      
    
  




Recall from Eq. (25) that





  
    
      
        ξ
        1
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            σ
            
              d
              2
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              r
              
                
                  x
                  2
                
                ⁢
                
                  d
                  2
                
              
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              R
              
                x
                2
              
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              r
              
                
                  x
                  2
                
                ⁢
                
                  d
                  2
                
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
      =
      
        
          σ
          
            ε
            1
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,




where ε1[i]=d1[i]−rx1d1†[i]Rx1−1[i]x1[i] is defined similarly to ε2[i] in Eq. (40). From Eqs. (39) and (40), one obtains the relation

ε1[i]=y[i]=d1[i]−ω2*[i]ε2[i],  (43)

between ε1[i] and ε2[i]. Hence the variance ξ1[i] in Eq. (25) can be expressed further by





  
    
      
        
          
            
              
                
                  ξ
                  1
                
                ⁡
                
                  [
                  i
                  ]
                
              
              =
              
                
                  
                    σ
                    
                      d
                      1
                    
                    2
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                -
                
                  
                    
                      r
                      
                        
                          x
                          1
                        
                        ⁢
                        
                          d
                          1
                        
                      
                      †
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        T
                        2
                        †
                      
                      ⁡
                      
                        (
                        
                          
                            T
                            2
                          
                          ⁢
                          
                            
                              R
                              
                                x
                                1
                              
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            T
                            2
                            †
                          
                        
                        )
                      
                    
                    
                      -
                      1
                    
                  
                  ⁢
                  
                    T
                    2
                  
                  ⁢
                  
                    
                      r
                      
                        
                          x
                          1
                        
                        ⁢
                        
                          d
                          1
                        
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
          
        
        
          
            
              
                =
                
                  
                    
                      σ
                      
                        d
                        1
                      
                      2
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  -
                  
                    
                      
                        ξ
                        2
                        
                          -
                          1
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        δ
                        2
                        2
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              ,
            
          
        
      
    
    
      
        (
        44
        )
      
    
  




thereby directly relating the variance ξ1[i] with the corresponding variance ξ2[i] of the second stage of the multistage decomposition.

A continuation of this decomposition process, extending Eq. (39), yields the N-stage likelihood ratio test in terms of only scalar quantities in recursive form as follows:

y[i]=d1[i]−ω2*[i](d2[i]−ω3*[i]( . . . ωN−1*[i](dN−1[i]−ωN*[i]dN[i]) . . . )).  (45)

More complete details of the multistage decomposition are developed in [16]; and J. S. Goldstein, I. S. Reed, and P. A. Zulch, “Multistage partially adaptive STAP CFAR detection algorithm, ” IEEE Trans. Aerosp. Electron. Syst., vol. 35, pp. 645–661, April 1999 [19], the contents of which are hereby expressly incorporated by reference.

Rank reduction is realized as a truncation of the full-scale structure of the formula in Eq. (45) at the M-th stage, where M<N. That is, the rank-M detector is obtained by stopping the decomposition at stage M, i.e. by setting BM[i]=0. As consequence, εM[i]=dM[i] and




  
    
      ξ
      M
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        σ
        
          ε
          M
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          σ
          
            d
            M
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      .
    
  




The complete recursion procedure for the rank-M version of the likelihood ratio test in Eq. (13a) is summarized in Table 1 as a pseudocode (also given in [16] and FIG. 5). The exemplary block diagram of FIG. 5 illustrates the likelihood ratio test for M=4.
Table 1 shows recursion formulas for the reduced-rank likelihood ratio test.









TABLE 1









Initialization:







  
    
      u
      1
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ,
  
    
  
  ⁢
  
    
      B
      1
    
    =
    
      null
      ⁡
      
        (
        
          u
          1
        
        )
      
    
  
  ,
  
    
      
        x
        0
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      x
      ⁡
      
        [
        i
        ]
      
    
  







 



Forward Recursion



For j = 1 to M − 1













  
    
      d
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        u
        j
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        x
        
          j
          -
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
  







xj[i] = Bj[i]xj−1[i]







  
    
      r
      
        
          x
          j
        
        ⁢
        
          d
          j
        
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    E
    ⁢
    
      {
      
        
          
            x
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            d
            j
            *
          
          ⁡
          
            [
            i
            ]
          
        
      
      }
    
  











  
    
      δ
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
    
      
        r
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    
  







 







  
    
      u
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          r
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
        
          
            r
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
          
          ⁡
          
            [
            i
            ]
          
        
        
      
    
    =
    
      
        
          r
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          δ
          
            j
            +
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  







 



Bj+1[i] = null(uj+1[i])









End









Define xM−1[i] = dM[i] = εM[i]









Backward Recursion













  
    
      σ
      
        d
        M
      
      2
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    E
    ⁢
    
      {
      
        
          
          
            
              d
              M
            
            ⁡
            
              [
              i
              ]
            
          
          
        
        2
      
      }
    
  











  
    
      
        ξ
        M
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        σ
        
          d
          M
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
  
  ,
  
    
      
        ω
        M
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          ξ
          M
          
            -
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          
            δ
            M
          
          ⁡
          
            [
            i
            ]
          
        
        .
      
    
  













For j = M − 1 to 2













  
    
      σ
      
        d
        j
      
      2
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    E
    ⁢
    
      {
      
        
          
          
            
              d
              j
            
            ⁡
            
              [
              i
              ]
            
          
          
        
        2
      
      }
    
  











  
    
      ξ
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        σ
        
          d
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    -
    
      
        
          ξ
          
            j
            +
            1
          
          
            -
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          δ
          
            j
            +
            1
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
    
  











  
    
      ω
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        ξ
        j
        
          -
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        δ
        j
      
      ⁡
      
        [
        i
        ]
      
    
  













End










Adaptive Realization of the Multistage Decomposition of the Test

Usually, the covariance matrix for an adaptive filter is not known a priori with any certainty. Thus to perform the detection test in Eq. (30), it is necessary to find a statistical estimate {circumflex over (R)}x[i] to substitute for Rx[i]. In addition, the inversion of {circumflex over (R)}x[i] is needed for each iTs where 0≦i≦NS−1. This involves high computational complexity, and it is not a trivial task to accomplish.
However, the multistage structure that is introduced in the previous section not only eliminates the task of covariance matrix inversion, but its adaptive versions can be realized directly from the observation data without the explicit estimate of the covariance matrix, given in Eq. (47). Furthermore, when the code vector of the desired user is known to the demodulator, the coefficients of the adaptive multistage detector, i.e., uj, Bj and ωj, are determined without any knowledge of the reference information symbols.
In [6, 7], a training-based algorithm for the multistage decomposition is introduced. Using this algorithm, one does not need to calculate an estimate of the covariance matrix. The coefficients of the detector can be estimated directly from the received data vectors and then be used to demodulate the data after the training period. Also, in this algorithm, the dimension of the blocking matrix {circumflex over (B)}j[i] can be kept the same (i.e., in an N×N matrix form) for every stage. Evidently, such a blocking matrix can be obtained from the following formula:




  
    
      
        
          
            
              
                B
                ^
              
              j
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            I
            -
            
              
                
                  
                    u
                    ^
                  
                  j
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  
                    u
                    ^
                  
                  j
                  †
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
        
        ,
      
    
    
      
        (
        48
        )
      
    
  




where ûj[i] is on estimate of unit vector uj[i] in Table. 1.

In this manner, the lengths of the registers needed to store the blocking matrices and vectors can be kept the same for every stage, a fact that is very desirable for either a hardware or software realization. To obtain this algorithm let




  
    
      
        
          
            
              d
              j
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            =
            Δ
          
          ⁢
          
            
              [
              
                
                  
                    
                      d
                      ^
                    
                    j
                    
                      (
                      1
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    
                      d
                      ^
                    
                    j
                    
                      (
                      L
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              ]
            
            =
            
              
                
                  
                    u
                    ^
                  
                  j
                  †
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  X
                  
                    j
                    -
                    1
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
        
        ,
      
    
    
      
        (
        49
        )
      
    
  
  
    
      
        
          
            
              X
              j
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            =
            Δ
          
          ⁢
          
            
              [
              
                
                  
                    x
                    j
                    
                      (
                      1
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    x
                    j
                    
                      (
                      L
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              ]
            
            =
            
              
                
                  
                    B
                    ^
                  
                  j
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  X
                  
                    j
                    -
                    1
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
        
        ,
      
    
    
      
        (
        50
        )
      
    
  




The estimate of the cross-correlation vector {circumflex over (r)}xjdj[i] is computed then as





  
    
      
        
          
            
              
                
                  
                    r
                    ^
                  
                  
                    
                      x
                      j
                    
                    ⁢
                    
                      d
                      j
                    
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              =
              
                
                  
                    
                      
                        B
                        ^
                      
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        R
                        ^
                      
                      
                        x
                        
                          j
                          -
                          1
                        
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        u
                        ^
                      
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                =
                
                  
                    1
                    L
                  
                  ⁢
                  
                    
                      
                        B
                        ^
                      
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      X
                      
                        j
                        -
                        1
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      X
                      
                        j
                        -
                        1
                      
                      †
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        u
                        ^
                      
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  
                    1
                    L
                  
                  ⁢
                  
                    
                      X
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      d
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                =
                
                  
                    1
                    L
                  
                  ⁢
                  
                    
                      ∑
                      
                        m
                        =
                        1
                      
                      L
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        
                          x
                          j
                          
                            (
                            m
                            )
                          
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        
                          
                            
                              d
                              j
                              
                                (
                                m
                                )
                              
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          *
                        
                        .
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        51
        )
      
    
  




Also let the estimate variance of dj[i] be computed by





  
    
      
        
          σ
          ^
        
        
          d
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
        
        ⁢
        
          
            
            
              
                
                  d
                  ^
                
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ,
  
    2
    ≤
    j
    ≤
    
      M
      .
    
  




Table 2 depicts a training-based multistage decomposition algorithm.








TABLE 2







Assume that L independent samples of the observation vector x(m)[i]






  
    are
    ⁢
    
      
    
    ⁢
    available
    ⁢
    
      
    
    ⁢
    for
    ⁢
    
      
    
    ⁢
    the
    ⁢
    
      
    
    ⁢
    initial
    ⁢
    
      
    
    ⁢
    
      acquisition
      .
      
        
      
      ⁢
      Let
    
    ⁢
    
      
    
    ⁢
    
      
        X
        0
      
      ⁡
      
        [
        i
        ]
      
    
  
  ⁢
  
    =
    Δ
  
  ⁢
  
    [
    
      
        
          x
          
            (
            1
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      ,
      ...
      ⁢
      
        
      
      ,
      
        
          x
          
            (
            L
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
    ]
  













Forward Recursion







  
    
      Initialization:
    
    ⁢
    
      
    
    ⁢
    Let
    ⁢
    
      
    
    ⁢
    
      
        u
        ^
      
      1
    
  
  =
  
    
      
        
          s
          1
        
        
          
          
            s
            1
          
          
        
      
      ⁢
      
        
      
      ⁢
      and
      ⁢
      
        
      
      ⁢
      
        
          B
          ^
        
        1
      
    
    =
    
      I
      -
      
        
          
            u
            ^
          
          j
        
        ⁢
        
          
            u
            ^
          
          j
          †
        
      
    
  







 



For j = 1 to (M − 1)









Calculate dj and xj













  
    
      
        d
        j
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        [
        
          
            
              
                d
                ^
              
              j
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ,
          
            
              
                d
                ^
              
              j
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            
              u
              ^
            
            j
            †
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            X
            
              j
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,











  
    
      
        X
        j
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        [
        
          
            
              x
              j
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ,
          
            
              x
              j
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            
              B
              ^
            
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            X
            
              j
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,













Calculate the (j + 1)-th stage basis vector,



 













  
    
      
        r
        ^
      
      
        
          x
          j
        
        ⁢
        
          d
          j
        
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
            
              x
              j
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                d
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            *
          
        
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          X
          j
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          d
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
  







 







  
    
      
        δ
        ^
      
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    
  







 







  
    
      
        u
        ^
      
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    
      
        
          δ
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
  







 









Determine the (j + 1)-th blocking matrix {circumflex over (B)}j+1













  
    
      
        B
        ^
      
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    I
    -
    
      
        
          
            u
            ^
          
          
            j
            +
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
      
      ⁢
      
        
          
            u
            ^
          
          
            j
            +
            1
          
          †
        
        ⁡
        
          [
          i
          ]
        
      
    
  













End







  Compute
  ⁢
  
    
  
  ⁢
  
    
      d
      M
      
        (
        m
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
  
  ⁢
  and
  ⁢
  
    
  
  ⁢
  set
  ⁢
  
    
  
  ⁢
  it
  ⁢
  
    
  
  ⁢
  equal
  ⁢
  
    
  
  ⁢
  to
  ⁢
  
    
  
  ⁢
  
    
      ε
      M
      
        (
        m
        )
      
    
    ⁡
    
      [
      i
      ]
    
  

















  
    
      
        d
        M
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        =
        Δ
      
      ⁢
      
        
          [
          
            
              
                
                  d
                  ^
                
                M
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                
                  d
                  ^
                
                M
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
        =
        
          
            
              e
              M
              †
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                
                  u
                  ^
                
                M
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                
                  M
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
    
  
  ,













Backward Recursion













  
    
      
        
          σ
          ^
        
        
          d
          M
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
              
              
                
                  
                    d
                    ^
                  
                  M
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              
            
            2
          
        
      
      =
      
        
          
            ξ
            ^
          
          M
        
        [
        i
        ]
      
    
  
  ,
  
    
      
        
          ω
          ^
        
        M
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            ξ
            ^
          
          M
          
            -
            1
          
        
        [
        i
        ]
      
      ⁢
      
        
          
            δ
            ^
          
          M
        
        ⁡
        
          [
          i
          ]
        
      
    
  







 









For j = M − 1 to 2









Estimate the variance of dj[i]









 







  
    
      
        σ
        ^
      
      
        d
        j
      
      2
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      1
      L
    
    ⁢
    
      
        ∑
        
          m
          =
          1
        
        L
      
      ⁢
      
        
          
          
            
              
                d
                ^
              
              j
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          
        
        2
      
    
  







 









Estimate the variance of εj













  
    
      
        ξ
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    =
    Δ
  
  ⁢
  
    
  
  ⁢
  
    
      
        
          σ
          ^
        
        
          ε
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            σ
            ^
          
          
            d
            j
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      -
      
        
          
            
              ξ
              ^
            
            
              j
              +
              1
            
            
              -
              1
            
          
          [
          i
          ]
        
        ⁢
        
          
            
              δ
              ^
            
            
              j
              +
              1
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  













Calculate the j-th scalar Wiener filter {circumflex over (ω)}j[i]









 







  
    
      
        ω
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          δ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
    
      
        
          ξ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
  







 









End










Then the variance of the error {circumflex over (ξ)}j[i] can be obtained from the difference equation,





  
    
      
        
          
            
              ξ
              ^
            
            j
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                σ
                ^
              
              
                d
                j
              
              2
            
            ⁡
            
              [
              i
              ]
            
          
          -
          
            
              
                
                  ξ
                  ^
                
                
                  j
                  +
                  1
                
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  
                    δ
                    ^
                  
                  
                    j
                    +
                    1
                  
                  2
                
                ⁡
                
                  [
                  i
                  ]
                
              
              .
            
          
        
      
    
    
      
        (
        52
        )
      
    
  




The rank-M algorithm shown in [7] is summarized in Table. 2. For the blocking matrix {circumflex over (B)}j[i], given in Eq. (48) in Table. 2, one observes that the matrix multiplications required to compute Xj[i] are given in Eq. (50). These matrix multiplications can be avoided by the substitution of {circumflex over (B)}j[i] into Eq. (50). That is,





  
    
      
        
          
            X
            j
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                
                  B
                  ^
                
                j
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                
                  j
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          =
          
            
              (
              
                I
                -
                
                  
                    
                      
                        u
                        ^
                      
                      j
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        u
                        ^
                      
                      j
                      †
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              )
            
            ⁢
            
              
                X
                
                  j
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
    
  
  
    
      
        =
        
          
            
              
                X
                
                  j
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            -
            
              
                
                  
                    u
                    ^
                  
                  j
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  
                    u
                    ^
                  
                  j
                  †
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  X
                  
                    j
                    -
                    1
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
          =
          
            
              
                X
                
                  j
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
            -
            
              
                
                  
                    u
                    ^
                  
                  j
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  
                    d
                    ^
                  
                  j
                  †
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
        
      
    
  




Using this result, a further simplified version of Table 2 is given in Table 3. Note that this new structure no longer requires the calculation of a blocking matrix and the computational complexity is reduced significantly.

In this invention, an iterative algorithm of the multistage decomposition is developed. Instead of estimating the parameters in the batch mode, the parameters also can be estimated iteratively. By this means, the coefficients of the filter are updated every time that data are received. Thus, the filter can more rapidly keep track adaptively of the changes in the interference environment.
An Iterative Version of the Multistage Adaptive Filter
In order to afford the possibility of following the statistical variations of the observed data when the detector operates in a non-stationary environment, a weighting factor is often used to ensure that data in the distant past are forgotten. A special form of weighting that is commonly used is the exponential weighting factor. As shown in Simon Haykin, Adaptive Filter Theory, Prentice-Hall, Upper Saddle River, N.J., 1996, the contents of which are hereby expressly incorporated by reference [20], an estimate of the cross-correlation vector {circumflex over (r)}xjdj[i] can be expressed as




  
    
      
        
          
            
              
                r
                ^
              
              
                
                  x
                  j
                
                ⁢
                
                  d
                  j
                
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              ∑
              
                m
                =
                1
              
              n
            
            ⁢
            
              
            
            ⁢
            
              
                
                  (
                  
                    1
                    -
                    α
                  
                  )
                
                
                  n
                  -
                  m
                
              
              ⁢
              
                
                  x
                  j
                  m
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  
                    d
                    j
                    
                      (
                      m
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                *
              
            
          
        
        ,
      
    
    
      
        (
        53
        )
      
    
  




where α is a positive constant less than 1. The inverse of α is, roughly speaking, a measure of the memory of the algorithm. The special case, when α approaches zero, corresponds to infinite memory.

Table 3 shows a simplified training-based batch-mode multistage decomposition algorithm.







TABLE 3







Assume that L independent samples of the observation vector x(m)[i]






  
    are
    ⁢
    
      
    
    ⁢
    available
    ⁢
    
      
    
    ⁢
    for
    ⁢
    
      
    
    ⁢
    the
    ⁢
    
      
    
    ⁢
    initial
    ⁢
    
      
    
    ⁢
    
      acquisition
      .
      
        
      
      ⁢
      Let
    
    ⁢
    
      
    
    ⁢
    
      
        X
        0
      
      ⁡
      
        [
        i
        ]
      
    
  
  ⁢
  
    =
    Δ
  
  ⁢
  
    [
    
      
        
          x
          
            (
            1
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      ,
      ...
      ⁢
      
        
      
      ,
      
        
          x
          
            (
            L
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
    ]
  













Forward Recursion







  
    
      Initialization:
    
    ⁢
    
      
    
    ⁢
    Let
    ⁢
    
      
    
    ⁢
    
      
        u
        ^
      
      1
    
  
  =
  
    
      
        
          s
          1
        
        
          
          
            s
            1
          
          
        
      
      ⁢
      
        
      
      ⁢
      and
      ⁢
      
        
          
        
        ⁢
        
          
        
      
      ⁢
      
        
          x
          0
        
        ⁡
        
          [
          i
          ]
        
      
    
    =
    
      x
      ⁡
      
        [
        i
        ]
      
    
  







 



For j = 1 to (M − 1)









Calculate dj and xj













  
    
      d
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          u
          ^
        
        j
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        x
        
          j
          -
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
  











  
    
      x
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        x
        
          j
          -
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    -
    
      
        
          
            u
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          d
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
  











  
    
      
        d
        J
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        =
        Δ
      
      ⁢
      
        
          [
          
            
              
                
                  d
                  ^
                
                J
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                
                  d
                  ^
                
                J
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
        =
        
          
            
              
                u
                ^
              
              j
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              X
              
                j
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ,











  
    
      X
      J
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
      =
      Δ
    
    ⁢
    
      
        [
        
          
            
              
                x
                ^
              
              J
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            
              x
              j
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            X
            
              j
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                u
                ^
              
              j
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              d
              j
              †
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  













Calculate the (j + 1)-th stage basis vector,



 













  
    
      
        r
        ^
      
      
        
          x
          j
        
        ⁢
        
          d
          j
        
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
            
              x
              j
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                d
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            *
          
        
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          X
          j
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          d
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
  







 







  
    
      
        δ
        ^
      
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    
  







 







  
    
      
        u
        ^
      
      
        j
        +
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    
      
        
          δ
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
  







 









End







  Compute
  ⁢
  
    
  
  ⁢
  
    
      d
      M
      
        (
        m
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
  
  ⁢
  and
  ⁢
  
    
  
  ⁢
  set
  ⁢
  
    
  
  ⁢
  it
  ⁢
  
    
  
  ⁢
  equal
  ⁢
  
    
  
  ⁢
  to
  ⁢
  
    
  
  ⁢
  
    
      ε
      M
      
        (
        m
        )
      
    
    ⁡
    
      [
      i
      ]
    
  

















  
    
      
        d
        M
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        =
        Δ
      
      ⁢
      
        
          [
          
            
              
                
                  d
                  ^
                
                M
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                
                  d
                  ^
                
                M
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
        =
        
          
            
              e
              M
              †
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                
                  u
                  ^
                
                M
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                
                  M
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
    
  
  ,













Backward Recursion













  
    
      Let
      ⁢
      
        
      
      ⁢
      
        
          
            σ
            ^
          
          
            d
            M
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
              
              
                
                  
                    d
                    ^
                  
                  M
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              
            
            2
          
        
      
      =
      
        
          
            ξ
            ^
          
          M
        
        [
        i
        ]
      
    
  
  ,
  
    
      
        
          ω
          ^
        
        M
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            ξ
            ^
          
          M
          
            -
            1
          
        
        [
        i
        ]
      
      ⁢
      
        
          
            δ
            ^
          
          M
        
        ⁡
        
          [
          i
          ]
        
      
    
  







 









For j = M − 1 to 2









Estimate the variance of dj[i]



 













  
    
      
        σ
        ^
      
      
        d
        j
      
      2
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      1
      L
    
    ⁢
    
      
        ∑
        
          m
          =
          1
        
        L
      
      ⁢
      
        
          
          
            
              
                d
                ^
              
              j
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          
        
        2
      
    
  







 









Estimate the variance of εj













  
    
      
        ξ
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    =
    Δ
  
  ⁢
  
    
  
  ⁢
  
    
      
        
          σ
          ^
        
        
          ε
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            σ
            ^
          
          
            d
            j
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      -
      
        
          
            
              ξ
              ^
            
            
              j
              +
              1
            
            
              -
              1
            
          
          [
          i
          ]
        
        ⁢
        
          
            
              δ
              ^
            
            
              j
              +
              1
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  













Calculate the j-th scalar Wiener filter by {circumflex over (ω)}j[i]



 













  
    
      
        ω
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          δ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
    
      
        
          ξ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
  







 









End










The summation on the right hand side of Eq. (53) can be written as the difference or iterative equation.





  
    
      
        
          
            
              
                
                  
                    r
                    ^
                  
                  
                    
                      x
                      j
                    
                    ⁢
                    
                      d
                      j
                    
                  
                  
                    (
                    n
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              =
              
                
                  
                    (
                    
                      1
                      -
                      α
                    
                    )
                  
                  ⁡
                  
                    [
                    
                      
                        ∑
                        
                          m
                          =
                          1
                        
                        
                          n
                          -
                          1
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          
                            (
                            
                              1
                              -
                              α
                            
                            )
                          
                          
                            n
                            -
                            1
                            -
                            m
                          
                        
                        ⁢
                        
                          
                            x
                            j
                            
                              (
                              m
                              )
                            
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        ⁢
                        
                          
                            d
                            j
                            
                              (
                              m
                              )
                            
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                      
                    
                    ]
                  
                
                +
                
                  
                    
                      x
                      j
                      
                        (
                        n
                        )
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      d
                      j
                      
                        (
                        n
                        )
                      
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
          
        
        
          
            
              
                =
                
                  
                    
                      (
                      
                        1
                        -
                        α
                      
                      )
                    
                    ⁢
                    
                      
                        
                          r
                          ^
                        
                        
                          
                            x
                            j
                          
                          ⁢
                          
                            d
                            j
                          
                        
                        
                          (
                          
                            n
                            -
                            1
                          
                          )
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  +
                  
                    
                      
                        x
                        j
                        
                          (
                          n
                          )
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        d
                        j
                        
                          (
                          n
                          )
                        
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              ,
            
          
        
      
    
    
      
        (
        54
        )
      
    
  




where





  
    
      r
      ^
    
    
      
        x
        j
      
      ⁢
      
        d
        j
      
    
    
      (
      
        n
        -
        1
      
      )
    
  
  ⁡
  
    [
    i
    ]
  




is the previous value of





  
    
      
        r
        ^
      
      
        
          x
          j
        
        ⁢
        
          d
          j
        
      
      
        (
        n
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ,




and the term





  
    
      x
      j
      
        (
        n
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
      
        d
        j
        
          (
          n
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    *
  




is obtained from the new data. Hence, for each iteration, only two quantities





  (
  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          
            n
            -
            1
          
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
    
    ⁢
    and
    ⁢
    
      
    
    ⁢
    
      
        x
        j
        
          (
          n
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        
          d
          j
          
            (
            n
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      *
    
  
  )




are necessary for updating





  
    
      
        r
        ^
      
      
        
          x
          j
        
        ⁢
        
          d
          j
        
      
      
        (
        n
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  .




The length of the observation-data that contributes to the estimate,





  
    
      
        r
        ^
      
      
        
          x
          j
        
        ⁢
        
          d
          j
        
      
      
        (
        n
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ,




is determined by the weighting factor





  
    α
    ⁢
    
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      1
      L
    
  
  ,




where L is the time constant corresponding to the length of the batch-mode in Tables 2 and 3.

The exponential weighting factor is substituted in the algorithm in Table 3. This results in the iterative algorithm shown in Table 4. The algorithms in Tables 3 and 4 do not require any need for matrix multiplications. Also in order to find the estimate î, the time phase interval in Eq. (30c) at which the information of user 1 is found, the algorithm in Table 4 is realized as an IIR adaptive filter bank while the algorithms in Tables. 1, 2 and 3 utilize FIR adaptive filter banks which need substantially more computer memory and computation to realize.
The time phase acquisition process to find the estimate î, defined in Eq. (30c), is illustrated by the conceptual block diagram shown in the FIG. 7. The composition of the data vectors in the exemplary block diagram of FIG. 7 is shown in FIG. 6. The observation data vectors are obtained by sliding a window of length N through the original data. The test statistic y(k)[i] can be derived by the subroutine shown in the FIG. 8. In addition, the conceptual block diagram to find the value of i=î that achieves the maximum value of |Re{y[i]}| is found in FIG. 9. An exemplary algorithm for finding the maximization in Eq. (30c) is shown in FIG. 9A. Finally, FIG. 10 shows the block diagram that is used to demodulate the signal of the desired user.
Numerical Results
In this section simulations were conducted to demonstrate the performance of the proposed asynchronous CDMA receiver. An asynchronous BPSK DS-CDMA system with the number of users K=6 is considered in these simulations. The spreading sequence of each user is a Gold sequence of length N=31 (see Appendix A). A single desired user, say user 1, is acquired and demodulated in the presence of multiple-access interference. Table 4 depicts an exemplary pseudo-code of the iterative multistage decomposition algorithm.







TABLE 4







Let k be the k-th clock time, where k = 1 is the first time the data is


observed. Also let α be the memory or time constant of the algorithm.


For k = 1 to n


 


  



  
    
      
        
          r
          ^
        
        
          
            x
            0
          
          ⁢
          
            d
            0
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      s
      1
    
  
  ,
  
    
      
        
          u
          ^
        
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ,
  
    
      
        
          δ
          ^
        
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
      
        s
        1
      
      
    
  
  ,






 


  



  
    
      x
      0
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
  
  ⁢
  is
  ⁢
  
    
  
  ⁢
  the
  ⁢
  
    
  
  ⁢
  received
  ⁢
  
    
  
  ⁢
  
    vector
    .
  













Forward Recursion



For j = 1 to M − 1













  
    
      d
      j
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          
            u
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      †
    
    ⁢
    
      
        x
        
          j
          -
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
  











  
    
      x
      j
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        x
        
          j
          -
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    -
    
      
        
          
            u
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          d
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  













Calculate the (j + 1)-th stage basis vector,













  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          (
          
            1
            -
            α
          
          )
        
        ⁢
        
          
            
              r
              ^
            
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
            
              (
              
                k
                -
                1
              
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
      +
      
        
          
            x
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
      
    
  
  ,











  
    
      
        δ
        ^
      
      
        j
        +
        1
      
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    
  







 







  
    
      
        u
        ^
      
      
        j
        +
        1
      
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    
      
        
          δ
          ^
        
        
          j
          +
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
  







 









End







  
    
      ε
      M
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          d
          M
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      †
    
    =
    
      
        
          
            
              u
              ^
            
            M
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        †
      
      ⁢
      
        
          x
          
            M
            -
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  







Backward Recursion



For j = M to 2













  Estimate
  ⁢
  
    
  
  ⁢
  the
  ⁢
  
    
  
  ⁢
  variance
  ⁢
  
    
  
  ⁢
  of
  ⁢
  
    
  
  ⁢
  
    
      ε
      j
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  

















  
    
      
        ξ
        ^
      
      j
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          (
          
            
              δ
              ^
            
            
              ε
              j
            
            
              (
              k
              )
            
          
          )
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          (
          
            1
            -
            α
          
          )
        
        ⁢
        
          
            
              ξ
              ^
            
            j
            
              (
              
                k
                -
                1
              
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
      +
      
        
          
          
            
              ε
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          
        
        2
      
    
  

















  Calculate
  ⁢
  
    
  
  ⁢
  the
  ⁢
  
    
  
  ⁢
  j
  ⁢
  
    -
  
  ⁢
  th
  ⁢
  
    
  
  ⁢
  scalar
  ⁢
  
    
  
  ⁢
  Wiener
  ⁢
  
    
  
  ⁢
  filter
  ⁢
  
    
  
  ⁢
  
    
      
        ω
        ^
      
      j
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
  
  ⁢
  by













 







  
    
      
        ω
        ^
      
      j
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          δ
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    
      
        
          ξ
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
  







 













  Calculate
  ⁢
  
    
  
  ⁢
  the
  ⁢
  
    
  
  ⁢
  
    (
    
      j
      -
      1
    
    )
  
  ⁢
  
    -
  
  ⁢
  th
  ⁢
  
    
  
  ⁢
  error
  ⁢
  
    
  
  ⁢
  signal
  ⁢
  
    
  
  ⁢
  
    
      ε
      
        j
        -
        1
      
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ⁢
  
    
  
  ⁢
  by

















  
    
      ε
      
        j
        -
        1
      
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        d
        
          j
          -
          1
        
        
          
            (
            k
            )
          
          ⁢
          
            
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    -
    
      
        
          
            
              ω
              ^
            
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        *
      
      ⁢
      
        
          ε
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  













End













  
    The
    ⁢
    
      
    
    ⁢
    output
    ⁢
    
      
    
    ⁢
    at
    ⁢
    
      
    
    ⁢
    time
    ⁢
    
      
    
    ⁢
    k
    ⁢
    
      -
    
    ⁢
    th
    ⁢
    
      
    
    ⁢
    is
    ⁢
    
      
    
    ⁢
    
      
        y
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
  
  =
  
    
      ε
      1
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  













End










The power ratio between each of the five interfering users and the desired user is designated the MAI level. In this simulation all interfering users are assumed to have the same power ratio relative to the desired user. This power ratio is denoted by a quantity called the near-far ratio (NFR), defined by




  
    
      
        
          NFR
          =
          
            
              A
              k
              2
            
            
              A
              1
              2
            
          
        
        ,
      
    
    
      
        (
        55
        )
      
    
  




where the subscript ‘k’ denotes user k; k=1 is the user of interest. For convenience and simplicity it is assumed in the simulations that the propagation delays of the different users are multiples of Tc. Note that this assumption is not necessary if the sampling rate is higher than 1/TC.

First, the performance of the asynchronous CDMA receiver is found under the assumption that the covariance matrix is known at the receiver. Even though an exact estimation of the covariance matrix is not possible to achieve practically in a real communication system, this experiment provides an upper bound on the performance of the asynchronous CDMA receiver. The algorithm in Table 1 is used for this case.
In FIG. 11, the probability of correct synchronization and the probability of correct demodulation are presented as a function of the signal-to-white noise ratio (Eb/No) under the perfect power-control scenano, i.e., all users have the same signal power (NFR=0 dB). In this case the dimension of the full-rank receiver is equal to N=31. Demodulation is accomplished by the use of the estimate of the propagation delay that is obtained from the synchronization system. It is shown in FIG. 11 (NFR=0 dB) that the detector performs better than the conventional detector. Actually, the conventional detector can be considered to be the rank 1 version of the proposed receiver. It is demonstrated in this figure that a rank 2 filter already gains a significant improvement over the conventional detector. This improvement can be even more when the near-far ratio (NFR) is higher. A rank 3 filter achieves almost the same performance as the full rank (rank 31) filter.
FIG. 12 demonstrates the probability of correct synchronization and the probability of correct demodulation in terms of Eb/No under the near-far situation of NFR=3 dB. All of the other parameters are identical to those used in FIG. 11. Again the covariance matrix is assumed to be known. When the MAI becomes more severe, the receiver performs significantly better than the conventional detector. However, a greater rank (rank 4) is necessary in order to achieve an almost full-rank performance.
The performance of the adaptive implementation of the receiver for the batch algorithm (FIR), given in Table. 3, is shown in FIGS. 13 to 16 with different scenarios for each figure. The different scenarios used in these simulation are summarized in Table 5.







TABLE 5







Exemplary scenarios for testing the adaptive multistage decomposition.












N
K
L
NFR















FIG. 13
31
6
3N
0 dB


FIG. 14
31
6
3N
3 dB


FIG. 15
31
6
6N
0 dB


FIG. 16
31
6
6N
3 dB









In FIGS. 13(a)–13(c), (NFR=0 dB and L=1/3N) it is shown that rank 2 of receiver performs much better than the conventional detector. The case of rank 2 provides almost the same performance as the full-rank case while rank 3 outperforms the full-rank case. This is due to a lack of training samples in the full-rank case needed to obtain a good estimate of the covariance matrix. As previously stated, the reduced-rank version of the proposed detector requires a smaller number of samples to achieve synchronization and demodulation. FIG. 13(a) shows the probability of correct synchronization vs. signal-to-white noise ratio for k=6, N=31, and NFR=0 dB. FIG. 13(b) depicts the probability of correct demodulation vs. signal-to-white noise ratio for k=6, N=31, and NFR=0 dB
However, for the more severe MAI (NFR=3 dB) a greater rank is needed in order to achieve the same or better performance than the full-rank case. This is shown in FIGS. 14(a) and 14(b). By examining FIGS. 13 to 16 one can note that the full-rank receiver needs a larger amount of sample support to perform close to the known covariance matrix case while the reduced-rank receiver requires a smaller number of samples. The required computations to realize the adaptive full-rank receiver is sizeable due to the necessary matrix inversions, especially when the processing gain N of the CDMA system is larger than N=31.
FIGS. 15a and 15B show the batch algorithm in Table 3 with number of training samples L=6N. FIG. 15a shows a graph for the probability of correct synchronization vs. signal to white noise ratio for K=6, N=31, and NFR is 0 dB. FIG. 15b shows a graph for the probability of correct demodulation vs. signal to white noise ratio for K=6, N=31, and NFR is 0 dB. FIGS. 16a and 16B show the Batch algorithm in Table 3 with number of training samples L=6N. FIG. 16a shows a graph for the probability of correct synchronization vs. signal to white noise ratio for K=6, N=31, and NFR is 3 dB. FIG. 16b shows a graph for the probability of correct demodulation vs. signal to white noise ratio for K=6, N=31, and NFR is 3 dB.
Finally, the performance of the iterative or IIR algorithm of the receiver in Table 4 is shown in FIGS. 17 and 18 with α=1/3N and FIGS. 19 and 20 with α=1/6N. Also for these two cases the near-far ratios are set respectively to 0 dB and 3 dB. FIG. 19a shows the probability of correct synchronization vs. signal to white noise ratio for K=6, N=31, and NFR=0 dB, and FIG. 19a shows the probability of correct demodulation vs. signal to white noise ratio for K=6, N=31, and NFR=0 dB. FIG. 20a shows the probability of correct synchronization vs. signal to white noise ratio for K=6, N=31, and NFR=3 dB, and FIG. 20b shows the probability of correct demodulation vs. signal to white noise ratio for K=6, N=31, and NFR=3 dB.
For the equal power case (NFR=0 dB), the results show that the reduced-rank iterative version of the receiver outperforms the full-rank receiver, especially when the number of training samples is small. However, when the MAI become more severe (NFR=3 dB), the performance of the reduced-rank iterative receiver is degraded. A larger number of training samples is needed to obtain a better performance. When compared to the batch algorithm in Table 3 the recursive algorithm is computationally and physically much simpler, but does not perform as well as the batch algorithm. This is consistent with the results reported in [6]. To obtain a better performance, the iterative algorithm requires an equivalent number of samples as the full-rank case but with a much simpler computation. A more sophisticated iterative adaptive-weight filter algorithm can be used to obtain a better performance. However, in all cases the reduced-rank adaptive filter bank outperforms the conventional matched-filter detector.
In summary, in this invention an adaptive near-far resistant receiver for an asynchronous CDMA system is developed without the use of prior synchronization. It does not require a training period or data-free observations. Only knowledge of the spreading sequence of the desired user is necessary. These are the requirements needed by the conventional receiver of an asynchronous CDMA system. Due to the near-far resistant property of the receiver, this new CDMA receiver does not require the accurate power control that is needed in a conventional receiver system.
It is shown that the receiver obtains a better performance than that of the conventional receiver in all simulations. Though an optimum adaptive receiver that uses a full-rank covariance matrix can suppress multiple-access interference that comes from the co-existing users, its practical implementation generally is not feasible due to a lack of the sample support that is needed to estimate the covariance matrix and the substantial computations needed to invert this matrix.
To remedy this situation a lower-complexity adaptive receiver is developed that is based on the concept of the reduced-rank multistage decomposition [16]. With this method one can design a lower-complexity receiver without a significant loss in performance as compared with the full-rank system. Also the number of samples, needed to initially estimate the filter coefficients, is considerably decreased. This fact translates into an enhancement of the bandwidth efficiency of the underlying communication system or the potential performance gain when the size of the sample support for the adaptation of the filter coefficients is limited.
Finally, an iterative version of the filter that utilizes the multistage decomposition is developed. This makes possible a receiver that can be realized as a bank of iterative adaptive filters that are multiplexed in time sequence. By this means, the coefficients of the filter are updated every time new data are received. The implementation of the iterative version requires a substantially smaller memory size than the earlier FIR versions. Although, the iterative version does not perform as well as the batch version, it is of practical importance because of its much simpler realization. The convergence rate of the iterative filters used for the filter bank can be improved by the used of higher order iterative filters in this DS-CDMA system. However the bank of iterative adaptive filters developed in this invention evidently results in a very fast, efficient and effective near-far resistant asynchronous CDMA receiver. As demonstrated above, using only the first 2 stages of the proposed receiver (the rank 2 receiver) gains significant improvement in all cases over the conventional detector (which is equivalent to the first stage of the proposed receiver) while also the computational complexity of the rank 2 filter is only minimally greater than the conventional detector.
Simulation results show that the receiver of the present invention can significantly outperform the conventional DS-CDMA receiver that uses a standard matched filter for acquisition. When compared to the MMSE type receiver, the receiver can achieve a similar performance level without the requirement of synchronization or known propagation delays. Some applications for the present invention include digital wireless networks including home networking, and any other wireless application that uses code modulation.
It will be recognized by those skilled in the art that various modifications may be made to the illustrated and other embodiments of the invention described above, without departing from the broad inventive scope thereof. It will be understood therefore that the invention is not limited to the particular embodiments or arrangements disclosed, but is rather intended to cover any changes, adaptations or modifications which are within the scope and spirit of the invention.
Appendix A
A. Gold Sequence Generator
Due to the large range of values of the cross-correlations of the maximum-length shift-register sequence, sometimes called m-sequence, they usually are not adopted to CDMA-like applications. PN-sequences with better periodic cross-correlation properties than m-sequences are given by the sequences of Gold (1967, 1968) and Kasami (1966), where the two-values of their sequences are +1 and −1. In Robert Gold, “Maximal recursive sequences with 3-valued recursive cross-correlation functions,” IEEE Trans. on Inform. Theory, vol. 41, pp. 154–156, January 1968 [21], the contents of which are hereby expressly incorporated by reference, it was proved that certain pairs of m-sequences of length N exhibit a three-valued cross-correlation function [21] with the values −1, −t(m), t(m)−2}, where




  
    
      t
      ⁡
      
        (
        m
        )
      
    
    =
    
      
    
    ⁢
    
      
        
          
            
              2
              
                
                  (
                  
                    m
                    +
                    2
                  
                  )
                
                /
                2
              
            
            +
            1
          
        
        
          
            (
            
              odd
              ⁢
              
                
              
              ⁢
              m
            
            )
          
        
      
      
        
          
            
              2
              
                
                  (
                  
                    m
                    +
                    2
                  
                  )
                
                /
                2
              
            
            +
            1
          
        
        
          
            (
            
              even
              ⁢
              
                
              
              ⁢
              m
            
            )
          
        
      
    
  
  ⁢
  
    
  




and where m denotes an m-stage shift register of sequence length N=2m−1.

Consider the generation of the Gold sequences of length N=31 =25−1 with the pair of preferred sequences, that are obtained from the book by Peterson and Weldon (W. W. Peterson and E. J. Weldon, Error Correcting Codes, MIT Press, Cambridge, Mass., 1972 [22], the contents of which are hereby expressly incorporated by reference) are described by the polynomials,

g1(D)=D5+D2+1,

g2(D)=D5+D4+D3+D2+1

Let b and b′ represent the two m-sequences with period N=31 that are generated by g1(D) and g2(D), respectively. The Gold family for the sequences of length 31 comprises of 2m+1=33 sequences given in R. L. Peterson, R. E. Ziemer, and D. E. Borth, Introduction to Spread Spectrum Communications, Prentice Hall, Englewood Cliffs, N.J., 1995 [23], the contents of which are hereby expressly incorporated by reference, by

G={b}∪{b′}∪{{b+Dτb′}|0≦τ≦N−1},  (56)

where the term Dτb′ represents a phase shift of the m-sequence b′ by τ units and “∪” denotes set union. The sequences s1 and s2 in the example of Section 2 are derived by setting τ in Eq. (56) equal to 0 and 1, respectively.

## Claims

1. A method performed by a computer for filtering interference and noise of an asynchronous wireless signal comprising the steps of:
receiving an asynchronous data vector including a spreading code;
using the received asynchronous data vector, to update weight coefficients of an adaptive filter without prior knowledge of synchronization of the spreading code;
using the updated weight coefficients information to determine synchronization of the spreading code; and
demodulating the output of the filter using the determined synchronization of the spreading code for obtaining a filtered data vector.

2. The method of claim 1, further comprising the step of dividing the received asynchronous data vector represented by x[i] into two channels x1[i] and d1[i] using a transformation T1 on x[i], represented by T1x[i], wherein the transformed data vector x[i] does not contain information about a designated sender's spreading code s1, and d1[i] contains primarily only information about the spreading code s1 and residual data from correlation of s1 and x[i].

3. The method of claim 2, wherein the transformation T1 is defined by




  
    
      
        
          
            T
            1
          
          =
          
            [
            
              
                
                  
                    u
                    1
                    †
                  
                
              
              
                
                  
                    B
                    1
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        16
        )
      
    
  



where B1 is a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector





  
    
      u
      1
    
    =
    
      
        s
        1
      
      /
      
        
          
            
              s
              1
              t
            
            ⁢
            
              s
              1
            
          
        
        .
      
    
  
  ,




[.]T denotes matrix transpose, and where B1u1=B1s1=0.

4. The method of claim 1, wherein the step of determining synchronization comprises the steps of:
computing î, the time occurrence of the information data bit, from the equation;





  
    
      
        
          
            
            
              Re
              ⁢
              
                {
                
                  y
                  ⁡
                  
                    [
                    
                      i
                      ^
                    
                    ]
                  
                
                }
              
            
            
          
          =
          
            
              max
              
                k
                ∈
                
                  {
                  
                    0
                    ,
                    1
                    ,
                    
                      
                    
                    ⁢
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      
                    
                    ⁢
                    
                      NS
                      -
                      1
                    
                  
                  }
                
              
            
            ⁢
            
              
              
                Re
                ⁢
                
                  {
                  
                    y
                    ⁡
                    
                      [
                      
                        i
                        -
                        k
                      
                      ]
                    
                  
                  }
                
              
              
            
          
        
        ,
      
    
    
      
        (
        
          30c
        
        )
      
    
  



where y[i]=w[i]†x[i] is filtered output from a likelihood ratio test at clock time i detecting sequentially maximum of all likelihood tests in the set Y[i] given by


Y[i]={|Re{y[i]}|, . . . , Re{y[i−NS+1]}|},


where N is number of chips in the spreading code, S is number of samples per chip time, and W[i]† is a tap-weights' vector.

5. The method of claim 1, wherein the step of updating weight coefficients comprises the steps of:
computing maximum likelihood estimator for covariance matrix Rx[i]





  
    
      
        R
        ^
      
      x
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
            
              x
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              x
              
                
                  (
                  m
                  )
                
                *
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          0
          †
        
        ⁡
        
          [
          i
          ]
        
      
    
  



 wherein, x(m)[i] is an observation vector at a sampling time iTs of the mth symbol, L is number of independent samples of the observation vector x(m)[i] for the initial acquisition of detector parameters, and the data is given in matrix form by


X0[i]Δ[x(1)[i], . . . , x(L)[i]];


 computing estimate of Rx1[i]





  
    
      
        R
        ^
      
      
        x
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        B
        1
      
      ⁢
      
        
          
            R
            ^
          
          
            x
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        B
        1
        †
      
    
    =
    
      
        1
        L
      
      ⁢
      
        B
        1
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          0
          †
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        B
        1
        †
      
    
  




and estimate of cross-correlation vector rxl as,




  
    
      r
      ^
    
    
      
        x
        1
      
      ⁢
      
        d
        1
      
    
  
  =
  
    
      
        B
        1
      
      ⁢
      
        
          
            R
            ^
          
          x
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        s
        1
      
    
    =
    
      
        1
        L
      
      ⁢
      
        B
        1
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          0
          t
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        s
        1
      
    
  



computing





  
    
      
        
          
            
              w
              GSC
              †
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                r
                
                  
                    x
                    1
                  
                  ⁢
                  
                    d
                    1
                  
                
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                R
                
                  x
                  1
                
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
        ;
      
    
    
      
        (
        29
        )
      
    
  



estimating





  
    
      
        
          
            b
            ^
          
          1
        
        =
        
          
            sgn
            ⁡
            
              (
              
                
                  (
                  
                    
                      u
                      1
                      †
                    
                    -
                    
                      
                        
                          w
                          GSC
                          †
                        
                        ⁡
                        
                          [
                          
                            i
                            ^
                          
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                      
                    
                  
                  )
                
                ⁢
                
                  x
                  ⁡
                  
                    [
                    
                      i
                      ^
                    
                    ]
                  
                
              
              )
            
          
          .
        
      
    
    
      
        (
        35
        )
      
    
  



wherein





  
    
      
        
          u
          1
          †
        
        -
        
          
            
              w
              GSC
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            B
            1
          
        
      
    
    
      
        (
        
          30a
        
        )
      
    
  



 is a weight vector; and
computing output





  
    
      
        
          y
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            (
            
              
                u
                1
                †
              
              -
              
                
                  
                    w
                    GSC
                    †
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  B
                  1
                
              
            
            )
          
          ⁢
          
            
              x
              ⁡
              
                [
                i
                ]
              
            
            .
          
        
      
    
    
      
        (
        
          30b
        
        )

6. The method of claim 1, wherein the step of updating weight coefficients further comprises the steps of:
applying





  
    
      
        X
        0
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      
        Δ
        =
      
      ⁡
      
        [
        
          
            
              x
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            
              x
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
    
  
  ,



 wherein L is number of independent samples of an observation vector x(m)[i] and s1 is a designated sender's spreading code;
applying





  
    
      
        u
        ^
      
      1
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ;



applying





  
    
      
        B
        ^
      
      1
    
    =
    
      I
      -
      
        
          
            u
            ^
          
          j
        
        ⁢
        
          
            u
            ^
          
          j
          †
        
      
    
  
  ,



 where B1 is a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector u1=s1/√{square root over (s1†s1)}., [.]T denotes matrix transpose, and where B1u1=B1s1=0 (17);
for j=1 to (M−1), computing dj and xj 





  
    
      
        
          d
          j
          t
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          Δ
          =
        
        ⁡
        
          [
          
            
              
                
                  d
                  ^
                
                j
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                
                  d
                  ^
                
                j
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
      
    
    =
    
      
        
          
            u
            ^
          
          j
          t
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          
            j
            -
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,
  
    

  
  ⁢
  
    
      
        
          X
          j
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          Δ
          =
        
        ⁡
        
          [
          
            
              
                x
                j
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                x
                j
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
      
    
    =
    
      
        
          
            B
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          
            j
            -
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,



 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
computing (j+1)th stage basis vector ûj+1[i],





  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
              
                x
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  d
                  j
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              *
            
          
        
      
      =
      
        
          1
          L
        
        ⁢
        
          
            X
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            d
            j
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,



 where {circumflex over (r)}xjdj[i] is estimate of cross-correlation vector rxldl,





  
    
      
        
          u
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,



 where {circumflex over (δ)}j+1[i]=∥{circumflex over (r)}xjdj[i]∥;
computing (j+1)th blocking matrix {circumflex over (B)}j+1


{circumflex over (B)}j+1[i]=I−ûj+1[i]ûj+1†[i];


computing





  
    d
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  



 and setting it equal to Mth error signal





  
    ∈
    M
    
      (
      m
      )
    
  
  ⁢
  
    [
    i
    ]
  







  
    
      
        
          d
          M
          †
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        =
        Δ
      
      ⁢
      
        
          [
          
            
              
                
                  d
                  ^
                
                M
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                
                  d
                  ^
                
                M
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
        =
        
          
            
              e
              M
              †
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                
                  u
                  ^
                
                M
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                
                  M
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
    
    ;
  




  applying




  
    
      
        
          
            σ
            ^
          
          
            d
            M
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            1
            L
          
          ⁢
          
            
              ∑
              
                m
                =
                1
              
              L
            
            ⁢
            
              
                
                
                  
                    
                      d
                      ^
                    
                    M
                    
                      (
                      m
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                
              
              2
            
          
        
        =
        
          
            
              ξ
              ^
            
            M
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ,
    
      
        
          
            
              ω
              ^
            
            M
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                ξ
                ^
              
              M
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                δ
                ^
              
              M
            
            ⁡
            
              [
              i
              ]
            
          
        
      
      ;
    
  


for j=(M−1) to 2, estimating variance of dj[i]





  
    
      
        
          σ
          ^
        
        
          d
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
            
            
              
                
                  d
                  ^
                
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



estimating variance of error signal εj





  
    
      
        
          ξ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        
          
            σ
            ^
          
          
            ∈
            j
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              σ
              ^
            
            
              d
              j
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                ξ
                ^
              
              
                j
                +
                1
              
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                δ
                ^
              
              
                j
                +
                1
              
              2
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ;



 and
computing jth scalar Wiener filter {circumflex over (ω)}j[i]





  
    
      
        ω
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          
            δ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
    .

7. The method of claim 1, wherein the step of updating weight coefficients further comprises the steps of:
applying X0[i]Δ[x(1)[i], . . . , x(L)[i]], wherein L is number of independent samples of an observation vector x(m)[i] and s1 is a designated sender's spreading code;
applying





  
    
      u
      ^
    
    1
  
  =
  
    
      s
      1
    
    
      
      
        s
        1
      
      
    
  



 and x0[i]=x[i], where B1 is a blocking matrix whose rows are composed of any orthonormal basis set of nullspace of the normalized signal vector u1 =s1/√{square root over (s1†s1)}., [.]T denotes matrix transpose, and where B1u1=B1s1=0. (17);
for j=1 to (M−1), computing dj and xj 




  
    
      
        d
        j
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            u
            ^
          
          j
          †
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          x
          
            j
            -
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  




  
    
      
        x
        j
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          x
          
            j
            -
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              u
              ^
            
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            d
            j
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  


 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
computing (j+1)th stage basis vector ûj+1[i],





  
    
      
        
          r
          ^
        
        
          
            x
            i
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
          
          ⁢
          
            
              
                x
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  d
                  j
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              *
            
          
        
      
      =
      
        
          1
          L
        
        ⁢
        
          
            X
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            d
            j
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,



 where {circumflex over (r)}xjdj[i] is estimate of cross-correlation vector rxldl,





  
    
      
        
          u
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,



 where {circumflex over (δ)}j+1[i]=∥{circumflex over (r)}xjdj[i]∥;
computing





  
    d
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  



 and setting it equal to Mth error signal





  
    ε
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  







  
    
      
        
          d
          M
          †
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        =
        Δ
      
      ⁢
      
        
          [
          
            
              
                
                  d
                  ^
                
                M
                
                  (
                  1
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ,
            ,
            
              
                
                  d
                  ^
                
                M
                
                  (
                  L
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
          
          ]
        
        =
        
          
            
              e
              M
              †
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                
                  u
                  ^
                
                M
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                X
                
                  M
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
    
    ;
  




  applying




  
    
      
        
          
            σ
            ^
          
          
            d
            M
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            1
            L
          
          ⁢
          
            
              ∑
              
                m
                =
                1
              
              L
            
            ⁢
            
              
            
            ⁢
            
              
                
                
                  
                    
                      d
                      ^
                    
                    M
                    
                      (
                      m
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                
              
              2
            
          
        
        =
        
          
            
              ξ
              ^
            
            M
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ,
    
      
        
          
            
              ω
              ^
            
            M
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                ξ
                ^
              
              M
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                δ
                ^
              
              M
            
            ⁡
            
              [
              i
              ]
            
          
        
      
      ;
    
  


for j=(M−1) to 2, estimating variance of dj[i],





  
    
      
        
          σ
          ^
        
        
          d
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
        
        ⁢
        
          
            
            
              
                
                  d
                  ^
                
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



estimating variance of error signal εj,





  
    
      
        
          ξ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        
          
            σ
            ^
          
          
            ε
            j
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              σ
              ^
            
            
              d
              j
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                ξ
                ^
              
              
                j
                +
                1
              
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                δ
                ^
              
              
                j
                +
                1
              
              2
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ;




and
computing jth scalar Wiener filter by {circumflex over (ω)}j[i],





  
    
      
        ω
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          
            δ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
    .

8. The method of claim 1, wherein the steps of updating weight coefficients and using the updated weight coefficients further comprises the steps of:
for k=1 to n, applying





  
    
      
        
          r
          ^
        
        
          
            x
            0
          
          ⁢
          
            d
            0
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      s
      1
    
  
  ,
  
    
      
        
          u
          ^
        
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ,



 and {circumflex over (δ)}1(k)[i]=∥s1∥, wherein x0(k)[i] is the received asynchronous data vector, s1 is a designated sender's spreading code, and k is kth clock time, where k=1 is the first time the data is observed;
for j=1 to (M−1), applying




  
    
      
        
          d
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              
                u
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          †
        
        ⁢
        
          
            x
            
              j
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ,
    and
  




  
    
      
        
          x
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            x
            
              j
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                u
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    ,
  


 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
computing (j+1)th stage basis vector ûj+1(k)[i],





  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          (
          
            1
            -
            α
          
          )
        
        ⁢
        
          
            
              r
              ^
            
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
            
              (
              
                k
                -
                1
              
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
      +
      
        
          
            x
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
      
    
  
  ,



 where {circumflex over (r)}xjdj[i] is estimate of cross-correlation vector rxldl,





  
    
      
        
          u
          ^
        
        
          j
          +
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,
  
    
  
  ⁢
  
    
      wherein
      ⁢
      
        
          
        
        ⁢
        
          
        
      
      ⁢
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
    =
    
      
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
    
  



and α is a time constant;
applying Mth error signal





  
    
      
        ε
        M
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            d
            M
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        †
      
      =
      
        
          
            
              
                u
                ^
              
              M
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          †
        
        ⁢
        
          
            x
            
              M
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



for j=M to 2, estimating variance of error signal





  
    ε
    j
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        
          ξ
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            (
            
              
                δ
                ^
              
              
                ε
                j
              
              
                (
                k
                )
              
            
            )
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            (
            
              1
              -
              α
            
            )
          
          ⁢
          
            
              
                ξ
                ^
              
              j
              
                (
                
                  k
                  -
                  1
                
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        +
        
          
            
            
              
                ε
                j
                
                  (
                  k
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



computing jth scalar Wiener filter





  
    
      ω
      ^
    
    j
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        
          ω
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            δ
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ;



 and
computing (j−1)th error signal





  
    ε
    
      j
      -
      1
    
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        ε
        
          j
          -
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          d
          
            j
            -
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      -
      
        
          
            
              
                ω
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
        ⁢
        
          
            ε
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



wherein output at time kth is y(k)[i]=ε1(k)[i].

9. An adaptive near-far resistant receiver for an asynchronous wireless system comprising:
means for receiving an asynchronous data vector including a spreading code;
using the received asynchronous data vector, means for updating weight coefficients of an adaptive filter without prior knowledge of synchronization of the spreading code of the data vector;
using the updated weight coefficients, means for determining synchronization of the spreading code; and
means for demodulating the output of the filter using the determined synchronization of the spreading code for obtaining a filtered data vector.

10. The receiver of claim 9, further comprising means for dividing the received asynchronous data vector represented by x[i] into two channels x1[i] and d1[i] using a transformation T1 on x[i], represented by T1x[i], wherein the transformed data vector x[i] does not contain information about a designated sender's spreading code s1 and d1[i] contains primarily only information about the spreading code s1 and residual data from correlation of s1 and x[i].

11. The receiver of claim 10, wherein the transformation T1 is defined by




  
    
      
        
          
            T
            1
          
          =
          
            [
            
              
                
                  
                    u
                    1
                    †
                  
                
              
              
                
                  
                    B
                    1
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        16
        )
      
    
  



where B1is a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector





  
    
      u
      1
    
    =
    
      
        s
        1
      
      /
      
        
          
            s
            1
            †
          
          ⁢
          
            s
            1
          
        
      
    
  
  ,



 [.]T denotes matrix transpose, and where B1u1=B1s1=0.

12. The receiver of claim 9, wherein the means for determining the synchronization of the spreading code comprises:
means for computing î, the time occurrence of the information data bit, from the equation;





  
    
      
        
          
            
            
              Re
              ⁢
              
                {
                
                  y
                  ⁡
                  
                    [
                    
                      i
                      ^
                    
                    ]
                  
                
                }
              
            
            
          
          =
          
            
              max
              
                kε
                ⁢
                
                  {
                  
                    0
                    ,
                    1
                    ,
                    
                      
                    
                    ⁢
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      NS
                      -
                      1
                    
                  
                  }
                
              
            
            ⁢
            
              
              
                Re
                ⁢
                
                  {
                  
                    y
                    ⁡
                    
                      [
                      
                        i
                        -
                        k
                      
                      ]
                    
                  
                  }
                
              
              
            
          
        
        ,
      
    
    
      
        (
        
          30c
        
        )
      
    
  



 where y[i]=w[i]†x [i] is filtered output from a likelihood ratio test at clock time i detecting sequentially maximum of all likelihood ratio tests in the set Y[i] given by Y[i]={|Re{y[i]}|, . . . , |Re{y[i−NS+1]}|}, where N is number of chips in the spreading code and S is number of samples per chip time, and W[i]t is a tap-weights' vector.

13. The receiver of claim 9, wherein the means for using the received asynchronous data vector, to update weight coefficients further comprises:
means for applying X0[i]Δ[x(1)[i], . . . , x(L)[i]], wherein L is number of independent samples of an observation vector x(m)[i] and s1 is a designated sender's spreading code;
means for applying





  
    
      
        u
        ^
      
      1
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ;



means for applying {circumflex over (B)}1=I−ûjûj†, where B1 is a blocking matrix whose rows are composed of any orthnormal basis set of the nullspace of the normalized signal vector u1=s1/√{square root over (s1†s1)}., [.]T denoted matrix transpose, and where B1u1=B1s 1=0. (17);
for j=1 to (M−1), means for computing dj and xj 





  
    
      
        d
        j
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        [
        
          
            
              
                d
                ^
              
              j
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            
              
                d
                ^
              
              j
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            u
            ^
          
          j
          †
        
        ⁢
        
          
            X
            
              j
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,
  
    

  
  ⁢
  
    
      
        X
        j
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        [
        
          
            
              x
              j
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            
              x
              j
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            
              B
              ^
            
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            X
            
              j
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,



 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
means for computing (j+1)th stage basis vector ûj+1[i],





  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
          
          ⁢
          
            
              
                x
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  d
                  j
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              *
            
          
        
      
      =
      
        
          1
          L
        
        ⁢
        
          
            X
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            d
            j
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,



 where {circumflex over (r)}xj dj[i] is estimate of cross-correlation vector rxldl,





  
    
      
        
          u
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,



 where {circumflex over (δ)}j+1[i]=∥{circumflex over (r)}xjdj[i]∥;
means for computing (j+1)th blocking matrix {circumflex over (B)}j+1 





  
    
      
        
          B
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      I
      -
      
        
          
            
              u
              ^
            
            
              j
              +
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              u
              ^
            
            
              j
              +
              1
            
            †
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



means for computing





  
    d
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  



 and set it equal to Mth error signal





  
    ε
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        d
        M
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        [
        
          
            
              
                d
                ^
              
              M
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            
              
                d
                ^
              
              M
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            e
            M
            †
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                u
                ^
              
              M
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              X
              
                M
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ;



means for applying





  
    
      
        
          σ
          ^
        
        
          d
          M
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
          
          ⁢
          
            
              
              
                
                  
                    d
                    ^
                  
                  M
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              
            
            2
          
        
      
      =
      
        
          
            ξ
            ^
          
          M
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,
  
    
      
        
          
            ω
            ^
          
          M
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              ξ
              ^
            
            M
            
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              δ
              ^
            
            M
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ;
  



for j=(M−1) to 2, means for estimating variance of dj[i]





  
    
      
        
          σ
          ^
        
        
          d
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
        
        ⁢
        
          
            
            
              
                
                  d
                  ^
                
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



means for estimate variance of error signal εj





  
    
      
        
          ξ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        
          
            σ
            ^
          
          
            ε
            i
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              σ
              ^
            
            
              d
              j
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                ξ
                ^
              
              
                j
                +
                1
              
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                δ
                ^
              
              
                j
                +
                1
              
              2
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ;



 and
means for computing jth scalar Wiener filter {circumflex over (ω)}j[i]





  
    
      
        ω
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          
            δ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
    .

14. The receiver of claim 9, wherein the means for using the received asynchronous data vector, to update weight coefficients further comprises:
means for applying X0[i]Δ[x(1)[i], . . . , x(L)[i]], wherein L is number of independent samples of an observation vector x(m)[i] and s1 is a designated sender's spreading code;
means for applying





  
    
      u
      ^
    
    1
  
  =
  
    
      s
      1
    
    
      
      
        s
        1
      
      
    
  



 and x0[i]=x[i], where B1 is a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector u1=s1/√{square root over (s1 †s1)}., [.]T denotes matrix transpose, and where B1u1=B1s1=0.(17);
for j=1 to (M−1), means for computing dj and xj 





  
    
      
        
          
            d
            j
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
        ⁢
        
          
            
              
                u
                ^
              
              j
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              x
              
                j
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  
    
      
        
          
            x
            j
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
        ⁢
        
          
            
              x
              
                j
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          -
          
            
              
                
                  u
                  ^
                
                j
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                d
                j
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
    
  
  
    
      
        
          
            
              d
              j
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            =
            Δ
          
          ⁢
          
          ⁢
          
            
              [
              
                
                  
                    
                      d
                      ^
                    
                    j
                    
                      (
                      1
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    
                      d
                      ^
                    
                    j
                    
                      (
                      L
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              ]
            
            =
            
              
                
                  
                    u
                    ^
                  
                  j
                  †
                
                ⁡
                
                  [
                  i
                  ]
                
              
              ⁢
              
                
                  X
                  
                    j
                    -
                    1
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
        
        ,
      
    
  
  
    
      
        
          
            
              X
              j
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            =
            Δ
          
          ⁢
          
          ⁢
          
            
              [
              
                
                  
                    x
                    j
                    
                      (
                      1
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    x
                    j
                    
                      (
                      L
                      )
                    
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              ]
            
            =
            
              
                
                  X
                  
                    j
                    -
                    1
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              -
              
                
                  
                    
                      u
                      ^
                    
                    j
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  
                    d
                    j
                    †
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
            
          
        
        ,
      
    
  



 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
means for computing (j+1)th stage basis vector ûj+1[i],





  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            i
          
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
          
          ⁢
          
            
              
                x
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                
                  d
                  j
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              *
            
          
        
      
      =
      
        
          1
          L
        
        ⁢
        
          
            X
            j
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            d
            j
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ,



 where {circumflex over (r)}xjdj[i] is estimate of cross-correlation vector rxxldl,





  
    
      
        
          u
          ^
        
        
          j
          +
          1
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,



 where {circumflex over (δ)}j+1[i]=∥{circumflex over (r)}xjdj[i]∥;
means for computing





  
    d
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  



 and set it equal to Mth error signal





  
    ε
    M
    
      (
      m
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        d
        M
        †
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
    ⁢
    
      
        [
        
          
            
              
                d
                ^
              
              M
              
                (
                1
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ,
          ,
          
            
              
                d
                ^
              
              M
              
                (
                L
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        ]
      
      =
      
        
          
            e
            M
            †
          
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            
              
                u
                ^
              
              M
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              X
              
                M
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ;



means for applying





  
    
      
        
          σ
          ^
        
        
          d
          M
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          1
          L
        
        ⁢
        
          
            ∑
            
              m
              =
              1
            
            L
          
          ⁢
          
            
          
          ⁢
          
            
              
              
                
                  
                    d
                    ^
                  
                  M
                  
                    (
                    m
                    )
                  
                
                ⁡
                
                  [
                  i
                  ]
                
              
              
            
            2
          
        
      
      =
      
        
          
            ξ
            ^
          
          M
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,
  
    
      
        
          
            ω
            ^
          
          M
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              ξ
              ^
            
            M
            
              -
              1
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              δ
              ^
            
            M
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ;
  



for j=(M−1) to 2, means for estimating variance of dj[i],





  
    
      
        
          σ
          ^
        
        
          d
          j
        
        2
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
        
        ⁢
        
          
            
            
              
                
                  d
                  ^
                
                j
                
                  (
                  m
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



means for estimating variance of error signal εj 





  
    
      
        
          ξ
          ^
        
        j
      
      ⁡
      
        [
        i
        ]
      
    
    ⁢
    
      =
      Δ
    
    ⁢
    
      
        
          
            σ
            ^
          
          
            ε
            j
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              σ
              ^
            
            
              d
              j
            
            2
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                ξ
                ^
              
              
                j
                +
                1
              
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              
                δ
                ^
              
              
                j
                +
                1
              
              2
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
  
  ;



 and
means for computing jth scalar Wiener filter by {circumflex over (ω)}j[i],





  
    
      
        ω
        ^
      
      j
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        
          
            δ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
        
        ⁡
        
          [
          i
          ]
        
      
    
    .

15. The receiver of claim 9, wherein the means for using the received asynchronous data and updates weight coefficients further comprises:
for k=1 to n, means for applying





  
    
      
        
          r
          ^
        
        
          
            x
            0
          
          ⁢
          
            d
            0
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      s
      1
    
  
  ,
  
    
      
        
          u
          ^
        
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ,
  
    
      and
      ⁢
      
        
      
      ⁢
      
        
          
            δ
            ^
          
          1
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
    =
    
      
      
        s
        1
      
      
    
  
  ,



 wherein x0(k)[i] is the received asynchronous data vector, s1 is a designated sender's spreading code, and k is kth clock time, where k=1 is the first time the data is observed;
for j=1 to (M−1), means for applying




  
    
      
        
          d
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              
                u
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          †
        
        ⁢
        
          
            x
            
              j
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ,
    and
  




  
    
      
        
          x
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            x
            
              j
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                u
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    ,
  


 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
means for computing (j+1)th stage basis vector,





  
    
      
        u
        ^
      
      
        j
        +
        1
      
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ,








  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          (
          
            1
            -
            α
          
          )
        
        ⁢
        
          
            
              r
              ^
            
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
            
              (
              
                k
                -
                1
              
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
      +
      
        
          
            x
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
      
    
  
  ,



 where {circumflex over (r)}xjdj[i] is estimate of cross-correlation vector rxldl,





  
    
  
  ⁢
  
    
      
        
          
            u
            ^
          
          
            j
            +
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              r
              ^
            
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        
          
            
              δ
              ^
            
            
              j
              +
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ,
    
      
        wherein
        ⁢
        
          
        
        ⁢
        
          
            
              δ
              ^
            
            
              j
              +
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
      =
      
        
        
          
            
              r
              ^
            
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        
      
    
  



and α is a time constant;
means for applying





  
    
      
        ε
        M
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            d
            M
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        †
      
      =
      
        
          
            
              
                u
                ^
              
              M
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          †
        
        ⁢
        
          
            x
            
              M
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



for j=M to 2, means for estimating variance of error signal εj(k)[i]





  
    
      
        
          ξ
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            (
            
              
                δ
                ^
              
              
                ε
                j
              
              
                (
                k
                )
              
            
            )
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            (
            
              1
              -
              α
            
            )
          
          ⁢
          
            
              
                ξ
                ^
              
              j
              
                (
                
                  k
                  -
                  1
                
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        +
        
          
            
            
              
                ε
                j
                
                  (
                  k
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



means for computing jth scalar Wiener filter





  
    
      ω
      ^
    
    j
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        
          ω
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            δ
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ;



 and
means for computing (j−1)th error signal





  
    ε
    
      j
      -
      1
    
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        ε
        
          j
          -
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          d
          
            j
            -
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      -
      
        
          
            
              
                ω
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
        ⁢
        
          
            ε
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



 wherein output at time kth is





  
    
      y
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        ε
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    .

16. The receiver of claim 9, wherein the means for using the received asynchronous data vector, to update weight coefficients further comprises:
means for computing maximum likelihood estimator for covariance matrix Rx[i]





  
    
      
        R
        ^
      
      x
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        1
        L
      
      ⁢
      
        
          ∑
          
            m
            =
            1
          
          L
        
        ⁢
        
          
        
        ⁢
        
          
            
              x
              
                (
                m
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              x
              
                
                  (
                  m
                  )
                
                *
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    =
    
      
        1
        L
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          0
          †
        
        ⁡
        
          [
          i
          ]
        
      
    
  



 wherein, x(m)[i] is an observation vector at a sampling time iTs of the mth symbol, L is the number of independent samples of the observation vector x(m)[i] for the initial acquisition of detector parameters, and the data is given in matrix form by


X0[i]Δ[x(1)[i], . . . , x(L)[i]];


means for computing estimate of Rx1[i]





  
    
      
        R
        ^
      
      
        x
        1
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        B
        1
      
      ⁢
      
        
          
            R
            ^
          
          
            x
            1
          
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        B
        1
        †
      
    
    =
    
      
        1
        L
      
      ⁢
      
        B
        1
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          0
          †
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        B
        1
        †
      
    
  




and estimate of cross-correlation vector rxldl as,




  
    
      r
      ^
    
    
      
        x
        1
      
      ⁢
      
        d
        1
      
    
  
  =
  
    
      
        B
        1
      
      ⁢
      
        
          
            R
            ^
          
          x
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        s
        1
      
    
    =
    
      
        1
        L
      
      ⁢
      
        B
        1
      
      ⁢
      
        
          X
          0
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        
          X
          0
          t
        
        ⁡
        
          [
          i
          ]
        
      
      ⁢
      
        s
        1
      
    
  



means for computing





  
    
      
        
          
            
              w
              GSC
              †
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              
                r
                
                  
                    x
                    1
                  
                  ⁢
                  
                    d
                    1
                  
                
                †
              
              ⁡
              
                [
                i
                ]
              
            
            ⁢
            
              
                R
                
                  x
                  1
                
                
                  -
                  1
                
              
              ⁡
              
                [
                i
                ]
              
            
          
        
        ;
      
    
    
      
        (
        29
        )
      
    
  



means for estimating





  
    
      
        
          
            
              b
              ^
            
            1
          
          =
          
            sgn
            ⁡
            
              (
              
                
                  (
                  
                    
                      u
                      1
                      t
                    
                    -
                    
                      
                        
                          w
                          GSC
                          t
                        
                        ⁡
                        
                          [
                          
                            i
                            ^
                          
                          ]
                        
                      
                      ⁢
                      
                        B
                        1
                      
                    
                  
                  )
                
                ⁢
                
                  x
                  ⁡
                  
                    [
                    
                      i
                      ^
                    
                    ]
                  
                
              
              )
            
          
        
        ,
      
    
    
      
        (
        35
        )
      
    
  



wherein





  
    
      
        
          u
          1
          †
        
        -
        
          
            
              w
              GSC
              †
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            B
            1
          
        
      
    
    
      
        (
        
          30a
        
        )
      
    
  



 is a weight vector; and
means for computing output





  
    
      
        
          y
          ⁡
          
            [
            i
            ]
          
        
        =
        
          
            (
            
              
                u
                1
                †
              
              -
              
                
                  
                    w
                    GSC
                    †
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  B
                  1
                
              
            
            )
          
          ⁢
          
            
              x
              ⁡
              
                [
                i
                ]
              
            
            .
          
        
      
    
    
      
        (
        
          30b
        
        )

17. A digital signal processor having stored thereon a set of instructions including instructions for filtering interference and noise of an asynchronous wireless signal, when executed, the instructions cause the digital signal processor to perform the steps of:
receiving an asynchronous data vector including a spreading code;
using the received asynchronous data vector, updating weight coefficients of an adaptive filter without prior knowledge of synchronization of the spreading code of the data vector;
using the updated weight coefficients information data bits to determine the synchronization of the spreading code of the data vector; and
demodulating the output of the filter using the determined synchronization of the spreading code of the data vector for obtaining a filtered data vector.

18. The digital signal processor of claim 17, further comprising instructions for dividing the received asynchronous data vector represented by x[i] into two channels x1[i] and d1[i] using a transformation T1 on x[i], represented by T1x[i], wherein the transformed data vector x[i] does not contain information about a designated sender's spreading code s1, and d1[i] contains primarily only information about the spreading code s1 and residual data from correlation of s1 and x[i].

19. The digital signal processor of claim 18, wherein the transformation T1 is defined by




  
    
      
        
          
            T
            1
          
          =
          
            [
            
              
                
                  
                    u
                    1
                    †
                  
                
              
              
                
                  
                    B
                    1
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        16
        )
      
    
  



where B1 is a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector





  
    
      u
      1
    
    =
    
      
        s
        1
      
      /
      
        
          
            s
            1
            †
          
          ⁢
          
            s
            1
          
        
      
    
  
  ,



 [.]T denotes matrix transpose and where B1u1=B1s1=0.

20. The digital signal processor of claim 17, wherein the instructions for determining synchronization comprises instructions for:
computing î, the time occurrence of the information data bit, from the equation;





  
    
      
        
          
            
            
              Re
              ⁢
              
                {
                
                  y
                  ⁡
                  
                    [
                    
                      i
                      ^
                    
                    ]
                  
                
                }
              
            
            
          
          =
          
            
              max
              
                kε
                ⁢
                
                  {
                  
                    0
                    ,
                    1
                    ,
                    
                      
                    
                    ⁢
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      NS
                      -
                      1
                    
                  
                  }
                
              
            
            ⁢
            
              
              
                Re
                ⁢
                
                  {
                  
                    y
                    ⁡
                    
                      [
                      
                        i
                        -
                        k
                      
                      ]
                    
                  
                  }
                
              
              
            
          
        
        ,
      
    
    
      
        (
        
          30c
        
        )
      
    
  



 where y[i]=w[i]†x[i] is filtered output from a likelihood test at clock time I detecting sequentially maximum of all likelihood tests in the set Y[i] given by Y[i]={|Re{y[i]}|, . . . ,|Re{y[i−NS+1]}|}, where N is number of chips in the spreading code and S is number of samples per chip time, and W[i]t is a tap-weights' vector.

21. An adaptive receiver for filtering interference and noise of an asynchronous wireless signal comprising:
means for receiving an asynchronous data vector including information data bits;
means for updating weight coefficients of an adaptive filter without a prior knowledge of synchronization of the information data bits;
using the updated weight coefficient, means for determining the start of the information data bits; and
means for demodulating the output of the adaptive filter.

22. The adaptive receiver of claim 21, further comprising means for dividing the data vector represented by x[i] into two channels x1[i] and d1[i] using a transformation T1on x[i], represented by T1x[i], wherein the transformed data vector x[i] does not contain information about a designated sender's spreading code s1, and d1[i] contains primarily only information about the spreading code s1 and residual data from correlation of s1 and x[i].

23. The adaptive receiver of claim 22, wherein the transformation T1is defined by




  
    
      
        
          
            T
            1
          
          =
          
            [
            
              
                
                  
                    u
                    1
                    †
                  
                
              
              
                
                  
                    B
                    1
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        16
        )
      
    
  



 where B1is a blocking matrix whose rows are composed of any orthonormal basis set of the nullspace of the normalized signal vector





  
    
      u
      1
    
    =
    
      
        s
        1
      
      /
      
        
          
            s
            1
            †
          
          ⁢
          
            s
            1
          
        
      
    
  
  ,



 [.]T denotes matrix transpose, and where B1u1=B1s1=0.

24. The adaptive receiver of claim 21, wherein the means for determining the start of the information data bits comprises means for:
computing î, the time occurrence of the information data bit, from the equation;





  
    
      
        
          
            
            
              Re
              ⁢
              
                {
                
                  y
                  ⁡
                  
                    [
                    
                      i
                      ^
                    
                    ]
                  
                
                }
              
            
            
          
          =
          
            
              max
              
                kε
                ⁢
                
                  {
                  
                    0
                    ,
                    1
                    ,
                    
                      
                    
                    ⁢
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      NS
                      -
                      1
                    
                  
                  }
                
              
            
            ⁢
            
              
              
                Re
                ⁢
                
                  {
                  
                    y
                    ⁡
                    
                      [
                      
                        i
                        -
                        k
                      
                      ]
                    
                  
                  }
                
              
              
            
          
        
        ,
      
    
    
      
        (
        
          30c
        
        )
      
    
  



 where y[i]=w[i]†x[i] is filtered output from a likelihood ratio test at clock time i detecting sequentially maximum of all likelihood ratio tests in the set Y[i] given by
 Y[i]={|Re{y[i]}|, . . . ,|Re{y[i−NS+1]}|}, where N is number of chips in the spreading code and S is number of samples per chip time, and W[i]t is a tap-weights' vector.

25. The adaptive receiver of claim 21, wherein the means for determining the start of the information data bits comprises:
for k=1to n, means for applying





  
    
      
        
          r
          ^
        
        
          
            x
            0
          
          ⁢
          
            d
            0
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      s
      1
    
  
  ,
  
    
      
        
          u
          ^
        
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        s
        1
      
      
        
        
          s
          1
        
        
      
    
  
  ,
  
    
      and
      ⁢
      
        
      
      ⁢
      
        
          
            δ
            ^
          
          1
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
    =
    
      
      
        s
        1
      
      
    
  
  ,
  
    wherein
    ⁢
    
      
    
    ⁢
    
      
        x
        0
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
  



 is the received asynchronous data vector, s1 is a designated sender's spreading code, and k is kth clock time, where k=1 is the first time the data is observed;
for j=1 (M−1), means for applying




  
    
      
        
          d
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            
              
                u
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          †
        
        ⁢
        
          
            x
            
              j
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
    ,
    and
  




  
    
      
        
          x
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            x
            
              j
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        -
        
          
            
              
                u
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          ⁢
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    ,
  


 where d1[i]=u1†x[i] is a signal-plus-noise scalar process and x1[i]=B1x[i], is an (N−1)-dimensional process with the signal removed;
means for computing (j+1)th stage basis vector





  
    
      
        u
        ^
      
      
        j
        +
        1
      
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  ,








  
    
      
        
          r
          ^
        
        
          
            x
            j
          
          ⁢
          
            d
            j
          
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          (
          
            1
            -
            α
          
          )
        
        ⁢
        
          
            
              r
              ^
            
            
              
                x
                j
              
              ⁢
              
                d
                j
              
            
            
              (
              
                k
                -
                1
              
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
      +
      
        
          
            x
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        ⁢
        
          
            
              d
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
      
    
  
  ,



 where {circumflex over (r)}xjdj[i] is estimate of cross-correlation vector rxldl,





  
    
      
        
          u
          ^
        
        
          j
          +
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ,
  
    
  
  ⁢
  
    
      wherein
      ⁢
      
        
          
        
        ⁢
        
          
        
      
      ⁢
      
        
          
            δ
            ^
          
          
            j
            +
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
    =
    
      
      
        
          
            r
            ^
          
          
            
              x
              j
            
            ⁢
            
              d
              j
            
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
    
  



 and α is a time constant;
means for applying Mth error signal





  
    
      
        ε
        M
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            d
            M
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
        †
      
      =
      
        
          
            
              
                u
                ^
              
              M
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          †
        
        ⁢
        
          
            x
            
              M
              -
              1
            
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



for j=M to 2, means for estimating variance of error signal





  
    ε
    j
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        
          ξ
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            (
            
              
                δ
                ^
              
              
                ε
                j
              
              
                (
                k
                )
              
            
            )
          
          2
        
        ⁡
        
          [
          i
          ]
        
      
      =
      
        
          
            (
            
              1
              -
              α
            
            )
          
          ⁢
          
            
              
                ξ
                ^
              
              j
              
                (
                
                  k
                  -
                  1
                
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
        
        +
        
          
            
            
              
                ε
                j
                
                  (
                  k
                  )
                
              
              ⁡
              
                [
                i
                ]
              
            
            
          
          2
        
      
    
  
  ;



means for computing jth scalar Wiener filter





  
    
      ω
      ^
    
    j
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        
          ω
          ^
        
        j
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          
            δ
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      
        
          
            ξ
            ^
          
          j
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
    
  
  ;



 and
means for computing (j−1)th error signal





  
    ε
    
      j
      -
      1
    
    
      (
      k
      )
    
  
  ⁡
  
    [
    i
    ]
  








  
    
      
        ε
        
          j
          -
          1
        
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    =
    
      
        
          d
          
            j
            -
            1
          
          
            (
            k
            )
          
        
        ⁡
        
          [
          i
          ]
        
      
      -
      
        
          
            
              
                ω
                ^
              
              j
              
                (
                k
                )
              
            
            ⁡
            
              [
              i
              ]
            
          
          *
        
        ⁢
        
          
            ε
            j
            
              (
              k
              )
            
          
          ⁡
          
            [
            i
            ]
          
        
      
    
  
  ;



 wherein output at time kth is





  
    
      y
      
        (
        k
        )
      
    
    ⁡
    
      [
      i
      ]
    
  
  =
  
    
      
        ε
        1
        
          (
          k
          )
        
      
      ⁡
      
        [
        i
        ]
      
    
    .