Filter Design Toolbox 4

Design and analyze fixed-point, adaptive, and multirate filters
The Filter Design Toolbox is a collection of tools that provide advanced techniques for designing, simulating, and analyzing digital filters. It extends Signal Processing Toolbox (required, available separately) with filter architectures and design methods for complex real-time DSP applications, including adaptive and multirate filtering. When used with Fixed-Point Toolbox (available separately), Filter Design Toolbox provides functions that simplify the design of fixed-point filters and the analysis of quantization effects. When used with Filter Design HDL Coder (available separately), Filter Design Toolbox lets you generate VHDL and Verilog code for fixed-point filters. When used with Signal Processing Blockset (available separately), Filter Design Toolbox enables you to fully integrate the filter design process with modeling and simulation in Simulink by providing a filter design block library.

Key features

Advanced FIR filter design methods, including minimumorder, minimum-phase, halfband, complexity-optimized multistage, Farrow, and interpolated FIR Advanced IIR design methods, including arbitrary magnitude, group-delay equalizers, halfband, quasi-linear phase, and comb filters Multirate filter design methods, including cascaded integrator-comb (CIC), CIC compensator, polyphase FIR and IIR, and multistage Nyquist filters Support for efficient IIR filter implementations, including second-order sections and lattice wave digital filters Adaptive filter design, analysis, and implementation, including LMS-based, RLS-based, lattice-based, frequency-domain, fast transversal, and affine projection
FIR and IIR Filter Design
The Filter Design Toolbox enables you to design advanced FIR and IIR filters, import designed filters to Simulink, quantize floating-point filters, and analyze quantization effects. You can design filters from the MATLAB command line, in Simulink with the filter design block library, or from a graphical user interface such as FilterBuilder in the toolbox or Filter Design and Analysis Tool (FDATool). The new FilterBuilder GUI facilitates the filter design process with capabilities beyond those of the FDATool.

Multirate Filters

Filter Design Toolbox provides functions for the design and implementation of multirate filters, including polyphase interpolators, decimators, sample-rate converters, and CIC filters and compensators; and support for multistage design methods. Specialized analysis functions to automatically estimate the computational complexity of multirate filters are also available.
Design Methods (partial list)
Advanced equiripple FIR filters, including minimum-order, constrainedripple, minimum-phase designs
Nyquist and halfband FIR and IIR filters, providing linear phase, minimum-phase, and quasi-linear phase (IIR) designs, as well as equiripple, sloped-stopband, and window methods

Related Products

Filter Design HDL Coder. Generate VHDL and Verilog code for fixed-point filters from MATLAB Fixed-Point Toolbox. Design and verify fixed-point algorithms and analyze fixedpoint data Signal Processing Blockset. Design and simulate signal processing systems and devices Simulink Fixed Point. Design and simulate fixed-point systems For more information on related products, visit www.mathworks.com/products/filterdesign
Optimized multistage designs, enabling you to optimize the number of cascaded stages to achieve the lowest computational complexity Fractional-delay filters, including implementation using Farrow filter structures well-suited for tunable filtering applications Allpass IIR filters with arbitrary group delay, enabling you to compensate for the group delays of other IIR filters to obtain an approximate linear phase passband response Lattice wave digital IIR filters, for robust fixed-point implementation Arbitrary magnitude and phase FIR and IIR, enabling design of any userspecified filter
Platform and System Requirements
For platform and system requirements, visit www.mathworks.com/products/filterdesign

Resources and Support

ONLINE USER COMMUNITY
www.mathworks.com/matlabcentral
Fixed-Point Filters and Floating-to-FixedPoint Conversion

When used with Fixed-Point Toolbox, the Filter Design Toolbox offers bit-true, fixedpoint implementation of single-rate and multirate filters, including second-order sections (SOS) with section scaling and reordering, CIC, polyphase FIR and IIR filters. Word lengths for different quantities, such as coefficients, products, and accumulators, can be set to arbitrary values. Full-precision modes are available to simulate the filtering process without round-off errors. The Filter Design Toolbox provides analysis tools for easier conversion of a design from floating-point to a fixed-point representation, including dynamic range and round-off-noise analyses. lattice-based. The toolbox also includes algorithms for the analysis of these filters, including tracking of coefficients, learning curves, and convergence.

D EMOS

www.mathworks.com/demos
T HIRD-PARTY PRODUCTS AND SERVICES
www.mathworks.com/connections
TECHNICAL SUPPORT T RAINING SERVICES
www.mathworks.com/support www.mathworks.com/training
Integrating Filter Design with System Simulation
Filter Design Toolbox integrates the filter design process in MATLAB with systemlevel simulation in Simulink. It provides functions that generate bit-true Simulink models from MATLAB filter objects. When you use Filter Design Toolbox with Signal Processing Blockset, you have access to a block library that lets you design, simulate, and implement filters directly in Simulink.

C ONSULTING SERVICES

