## Net Slope Computation

### Handle Net Slope Computation

The Fixed-Point Designer™ software provides an optimization parameter, **Use division for
fixed-point net slope computation**, that controls how the software handles net
slope computation. To learn how to enable this optimization, see Use Integer Division to Handle Net Slope Computation.

When a change of fixed-point slope is not a power of two, net slope computation is necessary. Normally, net slope computation is implemented using an integer multiplication followed by shifts. Under certain conditions, net slope computation can be implemented using integer division or a rational approximation of the net slope. One of the conditions is that the net slope can be accurately represented as a rational fraction or as the reciprocal of an integer. Under this condition, the division implementation gives more accurate numerical behavior. Depending on your compiler and embedded hardware, a division implementation might be more desirable than the multiplication and shifts implementation. The generated code for the rational approximation and/or integer division implementation might require less ROM or improve model execution time.

#### When to Use Division for Fixed-Point Net Slope Computation

This optimization works if:

The net slope can be approximated with a fraction or is the reciprocal of an integer.

Division is more efficient than multiplication followed by shifts on the target hardware.

**Note**The Fixed-Point Designer software is not aware of the target hardware. Before selecting this option, verify that division is more efficient than multiplication followed by shifts on your target hardware.

#### When Not to Use Division to Handle Net Slope Computation

This optimization does not work if:

The software cannot perform the division using the production target

`long`

data type and therefore must use multiword operations.Using multiword division does not produce code suitable for embedded targets. Therefore, do not use division to handle net slope computation in models that use multiword operations. If your model contains blocks that use multiword operations, change the word length of these blocks to avoid these operations.

Net slope is a power of 2 or a rational approximation of the net slope contains division by a power of 2.

Binary-point-only scaling, where the net slope is a power of 2, involves moving the binary point within the fixed-point word. This scaling mode already minimizes the number of processor arithmetic operations.

### Use Division to Handle Net Slope Computation

To enable this optimization:

In the

**Configuration Parameters**dialog box, on the**Math and Data Types**>**Data Types**pane, set**Use division for fixed-point net slope computation**to`On`

, or`Use division for reciprocals of integers only`

For more information, see Use division for fixed-point net slope computation.

On the

**Hardware Implementation**>**Device details**pane, set the**Signed integer division rounds to**configuration parameter to`Floor`

or`Zero`

, as appropriate for your target hardware. The optimization does not occur if the**Signed integer division rounds to**parameter is`Undefined`

.**Note**Set this parameter to a value that is appropriate for the target hardware. Failure to do so might result in division operations that comply with the definition on the

**Hardware Implementation**pane, but are inappropriate for the target hardware.Set the

**Integer rounding mode**of the blocks that require net slope computation (for example, Product, Gain, and Data Type Conversion) to`Simplest`

or match the rounding mode of your target hardware.

**Note**

You can use the Model Advisor to alert you if you have not configured your model
correctly for this optimization. Open the Model Advisor and run the **Identify
questionable fixed-point operations** check. For more information, seeIdentify blocks that will invoke net slope computation .

### Improve Numerical Accuracy of Simulation Results with Rational Approximations to Handle Net Slope

This example illustrates how setting the **Math and Data Types** > ** Use division for fixed-point net slope computation** parameter to `On`

improves numerical accuracy.

#### Open `ex_net_slope1`

Model

ex_net_slope1

#### Explore the Model

$${S}_{a}{Q}_{a}={S}_{b}{Q}_{b}.{S}_{c}{Q}_{c}$$

or

$${Q}_{a}=\frac{{S}_{b}{S}_{c}}{{S}_{a}}.{Q}_{b}{Q}_{c}$$

where the net slope is:

$$\frac{{S}_{b}{S}_{c}}{{S}_{a}}$$

The net slope for the Product block is
`7/11`

. Because the net slope can be represented as a fractional value
consisting of small integers, you can use the `On`

setting of the
**Use division for fixed-point net slope computation**
optimization parameter if your model and hardware configuration are suitable. For more
information, see When to Use Division for Fixed-Point Net Slope Computation.

For the Product block in this model,

These values are represented by the general [Slope Bias] encoding scheme described in Scaling:$${V}_{i}={S}_{i}{Q}_{i}+{B}_{i}$$.

Because there is no bias for the inputs or outputs:

#### Set Up Model and Run Simulation

For the Constant block

`Vb`

, set the**Output data type**to`fixdt(1, 8, 0.7, 0)`

. For the Constant block`Vc`

, set the**Output data type**to`fixdt(1, 8, 0)`

.For the Product block, set the

**Output data type**to`fixdt(1, 16, 1.1, 0)`

. Set the**Integer rounding mode**to`Simplest`

.In the

**Configuration Parameters**dialog box, set the**Hardware Implementation**>**Device details**>**Signed integer division rounds to**configuration parameter to`Zero`

.Set the

**Math and Data Types**>**Use division for fixed-point net slope computation**to`Off`

.In your Simulink

^{®}model window, in the**Simulation**tab, click**Run**.Because the simulation uses multiplication followed by shifts to handle the net slope computation, net slope precision loss occurs. This precision loss results in numerical inaccuracy: the calculated product is

`306.9`

, not`308`

