Main Content

`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
cannot 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.