# Patent

## Title
High-rate interpolation or decimation filter in integrated circuit device

## Abstract

On a device having a maximum data rate, an interpolation filter can be configured in stages, with each stage may be broken into subfilters, which divides the output into phases. The ratio of the number of subfilters or phases in the final stage to the number of subfilters or phases in the initial stage is equal to the factor by which the data rate would otherwise increase. Thus for an interpolation factor of M, the output data rate can be kept the same as the input data rate by providing M subfilters, yielding M output phases each having an output rate equal to the input rate. The effective, or synthesized, output rate is M times the input rate. A decimation filter can be provided in the same way, with the effective input rate M times the output rate, even where the effective input rate would exceed the maximum data rate.

## Background
BACKGROUND OF THE INVENTION
This invention relates to the implementation of high-rate interpolation or decimation filters on integrated circuit devices, especially programmable integrated circuit devices such as programmable logic devices (PLDs).
Finite impulse response (FIR) filters are commonly used in digital signal processing. FIR filters include interpolation and decimation filters, in which, in order to add or remove samples, respectively, by a certain factor N, each input sample has to be held while calculations for the N−1 interpolated samples are made, or each output sample has to be held while calculations for the N−1 decimated samples are made. If the filter is to operate in real time, the portion of the filter that performs those calculations has to run at N times the input sample rate (in the interpolation case) or the output sample rate (in the decimation case).
However, the filter cannot run faster than the clock rate of the device on which the filter is built. This becomes more of an issue as data rates of signals to be processed increase. If the filter is built in fixed logic, it may be possible to design the device speed to take the data rate into account. But on a programmable device, such as a PLD, one cannot know, when designing the programmable device itself, what kind of logic a user may want to program onto the device, so the device clock rate cannot be designed with a particular data rate in mind. And even with a fixed device, the ability to design to any clock rate may be limited.
In addition, the number of filter taps is directly proportional to the ratio of sample rate to transition bandwidth. Each filter tap requires at least one multiplier. Again, on a fixed device, one may be able to provide whatever number of multipliers one needs (although again, there may be reasons why there are limits to the number of multipliers), but on a programmable device, a certain number of multipliers will be provided but it is not possible to predict how many a user may need. One solution that a user may resort to is to break the filter down into stages, thereby limiting the number of multipliers required. However, the data rate increases with each stage, so the problem of the input rate for later stages (in the interpolation case), or the output rate for earlier stages (in the decimation case), exceeding the device rate may arise for this reason as well.
SUMMARY OF THE INVENTION
In accordance with the present invention, an interpolation filter not only may be broken into stages, but each stage may be broken into subfilters, which divides the output into phases. The number of subfilters or phases in the final stage is equal to the factor by which the data rate would otherwise increase. Thus, in one example, for an interpolation factor of M, the output data rate can be kept within the device rate by providing M subfilters, yielding M output phases each having an output rate equal to the input rate. The effective, or synthesized, output rate in such a case is M times the input rate.
Moreover, the number of input phases will increase with each stage. For stages after the first stage, the number of input phases would be the number of output phases of the previous stage. However, even for the first stage, the number of input phases may be greater than one. To generalize, for each stage, there may be any number of input phases (Pi), and a stage interpolation factor (Ms ), yielding a number of output phases (Po), where Po=Pi Ms. Each output phase is produced by a subfilter, so there are Po subfilters. Each subfilter has Pi  branches to accept the Pi input phases.
For the filter as a whole, having n stages, the overall effective interpolation factor is:




  M
  =
  
    
      ∏
      
        j
        =
        1
      
      n
    
    ⁢
    
      
    
    ⁢
    
      M
      sj
    
  




However, while the effective output data rate is M times the input data rate Ri, the actual data rate of each output phase is only MRi/Pof where Pof is the number of final output phases.

The case of a decimation filter is similar. For an overall decimation factor of M, there can be more than one stage. Because in decimation, the number of samples is decreased by the filter, the number of input phases exceeds the number of output phases. Thus the earlier stages have the larger number of subfilters sampling the respective input phases. The output phases of the subfilters in the earlier stage are combined for input to corresponding taps of the subfilters in the later stage. While the effective input data rate is M times the output data rate Ro, the actual data rate of each input phase is only MRo/Pif where Pif is the number of initial input phases.
Therefore, in accordance with the present invention, there is provided a FIR filter structure on an integrated circuit device for processing data samples and a set of a number of coefficients at an effective data rate that exceeds a maximum data rate of said device by a factor. The FIR filter structure includes a plurality of FIR filter stages including at a least an initial filter stage and a final filter stage. Each of the filter stages has one or more subfilters. A first one of the initial and final filter stages has a number of subfilters that exceeds a number of subfilters in a second of the initial and final filter stages by the aforementioned factor. Each subfilter in each respective filter stage convolves input data with a subset of coefficients whose number is related to a number of subfilters in an adjacent filter stage.
A method of configuring such circuitry on a programmable device, a programmable device so configurable, and a machine-readable data storage medium encoded with software for performing the method, are also provided.



BRIEF DESCRIPTION OF THE DRAWINGS
Further features of the invention, its nature and various advantages will be apparent upon consideration of the following detailed description, taken in conjunction with the accompanying drawings, in which like reference characters refer to like parts throughout, and in which:
FIG. 1 is a representation of a conventional polyphase 1:M interpolation filter;
FIG. 2 is a representation of a conventional interpolation filter broken into stages;
FIG. 3 is a representation of an interpolation filter according to an embodiment of the present invention;
FIGS. 4 and 5 are representations of one of the stages of the embodiment of FIG. 3;
FIG. 6 is a representation of an interpolation filter according to another embodiment of the present invention;
FIG. 7 is a representation of an decimation filter according to still another embodiment of the present invention;
FIG. 8 is a simplified block diagram of an illustrative system employing a programmable logic device incorporating the present invention;
FIG. 9 is a cross-sectional view of a magnetic data storage medium encoded with a set of machine-executable instructions for performing the method according to the present invention; and
FIG. 10 is a cross-sectional view of an optically readable data storage medium encoded with a set of machine executable instructions for performing the method according to the present invention.



