Patent Publication Number: US-9407472-B1

Title: Fast transversal multi-input system

Description:
SUMMARY 
     In some embodiments, an apparatus can comprise a circuit including a first input to receive a first signal, a second input to receive a second signal, and filter circuits adapted to determine weighting coefficients based on the first and second signals and an error signal. Further, the apparatus can have a second filter circuit adapted to modify the first and second signals via the weighting coefficients to produce filtered signals. The apparatus may have a combiner circuit configured to combine the filtered signals to produce a combined signal, and an output to provide the combined signal. 
     In some embodiments, an apparatus can comprise a circuit including a first input to receive a first signal, another input to receive another signal, a first forward error calculator circuit adapted to calculate a first extended gain vector based on the first signal, and another forward error calculator circuit adapted to calculate another extended gain vector based on the another signal. The apparatus can further comprise a first backwards error calculator circuit adapted to calculate a first gain vector based on the first extended gain signal, another backwards error calculator circuit adapted to calculate another gain vector based on the another extended gain vector, and a multiple input combiner circuit adapted to calculate an output signal, an error signal, and an overall tap vector based on the first signal, the another signal, the first gain vector, and the another gain vector. 
     In some embodiments, a method can comprise receiving a first signal at a first input, receiving another signal at another input, filtering the first signal via a recursive least square (RLS) process to produce a first filtered signal, and filtering the other signal via the RLS process to produce another filtered signal. The method can further comprise combining the first filtered signal and the other filtered signal to produce an output signal, and combining the output signal with a reference signal to produce an error signal. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1 . is a system with a fast transversal MISO system, in accordance with certain embodiments of the present disclosure; 
         FIG. 2 . is a system of adaptively combining waveforms, in accordance with certain embodiments of the present disclosure; 
         FIG. 3 . is a system of adaptively combining waveforms, in accordance with certain embodiments of the present disclosure; 
         FIG. 4 . is a system with a fast transversal MISO system, in accordance with certain embodiments of the present disclosure; 
         FIG. 5  is a system with a simplified fast transversal MISO system, in accordance with certain embodiments of the present disclosure; and 
         FIG. 6 . is a parameter table for fast transversal MISO systems, in accordance with certain embodiments of the present disclosure. 
     
    
    
     DETAILED DESCRIPTION 
     In the following detailed description of the embodiments, reference is made to the accompanying drawings which form a part hereof, and in which are shown by way of illustrations. It is to be understood that features of the various described embodiments may be combined, other embodiments may be utilized, and structural changes may be made without departing from the scope of the present disclosure. It is also to be understood that features of the various embodiments and examples herein can be combined, exchanged, or removed without departing from the scope of the present disclosure. 
     In accordance with various embodiments, the methods and functions described herein may be implemented as one or more software programs running on a computer processor or controller. Dedicated hardware implementations including, but not limited to, application specific integrated circuits, programmable logic arrays, and other hardware devices can likewise be constructed to implement the methods and functions described herein. Further, the methods described herein may be implemented as a computer readable storage medium or memory device including instructions that when executed cause a processor to perform the methods. 
     Multiple input, single output (MISO) systems can have multiple input signals, such as from multiple antennas, that can be combined to minimize errors and optimize data. The multiple inputs can be two or more inputs. For example, sound recording systems may receive input signals from multiple microphones or from musical instruments. The multiple input signals may be combined to produce a single output signal via MISO system that can optimize signals from two or more sources, such as by equalizing the signals by applying a weighting factor to each input signal before the signals are combined. 
     Referring to  FIG. 1 , a system with a fast transversal MISO system a system with a fast transversal MISO system is shown and generally designated  100 . System  100  can include input devices  106  and  108 , signal acquisition front end one  104 , signal acquisition front end n  102  (n is the number of MISO inputs), and MISO filter circuit  101 . 
     Input devices  106  and  108  may be transducers, antennae, optical receivers, data converters, voltage detectors, current detectors, amplifiers, other devices, or any combination thereof. Input devices  106  and  108  can be different types of detectors (e.g. input device  106  can be an antenna and input device  108  can be a transducer), and in some systems (e.g. system  100 ), can have two or more inputs. 
     The input signals from input devices  106  and  108  can be coupled to signal acquisition front ends one  104  and n  102 , respectively. Signal acquisition front ends one  104  and two  102  can condition (e.g. buffer, convert, encode/decode, decrypt, etc.) the input signals, and can include analog to digital converters (ADCs), decoders, buffers, other circuits, or any combination thereof. Further, signal acquisition front ends one  104  and n  102  may be circuits, firmware, software, application specific integrated circuits, systems on chip, other circuits, or any combination thereof. In some embodiments, two or more input devices can be coupled to a single signal acquisition front end. 
     MISO filter circuit  101  can be coupled to the signal acquisition front ends  104  and  102 , and can apply a weighting factor to the output signals of the front ends  104  and  102 . The weighting factor applied to front end  102  may be the same or different than the weighting factor applied to front end  104 . The MISO filter circuit  101  can combine the signals to produce a single output signal, which may be provided to a processor, channel, buffer, other circuit, or any combination thereof. The equalization operations of the MISO filter circuit  101  can be based on algorithms, such as least mean squares (LMS) algorithms, and recursive least-squares (RLS) algorithms 
     Least mean squares (LMS) algorithms can be efficient; the number of operations required to arrive at a solution may be lower than with other algorithms. The convergence rate (the rate at which a solution is determined) can be slower than with other algorithms. Recursive least-squares (RLS) algorithms may be less efficient (e.g. more complex) than LMS algorithms, but the convergence rate can be much faster. Fast transversal RLS (FT-RLS) algorithms can be less complex than RLS algorithms; FT-RLS complexity can be represented as O(M) for each input, RLS complexity can be O(M 2 ) for each input, where M is the number of taps (coefficients) in a digital filter (e.g. finite impulse response (FIR) filter). For example, an FT-RLS algorithm can include 7M+13 multiplications, 7M+3 additions, and three divisions per iteration, for each input. 
     Adaptive algorithms may be implemented by a circuit, firmware, as instructions executable by a processor (e.g. software), other means, or any combination thereof. 
     Referring to  FIG. 2 , a system of adaptively combining waveforms is shown and generally designated  200 . The system  200  can be an example of a data storage device (DSD), and may be an embodiment of an implementation of system  100 . The DSD  216  can optionally connect to be removable from a host device  214 , which can be a device or system having stored data, such as a desktop computer, a laptop computer, a server, a digital video recorder, a photocopier, a telephone, a music player, other electronic devices or systems not listed, or any combination thereof. The data storage device  216  can communicate with the host device  214  via the hardware/firmware based host interface circuit  212  that may include a connector (not shown) that allows the DSD  216  to be physically connected and disconnected from the host  214 . 
     The DSD  216  can include a system processor  202 , which may be a programmable controller, and associated memory  204 . The system processor  202  may be part of a system on chip (SOC). A buffer  206  may temporarily store data during read and write operations and can include a command queue. The read/write (R/W) channel  210  can encode data during write operations and reconstruct data during read operations to and from the data storage medium  208 . The data storage medium  208  may be a magnetic medium, such as a hard disc, flash medium, optical medium, or other medium, or any combination thereof. 
     The R/W channel  210  may receive data from more than one data storage medium at a time, and can also receive data concurrently from more than one output of a single storage medium. For example, storage systems having two-dimensional magnetic recording (TDMR) systems can have two recording heads, and can read from two tracks simultaneously. Multi-dimensional recording (MDR) systems can receive two or more inputs from multiple sources (e.g. recording heads, flash memory, optical memory, and so forth). 
     The MISO filter circuit  201  can be an equalizer (e.g. filter) and combine the input signals produced by the data storage medium  208  using an FT-RLS adaptive algorithm. The FT-RLS adaptive algorithm, when used in the MISO filter circuit  201 , can minimize channel errors by applying weighting factors to each input signal and combining the weighted signals to produce an equalized or filtered signal. The weighting factor applied to an input signal may be the same or different than the weighting factor applied to another input signal. In some embodiments, the MISO filter circuit  201  may be a separate circuit, integrated into the R/W channel  210 , included in a system on chip, firmware, software, and so forth. 
     Referring to  FIG. 3 , a system of adaptively combining waveforms is shown and generally designated  300 . The system  300  can be an embodiment of R/W channel  210  in a data storage system. System  300  may include n input sources A 1   306  up to An  308 , which may be the channel sources  106  or  108 , the signal acquisition front ends  102  or  104 , data storage medium  208 , other source, or any combination thereof. The input sources  306  and  308  can be coupled to a MISO filter (equalizer) circuit  301 , which can be an embodiment of MISO filter circuits  101  or  201 . 
     The system  300  can include a detector  310 , inner decoder  312 , modulation decoder  314 , outer decoder  316 , and buffer  318 . MISO filter circuit  301  can combine signals from n sources A 1    306  . . . A n    308 , with target signal d(k) to produce an equalized signal. The equalized signal can be detected by the detector  310 , which may be a Viterbi detector, soft-output Viterbi detector, Bahl-Cocke-Jelinek-Raviv (BCJR), or other detector. In some embodiments, the MISO filter circuit  301  may be integrated with the detector  310 . The signal may be decoded by an inner decoder  312 , which can decode inner codes, a modulation decoder  314 , which can decode modulation codes, and an outer decoder  316 , which can decode outer codes. A buffer  318  can store the signal, and provide it to a circuit, such as an interface, transmitter, memory, storage device, processor, other circuit, or any combination thereof, upon receipt of instructions or detection of a trigger. In some embodiments, the MISO filter circuit  301  may be integrated with the detector  310 , decoders  312 - 316 , other circuits, or any combination thereof. In some examples, the types, number, or order of channel components may be different; the MISO filter circuit  301  can be implemented with decoders, detectors, or other circuits not shown. 
     Filter target circuit  304  can be a programmable finite impulse response (FIR) filter having two coefficients (taps); in some examples, the filter target circuit  304  can have three or more coefficients. The filter target circuit  304  can produce, d(k), based on decisions from a detector (e.g. detector  310 ), decoder (e.g. decoder  312 ,  314 , or  316 ), or a training sequence (true bits), during calibration. Calibration may occur during production, or during or after an event such as transport, change of hardware, change of environment, software changes, and so forth. In some embodiments, a multiplexer (MUX)  302  can receive detected bits from a detector, decoded bits from a decoder or true bits from a training system, and a select signal to select which input signal to provide to the filter target circuit  304 , which can be integrated with the MISO filter circuit  301 . 
     In some embodiments of system  300 , some or all of the functions of the components (e.g.  302 - 318 ) can be performed by the MISO filter circuit  301 . In some data channel systems, some or all of the components may be different. MISO filter can be applied to communication systems where multiple input signals can be combined into one output signal. For example, the MISO filter circuit  301  can be configured to combine signals from wireless communication systems (e.g. cellular phone systems, satellite communication systems, digital radio, internet communication systems such as 802.11x, etc.), sound navigation and ranging (SONAR), or radio detection and ranging (RADAR). The MISO filter circuit  301  can also be configured to combine signals from other systems such as data storage systems, audio/video systems, medical systems, or other systems, or any combination thereof. 
     Referring to  FIG. 4 , a system with a fast transversal MISO system is shown and generally designated  400 . System  400  is an example of a MISO filter circuit with a fast transversal recursive least-squares (FT-RLS) adaptive algorithm, and can be an embodiment of MISO filter circuits  101 ,  201 , or  301 . 
     The MISO filter circuit of system  400  can include a MISO filter circuit  410 , an adaptive circuit  403 , and a multiplexer (MUX)  414 . The MISO filter circuit  410  can have n input adaptive filter circuits, including f 1 (k)  406  coupled to input signal x 1 , input adaptive filter circuit f n (k)  404  coupled to input signal x n , and a combiner circuit  408  coupled to the outputs of the adaptive filter circuits f 1 (k)  406  and f n (k)  404 . The input adaptive filter circuits f 1 (k)  406  and f n (k)  404 , and the combiner circuit  408  may be grouped together into one circuit, such as MISO filter circuit  410 , implemented separately, or in other configurations. In some embodiments, not all n MISO filter circuit  410  inputs may receive a signal, and in some examples, signals may be applied to the MISO circuit  410  inputs in any order. 
     An adaptive filter circuit, such as input adaptive filter circuits f 1 (k)  406  and f n (k)  404 , can be a computational device, such as a finite impulse response (FIR) filter, that filters input signals to produce an output signal in real time by changing (e.g. adjusting) the taps (e.g. coefficients) in response to the variation of an error signal and input signals. Note that “k” represents a point in time, and that f(k) (or x(k), etc.) is the value of a particular function at time “k”. The input adaptive filter circuits f 1 (k)  406  and f n (k)  404 , and the combiner circuit  408  may be implemented via application specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), controllers, other circuits, firmware, software, or other means not listed. The combiner circuit may be a summing circuit, a convolution circuit, other circuit, or any combination thereof. 
     The adaptive circuit  403  can include an FT-RLS adaptive algorithm circuit  401 , a combiner circuit  402 , and the filter target circuit  412 . The filter target circuit  412  can be filter target circuit  304 , and may be integrated with the adaptive filter  403 . The filter target circuit  412  can calculate the target signal, d(k), via the following equation: 
               d   ⁡     (   k   )       =       ∑     i   =   0         L   ⁢           ⁢   g     -   1       ⁢       g   ⁡     (   i   )       ⁢     b   ⁡     (     k   -   i     )                 
