Trying to identify the best method for IIR realizations

Question

I'm relatively new to implementing IIR filters in raw programming formats (i.e. C or C++) and I've run into the concept of IIR filter realizations.

So my question: is there a 'best format (works 99% of the time)' for implementing these filters? i.e. an implementation that will typically be 'best' regardless of the application? Or is the actual implementation highly dependent on the application?

Here's an array of smaller yet related questions:

• Is there ever an application in IIR filters where implementing the direct form of the filter is beneficial? Or should I always attempt to realize the filter as a cascade of subsystems?
• Regarding cascade and parallel realizations, is cascaded always better?
• Assuming that the exact filter implementation is dependent on the application, is it worth the effort to spend time and analyze the filter implementation from the beginning, or should I always aim for implementing as a cascaded subsystem and only deviate from that if the results are poor?
• What is the purpose of transposed systems? I understand mathematically the differences, however, are there actual physical benefits of implementing a transposed vs nontransposed system?

Answer 1

I don't think "regardless of application" works here. Every application has different requirements and hence the optimum choice would be different.

However in gross oversimplification

1. Direct Form I is the "safest choice". Direct Form II is slightly better since it has only half the amount of state variables. Stay away from Direct Form II and Transposed Form I since the transfer functions to the state variables are only determined by the poles and there can be massive gain scaling issues
2. Cascaded is the easiest choice. It's fairly simple to convert between poles and zeros and actual filter coefficients. Parallel requires calculating the roots of a large polynomial which is a numerically ill defined problem.
3. There are different ways to pair poles and zeros to create second order sections. Best one is this : http://scipy.github.io/devdocs/generated/scipy.signal.zpk2sos.html
4. Use floating point whenever possible. Fixed point IIR requires very careful analysis and application specific implementation.
5. Whether optimization is worth it really depends on the application. Requirements can be all over the place: precision, speed, memory, mips, ease of us, stability against outlier condition, etc.

Answer 2

I'll post this as an answer, simply because no matter what engineering you're doing:

i.e. an implementation that will typically be 'best' regardless of the application?

No. Something like this doesn't exist.

And it especially doesn't exist for filters, since their desired properties fully depend on the application you're designing for, and mostly are mutually contradicting:

• Filter length vs attenuation
• attenuation vs passband ripple
• Filter length vs transition width
• numerical stability vs steepness
• Phase stability vs delay
• …

So, every application defines requirements and objectives for a filter that demand for different parametrizations of different design methods.