Simulink®

fixpt_look1_func_approx - Optimize for fixed-point function, x values, or breakpoints that are generated for lookup table

Syntax

[xdata,ydata,errworst]=fixpt_look1_func_approx('funcstr',...
xmin,xmax,xdt,xscale,ydt,yscale,rndmeth,errmax,nptsmax)

[xdata,ydata,errworst]=fixpt_look1_func_approx('funcstr',...
xmin,xmax,xdt,xscale,ydt,yscale,rndmeth,errmax,[])

[xdata,ydata,errworst]=fixpt_look1_func_approx('funcstr',...
xmin,xmax,xdt,xscale,ydt,yscale,rndmeth,[],nptsmax)

[xdata,ydata,errworst]=fixpt_look1_func_approx('funcstr',...
xmin,xmax,xdt,xscale,ydt,yscale,rndmeth,errmax,nptsmax,spacing)

Description

fixpt_look1_func_approx('funcstr',xmin,xmax,xdt,xscale,ydt,
yscale,rndmeth,errmax,nptsmax) optimizes the breakpoints of a lookup table over a specified range. The lookup table satisfies the maximum acceptable error, maximum number of points, and spacing requirements given by the optional parameters. The breakpoints refer to the x values of the lookup table. The command

[xdata,ydata,errworst]=fixpt_look1_func_approx('funcstr',...
 xmin,xmax,xdt,xscale,ydt,yscale,rndmeth,errmax,[])

returns the x- and y- coordinates of the lookup table as vectors xdata and ydata, respectively. It also returns the maximum absolute error of the lookup table as a variable errworst.

The fixed-point approximation is found by interpolating between the lookup table data points. The required input parameters are as follows.

• xmin and xmax specify the range over which the breakpoints are approximated.

• xdt, xscale, ydt, yscale, and rndmeth follow conventions used by fixed-point Simulink blocks.

• rndmeth has a default value listed in the input table.

In addition to the required parameters, there are three optional inputs, as follows.

Of these, you must use at least one of the parameters errmax and nptsmax. If you omit one of these, you must use brackets, [], in place of the omitted parameter. The function will then ignore that requirement for the lookup table.

The outputs of the function are as follows.

Criteria For Optimizing the Breakpoints: errmax, nptsmax, and spacing

The approximation produced from the lookup table must satisfy the requirements for the maximum acceptable error, errmax, the maximum number of points, nptsmax, and the spacing, spacing. The requirements are

• The maximum absolute error is less than errmax.

• The number of points required is less than nptsmax.

• The spacing is specified as unrestricted, even or even power of 2.

Modes for errmax and nptsmax

• If both errmax and nptsmax are specified

  The returned breakpoints will meet both criteria if possible. The errmax parameter is given priority, and nptsmax is ignored, if both criteria cannot be met with the specified spacing.

• If only errmax is specified

  The breakpoints that meet the error criteria, and have the least number of points are returned

• If only nptsmax is specified

  The breakpoints that require nptsmax or fewer, and give the smallest worst case error are returned

Modes for Spacing

If no spacing is specified, and more than one spacing method meets the requirements given by errmax and nptsmax, power of 2 spacing is chosen over even spacing, which in turn is chosen over uneven spacing. This case occurs when the errmax and nptsmax are both specified, but typically does not occur when only one is specified:

• If unrestricted is entered, the function chooses the spacing that provides the best optimization.

• If even is entered, the function chooses an evenly spaced set of points, including the pow2 spacing.

• If pow2 spacing is entered, the function chooses an even power of 2 spaced set of points.

  Note   The global optimum may not be found. The worst case error can depend on fixed-point calculations, which are highly nonlinear. Furthermore, the optimization approach is heuristic.

The spacing you choose depends on the parameters you want to optimize: execution speed, function approximation error, ROM usage, and RAM usage:

• The execution speed depends on the bisection search, and the interpolation method.

• The error depends on how accurately the method approximates the nonuniform curvature of the function.

• The ROM usage depends on the amount of data and command ROM used.

• The RAM usage depends on how much global and stack RAM is used.

When the lookup table has even power of two spacing, division is replaced by a bit shift. As a result, the execution speed is faster than for evenly spaced data.

Using the Approximation Function

1. Choose a function and use the eval('funcstr'); command to view the function before creating the lookup table.

2. Define the remaining inputs.

3. Run the fixpt_look1_func_approx function.

4. Use the fixpt_look1_func_plot function to plot the function from the selected breakpoints, and to calculate the error and the number of points used.

5. Vary the inputs to produce sets of breakpoints that generate functions with varying number of points required and worst case error.

6. Compare the number of points required and worst case error from various runs to choose the best set of breakpoints.

Calculating the Output Function

To calculate the function, use the returned breakpoints with

• The eval function

• A function lookup table. The x values are the breakpoints from the fixpt_look1_func_approx function, and the y values can be supplied using the eval function.

See Tutorial: Producing Lookup Table Data in Simulink^® Fixed Point™ User's Guide for a tutorial on using fixpt_look1_func_approx.

The following table summarizes the effect of spacing on the execution speed, error, and memory used.

Examples

This example produces a lookup table for a sine function. The inputs for the example are as follows:

funcstr = 'sin(2*pi*x)';
xmin = 0;
xmax = 0.25;
xdt = ufix(16);
xscale = 2^-16;
ydt = sfix(16);
yscale = 2^-14;
rndmeth = 'Floor';
errmax = 2^-10;
spacing = 'pow2';

To create the lookup table, type

[xdata, ydata, errWorst]=fixpt_look1_func_approx(funcstr,...
 xmin,xmax,xdt,xscale,ydt,yscale,rndmeth,errmax,[],spacing);

The brackets [ ] are a place holder for the nptsmax parameter, which is not used in this example.

You can then plot the ideal function, the approximation, and the errors by typing

fixpt_look1_func_plot(xdata,ydata,funcstr,xmin,xmax,xdt,...
 xscale,ydt,yscale,rndmeth);

The fixpt_look1_func_plot function produces a plot of the fixed-point sine function, using these breakpoints, and a plot of the error between the ideal function and the fixed-point function. The maximum absolute error and the number of points required are listed with the plot. The error drops to zero at a breakpoint, and increases between breakpoints due to the difference in curvature of the ideal function and the line drawn between breakpoints.

The resulting plots are shown.

The lookup table requires 33 points to achieve a maximum absolute error of 2^-11.3922.

See Also

fixpt_look1_func_plot

fixpt_interp1

fixpt_look1_func_plot