www.mathworks.com/consulting
MATHWORKS ACCOUNT MATHWORKS OFFICES
US & Canada Australia Benelux France Germany Italy Korea Spain Sweden Switzerland UK
www.mathworks.com/account
+1-508-647-7000 +4700 +31 (0) 182-696-700 +33 (0) 1-41-14-67-14 +49 (0) 241-470-750 +39 (011) 2274-700 +82 (0) 2-6006-5114 +34 91-799-18-80 +46 (8) 505-317-00 +41 (0) 31-950-60-20 +44 (0)700

Adaptive Filters

The Filter Design Toolbox provides the following techniques for adaptive filters: LMS-based, RLS-based, affine projection, fast transversal, frequency-domain, and

Required Products

MATLAB Signal Processing Toolbox
For more information on MathWorks products and services: www.mathworks.com
Tel: 508.647.7000 info@mathworks.com www.mathworks.com

9860v02 09/06

2006 MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, and xPC TargetBox are registered trademarks and SimBiology, SimEvents, and SimHydraulics are trademarks of The MathWorks, Inc. Other product or brand names are trademarks or registered trademarks of their respective holders.

Menu and dialog box titles New terms and for emphasis Omitted input arguments
Choose the File Options menu. An array is an ordered collection of information.

[c,ia,ib] = union(.)

Italics (.) ellipsis denotes all of the input/output arguments from preceding syntaxes.

Monospace italics

String variables (from a finite list)
sysc = d2c(sysd,'method')
Filter Design Functions in the Toolbox (p. 1-4) Quantization Functions in the Toolbox (p. 1-7) Comparison to the Signal Processing Toolbox (p. 1-11) Getting Started with the Toolbox (p. 1-15) Selected Bibliography (p. 1-28)
Outlines the filter design functions available in the toolbox Outlines the quantization functions available in the toolbox Explains where the toolbox differs from the Signal Processing Toolboxthe different and more advanced features Provides an introduction to the toolbox by presenting examples that design various filters Lists some books that offer details about digital filtering and digital signal processing
When you install Filter Design Toolbox in your MATLAB environment, you can perform digital filter design, fixed- and floating-point filter quantization, and filter performance analysis on your desktop computer. But what are filtering and quantization and what benefits do they provide? Designers use filtering and its variant, digital filtering, for many tasks: To separate signals that have been combined, such as a musical recording and the noise added during the recording process To separate signals into their constituent frequencies To demodulate signals To restore signals that have been degraded by some process, known or unknown You can use analog filters to accomplish these tasks, but digital filters offer greater flexibility and accuracy than analog filters. In addition, digital signal processing (DSP) depends in large measure on digital filtering to meet the needs of its users. Analog filters can be cheaper, faster, and have greater dynamic range; digital filters outstrip their analog cousins in flexibility. The ability to create filters that have arbitrary shape frequency response curves, and filters that meet performance constraints, such as bandpass width and transition region width, is well beyond that of analog filters. Quantization is a natural outgrowth of digital filtering and digital signal processing development. Also, there is a growing need for fixed-point filters that meet power, cost, and size restrictions. When you convert a filter from floating-point to fixed-point, you use quantization to perform the conversion. As filter designers began to use digital filters in applications where power limitations and size constraints drove the filter design, they moved from double-precision, floating-point filters to fixed-point filters. When you have enough power to run a floating-point digital signal processor, such as on desktop PC or in your car, fixed-point processing and filtering are unnecessary. But, when your filter needs to run in a cellular phone, or you want to run a hearing aid for hours instead of seconds, fixed-point processing can be essential to ensure long battery life and small size. Filter Design Toolbox provides the functions you need to develop filters that meet the needs of fixed-point algorithms and electronics systems. In addition

6 Click OK to close the dialog and convert the filter according to your settings. 7 Select Magnitude Response from the FDATool Analysis menu.
Our quantized second-order section filter now has the magnitude response we require, and matches the unquantized filter specifications. In the following figure showing the magnitude response curves for both filters, you cann distinguish between the reference and quantized filter curves only
within the beginning of the passband. To emphasize the match between the reference and quantized filters in the passband, use the zoom function to look more closely at the passband as shown.
As you followed this example, you created an arbitrary magnitude IIR filter to match an ideal filter response. Then you quantized the filter and converted it to second-order section form. All of this you accomplished using FDATool, although you could have used the command line to perform the same filter design and quantization operations. To save the filter you created in FDATool, either select File->Save Session to save the session and your FDATool interface settings, or choose File->Export to export the filter to your MATLAB workspace in transfer function form.

Selected Bibliography

For further information about the algorithms and computer models used to design filters and apply quantization in the toolbox, refer to one or more of the following references.

Digital Filters

