Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

`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?