DETAILED DESCRIPTION OF THE INVENTION
A FIR filter calculates a weighted sum of a finite number of inputs, summing a number of multiplication results, where each multiplication is between a sample and a coefficient. Each such multiplication may be referred to as a “tap.” Mathematically, a FIR filter may be described as:




  
    Y
    k
  
  =
  
    
      
        ∑
        
          i
          =
          0
        
        
          Taps
          -
          1
        
      
      ⁢
      
        ci
        ⁢
        
          
        
        ·
        
          
        
        ⁢
        Sk
      
    
    -
    i
  




where Yk is the kth output term, ci is the ith coefficient, sk-i is the (k−i)th sample, and Taps is the number of taps in the filter.

One example of a digital signal processing block for a programmable device, that may be configured as different types of filters, including an interpolation FIR filter and a decimation FIR filter, is shown in copending, commonly-assigned U.S. patent application Ser. No. 11/447,370, filed Jun. 5, 2006, which is hereby incorporated by reference herein in its entirety, although the present invention may be used with other types of devices.
In the case of interpolation, one inserts outputs between the outputs that are generated based on input samples. In the case, for example, of interpolation by two, one must create one output between each output based on an input sample. Therefore, the FIR filter circuitry must generate two outputs in the time interval occupied by one input—i.e., it must run at twice the input clock rate. For interpolation by a higher factor M, the circuitry must generate M−1 outputs between the outputs that are generated based on input samples, or a total of M outputs in the time interval occupied by one input—i.e., in a conventional interpolation filter, the circuitry must run at M times the input clock rate.
Similarly in the case of decimation, only one output is generated for every M inputs. In the case, for example, of decimation by two, one must accept two inputs for each output sample generated per output clock. Therefore, the FIR filter circuitry must generate an output in the time interval occupied by two inputs—i.e., it must run at twice the output clock rate. For decimation by a higher factor M, the circuitry must generate an output in the time interval occupied by M inputs—i.e., in a conventional interpolation filter, the circuitry must run at M times the output clock rate.
FIG. 1 shows an example of a conventional polyphase 1:M interpolation filter 101. In this example, interpolation filter 101 is configured on a programmable logic device 100 which may be an FPGA. Filter 101 is decomposed into M subfilters 102, where M is the interpolation factor. Both the input 103 and the M output legs 104 run at the device clock rate (“ClockRate”). Each leg represents every Mth sample and is shifted by one sample from the previous leg. An LVDS serializer 105 may be used to multiplex the M legs into a single signal at a synthesized higher output sample rate MxClockRate for further processing by digital-to-analog converter 106 and beyond.
The invention will now be described with reference to FIGS. 2-4, using interpolation as an example.
Many gigabit serial data standards now support synthesized output sample rates at or exceeding one billion samples per second (1 Gsps), but device clock rates have not kept pace, resulting in ever-higher interpolation factors M. Because the input data rate cannot exceed the device clock rate, sampling is performed with a narrow transition bandwidth. According to the filter design theory, the number of filter taps is proportional to the ratio of sample frequency to transition bandwidth. The use of ever-higher interpolation factors increases this ratio by both increasing the numerator and decreasing the denominator, thereby greatly increasing the number of filter taps. Each filter tap requires at least one multiplier, and if the number of multipliers on the device is limited, as it would be on a programmable device such as an FPGA that is not manufactured with a particular filter implementation in mind (and as might be the case even in a fixed logic device for other manufacturing reasons) the required number of taps could exceed the available number of multipliers on the device.
One known solution is to break down the 1:M interpolation into a number of cascaded filter stages to reduce the total number of multipliers. FIG. 2 shows an example of such a cascaded interpolation filter 200, in which M=16. As shown, the input data rate is 256 Msps, while the output data rate is 4096 Msps (i.e., 4 Gsps). Low-pass filtering may be used to preserve the input bandwidth while preventing aliasing due to the up-sampling process. In this design, the interpolation-by-16 filter is broken down into four stages 201-204, each of which may be an interpolation-by-2 filter. The output rate of each stage 201-204 is twice that stage's input rate, and that output rate becomes the input rate for the next one of stages 202-204. However, at some point in the cascade, the output rate of one of the stages may exceed the device clock rate, requiring the subsequent stage to have an input clock rate higher than the device clock rate, which is not permitted.
Therefore, in accordance with an embodiment of the present invention, filter 300 may be provided, as shown in FIG. 3. Filter 300 is broken down into stages 301-304, similar to stages 201-204 of filter 200, except that each stage 301-304 is broken down into subfilters 305, each of which provides a separate phase of the output of stage 301-304. In this way, the output rate of each subfilter 305 can be designed so that it does not exceed the input rate of the next subfilter 305 (i.e., does not exceed the device clock rate). The synthesized output rate of the stage 301-304 is the sum of the output rates of the individual subfilters 305 in the final stage 304.
The output rate of each subfilter 305 may be the same as the original input rate of the first stage 301, and the full multiplication of the input rate by M to achieve the final output rate is accomplished by having M subfilters 305 in the final stage 304. Alternatively, the output rate of each subfilter 305 may be the more or less than the original input rate of the first stage 301, as long as it does not exceed the device rate, and the number of subfilters 305 in final stage 304 can be adjusted accordingly.
FIG. 4 shows an embodiment 400 of the implementation of the subfilters bs0 (401), bs1 (402), bs2 (402), and bs3 (404) of filter stage 302. Filter stage 302 has a set of coefficients b(n), (n=0, . . . , N−1), where N equals the number of taps, which preferably is a multiple of the number of output phases Po (i.e., 4, in this example). To create the Po subfilters, b(n) is decomposed into Po decomposed filters (b0, b1, b2, b3 in this example), each of which starts at the nth coefficient and takes every Poth coefficient. The decomposed filters can them be combined according to the needs of the particular situation, including delaying and rotating the decomposed filters.
Thus, as seen in FIG. 4, and in more detail in FIG. 5, subfilters bs0 (401) and bs2 (403) both include decomposed filters b0 and b2, but in bs2 (403), the subfilters are rotated as compared to bs0 (401). Moreover, as seen in FIG. 5, while in subfilter bs2 (403), the b2′ inputs are taken starting after the first delay 501 of input0, in subfilter bs0 (401), the b2 inputs are taken starting after the second delay 502 of input1. These rotations and delays are exemplary only, and will be determined by the user as a function of the particular application when the filter is designed.
More generally, each of n subfilters picks a consistent pattern of coefficients—e.g., every nth coefficient, with the starting point and rotation determined by the user as a function of the particular application when the filter is designed. Over all of the subfilters, each of the coefficients is selected Ms times.
Although in the example shown in FIG. 3, the number of phases output by the final stage is equal to the overall interpolation factor M so that there is no change in data rate, the number of subfilters per stage can be arranged to provide any desired relationship of the number output phases to the interpolation factor, and therefore any desired change in data rate (within the limitations of the device).
Another example 610 of interpolation-by-6, in two filter stages, is shown in FIG. 6. The first stage 611 includes three subfilters 621, 631, 641 of a filter a, which take a single input phase 612 and provide three intermediate phases 613, 623, 633, which are input to second filter stage 604 including six subfilters 614, 624, 634, 644, 654, 664 of a filter b. Each subfilter in second stage 604 convolves the intermediate phases with either even or odd coefficients, which may be delayed or rotated.
FIG. 7 shows an example 710 of decimation-by-6 in two stages. First filter stage 711 including six subfilters 712, 713, 714, 715, 716, 717 of a filter b. Each subfilter in first stage 711 convolves the six input phases with either even or odd coefficients, which may be delayed or rotated, each providing three outputs that are combined into three intermediate phases 721, 722, 723. The second stage 731 includes three subfilters 732, 733, 734 of a filter a, which take the three intermediate phases 721, 722, 723 and provide a single output phase 740.
These arrangements can be proven mathematically. A regular interpolation-by-two filter can be represented by