[1] Antoniou, Andreas, Digital Filters, Second Edition, McGraw-Hill, Inc., 1993 [2] Mitra, Sanjit K., Digital Signal Processing: A Computer-Based Approach, McGraw-Hill, Inc, 1998 [3] Oppenheim, Alan. V., R.W. Schafer, Discrete-Time Signal Processing, Prentice-Hall, Inc, 1989
Quantization and Signal Processing
[4] Lapsley, Phil, J, Bier, A. Shoham, E.A. Lee, DSP Processor Fundamentals, IEEE Press, 1997 [5] McClellan, James H., C.S. Burrus, A.V. Oppenheim, T.W. Parks, R.W. Schafer, H.W. Schuessler, Computer-Based Exercises for Signal Processing Using MATLAB 5, Prentice-Hall, Inc., 1998 [6] Roberts, Richard A., C.T. Mullis, Digital Signal Processing, Addison-Wesley Publishing Company, 1987 [7] Van Loan, Charles, Computational Frameworks for the Fast Fourier Transform, SIAM,1992

Table 3-1: Adaptive Filter Functions in the Toolbox Function adaptkalman Description
Use a Kalman algorithm to determine the coefficients for a filter to model an unknown system. Use a least mean squares (LMS) algorithm to determine the coefficients for a filter to model an unknown system. Use a normalized least mean squares algorithm to determine the coefficients for a filter to model an unknown system. Use a recursive least squares algorithm to determine the coefficients for a filter to model an unknown system. Use a sign-data LMS algorithm to determine the coefficients for a filter to model an unknown system. Use a sign-error LMS algorithm to determine the coefficients for a filter to model an unknown system. Use a sign-sign LMS algorithm to determine the coefficients for a filter to model an unknown system.

adaptlms

adaptnlms

adaptrls

adaptsd

adaptse

adaptss
Presenting a detailed derivation of the Wiener-Hopf equation and determining solutions to it is beyond the scope of this Users Guide. Full descriptions of the theory appear in the adaptive filter references provided in the Selected Bibliography on page 3-41.
Examples of Adaptive Filters That Use LMS Algorithms
This section provides introductory examples using each of the least mean squares (LMS) adaptive filter functions in the toolbox. The Filter Design Toolbox provides five adaptive filter design functions that use the LMS algorithms to search for the optimal solution to the adaptive filter: adaptlms implement the LMS algorithm to solve the Weiner-Hopf equation and find the filter coefficients for an adaptive filter. adaptnlms implement the normalized variation of the LMS algorithm to solve the Weiner-Hopf equation and determine the filter coefficients of an adaptive filter. adaptsd implement the sign-data variation of the LMS algorithm to solve the Weiner-Hopf equation and determine the filter coefficients of an adaptive filter. The correction to the filter weights at each iteration depends on the sign of the input x(k). adaptse implement the sign-error variation of the LMS algorithm to solve the Weiner-Hopf equation and determine the filter coefficients of an adaptive filter. The correction applied to the current filter weights for each successive iteration depends on the sign of the error, e(k). adaptss implement the sign-sign variation of the LMS algorithm to solve the Weiner-Hopf equation and determine the filter coefficients of an adaptive filter. The correction applied to the current filter weights for each successive iteration depends on both the sign of x(k) and the sign of e(k). To demonstrate the differences and similarities between the various LMS algorithms supplied in the toolbox, the LMS and NLMS adaptive filter examples use the same filter for the unknown system. In this case, the unknown filter is one of the filters used in the examples from gremez Examples on page 2-8 the constrained lowpass filter.

x = 0.1*randn(1,500); [b,err,res] = gremez(12,[0 0.4 0.5 1], [0 0], [1 0.2],. {'w' 'c'}); d = filter(b,1,x);
Again d represents the desired signal d(x) as we defined it in Figure 3-1 and b contains the filter coefficients for our unknown filter.
w0 = zeros(1,13); mu = 0.8; s = initnlms(w0,mu);
We use the preceding code to initialize the normalized LMS algorithm, just as we used initlms to prepare the LMS algorithm in the adaptlms example. You can see the input arguments are identical in this case. While there are optional input arguments that you use to refine the normalized algorithm, such as offset and leakage factor, to maintain the comparison to our LMS example we use the same set of input arguments used earlier. For more information about the optional input arguments, refer to initnlms in the reference section of this Users Guide. Running the system identification process is a matter of using adaptnlms with the desired signal, the input signal, and the initial filter coefficients and conditions specified in s as input arguments. Then plot the results to compare the adapted filter to the actual filter.
[y,e,s] = adaptnlms(x,d,s); stem([b.' s.coeffs.'])
As shown in the following stem plot (a convenient way to compare the estimated and actual filter coefficients), the two are close to identical.
System Identification by Normalized LMS Algorithm 0.6 Actual Filter Weights Estimated Filter Weights 0.5
If we compare the convergence performance of the regular LMS algorithm to the normalized LMS variant, you see the normalized version adapts in far fewer iterations to a result almost as good as the nonnormalized version.
Comparing the LMS and NLMS Convergence Performance 0.08 NLMS Derived Filter Weights LMS Derived Filter Weights 0.06

