`fimath`

properties define the rules for performing
arithmetic operations on `fi`

objects. The `fimath`

properties
that govern fixed-point arithmetic operations can come from a local `fimath`

object
or the `fimath`

default values.

To determine whether a `fi`

object has a local `fimath`

object,
use the `isfimathlocal`

function.

The following sections discuss how `fi`

objects
with local `fimath`

objects interact with `fi`

objects
without local fimath.

In binary fixed-point operations such as `c = a + b`

,
the following rules apply:

If both

`a`

and`b`

have no local fimath, the operation uses default fimath values to perform the fixed-point arithmetic. The output`fi`

object`c`

also has no local fimath.If either

`a`

or`b`

has a local`fimath`

object, the operation uses that`fimath`

object to perform the fixed-point arithmetic. The output`fi`

object`c`

has the same local`fimath`

object as the input.

In unary fixed-point operations such as `b = abs(a)`

,
the following rules apply:

If

`a`

has no local fimath, the operation uses default fimath values to perform the fixed-point arithmetic. The output`fi`

object`b`

has no local fimath.If

`a`

has a local`fimath`

object, the operation uses that`fimath`

object to perform the fixed-point arithmetic. The output`fi`

object`b`

has the same local`fimath`

object as the input`a`

.

When you specify a `fimath`

object in the function
call of a unary fixed-point operation, the operation uses the `fimath`

object
you specify to perform the fixed-point arithmetic. For example, when
you use a syntax such as `b = abs(a,F)`

or ```
b
= sqrt(a,F)
```

, the `abs`

and `sqrt`

operations use the `fimath`

object `F`

to
compute intermediate quantities. The output `fi`

object `b`

always
has no local fimath.

In fixed-point concatenation operations such as ```
c =
[a b]
```

, `c = [a;b]`

and `c = bitconcat(a,b)`

,
the following rule applies:

The

`fimath`

properties of the leftmost`fi`

object in the operation determine the`fimath`

properties of the output`fi`

object`c`

.

For example, consider the following scenarios for the operation ```
d
= [a b c]
```

:

If

`a`

is a`fi`

object with no local fimath, the output`fi`

object`d`

also has no local fimath.If

`a`

has a local`fimath`

object, the output`fi`

object`d`

has the same local`fimath`

object.If

`a`

is not a`fi`

object, the output`fi`

object`d`

inherits the`fimath`

properties of the next leftmost`fi`

object. For example, if`b`

is a`fi`

object with a local`fimath`

object, the output`fi`

object`d`

has the same local`fimath`

object as the input`fi`

object`b`

.

The output of the `fimath`

object operations `add`

, `mpy`

,
and `sub`

always have no
local fimath. The operations use the `fimath`

object
you specify in the function call, but the output `fi`

object
never has a local `fimath`

object.

Fixed-point operations performed with the MATLAB Function block
use the same rules as fixed-point operations performed in MATLAB^{®}.

All input signals to the MATLAB Function block that you treat
as `fi`

objects associate with whatever you specify
for the **MATLAB Function block fimath** parameter.
When you set this parameter to `Same as MATLAB`

,
your `fi`

objects do not have local fimath. When
you set the **MATLAB Function block fimath** parameter
to `Specify other`

, you can define your own
set of `fimath`

properties for all `fi`

objects
in the MATLAB Function block to associate with. You can choose to
treat only fixed-point input signals as `fi`

objects
or both fixed-point and integer input signals as `fi`

objects.
See Using fimath Objects in MATLAB Function Blocks.

The `fimath`

object encapsulates the math properties
of Fixed-Point Designer™ software.

`fi`

objects only have a local `fimath`

object
when you explicitly specify `fimath`

properties in
the `fi`

constructor. When you use the `sfi`

or `ufi`

constructor
or do not specify any `fimath`

properties in the `fi`

constructor,
the resulting `fi`

object does not have any local
fimath and uses default fimath values.

a = fi(pi)

a = 3.1416 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 13

a.fimath isfimathlocal(a)

ans = RoundingMethod: Nearest OverflowAction: Saturate ProductMode: FullPrecision SumMode: FullPrecision ans = 0

To perform arithmetic with `+`

