Contents

# Advantages and Limitations of Arbitrary Precision Data Types

The arbitrary precision data types have the following advantages over the use of standard C/C++ data types:
• You can achieve narrower data paths and processing elements for various operations in the circuit.
• The data types ensure that all operations are carried out in a size guaranteed not to lose any data. However, you can still lose data if you store data in a location where the data type is too narrow in size.

## Limitations

AC Data Types
The AC data types have the following limitations:
• Multipliers are limited to generating 512-bit results.
• Dividers for
ac_int
data types are limited to a maximum of 128-bit unsigned or 127-bit signed.
• Dividers for
ac_fixed
data types are limited to a maximum of 64-bits (unsigned or signed).
• The bit select operator (
[]
) is not supported, that is, the following operations are not supported:
``````ac_int<32, true> a = 55;
a[2] = 1 & N;
ac_int<5, false> x = a[3];``````
• Creation of
ac_fixed
variables larger than 32 bits are supported only with the use of the
bit_fill
utility function.
For example:
``````// Creating an ac_fixed with value set to 4294967298, which is larger than 2^32.

// Unsupported
ac_fixed<64, 64, false> v1 = ac_fixed<64, 64, false>(4294967298);

// Supported
// 4294967298 is 0b100000000000000000000000000000010 in binary
// Express that as two 32-bit numbers and use the bit_fill utility function.
const int vec_inp[2] = {0x00000001, 0x00000002};
ac_fixed<64, 64, false> bit_fill_res;
bit_fill_res.bit_fill<2>(vec_inp);``````
hls_float
Data Type
The
hls_float
data type has the following limitations:
• hls_float
data type is not currently supported on Windows.
• While the floating-point optimization of converting into constants is performed for
float
and
double
data types, it is not performed for the
hls_float
data type.
• A limited set of math functions is supported. For details, see Math Functions Supported by hls_float Data Type.
• Constant initialization works only with the round-towards-zero (
RZERO
) rounding mode.
• When casting
hls_float
data types to integers, only signed integer casts are supported. Casting to unsigned integer simply generates a signed integer cast.

#### Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.