0.02 Mean Square Error

Sample Number
adaptsd Example Noise Cancellation
When the amount of computation required to derive an adaptive filter drives your development process, the sign-data variant of the LMS (SDLS) algorithm may be a very good choice. Fortunately, the current state of digital signal processor (DSP) design has relaxed the need to minimize the operations count by making DSPs whose multiply and shift operations are as fast as add operations. Thus some of the impetus for the sign-data algorithm (and the sign-error and sign-sign variations) has been lost to DSP technology improvements. In the standard and normalized variations of the LMS adaptive filter, coefficients for the adapting filter arise from the mean square error between the desired signal and the output signal from the unknown system. Using the sign-data algorithm changes the mean square error calculation by using the
sign of the input data to change the filter coefficients. When the error is positive, the new coefficients are the previous coefficients plus the error multiplied by the step size. If the error is negative, the new coefficients are again the previous coefficients minus the error multiplied by note the sign change. When the input is zero, the new coefficients are the same as the previous set. In vector form, the sign-data LMS algorithm is 1, x ( k ) > 0 w ( k + 1 ) = w ( k ) + e ( k )sgn [ x ( k ) ] , sgn [ x ( k ) ] = 0, x ( k ) = 0 1, x ( k ) < 0 with vector w containing the weights applied to the filter coefficients and vector x containing the input data. e(k) (equal to desired signal - filtered signal) is the error at time k and is the quantity the SDLMS algorithm seeks to minimize. (mu) is the step size. As you specify mu smaller, the correction to the filter weights gets smaller for each sample and the SDLMS error falls more slowly. Larger mu changes the weights more for each step so the error falls more rapidly, but the resulting error does not approach the ideal solution as closely. To ensure good convergence rate and stability, select mu within the following practical bounds < < ------------------------------------------------------------------N { InputSignalPower } where N is the number of samples in the signal. Also, define mu as a power of two for efficient computing.

Noise Cancellation Performance by the SignError LMS Algorithm 2 Actual Signal Error After Noise Reduction 1.5
adaptss Example Noise Cancellation
The final variation of the LMS algorithm in the toolbox is the sign-sign variant (SSLMS). The rationale for this version matches those for the sign-data and sign-error algorithms presented in preceding sections. For more details, refer to adaptsd Example Noise Cancellation on page 3-21. The sign-sign algorithm (SSLMS) replaces the mean square error calculation to using the sign of the input data to change the filter coefficients. When the error is positive, the new coefficients are the previous coefficients plus the error multiplied by the step size. If the error is negative, the new coefficients are again the previous coefficients minus the error multiplied by note the sign change. When the input is zero, the new coefficients are the same as the previous set. In essence, the algorithm quantizes both the error and the input by applying the sign operator to them.
In vector form, the sign-sign LMS algorithm is 1, z ( k ) > 0 sgn [ z ( k ) ] = 0, z ( k ) = 0 w ( k + 1 ) = w ( k ) + sgn [ e ( k ) ] sgn [ x ( k ) ] , 1, z ( k ) < 0 where z ( k ) = [ e ( k ) ] sgn [ x ( k ) ] Vector w contains the weights applied to the filter coefficients and vector x contains the input data. e(k) ( = desired signal - filtered signal) is the error at time k and is the quantity the SSLMS algorithm seeks to minimize. (mu) is the step size. As you specify mu smaller, the correction to the filter weights gets smaller for each sample and the SSLMS error falls more slowly. Larger mu changes the weights more for each step so the error falls more rapidly, but the resulting error does not approach the ideal solution as closely. To ensure good convergence rate and stability, select mu within the following practical bounds < < ------------------------------------------------------------------N { InputSignalPower } where N is the number of samples in the signal. Also, define mu as a power of two for efficient computation.
Note How you set the initial conditions of the sign-sign algorithm profoundly influences the effectiveness of the adaptation. Because the algorithm essentially quantizes the input signal and the error signal, the algorithm can become unstable easily. A series of large error values, coupled with the quantization process may result in the error growing beyond all bounds. You restrain the tendency of the sign-sign algorithm to get out of control by choosing a small step size (<< 1) and setting the initial conditions for the algorithm to nonzero positive and negative values.