y=Hx

More specifically,





  
    
      
        [
        
          
            
              ⋮
            
          
          
            
              
                y
                ⁡
                
                  (
                  
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    -
                    2
                  
                  )
                
              
            
          
          
            
              
                y
                ⁡
                
                  (
                  
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    -
                    1
                  
                  )
                
              
            
          
          
            
              
                y
                ⁡
                
                  (
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    i
                  
                  )
                
              
            
          
          
            
              
                y
                ⁡
                
                  (
                  
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    +
                    1
                  
                  )
                
              
            
          
          
            
              
                y
                ⁡
                
                  (
                  
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    +
                    2
                  
                  )
                
              
            
          
          
            
              
                y
                ⁡
                
                  (
                  
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    +
                    3
                  
                  )
                
              
            
          
          
            
              ⋮
            
          
        
        ]
      
      }
    
    
      
        
      
      ⁢
      
        y
        _
      
      ⁢
      
        
      
    
  
  =
  
    
      
        [
        
          
            
              
                
              
            
            
              ⋮
            
            
              
                
              
            
            
              
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    2
                  
                  )
                
              
            
            
              
                
              
            
            
              
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    1
                  
                  )
                
              
            
            
              
                
              
            
            
              
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  0
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    2
                  
                  )
                
              
            
            
              
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  1
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    1
                  
                  )
                
              
            
            
              
                
              
            
            
              
                
              
            
          
          
            
              ...
            
            
              
                h
                ⁡
                
                  (
                  2
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  0
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    2
                  
                  )
                
              
            
            
              ...
            
          
          
            
              
                
              
            
            
              ⋮
            
            
              
                h
                ⁡
                
                  (
                  1
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    1
                  
                  )
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    2
                  
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  2
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  0
                  )
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    1
                  
                  )
                
              
            
            
              ⋮
            
            
              
                h
                ⁡
                
                  (
                  1
                  )
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              ⋮
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    2
                  
                  )
                
              
            
            
              
                h
                ⁡
                
                  (
                  2
                  )
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    1
                  
                  )
                
              
            
            
              ⋮
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                
              
            
            
              ⋮
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    2
                  
                  )
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                
              
            
            
              
                
              
            
            
              
                h
                ⁡
                
                  (
                  
                    N
                    -
                    1
                  
                  )
                
              
            
            
              
                
              
            
          
          
            
              
                
              
            
            
              
                
              
            
            
              
                
              
            
            
              ⋮
            
            
              
                
              
            
          
        
        ]
      
      
        }
        H
      
    
    ⁢
    
      
        ·
        
          
            [
            
              
                
                  ⋮
                
              
              
                
                  
                    x
                    ⁡
                    
                      (
                      
                        i
                        -
                        1
                      
                      )
                    
                  
                
              
              
                
                  
                    x
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
              
              
                
                  
                    x
                    ⁡
                    
                      (
                      
                        i
                        +
                        1
                      
                      )
                    
                  
                
              
              
                
                  ⋮
                
              
            
            ]
          
          }
        
      
      
        
          
        
        ⁢
        
          x
          _
        
        ⁢
        
          
        
      
    
  




where N=length of the original filter, and h(0) . . . h(N−1)=the coefficients of the original filter.

