fimath Properties Usage for Fixed-Point Arithmetic

fimath Rules for Fixed-Point Arithmetic

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.

Binary Operations

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.

Unary Operations

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.

Concatenation Operations

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.

fimath Object Operations: add, mpy, sub

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.

MATLAB Function Block Operations

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.

Binary-Point Arithmetic

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.

[Slope Bias] Arithmetic

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?