Realizing Filters as Simulink Subsystem Blocks (p. 11-45) Getting Help for FDATool (p. 11-49)
The Filter Design Toolbox adds a new dialog and operating mode, and a new menu selection, to the Filter Design and Analysis Tool (FDATool) provided by the Signal Processing Toolbox. From the new dialog, titled Set Quantization Parameters, you can: View Simulink models of the filter structures available in the toolbox. Quantize double-precision filters you design in this GUI using the design mode. Quantize double-precision filters you import into this GUI using the import mode. Perform analysis of quantized filters. Scale the transfer function coefficients for a filter to be less than or equal to 1. Select the quantization settings for the properties of the quantized filter displayed by the tool: - Coefficient - Input - Output - Multiplicand - Product - Sum Change the input and output scale values for a filter. After you import a filter in to FDATool, the options on the quantization dialog let you quantize the filter and investigate the effects of various quantization settings. From the new selection on the FDATool menu bar Transformations you can transform lowpass FIR and IIR filters to a variety of passband shapes. You can convert your FIR filters from: Lowpass to lowpass. Lowpass to highpass. For IIR filters, you can convert from: Lowpass to lowpass. Lowpass to highpass.
Lowpass to bandpass. Lowpass to bandstop. This section presents the following information and procedures for using FDATool: Switching FDATool to Quantization Mode on page 11-4 Quantizing Filters in the Filter Design and Analysis Tool on page 11-7 Choosing Your Quantized Filter Structure on page 11-16 Scaling Transfer Function Coefficients on page 11-24 Scaling Inputs and Outputs of Quantized Filters on page 11-26
Switching FDATool to Quantization Mode
You use the quantization mode in FDATool to quantize filters. Quantization represents the fourth operating mode for FDATool, along with the filter design, filter transformation, and import modes. To switch to quantization mode, open FDATool from the MATLAB command prompt by entering

fdatool

When FDATool opens, click Set Quantization Parameters. FDATool switches to quantization mode and you see the following panel at the bottom of FDATool, with the default values shown. Controls within the dialog let you quantize filters and investigate the effects of changing quantization settings. To enable the quantization options, perform these steps:

Optimization Options

Four options enable you to tailor the way the realized model optimizes various filter features such as delays and gains. When you open the Realize Model panel, these options are selected by default.
Optimize for zero gains. Specify whether to remove zero-gain blocks from the

realized filter.

Optimize for unity gains. Specify whether to replace unity-gain blocks with direct connections in the filter subsystem. Optimize for -1 gains. Specify whether to replace negative unity-gain blocks with a sign change at the nearest sum block in the filter. Optimize delay chains. Specify whether to replace cascaded chains of delay blocks with a single integer delay block to provide an equivalent delay.
Each of these options can optimize the way your filter performs in simulation and in code you might generate from your model.
To Realize a Filter Using FDATool
After your quantized filter in FDATool is performing the way you want, with your desired phase and magnitude response, and with the right coefficients and form, follow these steps to realize your filter as a subsystem that you can use in a Simulink model.
1 Click Realize Model on the sidebar to change FDATool to realize model
2 From the Destination list under Model, select either:
- Current modelto add the realized filter subsystem to your current model - New modelto open a new Simulink model window and add your filter subsystem to the new window
3 Provide a name for your new filter subsystem in the Name field. 4 Decide whether to overwrite an existing block with this new one, and select
or clear Overwrite block to direct FDATool which way to gooverwrite or not.
5 Select Fixed-point blocks from the list in Block Type. 6 Select or clear the optimizations to apply.
- Optimize for zero gainsremoves zero gain blocks from the model realization
- Optimize for unity gainsreplaces unity gain blocks with direct connetions to adjacent blocks - Optimize for -1 gainsreplaces negative gain blocks by a change of sign at the nearest sum block - Optimize delay chainsreplaces cascaded delay blocks with a single delay block that produces the equivalent gain
7 Click Realize Model to realize your quantized filter as a subsystem block
according to the settings you selected. If you double-click the filter block subsystem created by FDATool, you see the filter implementation in Simulink model form. Depending on the options you chose when you realized your filter, and the filter you started with, you might see one or more sections, or different architectures based on the form of your quantized filter. From this point on, the subsystem filter block acts like any other block that you use in Simulink models.

s.invcov

s.lambda

lambda

initrls Element zi
Returns the states of the FIR filter after adaptation. This is an optional element. If omitted, it defaults to a zero vector of length equal to the filter order. When you use adaptrls in a loop structure, use this element to specify the initial filter states for the adapting FIR filter. RLS algorithm gain value. Computed and returned after every iteration. This is a read-only value. Returns the total number of iterations in the adaptive filter run. Although you can set this in s, you should not. Consider it a read-only value.
Algorithm to use. Optional field. Can be one of 'direct' for the conventional RLS algorithm or 'sqrt' for the more stable square root (QR) method.
[y,e] = adaptrls(x,d,s) also returns the prediction error e. Ultimately this shows you how well the filter adapted to the desired signal and input data how well y approximates d. [y,e,s] = adaptrls(x,d,s) returns the updated structure s.
In an application where the intermediate states are important, call this function in a sample by sample mode using a For-loop.
for n = 1:length(x) [y(n),e(n),s] = adaptrls(x(n),d(n),s); % States (The fields of S) here may be modified here. end
In lieu of assigning the strucure fields manually, the initrls function can be called to populate the structure S.
System Identification of a 32nd-order FIR filter (500 iterations). Identifying the characteristics of an unknown filter is a classic problem for adaptive filtering. This example uses an FIR filter as the unknown, and uses the RLS algorithm to calculate weights for the adapting filter. The stem plot that follows the example code demonstrates that the adapted filter matches the unknown quite closely.
x = 0.1*randn(1,500); % Desired signal. b = fir1(32,0.55); % FIR system to be identified. d = filter(b,1,x); % Input to the adapting filter. w0 = zeros(1,33); % Intial filter coefficients. p0 = 5*eye(33); % Initial input correlation matrix inverse. lambda = 1.0; % Exponential memory weighting factor. s = initrls(w0,p0,lambda); [y,e,s] = adaptrls(x,d,s); stem([b.',s.coeffs.']); legend('Actual','Estimated'); title('System Identification via RLS'); grid on;
System Identification of an FIR filter via RLS 0.6 Actual Estimated 0.5
Notice that the estimated filter misses on the actual coefficients between 15 and 20. By changing lambda from 1.0 to 0.9, we can make the actual and estimated match more closely, as shown in the next figure.
System ID of an FIR filter via RLS with Lambda=0.9 0.6 Actual Estimated 0.5
In vector form, the RLS algorithm, using exponential weighting, is]
w k + 1 = wk + mk e ( k )
where mk and Pk are defined as
Pk 1 xk m k = -----------------------------------------

