The sections in this topic compare the fi
object
with fixedpoint data types and operations in C. In these sections,
the information on ANSI^{®} C is adapted from Samuel P. Harbison
and Guy L. Steele Jr., C: A Reference Manual,
3rd ed., Prentice Hall, 1991.
This section compares the numerical range of fi
integer
data types to the minimum numerical range of C integer data types,
assuming a Two's Complement representation.
Many C compilers support a two's complement representation of
signed integer data types. The following table shows the minimum ranges
of C integer data types using a two's complement representation. The
integer ranges can be larger than or equal to the ranges shown, but
cannot be smaller. The range of a long
must be
larger than or equal to the range of an int
, which
must be larger than or equal to the range of a short
.
In the two's complement representation, a signed integer with n bits has a range from $${2}^{n1}$$ to $${2}^{n1}1$$, inclusive. An unsigned integer with n bits has a range from 0 to $${2}^{n}1$$, inclusive. The negative side of the range has one more value than the positive side, and zero is represented uniquely.
Integer Type  Minimum  Maximum 

 –128  127 
 0  255 
 –32,768  32,767 
 0  65,535 
 –32,768  32,767 
 0  65,535 
 –2,147,483,648  2,147,483,647 
 0  4,294,967,295 
The following table lists the numerical ranges of the integer
data types of the fi
object, in particular those
equivalent to the C integer data types. The ranges are large enough
to accommodate the two's complement representation, which is the only
signed binary encoding technique supported by FixedPoint
Designer™ software.
Constructor  Signed  Word Length  Fraction Length  Minimum  Maximum  Closest ANSI C Equivalent 

 Yes  n  0  $${2}^{n1}$$  $${2}^{n1}1$$  Not applicable 
 No  n  0  0  $${2}^{n}1$$  Not applicable 
 Yes  8  0  –128  127 

 No  8  0  0  255 

 Yes  16  0  –32,768  32,767 

 No  16  0  0  65,535 

 Yes  32  0  –2,147,483,648  2,147,483,647 

 No  32  0  0  4,294,967,295 

Unary conversions dictate whether and how a single operand is
converted before an operation is performed. This section discusses
unary conversions in ANSI C and of fi
objects.
Unary conversions in ANSI C are automatically applied to
the operands of the unary !
, –, ~, and *
operators,
and of the binary <<
and >>
operators,
according to the following table:
Original Operand Type  ANSI C Conversion 







Array of T  Pointer to T 
Function returning T  Pointer to function returning T 
^{1}If type int
cannot
represent all the values of the original data type without overflow,
the converted type is unsigned int
.
The following table shows the fi
unary conversions:
C Operator  fi Equivalent  fi Conversion 

 ~  Result is 
~ 
 Result is same numeric type as operand. 
 No equivalent  Not applicable 

 Result is same numeric type as operand. Round mode is
always 

 Result is same numeric type as operand. Round mode is
always 

 Result is same numeric type as operand. 

 Result is same numeric type as operand. Overflow mode
is obeyed. For example, overflow might occur when you negate an unsigned 
This section describes the conversions that occur when the operands of a binary operator are different data types.
In ANSI C, operands of a binary operator must be of the same type. If they are different, one is converted to the type of the other according to the first applicable conversion in the following table:
Type of One Operand  Type of Other Operand  ANSI C Conversion 

 Any 

 Any 

 Any 

 Any 













^{1}Type long
is
only used if it can represent all values of type unsigned
.
When one of the operands of a binary operator (+
,
–, *
, .*
) is a fi
object
and the other is a MATLAB^{®} builtin numeric type, then the nonfi
operand
is converted to a fi
object before the operation
is performed, according to the following table:
Type of One Operand  Type of Other Operand  Properties of Other Operand After Conversion to a fi Object 




























The following sections compare how ANSI C and FixedPoint Designer software handle overflows.
In ANSI C, the result of signed integer operations is whatever value is produced by the machine instruction used to implement the operation. Therefore, ANSI C has no rules for handling signed integer overflow.
The results of unsigned integer overflows wrap in ANSI C.
Addition and multiplication with fi
objects
yield results that can be exactly represented by a fi
object,
up to word lengths of 65,535 bits or the available memory on your
machine. This is not true of division, however, because many ratios
result in infinite binary expressions. You can perform division with fi
objects
using the divide
function,
which requires you to explicitly specify the numeric type of the result.
The conditions under which a fi
object overflows
and the results then produced are determined by the associated fimath
object.
You can specify certain overflow characteristics separately for sums
(including differences) and products. Refer to the following table:
fimath Object Properties Related to Overflow Handling  Property Value  Description 


 Overflows are saturated to the maximum or minimum value in the range. 
 Overflows wrap using modulo arithmetic if unsigned, two's complement wrap if signed.  

 Fullprecision results are kept. Overflow does not occur.
An error is thrown if the resulting word length is greater than The rules for computing the resulting product word and fraction lengths are given in fimath Object Properties in the Property Reference. 
 The least significant bits of the product are kept. Full precision is kept, but overflow is possible. This behavior models the C language integer operations. The The rule for computing the resulting product fraction length is given in fimath Object Properties in the Property Reference.  
 The most significant bits of the product are kept. Overflow is prevented, but precision may be lost. The The rule for computing the resulting product fraction length is given in fimath Object Properties in the Property Reference.  
 You can specify both the word length and the fraction length of the resulting product.  
 Positive integer  The word length of product results when 
 Positive integer  The maximum product word length allowed when 
 Integer  The fraction length of product results when 

 Fullprecision results are kept. Overflow does not occur.
An error is thrown if the resulting word length is greater than The rules for computing the resulting sum word and fraction lengths are given in fimath Object Properties in the Property Reference. 
 The least significant bits of the sum are kept. Full precision is kept, but overflow is possible. This behavior models the C language integer operations. The The rule for computing the resulting sum fraction length is given in fimath Object Properties in the Property Reference.  
 The most significant bits of the sum are kept. Overflow is prevented, but precision may be lost. The The rule for computing the resulting sum fraction length is given in fimath Object Properties in the Property Reference.  
 You can specify both the word length and the fraction length of the resulting sum.  
 Positive integer  The word length of sum results when 
 Positive integer  The maximum sum word length allowed when 
 Integer  The fraction length of sum results when 