Because the output data rate can not actually be faster than clock rate of the device, the interpolation-by-2 can be performed with 1-to-2 polyphase filter.




  
    [
    
      
        
          
            ⋮
          
        
        
          
            
              y
              ⁡
              
                (
                
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    i
                  
                  -
                  2
                
                )
              
            
          
        
        
          
            
              y
              ⁡
              
                (
                
                  2
                  ⁢
                  
                    
                  
                  ⁢
                  i
                
                )
              
            
          
        
        
          
            
              y
              ⁡
              
                (
                
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    i
                  
                  +
                  2
                
                )
              
            
          
        
        
          
            ⋮
          
        
      
      
        
          
            ⋮
          
        
        
          
            
              y
              ⁡
              
                (
                
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    i
                  
                  -
                  1
                
                )
              
            
          
        
        
          
            
              y
              ⁡
              
                (
                
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    i
                  
                  +
                  1
                
                )
              
            
          
        
        
          
            
              y
              ⁡
              
                (
                
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    i
                  
                  +
                  3
                
                )
              
            
          
        
        
          
            ⋮
          
        
      
    
    ]
  
  =
  
    
      
        [
        
          
            
              
                
                  
                
              
              
                ⋮
              
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      4
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      2
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      4
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      2
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      4
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                ...
              
              
                
                  j
                  ⁡
                  
                    (
                    2
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      2
                    
                    )
                  
                
              
              
                ...
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    4
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    2
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    0
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    4
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    2
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      4
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    4
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      2
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      4
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      2
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      4
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      2
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                ⋮
              
              
                
                  
                
              
            
          
          
            
              
                
                  
                
              
              
                ⋮
              
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      3
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      1
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      3
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    1
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      1
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      3
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    3
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    1
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      1
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                ...
              
              
                
                  h
                  ⁡
                  
                    (
                    5
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    3
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    1
                    )
                  
                
              
              
                ...
              
            
            
              
                
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    5
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    3
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      3
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    5
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      1
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      3
                    
                    )
                  
                
              
              
                ⋮
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      1
                    
                    )
                  
                
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      3
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  
                
              
              
                ⋮
              
              
                
                  h
                  ⁡
                  
                    (
                    
                      N
                      -
                      1
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                ⋮
              
              
                
                  
                
              
            
          
        
        ]
      
      
        }
        
          
            
          
          ⁢
          
            H
            ~
          
          ⁢
          
            
          
        
      
    
    ⁢
    
      
        ·
        
          
            [
            
              
                
                  ⋮
                
              
              
                
                  
                    x
                    ⁡
                    
                      (
                      
                        i
                        -
                        1
                      
                      )
                    
                  
                
              
              
                
                  
                    x
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
              
              
                
                  
                    x
                    ⁡
                    
                      (
                      
                        i
                        +
                        1
                      
                      )
                    
                  
                
              
              
                
                  ⋮
                
              
            
            ]
          
          }
        
      
      
        
          
        
        ⁢
        
          x
          _
        
        ⁢
        
          
        
      
    
  




To simplify the notation, the above can be written as:





  
    
      [
      
        
          y
          0
        
        
          
            y
            1
          
          _
        
      
      ]
    
    =
    
      
        
          H
          ~
        
        ⁢
        
          
        
        ⁢
        
          x
          _
        
      
      =
      
        
          [
          
            
              
                
                  H
                  0
                
              
            
            
              
                
                  H
                  1
                
              
            
          
          ]
        
        ·
        
          
        
        ⁢
        
          x
          _
        
      
    
  
  ⁢
  
    
  




However, the foregoing notation assumes the input data rate is lower or equal to the clock rate in the device. When the input data rate is faster than clock rate, the input can be separated into different phases as well. For example, an interpolation-by-2 filter can be designed as a 2 phase input/4 phase output system:




  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
      
        
          
            
              y
              2
            
            _
          
        
      
      
        
          
            
              y
              3
            
            _
          
        
      
    
    ]
  
  =
  
    
      
        H
        ~
      
      ·
      
        
      
      ⁢
      
        x
        _
      
    
    =
    
      
        [
        
          
            
              
                H
                0
              
            
            
              
                H
                2
                *
              
            
          
          
            
              
                H
                1
              
            
            
              
                H
                3
                *
              
            
          
          
            
              
                H
                2
              
            
            
              
                H
                0
              
            
          
          
            
              
                H
                3
              
            
            
              
                H
                1
              
            
          
        
        ]
      
      ·
      
        [
        
          
            
              
                
                  x
                  0
                
                _
              
            
          
          
            
              
                
                  x
                  1
                
                _
              
            
          
        
        ]
      
    
  




Hp is the filter matrix of the pth phase of an M-phase polyphase decomposition of the original filter H, where M is the number of output phases. For example:




  
    H
    0
  
  =
  
    [
    
      
        
          
            
          
        
        
          ⋮
        
        
          
            
          
        
        
          
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          ⋮
        
        
          
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          ⋮
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              0
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          
            
          
        
      
      
        
          ...
        
        
          
            h
            ⁡
            
              (
              M
              )
            
          
        
        
          
            h
            ⁡
            
              (
              0
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
              
              )
            
          
        
        
          ...
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                2
                ⁢
                M
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              M
              )
            
          
        
        
          
            h
            ⁡
            
              (
              0
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                2
                ⁢
                M
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              M
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                2
                ⁢
                M
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          ⋮
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            
          
        
        
          
            
          
        
        
          ⋮
        
        
          
            
          
        
      
    
    ]
  