T + x k Pk 1 xk

P k = -----------------------------------------------

Pk 1 mk x k Pk 1

bin2num

13bin2num
Convert a twos complement binary string to a number
y = bin2num(q,b) y = bin2num(q,b) uses the properties of quantizer q to convert binary string b to numeric array y. When b is a cell array containing binary strings, y will be
a cell array of the same dimension containing numeric arrays. The fixed-point binary representation is twos complement. The floating-point binary representation is in IEEE Standard 754 style.
bin2num and num2bin are inverses of one another. Note that num2bin always returns columnwise.
Create a quantizer and an array of numeric strings. Convert the numeric strings to binary strings, then use bin2num to convert them back to numeric strings.
q=quantizer([4 3]); [a,b]=range(q); x=(b:-eps(q):a)'; b = num2bin(q,x) b = 1001 1000
bin2num performs the inverse operation of num2bin. y=bin2num(q,b) y = 0.8750 0.7500 0.6250 0.5000 0.3750 0.2500 0.-0.1250 -0.2500 -0.3750 -0.5000 -0.6250 -0.7500 -0.8750 -1.0000

num2bin

13ca2tf
Convert coupled allpass filter form to transfer function forms
[b,a] = ca2tf(d1,d2) [b,a] = ca2tf(d1,d2,beta) [b,a,bp] = ca2tf(d1,d2) [b,a,bp] = ca2tf(d1,d2,beta) [b,a]=ca2tf(d1,d2) returns the vector of coefficients b and the vector of coefficients a corresponding to the numerator and the denominator of the transfer function
1 H ( z ) = B ( z ) A ( z ) = -- [ H1 ( z ) + H2 ( z ) ] 2
d1 and d2 are real vectors corresponding to the denominators of the allpass filters H1(z) and H2(z). [b,a]=ca2tf(d1,d2,beta) where d1, d2 and beta are complex, returns the vector of coefficients b and the vector of coefficients a corresponding to the numerator and the denominator of the transfer function
1 H ( z ) = B ( z ) A ( z ) = -- [ ( ) H1 ( z ) + H2 ( z ) ] 2
[b,a,bp]=ca2tf(d1,d2), where d1 and d2 are real, returns the vector bp of real coefficients corresponding to the numerator of the power complementary filter G(z)
1 G ( z ) = Bp ( z ) A ( z ) = -- [ H1 ( z ) H2 ( z ) ] 2
[b,a,bp]=ca2tf(d1,d2,beta), where d1, d2 and beta are complex, returns the vector of coefficients bp of real or complex coefficients that correspond to the numerator of the power complementary filter G(z)

560 Phase(degrees)

Example 2Design an order = 30 FIR filter with the stopedge keyword to define the response at the edge of the filter stopband.
h = firceqrip(n,wo,del,'stopedge'); fvtool(h)
Example 3Design an order = 30 FIR filter with the slope keyword and r = 20.
h = firceqrip(n,wo,del,'slope',20,'stopedge'); fvtool(h)
Example 4Design an order = 30 FIR filter defining the stopband and specifying that the resulting filter is minimum phase with the min keyword.
h = firceqrip(n,wo,del,'stopedge','min'); fvtool(h)

13-148

Comparing this filter to the filter in Example 1, notice that the cutoff frequency wo = 0.4 now applies to the edge of the stopband rather than the point at which the frequency response magnitude is 0.5. Viewing the zero-pole plot shown here reveals this is a minimum phase FIR filterthe zeros lie on or inside the unit circle, z = 1.
1 Filter #1: Zeros Filter #1: Poles
Example 5Design an order = 30 FIR filter with the invsinc keyword to shape the filter passband with an inverse sinc function.
h = firceqrip(n,wo,del,'invsinc',[2 1.5]); fvtool(h)

13-149

