# Specify Fixed-Point Math Properties in MATLAB Function Block

This example shows how to specify fixed-point math properties in a MATLAB® Function block. You can specify `fimath` properties to add fixed-point numbers without bit growth. The same methods also apply to subtraction and multiplication.

### Define Fixed-Point Variables with Attached `fimath`

Define fixed-point variables `A` and `B` with attached `fimath`.

```clearvars F = fimath(... 'RoundMode','Fix',... 'OverflowMode','Wrap',... 'ProductMode','SpecifyPrecision',... 'ProductWordLength',32,... 'ProductFractionLength',16,... 'SumMode','SpecifyPrecision',... 'SumWordLength',32,... 'SumFractionLength',16,... 'CastBeforeSum',true); A = fi(1,true,32,16,F); B = fi(1,true,32,16,F);```

Define a structure `T` containing prototypes of the variables `A` and `B`.

```T.A = cast(0,'like',A); T.B = cast(0,'like',B);```

The structure `T` functions as a types table. The values of the fields of `T` are not important. You will use the data types of the fields of `T` later in this example to specify fixed-point types that carry the `fimath` along with them.

Add the fixed-point variables `A` and `B`. In MATLAB, the `fimath` attached to variables `A` and `B` specify that the sum is to be computed as 32-bit word length and 16-bit fraction length.

`Y = A + B`
```Y = 2 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 32 FractionLength: 16 RoundingMethod: Zero OverflowAction: Wrap ProductMode: SpecifyPrecision ProductWordLength: 32 ProductFractionLength: 16 SumMode: SpecifyPrecision SumWordLength: 32 SumFractionLength: 16 CastBeforeSum: true ```

The `fimath` propagates to the variable `Y`.

### Default MATLAB Function Block Behavior

In general, the Simulink software does not propagate `fimath` on fixed-point `fi` objects. This rule applies even if the `fi` objects have attached `fimath` in a Constant block or are passed in as a MATLAB Function block parameter. However, any attached `fimath` defined inside a MATLAB Function block are respected. One exception to the rule about parameters is described in the next section.

This function is defined in the block named `MATLAB Function 1` in the `mParameterFIMath` model. If you execute this function in MATLAB, it returns the same 32-bit data type as the `Y = A + B` example.

```function Y1 = default_behavior(A,B) Y1 = A + B; end ``` Simulate the `mParameterFIMath` model to see how the MATLAB Function block executes this code.

```model = 'mParameterFIMath'; open_system(model); sim(model); Y1 = logsout.get('Y1').Values.Data ```
```Y1 = 2 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 33 FractionLength: 16 ```

The `MATLAB Function 1` block returns `Y1` with a 33-bit word length instead of the 32-bit word length returned in MATLAB. To see why, open the Property Inspector pane for the `MATLAB Funtion 1` block. The `MATLAB Function 1` block returns a 33-bit word length output because its MATLAB Function `fimath` setting has been set to Same as MATLAB. The input parameters `A` and `B` are stripped of their attached `fimath` and instead use the default `fimath` settings from MATLAB. The default `fimath` in MATLAB does full-precision sums. Therefore, the sum of two 32-bit variables return a 33-bit result.

To see the default `fimath` settings in MATLAB, first reset any global `fimath` settings, then enter `fimath` in the MATLAB Command Window.

```resetglobalfimath fimath```
```ans = RoundingMethod: Nearest OverflowAction: Saturate ProductMode: FullPrecision SumMode: FullPrecision ```

You can also to change the value of `globalfimath`, but doing so changes the fixed-point math behavior globally. This method is not recommended.

### Pass `fimath` into MATLAB Function Block from Parameter

In general, the MATLAB Function block strips `fimath` from fixed-point inputs. The exception to this rule is if an input parameter is a non-tunable structure, such as this one.

```T.A = cast(0,'like',A); T.B = cast(0,'like',B); ```

In the `mParameterFIMath` model, the `MATLAB Function 2` block has the structure `T` defined as a non-tunable input parameter. The fields `T.A` and `T.B` carry the data type and `fimath` of `A` and `B`. If you cast the inputs `A` and `B` like `T.A` and `T.B`, respectively, you recover the `fimath` that was defined in MATLAB.

```function Y2 = cast_like_non_tunable_types(A, B, T) A = cast(A,'like',T.A); B = cast(B,'like',T.B); Y2 = A + B; end ```

The output of the `MATLAB Function 2` block has the desired 32-bit word length.

`Y2 = logsout.get('Y2').Values.Data`
```Y2 = 2 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 32 FractionLength: 16 ```

This workflow provides a robust way of defining fixed-point data types in MATLAB Function blocks because it allows for the definition of different `fimath` and data type for each different variable. This method has these advantages:

• The algorithm and type specification can be separate, with the types controlled in a dictionary separate from the block. Changing the type does not change the algorithm or block.

• MATLAB and MATLAB Function blocks in Simulink have identical behavior.

• Each parameter can have its own `fimath` and data type.

• Each parameter can change to be types other than fixed-point. For instance, `T.A = single(0); T.B = single(0);` would change all types in this example to single without having to use global data-type override settings.

### Set `fimath` for All Input Parameters

An alternative way to define `fimath` in a MATLAB Function block is to declare the `fimath` in the Fixed-point properties of the MATLAB Function block.

In the `mParameterFIMath` model, the `MATLAB Function 3` block contains this code.

```function Y3 = mlfb_specify_fimath(A, B) Y3 = A + B; end ```

In the Property Inspector pane, under Fixed-point properties > MATLAB Function `fimath`, the option Specify Other is selected. The `fimath` is defined as the variable `F` from above. Alternatively, you can write the `fimath` definition directly in the MATLAB Function `fimath` box. Confirm that the output of this block has the desired 32-bit word length.

`Y3 = logsout.get('Y3').Values.Data `
```Y3 = 2 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 32 FractionLength: 16 ```

This method has these limitations:

• All MATLAB Function block input parameters get the same `fimath`.

• Each MATLAB Function block must be modified to specify the `fimath`.