H*p is the delayed version of the pth phase of an M-phase polyphase decomposition of the original filter H. For example:




  
    H
    2
    *
  
  =
  
    [
    
      
        
          
            
          
        
        
          ⋮
        
        
          
            
          
        
        
          
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  3
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          ⋮
        
        
          
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  3
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          ⋮
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  3
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          
            
          
        
      
      
        
          ...
        
        
          
            h
            ⁡
            
              (
              2
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          ...
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                M
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              2
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                M
                +
                2
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                M
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              2
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          
            h
            ⁡
            
              (
              
                M
                +
                2
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                
                  2
                  ⁢
                  M
                
                +
                2
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          ⋮
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            
          
        
        
          ⋮
        
        
          
            h
            ⁡
            
              (
              
                N
                -
                
                  2
                  ⁢
                  M
                
              
              )
            
          
        
        
          
            
          
        
      
      
        
          
            
          
        
        
          
            
          
        
        
          
            
          
        
        
          ⋮
        
        
          
            
          
        
      
    
    ]
  




The {tilde over (H)} matrix includes subfilter matrices (derived from polyphase decomposition) and the indices of the subfilter matrices have a regular structure and can be created by the following algorithm:

Ĥ=toeplitz(H[0:1:M−1],H*[M:−1):1]).

And {tilde over (H)}=Ĥ(:,1:f:end)

Where f is the interpolation factor and M is the number of outputs phases.

For example, the {tilde over (H)} filter for a 4-to-8 interpolator is:



  
    
      H
      ^
    
    =
    
      [
      
        
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              5
              *
            
          
          
            
              H
              4
              *
            
          
          
            
              H
              3
              *
            
          
          
            
              H
              2
              *
            
          
          
            
              H
              1
              *
            
          
        
        
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              5
              *
            
          
          
            
              H
              4
              *
            
          
          
            
              H
              3
              *
            
          
          
            
              H
              2
              *
            
          
        
        
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              5
              *
            
          
          
            
              H
              4
              *
            
          
          
            
              H
              3
              *
            
          
        
        
          
            
              H
              3
            
          
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              5
              *
            
          
          
            
              H
              4
              *
            
          
        
        
          
            
              H
              4
            
          
          
            
              H
              3
            
          
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              5
              *
            
          
        
        
          
            
              H
              5
            
          
          
            
              H
              4
            
          
          
            
              H
              3
            
          
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              6
              *
            
          
        
        
          
            
              H
              6
            
          
          
            
              H
              5
            
          
          
            
              H
              4
            
          
          
            
              H
              3
            
          
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              7
              *
            
          
        
        
          
            
              H
              7
            
          
          
            
              H
              6
            
          
          
            
              H
              5
            
          
          
            
              H
              4
            
          
          
            
              H
              3
            
          
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
        
      
      ]
    
  




  
    
      H
      ~
    
    =
    
      [
      
        
          
            
              H
              0
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              4
              *
            
          
          
            
              H
              2
              *
            
          
        
        
          
            
              H
              1
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              5
              *
            
          
          
            
              H
              3
              *
            
          
        
        
          
            
              H
              2
            
          
          
            
              H
              0
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              4
              *
            
          
        
        
          
            
              H
              3
            
          
          
            
              H
              1
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              5
              *
            
          
        
        
          
            
              H
              4
            
          
          
            
              H
              2
            
          
          
            
              H
              0
            
          
          
            
              H
              6
              *
            
          
        
        
          
            
              H
              5
            
          
          
            
              H
              3
            
          
          
            
              H
              1
            
          
          
            
              H
              7
              *
            
          
        
        
          
            
              H
              6
            
          
          
            
              H
              4
            
          
          
            
              H
              2
            
          
          
            
              H
              0
            
          
        
        
          
            
              H
              7
            
          
          
            
              H
              5
            
          
          
            
              H
              3
            
          
          
            
              H
              1
            
          
        
      
      ]
    
  



Also, the output phases can be computed by:




  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
      
        
          
            
              y
              2
            
            _
          
        
      
      
        
          
            
              y
              3
            
            _
          
        
      
      
        
          
            
              y
              4
            
            _
          
        
      
      
        
          
            
              y
              5
            
            _
          
        
      
      
        
          
            
              y
              6
            
            _
          
        
      
      
        
          
            
              y
              7
            
            _
          
        
      
    
    ]
  
  =
  
    
      
        H
        ~
      
      ·
      
        [
        
          
            
              
                
                  x
                  0
                
                _
              
            
          
          
            
              
                
                  x
                  1
                
                _
              
            
          
          
            
              
                
                  x
                  2
                
                _
              
            
          
          
            
              
                
                  x
                  3
                
                _
              
            
          
        
        ]
      
    
    =
    
      
        [
        
          
            
              
                H
                0
              
            
            
              
                H
                6
                *
              
            
            
              
                H
                4
                *
              
            
            
              
                H
                2
                *
              
            
          
          
            
              
                H
                1
              
            
            
              
                H
                7
                *
              
            
            
              
                H
                5
                *
              
            
            
              
                H
                3
                *
              
            
          
          
            
              
                H
                2
              
            
            
              
                H
                0
              
            
            
              
                H
                6
                *
              
            
            
              
                H
                4
                *
              
            
          
          
            
              
                H
                3
              
            
            
              
                H
                1
              
            
            
              
                H
                7
                *
              
            
            
              
                H
                5
                *
              
            
          
          
            
              
                H
                4
              
            
            
              
                H
                2
              
            
            
              
                H
                0
              
            
            
              
                H
                6
                *
              
            
          
          
            
              
                H
                5
              
            
            
              
                H
                3
              
            
            
              
                H
                1
              
            
            
              
                H
                7
                *
              
            
          
          
            
              
                H
                6
              
            
            
              
                H
                4
              
            
            
              
                H
                2
              
            
            
              
                H
                0
              
            
          
          
            
              
                H
                7
              
            
            
              
                H
                5
              
            
            
              
                H
                3
              
            
            
              
                H
                1
              
            
          
        
        ]
      
      ·
      
        [
        
          
            
              
                
                  x
                  0
                
                _
              
            
          
          
            
              
                
                  x
                  1
                
                _
              
            
          
          
            
              
                
                  x
                  2
                
                _
              
            
          
          
            
              
                
                  x
                  3
                
                _
              
            
          
        
        ]
      
    
  




As an example, the first output phase can be computed by the following:

y0=H0x0+H6*x1+H4*x2+H2*x3