where g(i) is the target coefficient values, Lg is the length (i.e. number of taps) of the target filter, and b(k) is the select bit sequence provided by MUX circuit  414  at time “k”. The target signal can be a reference signal.
 
     The FT-RLS adaptive algorithm circuit, “FT-RLS circuit”,  401  can receive input signals x 1 (k), . . . , x n (k), and MISO error signal e(k), and can produce weighting factors (i.e. taps, coefficients) via the overall tap vector for MISO with nM taps at time “k” w(k,nM). FT-RLS circuit  401  can be a processor with its own local memory, although in some embodiments, it may be implemented in firmware, software, or other circuits. In some embodiments, the combiner circuit  402  may be a separate circuit, implemented via ASIC, FPGA, controllers, software, etc., although in other embodiments, the combiner circuit  402  may be integrated with the FT-RLS circuit  401 . 
     The input filters circuits f 1 (k)  406  and f n (k)  404  can receive input signals from sources such as analog to digital converters, antennae, signal acquisition circuits (e.g. signal acquisition front end one  104 ), and so forth, and can implement w(k,nM). For example, the adaptive circuit  403  can adjust the weighing factors (e.g. taps, coefficients) of the input adaptive filter circuits f 1 (k)  406  and f n (k)  404 , which can filter the input signals to produce filtered signals that may be combined by the combiner  408  to produce an equalized output signal y(k). The equalized signal y(k) can couple to circuits in a channel circuit, such as a detector. In some embodiments, the equalized signal may couple to other circuits (not shown), such as feedback loops (e.g. timing loops, automatic gain control loops, etc.), channel quality block, buffer memory, other circuits, or any combination thereof. Embodiments of algorithms implemented by the RT-RLS circuit  401  are discussed later in this document. 
     The equalized signal y(k) may couple to combiner circuit,  402 , which can be a summing circuit, convolution circuit, other circuit, or any combination thereof. The combiner circuit  402  can combine the equalized signal y(k) with d(k) to produce a MISO error signal e(k). For example, y(k) can have a value of A at time k, and d(k) can have a value of B at time k. The error signal e(k) may therefore have a value of e(k)=B-A at time k. The adjustment or update of MISO weights may be performed in the FT-RLS adaptive algorithm circuit  401  using the error signal e(k)=B−A. In some examples, the combiner circuit  402  may provide e(k) to circuits internal to the adaptive filter circuit  403 , such as the FT-RLS circuit  401 , and to external circuits, such as feedback loops. In other examples, the combiner circuit  402  may provide e(k) only to circuits within the adaptive filter circuit  403 . 
     MISO filter circuits can have two or more inputs, and the inputs can have corresponding with adaptive filters. For example, a MISO filter circuit with four inputs can have four adaptive filter circuits, one combiner circuit configured to combine four signals, and an FT-RLS adaptive algorithm configured to produce weighting factors (e.g. taps, coefficients) for the four filters. All of the input adaptive filters of the MISO filter circuit use the same algorithm, although each filter may have a different number of taps. 
     As discussed in  FIG. 1 , recursive least squares (RLS) algorithms can have a higher complexity than equivalent LMS algorithms, require more computational power (e.g. processor operations), and have a faster convergence rate. FT-RLS algorithms may be more computationally efficient than RLS algorithms, and may use fewer processor operations to achieve the same result. Processors capable of handling increased operations may be expensive, both financially and physically (e.g. physical area, heat dissipation, power consumption, etc.). 
     MISO initialization may first be performed during the manufacturing process. MISO filter circuits may be re-initialized due to errors, such as a divergence (the FT-RLS algorithm fails to determine weighting factors), or as operating conditions change. Changes in operating conditions may be operating in a different zone of a data storage system, or moving wireless equipment from one location to another location having different radio-frequency (RF) properties (e.g. wall thickness, metal composition, etc.), and can affect signal to noise ratio (SNR) or other performance parameters. An example FT-RLS algorithm for MISO with n inputs is demonstrated by the following equations (refer to the parameter table of figure six for an explanation of terms): 
     Initialization: 
                       w     f   ⁢           ⁢   1       ⁡     (       -   1     ,   M     )       =         w     f   ⁢           ⁢   2       ⁡     (       -   1     ,   M     )       =           ⁢     …   ⁢           =         w   fn     ⁡     (       -   1     ,   M     )       =   0                 i   .                   w     b   ⁢           ⁢   1       ⁡     (       -   1     ,   M     )       =         w     b   ⁢           ⁢   2       ⁡     (       -   1     ,   M     )       =           ⁢     ⋯   ⁢           =         w   bn     ⁡     (       -   1     ,   M     )       =   0                 ii   .                 w   ⁡     (       -   1     ,   nM     )       =   0           iii   .                   k   1     ⁡     (       -   1     ,   M     )       =         k   2     ⁡     (       -   1     ,   M     )       =           ⁢     …   ⁢           =         k   n     ⁡     (       -   1     ,   M     )       =   0                 iv   .                   ξ     f   ⁢           ⁢   min   ⁢           ⁢   1       ⁡     (       -   1     ,   M     )       =         ξ     fmin   ⁢           ⁢   2       ⁡     (       -   1     ,   M     )       =           ⁢     …   ⁢           =         ξ       f   ⁢           ⁢   min     ,   n       ⁡     (       -   1     ,   M     )       =   η                 v   .               
