3.1.1 QuantizationType enum

This enum provides definitions for the possible quantization (truncation or rounding) modes in fixed-point arithmetic. It is defined as follows:

typedef enum {
  UNKNOWN_QUANT_TYPE = -1,
  AC_TRN,         /* Default in ACDT (Algorithmic C Datatypes). */
  AC_TRN_ZERO,
  AC_RND,         /* Default in VHDL fixed-point package. */
  AC_RND_ZERO,
  AC_RND_INF,     /* Implemented as "SC_RND" in SystemC 2005. */
  AC_RND_MIN_INF,
 AC_RND_CONV
} QuantizationType;

3.1.2 OverflowType enum

This enum provides definitions for the possible overflow-handling (wrapping or saturation) modes in fixed-point arithmetic. It is defined as follows:

typedef enum {
  UNKNOWN_OVERFLOW_TYPE = -1,
  AC_WRAP,        /* Default in ACDT (Algorithmic C Datatypes). */
  AC_SAT,         /* Default in VHDL fixed-point package. */
  AC_SAT_ZERO,
  AC_SAT_SYM
} OverflowType;

3.1.3 fixed struct

This struct defines the fixed data structure which essentially is the container of a fixed-point value. It consists of the val` (value), ``wl (word length), iwl (integer word length), lbp (location of binary point), and the overflow and rounding flags. The fixed struct is defined as follows:

typedef struct {
  int val;      /* 32-bit value value of the number */
  int wl;       /* Word length, in bits */
  int iwl;      /* Integer word length, in bits */
  int lbp;      /* Location of binary point, in bits */
  int overflow;
  int rounding;
} _fixed;
typedef _fixed fixed;

3.1.4 FIXED_INIT macro

The FIXED_INIT macro initializes a fixed-point variable x to a set of given values: w, i, l, ovr, rnd according to the definition of the fixed struct. It is defined as follows:

#define FIXED_INIT(x, w, i, l, ovr, rnd) \
  x.wl = w; \
  x.iwl = i; \
  x.lbp = l; \
  x.overflow = ovr; \
  x.rounding = rnd

3.2.1 fxp_quantize

Apply fixed-point arithmetic quantization rules to fixed r. These rules are used for handling the low-significance bits of r.

3.2.2 fxp_overflow

Apply fixed-point arithmetic overflow rules to fixed r. These rules are used for handling the high-significance bits of r.

3.2.3 fxp_create

Constructor for a signed fixed-point variable.

3.2.4 fxp

Constructor for a signed fixed-point variable. This version is provided for compatibility to a third-party tool/plugin, namely the Agility RMS.

This constructor cannot set the overflow mode. The overflow mode of AC_SAT is used by default, and can be changed by explicit modification of the "overflow" field of a fixed-point variable. An "offset" (for establishing.

"is_signed" is currently left unused.

3.2.5 fxp_resize

Extends or shrinks the number of bits left or right of the binary of a specified "fixed" arithmetic type. This version uses an additional specifier, "sign" which can take the values of 'u' or 's'. For proper use, the specified sign must be the same to that supposed for fixed r.

The location of the binary-point (LBP(.)) is not affected.

3.2.6 fxp_add

Fixed-point addition.

3.2.7 fxp_sub

Fixed-point subtraction.

3.2.8 fxp_mul

Fixed-point multiplication.

3.2.9 fxp_div

Fixed-point division.

3.2.10 int32_to_fxp

Convert a signed int to a fixed-point value.

3.2.11 fxp_to_int32

Convert a fixed-point value to a signed int.

3.2.12 fxp_neg

Fixed-point negation.

3.2.13 fxp_abs

Fixed-point absolute value.

3.2.14 fxp_min

Fixed-point minimum of two numbers.

3.2.15 fxp_max

Fixed-point maximum of two numbers.

3.2.16 fxp_to_string

Converts a fixed-point number of the form i.f to a string, assuming arithmetic in base b.

3.2.17 fxp_print

Prints the argument as a fixed point i.f number in base b.

3.2.18 string_to_fxp

Reads a string representing a b-base (b=2 for binary) fixed-point number and performs the conversion to an actual "fixed"-type number.

3.2.19 double_to_fxp

Converts a double (64-bit floating-point) to a binary fixed-point number with possible loss of precision.

3.2.20 fxp_to_double

Converts a binary fixed-point number (actually its integer emulation) to the corresponding double (64-bit floating-point) representation.

3.2.21 fxp_ceil

Fixed-point ceiling (rounding to positive infinity).