where:





  
    
      H
      0
    
    ⁢
    
      
        x
        0
      
      _
    
  
  =
  
    
      [
      
        
          
            
              
            
          
          
            ⋮
          
          
            
              
            
          
          
            
              
            
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            
              h
              ⁡
              
                (
                
                  
                    N
                    -
                    1
                  
                  8
                
                )
              
            
          
          
            ⋮
          
          
            
              
            
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            
              h
              ⁡
              
                (
                0
                )
              
            
          
          
            
              h
              ⁡
              
                (
                
                  
                    N
                    -
                    1
                  
                  8
                
                )
              
            
          
          
            ⋮
          
          
            
              
            
          
        
        
          
            ...
          
          
            
              h
              ⁡
              
                (
                8
                )
              
            
          
          
            
              h
              ⁡
              
                (
                0
                )
              
            
          
          
            
              h
              ⁡
              
                (
                
                  
                    N
                    -
                    1
                  
                  8
                
                )
              
            
          
          
            ...
          
        
        
          
            
              
            
          
          
            
              h
              ⁡
              
                (
                16
                )
              
            
          
          
            
              h
              ⁡
              
                (
                8
                )
              
            
          
          
            
              h
              ⁡
              
                (
                0
                )
              
            
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            ⋮
          
          
            
              h
              ⁡
              
                (
                16
                )
              
            
          
          
            
              h
              ⁡
              
                (
                8
                )
              
            
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            
              h
              ⁡
              
                (
                
                  
                    N
                    -
                    1
                  
                  8
                
                )
              
            
          
          
            ⋮
          
          
            
              h
              ⁡
              
                (
                16
                )
              
            
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            ⋮
          
          
            
              h
              ⁡
              
                (
                
                  
                    N
                    -
                    1
                  
                  8
                
                )
              
            
          
          
            ⋮
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            
              
            
          
          
            ⋮
          
          
            
              h
              ⁡
              
                (
                
                  
                    N
                    -
                    1
                  
                  8
                
                )
              
            
          
          
            
              
            
          
        
        
          
            
              
            
          
          
            
              
            
          
          
            
              
            
          
          
            ⋮
          
          
            
              
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            ⋮
          
        
        
          
            
              x
              ⁡
              
                (
                
                  i
                  -
                  8
                
                )
              
            
          
        
        
          
            
              x
              ⁡
              
                (
                
                  i
                  -
                  4
                
                )
              
            
          
        
        
          
            
              x
              ⁡
              
                (
                i
                )
              
            
          
        
        
          
            
              x
              ⁡
              
                (
                
                  i
                  +
                  4
                
                )
              
            
          
        
        
          
            
              x
              ⁡
              
                (
                
                  i
                  +
                  8
                
                )
              
            
          
        
        
          
            ⋮
          
        
      
      ]
    
  




The invention also applies to interpolation filters with interpolation factors greater than 2. For example, a interpolate-by-3 filter can be implemented as a 3-to-9 phase interpolator:




  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
      
        
          
            
              y
              2
            
            _
          
        
      
      
        
          
            
              y
              3
            
            _
          
        
      
      
        
          
            
              y
              4
            
            _
          
        
      
      
        
          
            
              y
              5
            
            _
          
        
      
      
        
          
            
              y
              6
            
            _
          
        
      
      
        
          
            
              y
              7
            
            _
          
        
      
      
        
          
            
              y
              8
            
            _
          
        
      
    
    ]
  
  =
  
    
      [
      
        
          
            
              H
              0
            
          
          
            
              H
              6
              *
            
          
          
            
              H
              3
              *
            
          
        
        
          
            
              H
              1
            
          
          
            
              H
              7
              *
            
          
          
            
              H
              4
              *
            
          
        
        
          
            
              H
              2
            
          
          
            
              H
              8
              *
            
          
          
            
              H
              5
              *
            
          
        
        
          
            
              H
              3
            
          
          
            
              H
              0
            
          
          
            
              H
              6
              *
            
          
        
        
          
            
              H
              4
            
          
          
            
              H
              1
            
          
          
            
              H
              7
              *
            
          
        
        
          
            
              H
              5
            
          
          
            
              H
              2
            
          
          
            
              H
              8
              *
            
          
        
        
          
            
              H
              6
            
          
          
            
              H
              3
            
          
          
            
              H
              0
            
          
        
        
          
            
              H
              7
            
          
          
            
              H
              4
            
          
          
            
              H
              1
            
          
        
        
          
            
              H
              8
            
          
          
            
              H
              5
            
          
          
            
              H
              2
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            
              
                x
                0
              
              _
            
          
        
        
          
            
              
                x
                1
              
              _
            
          
        
        
          
            
              
                x
                2
              
              _
            
          
        
      
      ]
    
  




From the foregoing, one can derive the following applications:
1. Single-rate filtering (n phases in and n phases out) at rates above the device rate:

Ĥ=toeplitz(H[0:1:n−1],H[n:(−1):1]*);

y=Ĥ*x; 

For example: 4 phases in and 4 phases out:





  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
      
        
          
            
              y
              2
            
            _
          
        
      
      
        
          
            
              y
              3
            
            _
          
        
      
    
    ]
  
  =
  
    
      [
      
        
          
            
              H
              0
            
          
          
            
              H
              3
              *
            
          
          
            
              H
              2
              *
            
          
          
            
              H
              1
              *
            
          
        
        
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              3
              *
            
          
          
            
              H
              2
              *
            
          
        
        
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              3
              *
            
          
        
        
          
            
              H
              3
            
          
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            
              
                x
                0
              
              _
            
          
        
        
          
            
              
                x
                1
              
              _
            
          
        
        
          
            
              
                x
                2
              
              _
            
          
        
        
          
            
              
                x
                3
              
              _
            
          
        
      
      ]
    
  




2. Decimation filtering (↓M: n phases in and n/M phases out):

Ĥ=toeplitz(H[0:1:n−1],H[n:(−1):1]*);

y=Ĥ(1:M:end,:)*x; 

For example: 4 phases in and 2 phases out (decimate-by-2):





  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
    
    ]
  
  =
  
    
      [
      
        
          
            
              H
              0
            
          
          
            
              H
              3
              *
            
          
          
            
              H
              2
              *
            
          
          
            
              H
              1
              *
            
          
        
        
          
            
              H
              2
            
          
          
            
              H
              1
            
          
          
            
              H
              0
            
          
          
            
              H
              3
              *
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            
              
                x
                0
              
              _
            
          
        
        
          
            
              
                x
                1
              
              _
            
          
        
        
          
            
              
                x
                2
              
              _
            
          
        
        
          
            
              
                x
                3
              
              _
            
          
        
      
      ]
    
  




3. Interpolation filtering (↑M: n phases in and nM phases out):

Ĥ=toeplitz(H[0:1:nM−1],H[nM:(−1):1]*);

y=Ĥ(:,1:M:end)*x; 