, `-`

, `.*`

,
or `*`

on two `fi`

operands with
local `fimath`

objects, the local `fimath`

objects
must be identical. If one of the `fi`

operands does
not have a local `fimath`

, the `fimath`

properties
of the two operands need not be identical. See fimath Rules for Fixed-Point Arithmetic for more information.

a = fi(pi); b = fi(8); isequal(a.fimath, b.fimath)

ans = 1

a + b

ans = 11.1416 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 19 FractionLength: 13

To perform arithmetic with `+`

, `-`

, `.*`

,
or `*`

, two `fi`

operands must also
have the same data type. For example, you can add two `fi`

objects
with data type `double`

, but you can not add an object
with data type `double`

and one with data type `single`

:

a = fi(3, 'DataType', 'double')

a = 3 DataTypeMode: Double

b = fi(27, 'DataType', 'double')

b = 27 DataTypeMode: Double

a + b

ans = 30 DataTypeMode: Double

c = fi(12, 'DataType', 'single')

c = 12 DataTypeMode: Single

a + c

Math operations are not allowed on FI objects with different data types.

Fixed-point `fi`

object operands do not have
to have the same scaling. You can perform binary math operations on
a `fi`

object with a fixed-point data type and a `fi`

object
with a scaled doubles data type. In this sense, the scaled double
data type acts as a fixed-point data type:

a = fi(pi)

a = 3.1416 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 13

b = fi(magic(2), ... 'DataTypeMode', 'Scaled double: binary point scaling')

b = 1 3 4 2 DataTypeMode: Scaled double: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 12

a + b

ans = 4.1416 6.1416 7.1416 5.1416 DataTypeMode: Scaled double: binary point scaling Signedness: Signed WordLength: 18 FractionLength: 13

Use the `divide`

function
to perform division with doubles, singles, or binary point-only scaling `fi`

objects.

Fixed-Point Designer software supports fixed-point arithmetic
using the local `fimath`

object or default fimath
for all binary point-only signals. The toolbox also supports arithmetic
for [Slope Bias] signals with the following restrictions:

[Slope Bias] signals must be real.

You must set the

`SumMode`

and`ProductMode`

properties of the governing`fimath`

to`'SpecifyPrecision'`

for sum and multiply operations, respectively.You must set the

`CastBeforeSum`

property of the governing`fimath`

to`'true'`

.Fixed-Point Designer does not support the

`divide`

function for [Slope Bias] signals.

f = fimath('SumMode', 'SpecifyPrecision', ... 'SumFractionLength', 16)

f = RoundingMethod: Nearest OverflowAction: Saturate ProductMode: FullPrecision SumMode: SpecifyPrecision SumWordLength: 32 SumFractionLength: 16 CastBeforeSum: true

`a = fi(pi, 'fimath', f)`

a = 3.1416 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 13 RoundingMethod: Nearest OverflowAction: Saturate ProductMode: FullPrecision SumMode: SpecifyPrecision SumWordLength: 32 SumFractionLength: 16 CastBeforeSum: true

`b = fi(22, true, 16, 2^-8, 3, 'fimath', f)`

b = 22 DataTypeMode: Fixed-point: slope and bias scaling Signedness: Signed WordLength: 16 Slope: 0.00390625 Bias: 3 RoundingMethod: Nearest OverflowAction: Saturate ProductMode: FullPrecision SumMode: SpecifyPrecision SumWordLength: 32 SumFractionLength: 16 CastBeforeSum: true

a + b

ans = 25.1416 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 32 FractionLength: 16 RoundingMethod: Nearest OverflowAction: Saturate ProductMode: FullPrecision SumMode: SpecifyPrecision SumWordLength: 32 SumFractionLength: 16 CastBeforeSum: true

Setting the `SumMode`

and `ProductMode`

properties
to `SpecifyPrecision`

are mutually exclusive except
when performing the `*`

operation between matrices.
In this case, you must set both the `SumMode`

and `ProductMode`

properties
to `SpecifyPrecision`

for [Slope Bias] signals. Doing
so is necessary because the `*`

operation performs
both sum and multiply operations to calculate the result.

Was this topic helpful?