On Jul 8, 5:10*pm, Oli Charlesworth <ca...@olifilth.co.uk> wrote:
> Hello all,
>
> This is a question which probably boils down to "what am I missing?".
>
> It seems to be commonly stated that for interpolation or decimation,
> it's generally more computationally efficient to perform the operation
> in multiple stages, i.e. factorise the rate-change factor, and design a
> lower-order filter for each stage. *I completely accept that designing
> the individual filters in this way achieves a lower complexity, but I'm
> beginning to question whether one actually needs to implement the rate
> change in separate stages.
>
> Consider a system where we need to decimate by L = L1.L2. *(For the sake
> of argument, let's assume that neither L1 nor L2 equals 2, so that we
> can't "cheat" by implementing half-band filters.) *Using the typical
> approach, we might come up with two decimation filters, H1 and H2, of
> length N1 and N2 respectively. *i.e. our system is:
>
> --> H1 --> v L1 --> H2 --> v L2 -->
>
> If implemented as polyphase filters, the number of operations per input
> sample is (N1 / L1) + (N2 / L1.L2).
>
> But we could construct an equivalent overall filter H as the convolution
> of H1 and H2', where H2' is H2 simply upsampled by L1 by zero-stuffing.
> *The equivalent overall system would be:
>
> --> H --> v L1.L2 -->
>
> The order of H is now approximately N1 + L1.N2. *Therefore, the number
> of operations per input sample in this approach is (N1 + L1.N2) / L1.L2
> = (N1 / L1.L2) + (N2 / L2).
>
> It would seem, therefore, that depending on the particular values being
> used, the single stage approach may be as efficient or more efficient
> than the multi-stage approach.
>
> What am I missing? *(Or, where have I made a mistake?)
>
> --
> Oli

Not sure why you can call this "single stage" approach because you
have to virtually design H1 and H2 before you can implement this
"single stage" approach.

In fact, they are the same in terms of efficiency. Consider the
conventional approach, i.e.,

--> H1 --> v L1 --> H2 --> v L2 -->

If doing a "noble identity" conversion just using

--> v L1 --> H2

You can get this:

--> H1 --> H2(z^L1) --> v L1 --> vL2 --> (H2(z^L1) means the H2
upsampling by L1)

Thus, H1(z)*H2(z^L1) is the H filter in your approach. So that you can
have vL1.L2 too. I don't see why it can be "more efficient" than the
multirate design. As an exmaple, say, you have a need to achieve
downsample 12 = 3 * 4 (can't be 2*6, as you specified). You either can
let H1 corresponds to L1=3 or L1=4 so that L2 is determined
respectively. That is,

L1=3: --> H1 --> v 3 --> H2 --> v 4 --->
L1=4: --> H2' --> v 4 ---> H1' --> v 3 -->

Note that H2' doesn't equal to H2 because the decimation filters need
to be alias-free. These anti-alias feature is what you mean "more
efficient"?