For example: 2 phases in and 4 phases out (interpolate-by-2):





  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
      
        
          
            
              y
              2
            
            _
          
        
      
      
        
          
            
              y
              3
            
            _
          
        
      
    
    ]
  
  =
  
    
      [
      
        
          
            
              H
              0
            
          
          
            
              H
              2
              *
            
          
        
        
          
            
              H
              1
            
          
          
            
              H
              3
              *
            
          
        
        
          
            
              H
              2
            
          
          
            
              H
              0
            
          
        
        
          
            
              H
              3
            
          
          
            
              H
              1
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            
              
                x
                0
              
              _
            
          
        
        
          
            
              
                x
                1
              
              _
            
          
        
      
      ]
    
  




4. Fractional filtering (↑M/N: n phase in and nM/N phases out):
For example: 4 phase input→decimate-by-2→interpolate by 3→6 phase output




  
    [
    
      
        
          
            
              y
              0
            
            _
          
        
      
      
        
          
            
              y
              1
            
            _
          
        
      
      
        
          
            
              y
              2
            
            _
          
        
      
      
        
          
            
              y
              3
            
            _
          
        
      
      
        
          
            
              y
              4
            
            _
          
        
      
      
        
          
            
              y
              5
            
            _
          
        
      
    
    ]
  
  =
  
    
      [
      
        
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                0
              
            
          
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                3
              
            
          
        
        
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                1
              
            
          
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                4
              
            
          
        
        
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                2
              
            
          
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                5
              
            
          
        
        
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                3
              
            
          
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                0
              
            
          
        
        
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                4
              
            
          
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                1
              
            
          
        
        
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                5
              
            
          
          
            
              H
              
                I
                ⁢
                
                  
                
                ⁢
                2
              
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                0
              
            
          
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                3
              
              *
            
          
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                2
              
              *
            
          
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                1
              
              *
            
          
        
        
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                2
              
            
          
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                1
              
            
          
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                0
              
            
          
          
            
              H
              
                D
                ⁢
                
                  
                
                ⁢
                3
              
              *
            
          
        
      
      ]
    
    ·
    
      [
      
        
          
            
              
                x
                0
              
              _
            
          
        
        
          
            
              
                x
                1
              
              _
            
          
        
        
          
            
              
                x
                2
              
              _
            
          
        
        
          
            
              
                x
                3
              
              _
            
          
        
      
      ]
    
  




A PLD 280 configured according to the present invention may be used in many kinds of electronic devices. One possible use is in a data processing system 900 shown in FIG. 8. Data processing system 900 may include one or more of the following components: a processor 281; memory 282; I/O circuitry 283; and peripheral devices 284. These components are coupled together by a system bus 285 and are populated on a circuit board 286 which is contained in an end-user system 287.
System 900 can be used in a wide variety of applications, such as computer networking, data networking, instrumentation, video processing, digital signal processing, or any other application where the advantage of using programmable or reprogrammable logic is desirable. PLD 280 can be used to perform a variety of different logic functions. For example, PLD 280 can be configured as a processor or controller that works in cooperation with processor 281. PLD 280 may also be used as an arbiter for arbitrating access to a shared resources in system 900. In yet another example, PLD 280 can be configured as an interface between processor 281 and one of the other components in system 900. It should be noted that system 900 is only exemplary, and that the true scope and spirit of the invention should be indicated by the following claims.
Various technologies can be used to implement PLDs 280 as described above and incorporating this invention.
Instructions for carrying out the method according to this invention may be encoded on a machine-readable medium, to be executed by a suitable computer or similar device to implement the method of the invention for programming PLDs. For example, a personal computer may be equipped with an interface to which a PLD can be connected, and the personal computer can be used by a user to program the PLD using a suitable software tool, such as the QUARTUS® II software available from Altera Corporation, of San Jose, Calif.
FIG. 9 presents a cross section of a magnetic data storage medium 600 which can be encoded with a machine executable program that can be carried out by systems such as the aforementioned personal computer, or other computer or similar device. Medium 600 can be a floppy diskette or hard disk, or magnetic tape, having a suitable substrate 601, which may be conventional, and a suitable coating 602, which may be conventional, on one or both sides, containing magnetic domains (not visible) whose polarity or orientation can be altered magnetically. Except in the case where it is magnetic tape, medium 600 may also have an opening (not shown) for receiving the spindle of a disk drive or other data storage device.
The magnetic domains of coating 602 of medium 600 are polarized or oriented so as to encode, in manner which may be conventional, a machine-executable program, for execution by a programming system such as a personal computer or other computer or similar system, having a socket or peripheral attachment into which the PLD to be programmed may be inserted, to configure appropriate portions of the PLD, including its specialized processing blocks, if any, as a filter in accordance with the invention.
FIG. 10 shows a cross section of an optically-readable data storage medium 700 which also can be encoded with such a machine-executable program, which can be carried out by systems such as the aforementioned personal computer, or other computer or similar device. Medium 700 can be a conventional compact disk read only memory (CD-ROM) or digital video disk read only memory (DVD-ROM) or a rewriteable medium such as a CD-R, CD-RW, DVD-R, DVD-RW, DVD+R, DVD+RW, or DVD-RAM or a magneto-optical disk which is optically readable and magneto-optically rewriteable. Medium 700 preferably has a suitable substrate 701, which may be conventional, and a suitable coating 702, which may be conventional, usually on one or both sides of substrate 701.
In the case of a CD-based or DVD-based medium, as is well known, coating 702 is reflective and is impressed with a plurality of pits 703, arranged on one or more layers, to encode the machine-executable program. The arrangement of pits is read by reflecting laser light off the surface of coating 702. A protective coating 704, which preferably is substantially transparent, is provided on top of coating 702.
In the case of magneto-optical disk, as is well known, coating 702 has no pits 703, but has a plurality of magnetic domains whose polarity or orientation can be changed magnetically when heated above a certain temperature, as by a laser (not shown). The orientation of the domains can be read by measuring the polarization of laser light reflected from coating 702. The arrangement of the domains encodes the program as described above.
It will be understood that the foregoing is only illustrative of the principles of the invention, and that various modifications can be made by those skilled in the art without departing from the scope and spirit of the invention. For example, the various elements of this invention can be provided on a PLD in any desired number and/or arrangement. One skilled in the art will appreciate that the present invention can be practiced by other than the described embodiments, which are presented for purposes of illustration and not of limitation, and the present invention is limited only by the claims that follow.