With the inverse sinc function being applied defined as 1/sinc(2*w)1.5, the figure shows the reshaping of the passband that results from using the invsinc keyword option, and entering c as the two-element vector [2 1.5].
firhalfband, firnyquist, gremez, ifir, iirgrpdelay, iirlpnorm, iirlpnormc fircls, firls, remez in your Signal Processing Toolbox documentation

13-150

firhalfband

13firhalfband

Design a halfband FIR filter
b b b b b = = = = = firhalfband(n,fp) firhalfband(n,win) firhalfband('minorder',fp,dev) firhalfband('minorder',fp,dev,'kaiser') firhalfband(.,'high')
b = firhalfband(n,fp) designs a lowpass halfband FIR filter of order N with
an equiripple characteristic. N must be selected such that N/2 is an odd integer.
fp determines the passband edge frequency, and it must satisfy 0 < fp < 1/2, where 1/2 corresponds to 2 rad/sample. b = firhalfband(n,win) designs a lowpass Nth-order filter using the truncated, windowed-impulse response method instead of the equiripple method. win is an n+1 length vector. The ideal impulse response is truncated to length n + 1, and then multiplied point-by-point with the window specified in win. b = firhalfband('minorder',fp,dev) designs a lowpass minimum-order filter, with passband edge fp. The peak ripple is constrained by the scalar dev. This design uses the equiripple method. b = firhalfband('minorder',fp,dev,'kaiser') designs a lowpass minimum-order filter, with passband edge fp. The peak ripple is constrained by the scalar dev. This design uses the Kaiser window method. b = firhalfband(.,'high') returns a highpass halfband FIR filter.

13-175

gf is a vector of grid points that have been chosen over each specified frequency band by gremez, and determines the frequencies at which gremez evaluates the response function. w is a vector of real, positive weights, one per band, for use during optimization. w is optional in the call to gremez. If you do not specify w, it is set to unity weighting before being passed to fresp. dh and dw are the desired frequency response and optimization weight vectors, evaluated at each frequency in grid gf.
gremez includes a predefined frequency response function named 'remezfrf2'. You can write your own based on the simpler 'remezfrf'. See the help for private/remezfrf for more information. b = gremez(n,f,{fresp,p1,p2,.},w) specifies optional arguments p1, p2,., pn to be passed to the response function fresp. b = gremez(n,f,a,w) is a synonym for b = gremez(n,f,{'remezfrf2',a},w), where a is a vector containing your specified response amplitudes at each band edge in f. By default, gremez designs symmetric (even) FIR filters. 'remezfrf2' is the predefined frequency
response function. If you do not specify your own frequency response function (the fresp string variable), gremez uses 'remezfrf2'.
b = gremez(.,'h') and b = gremez(.,'d') design antisymmetric (odd) filters. When you omit the 'h' or 'd' arguments from the gremez command syntax, each frequency response function fresp can tell gremez to design either an even or odd filter. Use the command syntax sym = fresp('defaults',{n,f,[],w,p1,p2,.}). gremez expects fresp to return sym = 'even' or sym = 'odd'. If fresp does not support this call, gremez assumes even symmetry.
For more information about the input arguments to gremez, refer to remez.
remez, cremez, butter, cheby1, cheby2, ellip, freqz, filter, firls, and fircls in your Signal Processing Toolbox documentation

13-176

Reference
Shpak, D.J. and A. Antoniou, "A generalized Remez method for the design of FIR digital filters," IEEE Trans. Circuits and Systems, pp. 161-174,Feb. 1990.

13-177

hex2num

13hex2num

Convert hexadecimal string to a number
x = hex2num(q,h) [x1,x2,.] = hex2num(q,h1,h2,.) x = hex2num(q,h) converts hexadecimal string h to numeric matrix x. The attributes of the numbers in x are specified by quantizer q. When h is a cell array containing hexadecimal strings, hex2num returns x as a cell array of the same dimension containing numbers. For fixed-point hexadecimal strings, hex2num uses twos complement representation. For floating-point strings, the representation is IEEE Standard 754 style.

|H(w)|2 + |G(w)|2 = 1.

[bp,ap,c] = iirpowcomp(b,a) where c is a complex scalar of magnitude =1, forces bp to satisfy the generalized hermitian property conj(bp(end:-1:1)) = c*bp.
When c is omitted, it is chosen as follows: When b is real, chooses C as 1 or -1, whichever yields bp real When b is complex, C defaults to 1

ap is always equal to a.

[b,a]=cheby1(10,.5,.4); [bp,ap]=iirpowcomp(b,a); [h,w,s]=freqz(b,a); [h1,w,s]=freqz(bp,ap); s.plot='mag'; s.yunits='sq';freqzplot([h h1],w,s) tf2ca, tf2cl, ca2tf, cl2tf

13-225

iirrateup

13iirrateup