For k=0, . . . ,N:
 
     The following loop for forward prediction error/filter taps calculator 
     For i=1, . . . , n (n is the number of MISO inputs) 
     
       
         
           
             
               
                 
                   
                     
                       e 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                         i 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             M 
                             + 
                             1 
                           
                         
                         ) 
                       
                     
                     ⁡ 
                     
                       [ 
                       
                         
                           
                             1 
                           
                         
                         
                           
                             
                               - 
                               
                                 
                                   w 
                                   fi 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     , 
                                     M 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   vi 
                   . 
                 
               
             
             
               
                 
                   
                     
                       w 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         w 
                         
                           f 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           , 
                           M 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           k 
                           i 
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               k 
                               - 
                               1 
                             
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           e 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   vii 
                   . 
                 
               
             
             
               
                 
                   
                     
                       ɛ 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                         i 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             M 
                             + 
                             1 
                           
                         
                         ) 
                       
                     
                     [ 
                     
                       
                         
                           1 
                         
                       
                       
                         
                           
                             - 
                             
                               
                                 w 
                                 
                                   f 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   i 
                                 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   , 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   viii 
                   . 
                 
               
             
             
               
                 
                   
                     
                       ξ 
                       
                         
                           f 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           min 
                         
                         , 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         λξ 
                         
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             min 
                           
                           , 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           , 
                           M 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           e 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           ɛ 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ix 
                   . 
                 
               
             
             
               
                 
                   
                     
                       r 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ɛ 
                         
                           f 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           M 
                         
                         ) 
                       
                     
                     / 
                     
                       
                         ξ 
                         
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             min 
                           
                           , 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           M 
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   x 
                   . 
                 
               
             
             
               
                 
                   
                     
                       k 
                       i 
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         
                           M 
                           + 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             0 
                           
                         
                         
                           
                             
                               
                                 k 
                                 i 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   , 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                       
                       ] 
                     
                     + 
                     
                       
                         
                           r 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               1 
                             
                           
                           
                             
                               
                                 - 
                                 
                                   
                                     w 
                                     
                                       f 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       i 
                                     
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       M 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   xi 
                   . 
                 
               
             
           
         
       
     
     End i 
     The following loop for backward prediction error/filter taps calculator 
     For j=1, . . . , n (n is the number of MISO inputs) 
     
       
         
           
             
               
                 
                   
                     
                       e 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         j 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                         j 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             M 
                             + 
                             1 
                           
                         
                         ) 
                       
                     
                     ⁡ 
                     
                       [ 
                       
                         
                           
                             
                               - 
                               
                                 
                                   w 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     j 
                                   
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     , 
                                     M 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             1 
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   xii 
                   . 
                 
               
             
             
               
                 
                   
                     
                       r 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         j 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     1 
                     - 
                     
                       
                         
                           e 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             j 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           k 
                           
                             j 
                             , 
                             
                               M 
                               + 
                               1 
                             
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             
                               M 
                               + 
                               1 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   xiii 
                   . 
                 
               
             
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               k 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 , 
                                 M 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           0 
                         
                       
                     
                     ] 
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             k 
                             j 
                           
                           ⁡ 
                           
                             ( 
                             
                               k 
                               , 
                               
                                 M 
                                 + 
                                 1 
                               
                             
                             ) 
                           
                         
                         - 
                         
                           
                             
                               k 
                               
                                 j 
                                 , 
                                 
                                   M 
                                   + 
                                   1 
                                 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 , 
                                 
                                   M 
                                   + 
                                   1 
                                 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             ( 
                             
                               
                                 
                                   
                                     - 
                                     
                                       
                                         w 
                                         
                                           b 
                                           ⁢ 
                                           
                                               
                                           
                                           ⁢ 
                                           j 
                                         
                                       
                                       ⁡ 
                                       
                                         ( 
                                         
                                           
                                             k 
                                             - 
                                             1 
                                           
                                           , 
                                           M 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                               
                               
                                 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                       ] 
                     
                     / 
                   
                 
               
               
                 
                   xiv 
                   . 
                 
               
             
             
               
                 
                   
                     r 
                     
                       b 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       j 
                     
                   
                   ⁡ 
                   
                     ( 
                     
                       k 
                       , 
                       M 
                     
                     ) 
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     
                       w 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         j 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         w 
                         
                           b 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           j 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           , 
                           M 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           k 
                           j 
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           e 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             j 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   xv 
                   . 
                 
               
             
           
         
       
     
     End j 
                     e   ⁡     (     k   ,   M     )       =       d   ⁡     (   k   )       -         w   T     ⁡     (       k   -   1     ,     n   ⁢           ⁢   M       )       ⁡     [             x   1     ⁡     (     k   ,   M     )               ⋮               x   n     ⁡     (     k   ,   M     )             ]                 xvi   .               
Output of the FT-RLS adaptive algorithm circuit  401 :
 
                     w   ⁡     (     k   ,     n   ⁢           ⁢   M       )       =       w   ⁡     (       k   -   1     ,     n   ⁢           ⁢   M       )       +       [             k   1     ⁡     (     k   ,   M     )               ⋮               k   n     ⁡     (     k   ,   M     )             ]     ⁢     e   ⁡     (     k   ,   M     )                   xvii   .               
Implemented in the adaptive filter circuits f 1    406 , . . . , f n    404 , and combiner circuit  408 :
 
     
       
         
           
             
               
                 
                   
                     y 
                     ⁡ 
                     
                       ( 
                       k 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         w 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             n 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             M 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       [ 
                       
                         
                           
                             
                               
                                 x 
                                 1 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   , 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           
                             ⋮ 
                           
                         
                         
                           
                             
                               
                                 x 
                                 n 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   , 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   xviii 
                   . 
                 
               
             
           
         
       
     
     End k 
     Note: bold formatting denotes a vector. 
     The above equations are but one example embodiment of a MISO filter with an FT-RLS adaptive algorithm. The adaptive circuit  403  can implement steps i through xvii to produce the overall tap vector for MISO w(k,nM), which may then be implemented by the MISO filter circuit  410  at step xviii. In other embodiments, mathematical operations i through xviii may be calculated or implemented in one circuit or more circuits. 
     The previous FT-RLS algorithm contains 2n division operations (two divisions per input per iteration per input). Equations x and xiv contain 2n division operations. Mathematical operations, such as division operations, can consume more resources and take more time to complete than other operations. For example, a processor may complete a multiplication operation 50 to 75 percent faster than a division operation, and less processing overhead. Reducing or eliminating time consuming operations can reduce overall cost, and speed up the convergence rate of the algorithm. 
     Experimental tests show that some parameters of the RLS algorithm are much smaller than other parameters. For example, r fi (k, M), i=1, . . . , n, from equation x is always a very small number because ξ fmin,i (k, M), i=1, . . . , n, are very large compared to ε fi (k, M), i=1, . . . , n. Selectable constant values ε i , i=1, . . . , n, can be selected to estimate the inverse of ε fi (k, M), i=1, . . . , n, thus replacing a division operation with a multiplication operation. 
     Referring to equation xiii, it can be shown the products 
                   e     b   ⁢           ⁢   j       ⁡     (     k   ,   M     )       ⁢       k     j   ,     M   +   1         ⁡     (     k   ,     M   +   1       )         ,     j   =   1     ,   …   ⁢           ,   n   ,         
are always very small. The expressions 1/r bj (k, M),j=1, . . . , n, may be approximated as:
 
     
       
         
           
             
               
                 
                   
                     
                       
                         γ 
                         j 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           M 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         1 
                         / 
                         
                           
                             r 
                             
                               b 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               j 
                             
                           
                           ⁡ 
                           
                             ( 
                             
                               k 
                               , 
                               M 
                             
                             ) 
                           
                         
                       
                       ≈ 
                       
                         1 
                         + 
                         
                           
                             
                               e 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 j 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 , 
                                 M 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             k 
                             
                               j 
                               , 
                               
                                 M 
                                 + 
                                 1 
                               
                             
                           
                           ⁢ 
                           
                             ( 
                             
                               k 
                               , 
                               
                                 M 
                                 + 
                                 1 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   , 
                 
               
             
             
               
                 
                   
                     j 
                     = 
                     1 
                   
                   , 
                   … 
                   ⁢ 
                   
                       
                   
                   , 
                   n 
                 
               
             
           
         
       
     
     The gain vectors in xiv may be re-written as: 
     
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 k 
                                 j 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   , 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           
                             0 
                           
                         
                       
                       ] 
                     
                     = 
                     
                       
                         [ 
                         
                           
                             
                               k 
                               j 
                             
                             ( 
                             
                                 
                             
                             ⁢ 
                             
                               k 
                               , 
                               
                                   
                               
                               ⁢ 
                               
                                 M 
                                 + 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                             
                             ) 
                           
                           - 
                           
                               
                           
                           ⁢ 
                           
                             
                               
                                 k 
                                 
                                   j 
                                   , 
                                   
                                     M 
                                     + 
                                     1 
                                   
                                 
                               
                               ( 
                               
                                   
                               
                               ⁢ 
                               
                                 k 
                                 , 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   M 
                                   + 
                                   
                                       
                                   
                                   ⁢ 
                                   1 
                                 
                               
                               ) 
                             
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               ( 
                               
                                 
                                   
                                     
                                       - 
                                       
                                         
                                           w 
                                           
                                             b 
                                             ⁢ 
                                             
                                                 
                                             
                                             ⁢ 
                                             j 
                                           
                                         
                                         ⁡ 
                                         
                                           ( 
                                           
                                             
                                               k 
                                               - 
                                               1 
                                             
                                             , 
                                             M 
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                 
                                 
                                   
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                         
                         ] 
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           γ 
                           j 
                         
                         ( 
                         
                             
                         
                         ⁢ 
                         
                           k 
                           , 
                           
                               
                           
                           ⁢ 
                           M 
                         
                         ⁢ 
                         
                             
                         
                         ) 
                       
                     
                   
                   ⁢ 
                   
                       
                   
                   , 
                 
               
             
             
               
                 
                   
                     j 
                     = 
                     1 
                   
                   , 
                   … 
                   ⁢ 
                   
                       
                   
                   , 
                   n 
                 
               
             
           
         
       
     
     Further tests demonstrate that e bj (k, M)k j,M+1 (k, M+1), j=1, . . . , n, are so small that γ j (k, M), j=1, . . . , n, may be approximated by unity, thus removing their computation altogether. Approximating γ j ,j=1, . . . , n, as unity, and converting a division operation to a multiplication operation in equation x produces a simplified FT-RLS algorithm. 
     The simplified FT-RLS algorithm can be mathematically demonstrated by the following set of equations (refer to the parameter table of figure six for an explanation of terms): 
     Initialization: 
                       w     f   ⁢           ⁢   1       ⁡     (       -   1     ,   M     )       =         w     f   ⁢           ⁢   2       ⁡     (       -   1     ,   M     )       =     …   =         w     f   ⁢           ⁢   n       ⁡     (       -   1     ,   M     )       =   0                 i   .                   w     b   ⁢           ⁢   1       ⁡     (       -   1     ,   M     )       =         w     b   ⁢           ⁢   2       ⁡     (       -   1     ,   M     )       =     …   =         w     b   ⁢           ⁢   n       ⁡     (       -   1     ,   M     )       =   0                 ii   .                 w   ⁡     (       -   1     ,     n   ⁢           ⁢   M       )       =   0           iii   .                   k   1     ⁡     (       -   1     ,   M     )       =         k   2     ⁡     (       -   1     ,   M     )       =     …   =         k   n     ⁡     (       -   1     ,   M     )       =   0                 iv   .                 ɛ   1     =       ɛ   2     =     …   =       ɛ   n     =       2     -   v       ⁢           ⁢     (     v   ⁢           ⁢   is   ⁢           ⁢   a   ⁢           ⁢   positive   ⁢           ⁢   integer     )                     v   .               
For k=0, . . . ,N:
 
     The following loop for forward prediction error/filter taps calculator 
     For i=1, . . . , n (n is the number of MISO inputs) 
     
       
         
           
             
               
                 
                   
                     
                       e 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                         i 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             M 
                             + 
                             1 
                           
                         
                         ) 
                       
                     
                     ⁡ 
                     
                       [ 
                       
                         
                           
                             1 
                           
                         
                         
                           
                             
                               - 
                               
                                 
                                   w 
                                   fi 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     , 
                                     M 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   vi 
                   . 
                 
               
             
             
               
                 
                   
                     
                       w 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         w 
                         
                           f 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           , 
                           M 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           k 
                           i 
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               k 
                               - 
                               1 
                             
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           e 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   vii 
                   . 
                 
               
             
             
               
                 
                   
                     
                       ɛ 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                         i 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             M 
                             + 
                             1 
                           
                         
                         ) 
                       
                     
                     ⁡ 
                     
                       [ 
                       
                         
                           
                             1 
                           
                         
                         
                           
                             
                               - 
                               
                                 
                                   w 
                                   
                                     f 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     i 
                                   
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     k 
                                     , 
                                     M 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   viii 
                   . 
                 
               
             
             
               
                 
                   
                     
                       ξ 
                       
                         
                           f 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           min 
                         
                         , 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         λξ 
                         
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             min 
                           
                           , 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           , 
                           M 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           e 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           ɛ 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ix 
                   . 
                 
               
             
             
               
                 
                   
                     
                       r 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         i 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ɛ 
                         
                           f 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           M 
                         
                         ) 
                       
                     
                     ⁢ 
                     
                       ɛ 
                       i 
                     
                   
                 
               
               
                 
                   x 
                   . 
                 
               
             
             
               
                 
                   
                     
                       k 
                       i 
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         
                           M 
                           + 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             0 
                           
                         
                         
                           
                             
                               
                                 k 
                                 i 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   , 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                       
                       ] 
                     
                     + 
                     
                       
                         
                           r 
                           
                             f 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               1 
                             
                           
                           
                             
                               
                                 - 
                                 
                                   
                                     w 
                                     
                                       f 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       i 
                                     
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       M 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   xi 
                   . 
                 
               
             
           
         
       
     
     End i 
     The following loop for forward prediction error/filter taps calculator 
     For j=1, . . . , n (n is the number of MISO inputs) 
     
       
         
           
             
               
                 
                   
                     
                       e 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         j 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                         j 
                         T 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           , 
                           
                             M 
                             + 
                             1 
                           
                         
                         ) 
                       
                     
                     ⁡ 
                     
                       [ 
                       
                         
                           
                             
                               - 
                               
                                 
                                   w 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     j 
                                   
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     , 
                                     M 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             1 
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   xii 
                   . 
                 
               
             
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               k 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 , 
                                 M 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           0 
                         
                       
                     
                     ] 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           k 
                           j 
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             
                               M 
                               + 
                               1 
                             
                           
                           ) 
                         
                       
                       - 
                       
                         
                           
                             k 
                             
                               j 
                               , 
                               
                                 M 
                                 + 
                                 1 
                               
                             
                           
                           ⁡ 
                           
                             ( 
                             
                               k 
                               , 
                               
                                 M 
                                 + 
                                 1 
                               
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           ( 
                           
                             
                               
                                 
                                   - 
                                   
                                     
                                       w 
                                       
                                         b 
                                         ⁢ 
                                         
                                             
                                         
                                         ⁢ 
                                         j 
                                       
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           k 
                                           - 
                                           1 
                                         
                                         , 
                                         M 
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             
                               
                                 1 
                               
                             
                           
                           ) 
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   xiii 
                   . 
                 
               
             
             
               
                 
                   
                     
                       w 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         j 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         k 
                         , 
                         M 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         w 
                         
                           b 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           j 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           , 
                           M 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           k 
                           j 
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           e 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             j 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             , 
                             M 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   xiv 
                   . 
                 
               
             
           
         
       
     
     End j 
                     e   ⁡     (     k   ,   M     )       =       d   ⁡     (   k   )       -         w   T     ⁡     (       k   -   1     ,     n   ⁢           ⁢   M       )       ⁡     [             x   1     ⁡     (     k   ,   M     )               ⋮               x   n     ⁡     (     k   ,   M     )             ]                 xv   .               
Output of the FT-RLS adaptive algorithm circuit  401 :
 
                     w   ⁡     (     k   ,     n   ⁢           ⁢   M       )       =       w   ⁡     (       k   -   1     ,     n   ⁢           ⁢   M       )       +       [             k   1     ⁡     (     k   ,   M     )               ⋮               k   n     ⁡     (     k   ,   M     )             ]     ⁢     e   ⁡     (     k   ,   M     )                   xvi   .               
Implemented in the adaptive filter circuits f 1    406 , . . . ,f n    404 , and combiner  408 :
 
                     y   ⁡     (   k   )       =         w   T     ⁡     (     k   ,     n   ⁢           ⁢   M       )       ⁡     [             x   1     ⁡     (     k   ,   M     )               ⋮               x   n     ⁡     (     k   ,   M     )             ]               xvii   .               
End k
 
Note: The parameter v can be determined during manufacturing, but may change due to changes in operating conditions, calibration, or other factors.
 
     The above equations are but one example embodiment of a MISO filter with a simplified FT-RLS algorithm. The adaptive circuit  403  can implement steps i through xvi to produce the overall tap vector for MISO w(k,nM), which may then be implemented by the MISO filter circuit  410  at step xvii. In other embodiments, mathematical operations i through xvii may be calculated or implemented in one or more circuits. 
     The simplified FT-RLS algorithm can be expanded to accommodate three or more inputs. The algorithm may also be configured to operate when some of the input signals are removed or in an inactive state. For example, an algorithm configured to filter three input signals can be automatically or manually reconfigured when one of the input signals is inactive (e.g. source is removed, floating input signals, etc.). 
     Referring to  FIG. 5 , a system of simplified fast transversal algorithms for MISO filters is shown and generally designated  500 . System  500  is an example of a MISO filter circuit with a fast transversal recursive least-squares (FT-RLS) adaptive algorithm, and can be an embodiment of MISO filter circuits  101 ,  201 ,  301 , and  400 . System  500  can include forward prediction error/filter taps calculator circuits  502  and  504 , backward prediction error/filter taps calculator circuits  506  and  508 , and multiple input combiner calculator circuit  501 , all of which may be implemented via ASICs, FPGAs, controllers, system on chip, firmware, software, by other means, or any combination thereof, and may be integrated in a system on chip, or may be separate. The multiple input combiner circuit  501  can include an error calculator, a weight adapter, and output filter/combiner. The forward prediction error/filter taps calculator circuits  502  and  504 , and backward prediction prediction/filter taps calculator circuits  506  and  508 , can adjust the forward and backward prediction error/filter taps calculator circuits, respectively, and update or adjust intermediate gain vectors k 1 , . . . , k n . The gain vectors k 1 , . . . , k n  may then be combined by multiple input combiner calculator circuit  501  to produce the overall tap vector for MISO w(k,nM), which can be used with inputs x 1 (k), . . . , x n (k) to produce output y(k). 
     Both the FT-RLS algorithm and the simplified FT-RLS algorithm can minimize the mean square error (MSE) between the target output, d(k), and the actual output, y(k), by using a minimum number of input samples to converge to an optimum minimum MSE (MMSE) solution without involving the computational complexity of performing divisions or matrix inversions. The MMSE is a criterion, or metric, used to measure the performance of the underlying algorithm. 
       FIG. 4  and  FIG. 5  may be different representations of the same system. For example, system  400  can be a functional block diagram that illustrates the operation of the system; the relationship between the functions (e.g. adaptive filter functions) and the MISO filter. Portions of the FT-RLS algorithm may be used in some functions; the adaptive functions can include all of the steps of the FT-RLS algorithm except for the last step, which can be performed by the MISO filter. 
     System  500  is identical to system  400 , but can be a circuit diagram illustrating how the FT-RLS algorithm is implemented. For example, the circuits in system  500  perform calculations that may be implemented by the functions of system  400 . The forward prediction error/filter taps calculator circuits  502  and  504 , and the backward prediction error/filter taps calculator circuits  506  and  508  can calculate steps of the FT-RLS algorithm that may be intermediate. The multiple input combiner circuit  501  can calculate the overall tap vector for MISO w(k,nM), which can be implemented by input adaptive filter circuits f 1 (k)  406  and f n (k)  404 . 
     Referring to  FIG. 6 , parameter table for fast transversal algorithms for MISO filters is shown and generally designated  600 . 
     The illustrations, examples, and embodiments described herein are intended to provide a general understanding of the structure of various embodiments. The illustrations are not intended to serve as a complete description of all of the elements and features of apparatus and systems that utilize the structures or methods described herein. Many other embodiments may be apparent to those of skill in the art upon reviewing the disclosure. Other embodiments may be utilized and derived from the disclosure, such that structural and logical substitutions and changes may be made without departing from the scope of the disclosure. Moreover, although specific embodiments have been illustrated and described herein, it should be appreciated that any subsequent arrangement designed to achieve the same or similar purpose may be substituted for the specific embodiments shown. 
     This disclosure is intended to cover any and all subsequent adaptations or variations of various embodiments. Combinations of the above examples, and other embodiments not specifically described herein, will be apparent to those of skill in the art upon reviewing the description. Additionally, the illustrations are merely representational and may not be drawn to scale. Certain proportions within the illustrations may be exaggerated, while other proportions may be reduced. Accordingly, the disclosure and the figures are to be regarded as illustrative and not restrictive.