## Claims

1. A FIR (Finite Impulse Response) filter structure on an integrated circuit device, for processing data samples and a set of coefficients, at an effective filter data rate that exceeds an input/output data rate by a factor, said FIR filter structure comprising:
a plurality of FIR filter stages including at a least an initial filter stage and a final filter stage, each of said filter stages having one or more subfilters defined by a subset of said set of coefficients, a first one of said initial and final filter stages having a number of subfilters that exceeds a number of subfilters in a second of said initial and final filter stages by said factor; wherein:
each subfilter in each respective filter stage convolves input data with a respective subset of said set of coefficients; and
in at least one particular stage, at least a first subfilter in said particular stage includes a plurality of decomposed filters in a first filter order representing said respective subset of said set of coefficients in a first coefficient order, and at least a second subfilter in said particular stage includes said plurality of decomposed filters in a second filter order, different from said first filter order, representing said respective subset of said set of coefficients in a second coefficient order different from said first coefficient order.

2. The filter structure of claim 1 wherein:
said filter structure is an interpolation filter;
said first one of said initial and final filter stages is said final filter stage;
said effective filter data rate is an output rate; and
said input/output data rate is an input data rate.

3. The filter structure of claim 1 wherein:
said filter structure is a decimation filter;
said first one of said initial and final filter stages is said initial filter stage;
said effective filter data rate is an input rate; and
said input/output data rate is an output data rate.

4. The FIR filter structure of claim 1 further comprising at least one intermediate filter stage.

5. The FIR filter structure of claim 1 wherein:
said integrated circuit device has a maximum device data rate; and
said effective filter data rate exceeds said maximum device data rate.

6. The filter structure of claim 1 wherein a particular one of said decomposed filters in said at least a first subfilter is delayed relative to said particular one of said decomposed filters in said at least a second subfilter.

7. A method of programmably configuring a programmable integrated circuit device, having a maximum device data rate, as a FIR (Finite Impulse Response) filter structure, for processing data samples and a set of a number of coefficients, at an effective filter data rate that exceeds an input/output data rate by a factor, said method comprising:
programmably configuring logic of said programmable integrated circuit device as a plurality of FIR filter stages including at a least an initial filter stage and a final filter stage, each of said filter stages having one or more subfilters defined by a subset of said set of coefficients, a first one of said initial and final filter stages having a number of subfilters that exceeds a number of subfilters in a second of said initial and final filter stages by said factor;
programmably configuring each subfilter in each respective filter stage to convolve input data with a respective subset of said set of coefficients; and
programmably configuring, in at least one particular stage, at least a first subfilter in said particular stage to include a plurality of decomposed filters in a first filter order representing said respective subset of said set of coefficients in a first coefficient order, and at least a second subfilter in said particular stage to include said plurality of decomposed filters in a second filter order, different from said first filter order representing said respective subset of said set of coefficients in a second coefficient order.

8. The method of claim 7 wherein said filter structure is an interpolation filter;
said first one of said initial and final filter stages is said final filter stage;
said effective filter data rate is an output rate; and
said input/output data rate is an input data rate.

9. The method of claim 7 wherein said filter structure is a decimation filter;
said first one of said initial and final filter stages is said initial filter stage;
said effective filter data rate is an input rate; and
said input/output data rate is an output data rate.

10. The method of claim 7 further comprising programmably configuring logic of said programmable integrated circuit device as at least one intermediate filter stage.

11. The method of claim 7 wherein:
said effective filter data rate exceeds said maximum device data rate.

12. The method of claim 7 further comprising programmably configuring a particular one of said decomposed filters in said at least a first subfilter to be delayed relative to said particular one of said decomposed filters in said at least a second subfilter.

13. A non-transitory machine-readable data storage medium encoded with machine-executable instructions for performing a method of programmably configuring a programmable integrated circuit device, having a maximum device data rate, as a FIR (Finite Impulse Response) filter structure, for processing data samples and a set of a number of coefficients, at an effective filter data rate that exceeds an input/output data rate by a factor, said instructions comprising:
instructions for programmably configuring logic of said programmable integrated circuit device as a plurality of FIR filter stages including at a least an initial filter stage and a final filter stage, each of said filter stages having one or more subfilters defined by a subset of said set of coefficients, a first one of said initial and final filter stages having a number of subfilters that exceeds a number of subfilters in a second of said initial and final filter stages by said factor;
instructions for programmably configuring each subfilter in each respective filter stage to convolve input data with a respective subset of said set of coefficients; and
instructions for programmably configuring, in at least one particular stage, at least a first subfilter in said particular stage to include a plurality of decomposed filters in a first filter order representing said respective subset of said set of coefficients in a first coefficient order, and at least a second subfilter in said particular stage to include said plurality of decomposed filters in a second filter order, different from said first filter order representing said respective subset of said set of coefficients in a second coefficient order.

14. The non-transitory machine-readable data storage medium of claim 13 wherein said instructions comprise instructions to configure said filter structure as an interpolation filter in which:
said first one of said initial and final filter stages is said final filter stage;
said effective filter data rate is an output rate; and
said input/output data rate is an input data rate.

15. The non-transitory machine-readable data storage medium of claim 13 wherein said instructions comprise instructions to configure said initial filter stage said filter structure as a decimation filter in which:
said first one of said initial and final filter stages is said initial filter stage;
said effective filter data rate is an input rate; and
said input/output data rate is an output data rate.

16. The non-transitory machine-readable data storage medium of claim 13 wherein said instructions comprise instructions to configure said filter such that said effective filter data rate exceeds said maximum device data rate.

17. The non-transitory machine-readable data storage medium of claim 13 further comprising instructions for programmably configuring a particular one of said decomposed filters in said at least a first subfilter to be delayed relative to said particular one of said decomposed filters in said at least a second subfilter.