, as you expect.**Note**You can set up the Fixed-Point Designer software to provide alerts when precision loss occurs in fixed-point constants. For more information, see Net Slope and Net Bias Precision.

Set the

**Math and Data Types**>**Use division for fixed-point net slope computation**to`On`

.Save your model, and simulate again.

The software implements the net slope computation using a rational approximation instead of multiplication followed by shifts. The calculated product is

`308`

, as you expect.The optimization works for this model because:

The net slope is representable as a fraction with small integers in the numerator and denominator.

The

**Hardware Implementation**>**Device details**>**Signed integer division rounds to**configuration parameter is set to`Zero`

.**Note**This setting must match your target hardware rounding mode.

The

**Integer rounding mode**of the Product block in the model is set to`Simplest`

.The model does not use multiword operations.

### Improve Efficiency of Generated Code with Rational Approximations to Handle Net Slope

This example shows how setting the optimization parameter **Math and Data Types** > ** Use division for fixed-point net slope computation** to `On`

improves the efficiency of generated code.

**Note**

The generated code is more efficient only if division is more efficient than multiplication followed by shifts on your target hardware.

#### Open `ex_net_slope_2`

Model

```
open_system("ex_net_slope2.slx")
```

#### Explore the Model

For the Product block in this model,

$${V}_{m}={V}_{a}\times {V}_{b}$$

These values are represented by the general [Slope Bias] encoding scheme described in Scaling:$${V}_{i}={S}_{i}{Q}_{i}+{B}_{i}$$.

Because there is no bias for the inputs or outputs:

$${S}_{m}{Q}_{m}={S}_{a}{Q}_{a}.{S}_{b}{Q}_{b}$$

or

$${Q}_{m}=\frac{{S}_{a}{S}_{b}}{{S}_{m}}.{Q}_{a}{Q}_{b}$$

where the net slope is:

$$\frac{{S}_{a}{S}_{b}}{{S}_{m}}$$

The net slope for the Product block is
`9/10`

.

Similarly, for the Data Type Conversion block in this model,

$${S}_{a}{Q}_{a}+{B}_{a}={S}_{b}{Q}_{b}+{B}_{b}$$

There is no bias. Therefore, the net slope is $$\frac{{S}_{b}}{{S}_{a}}$$. The net slope for this block is also `9/10`

.

Because the net slope can be represented as a fraction, you can set the **Math and Data Types** > ** Use division for fixed-point net slope computation** optimization parameter to `On`

if your model and
hardware configuration are suitable. For more information, see When to Use Division for Fixed-Point Net Slope Computation.

#### Set Up the Model and Generate Code

For the Inport block

`Va`

, set the**Output data type**to`fixdt(1, 8, 9/10, 0)`

; for the Inport block`Vb`

, set the**Output data type**to`int8`

.For the Data Type Conversion block, set the

**Integer rounding mode**to`Simplest`

. Set the**Output data type**to`int16`

.For the Product block, set the

**Integer rounding mode**to`Simplest`

. Set the**Output data type**to`int16`

.Set the

**Hardware Implementation**>**Device details**>**Signed integer division rounds to**configuration parameter to`Zero`

.Set the

**Math and Data Types**>**Use division for fixed-point net slope computation**to`Off`

.From the Simulink

**Apps**tab, select**Embedded Coder**. In the**C Code**tab, click**Build**.Conceptually, the net slope computation is

`9/10`

or`0.9`

:Vc = 0.9 * Va; Vm = 0.9 * Va * Vb;

The generated code uses multiplication with shifts:

% For the conversion Vc = (int16_T)(Va * 115 >> 7); % For the multiplication Vm = (int16_T)((Va * Vb >> 1) * 29491 >> 14);

The ideal value of the net slope computation is

`0.9`

. In the generated code, the approximate value of the net slope computation is`29491 >> 15 = 29491/2^15 = 0.899993896484375`

. This approximation introduces numerical inaccuracy. For example, using the same model with constant inputs produces the following results.In the original model with inputs

`Va`

and`Vb`

, set the**Math and Data Types**>**Use division for fixed-point net slope computation**parameter to`On`

, update the diagram, and generate code again.The generated code now uses integer division instead of multiplication followed by shifts:

% For the conversion Vc = (int16_T)(Va * 9/10); % For the multiplication Vm = (int16_T)(Va * Vb * 9/10);

In the generated code, the value of the net slope computation is now the ideal value of

`0.9`

. Using division, the results are numerically accurate.In the model with constant inputs, set the

**Math and Data Types**>**Use division for fixed-point net slope computation**parameter to`On`

and simulate the model.The optimization works for this model because the:

Net slope is representable as a fraction with small integers in the numerator and denominator.

**Hardware Implementation**>**Device details**>**Signed integer division rounds to**configuration parameter is set to`Zero`

.**Note**This setting must match your target hardware rounding mode.

For the Product and Data Type Conversion blocks in the model, the

**Integer rounding mode**is set to`Simplest`

.Model does not use multiword operations.

### Use Integer Division to Handle Net Slope Computation

Setting the **Math and Data Types** > ** Use division for fixed-point net slope computation** parameter to ```
Use division for reciprocals of integers
only
```

triggers the optimization only in cases where the net slope is the
reciprocal of an integer. This setting results in a single integer division to handle net
slope computations.