Upsample an IIR filter by an integer factor
[Num,Den,AllpassNum,AllpassDen] = iirrateup(B,A,N) [Num,Den,AllpassNum,AllpassDen] = iirrateup(B,A,N) returns the numerator and denominator vectors, Num and Den respectively, of the target filter being transformed from any prototype by applying an Nth-order rateup frequency transformation, where N is the upsample ratio. Transformation creates N equal replicas of the prototype filter frequency response.
It also returns the numerator, AllpassNum, and the denominator, AllpassDen, of the allpass mapping filter. The prototype lowpass filter is given with a numerator specified by B and a denominator specified by A. Relative positions of other features of an original filter do not change in the target filter. This means that it is possible to select two features of an original filter, F1 and F2, with F1 preceding F2. Feature F1 will still precede F2 after the transformation. However, the distance between F1 and F2 will not be the same before and after the transformation.
[b, a] = ellip(3, 0.1, 30, 0.409); [num, den] = iirrateup(b, a, 4);
Frequency multiplication ratio

13-226

iirftransf, allpassrateup, zpkrateup

13-227

iirshift

13iirshift

Shift the frequency response of an IIR real filter
[Num,Den,AllpassNum,AllpassDen] = iirshift(B,A,Wo,Wt) [Num,Den,AllpassNum,AllpassDen] = iirshift(B,A,Wo,Wt) returns the numerator and denominator vectors, Num and Den respectively, of the target filter transformed from the real lowpass prototype by applying a second-order real shift frequency mapping.
It also returns the numerator, AllpassNum, and the denominator of the allpass mapping filter, AllpassDen. The prototype lowpass filter is given with the numerator specified by B and the denominator specified by A. This transformation places one selected feature of an original filter located at frequency Wo to the required target frequency location, Wt. This transformation implements the DC Mobility, which means that the Nyquist feature stays at Nyquist, but the DC feature moves to a location dependent on the selection of Wo and Wt. Relative positions of other features of an original filter do not change in the target filter. This means that it is possible to select two features of an original filter, F1 and F2, with F1 preceding F2. Feature F1 will still precede F2 after the transformation. However, the distance between F1 and F2 will not be the same before and after the transformation. Choice of the feature subject to the real shift transformation is not restricted to the cutoff frequency of an original lowpass filter. In general it is possible to select any feature; e.g., the stopband edge, the DC, the deep minimum in the stopband, or other ones. This transformation can also be used for transforming other types of filters; e.g., notch filters or resonators can change their position in a simple way without designing them from the beginning.

function for 13-299 data formats 8-9, 8-11, 9-8 data formats, setting all 8-10, 9-8 defining 6-3 direct form FIR 12-26 direct form FIR transposed 12-27 direct form symmetric FIR 12-36 examples 6-14 exponent length 12-4 filter banks 10-17 filter types 5-7 filtering data 8-14, 13-141 finite impulse response 12-26, 12-27 floating point 12-4 fraction length 12-4 frequency response 13-164 noise loading method 5-13 getting properties 6-8 impulse response 13-232 lattice allpass 12-28 lattice AR 12-32 lattice ARMA 12-34 lattice coupled-allpass 12-28, 12-30 lattice coupled-allpass power complementary 12-31 lattice MA maximum phase 12-29 lattice MA minimum phase 12-33 limit cycles 5-14 multiple sections, specifying coefficients 12-47 table 12-44 normalizing 13-279 objects 6-3 overflow handling 12-6 overflows, logging 8-14 precision, setting 13-337 property values 8-6 Qfilt objects 1-13
real coefficients 13-264 reference coefficients 8-7 reference filter 12-40 rounding, property for 12-8 scaling 12-48 second-order sections 8-4 sections, number of 12-38 setting data formats 13-337 specifying 12-40 state vectors 13-144 states 12-50 structures 12-12 symmetric FIR 12-16 topology 8-8 word length 12-4 zero-pole plots 13-389 quantized filters properties getting 6-9 ScaleValues 12-48 specifying, command for 13-299 StatesPerSection 12-50 SumFormat 12-50 quantized inverse FFTs computing 9-10 QuantizedCoefficients property 12-40 quantizers calculating pdf 13-5 constructing 7-3 construction shortcuts 7-5 data types property for 12-5 properties Format 12-3 Max 12-5 Min 12-5 Mode 12-5
NOperations 12-6 NOverflows 12-6 NUnderflows 12-7 OverflowMode 12-7
property names, leaving out 7-5

RoundMode 12-8

settable 7-4 property values 7-4 testing accuracy 13-5 testing error variance 13-5 unit 7-2 unity 7-3 quantizing filters in FDATool 11-10
Radix 12-54 radix point 5-3 interpretation 5-17 range fixed-point 5-17 floating-point 5-22 range notation xxi reference coefficients specifying 12-40 reference filters quantized filters, specifying from 8-4 specifying 8-7 ReferenceCoefficients property 12-40 Remez exchange algorithm 2-6 robust filters 2-64 rounding property for 12-8 RoundMode property 12-8