IIR Digital Filter Functions ============================ An IIR filter is also known as a recursive digital filter because its output is a function of previous outputs as well as the input. If x[n] represents the nth input to the filter and y[n] is the nth output of the filter then a general iir filter is implemented as follows: y[n] = c0*x[n] + c1*x[n-1] + ... + cM*x[n-M] - ( d1*y[n-1] + d2*y[n-2] + ... + dN*y[n-N]) This means that the nth output is a linear function of the nth input, the previous M inputs, and the previous N outputs. The c and d coefficients are calculated to give the filter a specific frequency response. The number of coefficients, M and N, will vary depending on the type of filter. There are many different kinds of iir filters and many different ways to calculate the coefficients. Listed below are filter types (currently only Butterworth filters) and the functions that can be used to calculate the c and d coefficients for lowpass, highpass, bandpass, and bandstop implementations of the filter. I. Butterworth Filters ------------------- A Butterworth filter is also known as a maximally flat filter because its frequency response is characterized by no ripple in the pass band and stop band. A. Lowpass functions The example program that shows how to use all the lowpass functions is bwlp. double *dcof_bwlp( int N, double fcf ); This fuction calculates the d coefficients for a Butterworth lowpass filter. The coefficients are returned as an array of doubles. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. fcf = filter cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A pointer to an array of doubles is returned. The size of the array is equal to N+1, one more than the filter order. The first element of the array is d0, the coefficient of y[n], which will always be equal to 1. The second element of the array is d1, the coefficient of y[n-1], and so on. The calling program must free the array when finished with it. int *ccof_bwlp( int n ); This fuction calculates the c coefficients for a Butterworth lowpass filter. The coefficients are returned as an array of integers. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. Return value: A pointer to an array of integers is returned. The size of the array is equal to N+1, one more than the filter order. The first element of the array is c0, the coefficient of x[n], which is the current input to the filter. The second element of the array is c1, the coefficient of x[n-1], and so on. The calling program must free the array when finished with it. double sf_bwlp( int n, double fcf ); This fuction calculates the scaling factor for a Butterworth lowpass filter. The scaling factor is what the c coefficients must be multiplied by so that the frequency response of the filter has a maximum magnitude of 1. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. fcf = filter cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A double that is scaling factor. B. Highpass functions The example program that shows how to use all the highpass functions is bwhp. double *dcof_bwhp( int N, double fcf ); This fuction calculates the d coefficients for a Butterworth highpass filter. The coefficients are returned as an array of doubles. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. fcf = filter cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A pointer to an array of doubles is returned. The size of the array is equal to N+1, one more than the filter order. The first element of the array is d0, the coefficient of y[n], which will always be equal to 1. The second element of the array is d1, the coefficient of y[n-1], and so on. The calling program must free the array when finished with it. int *ccof_bwhp( int n ); This fuction calculates the c coefficients for a Butterworth highpass filter. The coefficients are returned as an array of integers. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. Return value: A pointer to an array of integers is returned. The size of the array is equal to N+1, one more than the filter order. The first element of the array is c0, the coefficient of x[n], which is the current input to the filter. The second element of the array is c1, the coefficient of x[n-1], and so on. The calling program must free the array when finished with it. double sf_bwhp( int n, double fcf ); This fuction calculates the scaling factor for a Butterworth highpass filter. The scaling factor is what the c coefficients must be multiplied by so that the frequency response of the filter has a maximum magnitude of 1. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. fcf = filter cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A double that is scaling factor. C. Bandpass functions The example program that shows how to use all the bandpass functions is bwbp. double *dcof_bwbp( int n, double f1f, double f2f ); This fuction calculates the d coefficients for a Butterworth bandpass filter. The coefficients are returned as an array of doubles. Note that, although there is no upper limit on the filter order, if the bandwidth, f2f - f1f, is very small, the coefficients returned may not give the desired response due to numerical instability in the calculation. This problem should not occure if the filter order is kept less that or equal to 10. For very small bandwidths you should always verify the frequency response using a program such as rffr. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. f1f = lower cutoff frequency as a fraction of pi. Range = [0,1]. f2f = upper cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A pointer to an array of doubles is returned. The size of the array is equal to 2N+1, one more than twice the filter order. The first element of the array is d0, the coefficient of y[n], which will always be equal to 1. The second element of the array is d1, the coefficient of y[n-1], and so on. The calling program must free the array when finished with it. int *ccof_bwbp( int n ); This fuction calculates the c coefficients for a Butterworth bandpass filter. The coefficients are returned as an array of integers. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. Return value: A pointer to an array of integers is returned. The size of the array is equal to 2N+1, one more than twice the filter order. The first element of the array is c0, the coefficient of x[n], which is the current input to the filter. The second element of the array is c1, the coefficient of x[n-1], and so on. The calling program must free the array when finished with it. Note that ck for all odd k, c1, c3, c5, and so on, will be equal to zero for this filter. double sf_bwbp( int n, double f1f, double f2f ); This fuction calculates the scaling factor for a Butterworth bandpass filter. The scaling factor is what the c coefficients must be multiplied by so that the frequency response of the filter has a maximum magnitude of 1. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. f1f = lower cutoff frequency as a fraction of pi. Range = [0,1]. f2f = upper cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A double that is scaling factor. D. Bandstop functions The example program that shows how to use all the bandstop functions is bwbs. double *dcof_bwbs( int n, double f1f, double f2f ); This fuction calculates the d coefficients for a Butterworth bandstop filter. The coefficients are returned as an array of doubles. Note that, although there is no upper limit on the filter order, if the bandwidth, f2f - f1f, is very small, the coefficients returned may not give the desired response due to numerical instability in the calculation. This problem should not occure if the filter order is kept less that or equal to 10. For very small bandwidths you should always verify the frequency response using a program such as rffr. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. f1f = lower cutoff frequency as a fraction of pi. Range = [0,1]. f2f = upper cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A pointer to an array of doubles is returned. The size of the array is equal to 2N+1, one more than twice the filter order. The first element of the array is d0, the coefficient of y[n], which will always be equal to 1. The second element of the array is d1, the coefficient of y[n-1], and so on. The calling program must free the array when finished with it. double *ccof_bwbs( int n, double f1f, double f2f ); This fuction calculates the c coefficients for a Butterworth bandstop filter. The coefficients are returned as an array of doubles. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. f1f = lower cutoff frequency as a fraction of pi. Range = [0,1]. f2f = upper cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A pointer to an array of doubles is returned. The size of the array is equal to 2N+1, one more than twice the filter order. The first element of the array is c0, the coefficient of x[n], which is the current input to the filter. The second element of the array is c1, the coefficient of x[n-1], and so on. The calling program must free the array when finished with it. Note that ck for all odd k, c1, c3, c5, and so on, will be equal to zero for this filter. double sf_bwbs( int n, double f1f, double f2f ); This fuction calculates the scaling factor for a Butterworth bandstop filter. The scaling factor is what the c coefficients must be multiplied by so that the frequency response of the filter has a maximum magnitude of 1. Parameters: N = filter order. Range = [1, 20 or more] no fixed upper limit. f1f = lower cutoff frequency as a fraction of pi. Range = [0,1]. f2f = upper cutoff frequency as a fraction of pi. Range = [0,1]. Return value: A double that is scaling factor.