Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# Complex 32-bit Block Floating-Point API

group bfp_complex_s32_api

  Functions

  void bfp_complex_s32_init(bfp_complex_s32_t *a, complex_s32_t *data, const exponent_t exp, const unsigned length, const unsigned calc_hr)

    Initialize a 32-bit complex BFP vector.

    This function initializes each of the fields of `a`.

    Unlike `bfp_complex_s16_t`, complex 32-bit BFP vectors use a single buffer to store the real and imaginary parts of each mantissa, such that the imaginary part of element `k` follows the real part of element `k` in memory. `data` points to the memory buffer used to store elements of the vector, and must be at least `length * 8` bytes long.

    `exp` is the exponent assigned to the BFP vector. The logical value associated with the `k`th complex element of the vector after initialization will be \( \left(data_{2k} + i\cdot data_{2k+1} \right)\cdot2^{exp} \).

    If `calc_hr` is false, `a->hr` is initialized to 0. Otherwise, the headroom of the the BFP vector is calculated and used to initialize `a->hr`.

    Parameters:

      - a – [out] BFP vector struct to initialize

      - data – [in] `complex_s32_t` buffer used to back `a`

      - exp – [in] Exponent of BFP vector

      - length – [in] Number of elements in BFP vector

      - calc_hr – [in] Boolean indicating whether the HR of the BFP vector should be calculated

  bfp_complex_s32_t bfp_complex_s32_alloc(const unsigned length)

    Dynamically allocate a complex 32-bit BFP vector from the heap.

    If allocation was unsuccessful, the `data` field of the returned vector will be NULL, and the `length` field will be zero. Otherwise, `data` will point to the allocated memory and the `length` field will be the user-specified length. The `length` argument must not be zero.

    Neither the BFP exponent, headroom, nor the elements of the allocated mantissa vector are set by this function. To set the BFP vector elements to a known value, use bfp_complex_s32_set() on the retuned BFP vector.

    BFP vectors allocated using this function must be deallocated using bfp_complex_s32_dealloc() to avoid a memory leak.

    To initialize a BFP vector using static memory allocation, use bfp_complex_s32_init() instead.

    See also

    bfp_complex_s32_dealloc, bfp_complex_s32_init

    Note

    Dynamic allocation of BFP vectors relies on allocation from the heap, and offers no guarantees about the execution time. Use of this function in any time-critical section of code is highly discouraged.

    Parameters:

      - length – [in] The length of the BFP vector to be allocated (in elements)

    Returns:

      Complex 32-bit BFP vector

  void bfp_complex_s32_dealloc(bfp_complex_s32_t *vector)

    Deallocate a complex 32-bit BFP vector allocated by bfp_complex_s32_alloc().

    Use this function to free the heap memory allocated by bfp_complex_s32_alloc().

    BFP vectors whose mantissa buffer was (successfully) dynamically allocated have a flag set which indicates as much. This function can safely be called on any bfp_complex_s32_t which has not had its `flags` or `data` manually manipulated, including:

    - bfp_complex_s32_t resulting from a successful call to bfp_complex_s32_alloc()

    - bfp_complex_s32_t resulting from an unsuccessful call to bfp_complex_s32_alloc()

    - bfp_complex_s32_t initialized with a call to bfp_complex_s32_init()

    In the latter two cases, this function does nothing. In the former, the `data`, `length` and `flags` fields of `vector` are cleared to zero.

    See also

    bfp_complex_s32_alloc

    Parameters:

      - vector – [in] BFP vector to be deallocated.

  void bfp_complex_s32_set(bfp_complex_s32_t *a, const complex_s32_t b, const exponent_t exp)

    Set all elements of a complex 32-bit BFP vector to a specified value.

    The exponent of `a` is set to `exp`, and each element’s mantissa is set to `b`.

    After performing this operation, all elements will represent the same value \(b \cdot 2^{exp}\).

    `a` must have been initialized (see bfp_complex_s32_init()).

    Parameters:

      - a – [out] BFP vector to update

      - b – [in] New value each complex mantissa is set to

      - exp – [in] New exponent for the BFP vector

  void bfp_complex_s32_use_exponent(bfp_complex_s32_t *a, const exponent_t exp)

    Modify a complex 32-bit BFP vector to use a specified exponent.

    This function forces complex BFP vector \(\bar A\) to use a specified exponent. The mantissa vector \(\bar a\) will be bit-shifted left or right to compensate for the changed exponent.

    This function can be used, for example, before calling a fixed-point arithmetic function to ensure the underlying mantissa vector has the needed Q-format. As another example, this may be useful when communicating with peripheral devices (e.g. via I2S) that require sample data to be in a specified format.

    Note that this sets the current encoding, and does not fix the exponent permanently (i.e. subsequent operations may change the exponent as usual).

    If the required fixed-point Q-format is `QX.Y`, where `Y` is the number of fractional bits in the resulting mantissas, then the associated exponent (and value for parameter `exp`) is `-Y`.

    `a` points to input BFP vector \(\bar A\), with complex mantissa vector \(\bar a\) and exponent \(a\_exp\). `a` is updated in place to produce resulting BFP vector \( \tilde{A} \) with complex mantissa vector \( \tilde{a} \) and exponent \(\tilde{a}\_exp\).

    `exp` is \(\tilde{a}\_exp\), the required exponent. \(\Delta{}p = \tilde{a}\_exp - a\_exp\) is the required change in exponent.

    If \(\Delta{}p = 0\), the BFP vector is left unmodified.

    If \(\Delta{}p > 0\), the required exponent is larger than the current exponent and an arithmetic right-shift of \(\Delta{}p\) bits is applied to the mantissas \(\bar a\). When applying a right-shift, precision may be lost by discarding the \(\Delta{}p\) least significant bits.

    If \(\Delta{}p < 0\), the required exponent is smaller than the current exponent and a left-shift of \(\Delta{}p\) bits is applied to the mantissas \(\bar a\). When left-shifting, saturation logic will be applied such that any element that can’t be represented exactly with the new exponent will saturate to the 32-bit saturation bounds.

    The exponent and headroom of `a` are updated by this function.

    Operation Performed

      \[\begin{split}\begin{aligned} & \Delta{}p = \tilde{a}\_exp - a\_exp \\ & \tilde{a_k} \leftarrow sat_{32}( a_k \cdot 2^{-\Delta{}p} ) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{A} \text{ (in elements) } \end{aligned}\end{split}\]
    Parameters:

      - a – [inout] Input BFP vector \(\bar A\) / Output BFP vector \(\tilde{A}\)

      - exp – [in] The required exponent, \(\tilde{a}\_exp\)

  headroom_t bfp_complex_s32_headroom(bfp_complex_s32_t *b)

    Get the headroom of a complex 32-bit BFP vector.

    The headroom of a complex vector is the number of bits that the real and imaginary parts of each of its elements can be left-shifted without losing any information. It conveys information about the range of values that vector may contain, which is useful for determining how best to preserve precision in potentially lossy block floating-point operations.

    In a BFP context, headroom applies to mantissas only, not exponents.

    In particular, if the complex 32-bit mantissa vector \(\bar x\) has \(N\) bits of headroom, then for any element \(x_k\) of \(\bar x\)

    \(-2^{31-N} \le Re\{x_k\} < 2^{31-N}\)

    and

    \(-2^{31-N} \le Im\{x_k\} < 2^{31-N}\)

    And for any element \(X_k = x_k \cdot 2^{x\_exp}\) of a complex BFP vector \(\bar X\)

    \(-2^{31 + x\_exp - N} \le Re\{X_k\} < 2^{31 + x\_exp - N} \)

    and

    \(-2^{31 + x\_exp - N} \le Im\{X_k\} < 2^{31 + x\_exp - N} \)

    This function determines the headroom of `b`, updates `b->hr` with that value, and then returns `b->hr`.

    Parameters:

      - b – complex BFP vector to get the headroom of

    Returns:

      Headroom of complex BFP vector `b`

  void bfp_complex_s32_shl(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const left_shift_t b_shl)

    Apply a left-shift to the mantissas of a complex 32-bit BFP vector.

    Each complex mantissa of input BFP vector \(\bar B\) is left-shifted `b_shl` bits and stored in the corresponding element of output BFP vector \(\bar A\).

    This operation can be used to add or remove headroom from a BFP vector.

    `b_shl` is the number of bits that the real and imaginary parts of each mantissa will be left-shifted. This shift is signed and arithmetic, so negative values for `b_shl` will right-shift the mantissas.

    `a` and `b` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b`.

    Note that this operation bypasses the logic protecting the caller from saturation or underflows. Output values saturate to the symmetric 32-bit range (the open interval \((-2^{31}, 2^{31})\)). To avoid saturation, `b_shl` should be no greater than the headroom of `b` (`b->hr`).

    Operation Performed

      \[\begin{split}\begin{aligned} & Re\{a_k\} \leftarrow sat_{32}( \lfloor Re\{b_k\} \cdot 2^{b\_shl} \rfloor ) \\ & Im\{a_k\} \leftarrow sat_{32}( \lfloor Im\{b_k\} \cdot 2^{b\_shl} \rfloor ) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B} \\ & \qquad\text{ and } b_k \text{ and } a_k \text{ are the } k\text{th mantissas from } \bar{B}\text{ and } \bar{A}\text{ respectively} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Complex output BFP vector \(\bar A\)

      - b – [in] Complex input BFP vector \(\bar B\)

      - b_shl – [in] Signed arithmetic left-shift to be applied to mantissas of \(\bar B\).

  void bfp_complex_s32_real_mul(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const bfp_s32_t *c)

    Multiply a complex 32-bit BFP vector element-wise by a real 32-bit BFP vector.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the complex product of \(B_k\) and \(C_k\), the corresponding elements of complex input BFP vector \(\bar B\) and real input BFP vector \(\bar C\) respectively.

    `a`, `b` and `c` must have been initialized (see bfp_complex_s32_init() and bfp_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b`.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow B_k \cdot C_k \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input real BFP vector \(\bar C\)

  void bfp_complex_s32_mul(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Multiply one complex 32-bit BFP vector element-wise by another.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the complex product of \(B_k\) and \(C_k\), the corresponding elements of complex input BFP vectors \(\bar B\) and \(\bar C\) respectively.

    `a`, `b` and `c` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b` or `c`.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow B_k \cdot C_k \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_conj_mul(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Multiply one complex 32-bit BFP vector element-wise by the complex conjugate of another.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the complex product of \(B_k\), the corresponding element of complex input BFP vectors \(\bar B\), and \((C_k)^*\), the complex conjugate of the corresponding element of complex input BFP vector \(\bar C\).

    `a`, `b` and `c` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b` or `c`.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow B_k \cdot (C_k)^* \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \\ & \qquad\text{and } (C_k)^* \text{ is the complex conjugate of } C_k \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_macc(bfp_complex_s32_t *acc, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Multiply one complex 32-bit BFP vector by another element-wise and add the result to a third vector.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow A_k + (B_k \cdot C_k) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \end{aligned}\end{split}\]
    Parameters:

      - acc – [inout] Input/Output accumulator complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_nmacc(bfp_complex_s32_t *acc, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Multiply one complex 32-bit BFP vector by another element-wise and subtract the result from a third vector.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow A_k - (B_k \cdot C_k) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \end{aligned}\end{split}\]
    Parameters:

      - acc – [inout] Input/Output accumulator complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_conj_macc(bfp_complex_s32_t *acc, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Multiply one complex 32-bit BFP vector by the complex conjugate of another element-wise and add the result to a third vector.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow A_k + (B_k \cdot C_k^*) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \\ & \qquad\text{and } (C_k)^* \text{ is the complex conjugate of } C_k \end{aligned}\end{split}\]
    Parameters:

      - acc – [inout] Input/Output accumulator complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_conj_nmacc(bfp_complex_s32_t *acc, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Multiply one complex 32-bit BFP vector by the complex conjugate of another element-wise and subtract the result from a third vector.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow A_k - (B_k \cdot C_k^*) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \\ & \qquad\text{and } (C_k)^* \text{ is the complex conjugate of } C_k \end{aligned}\end{split}\]
    Parameters:

      - acc – [inout] Input/Output accumulator complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_real_scale(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const float_s32_t alpha)

    Multiply a complex 32-bit BFP vector by a real scalar.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the complex product of \(B_k\), the corresponding element of complex input BFP vector \(\bar B\), and real scalar \(\alpha\cdot 2^{\alpha\_exp}\), where \(\alpha\) and \(\alpha\_exp\) are the mantissa and exponent respectively of parameter `alpha`.

    `a` and `b` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b`.

    Operation Performed

      \[\begin{aligned} \bar{A} \leftarrow \bar{B} \cdot \left( \alpha \cdot 2^{\alpha\_exp} \right) \end{aligned}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - alpha – [in] Real scalar by which \(\bar B\) is multiplied

  void bfp_complex_s32_scale(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const float_complex_s32_t alpha)

    Multiply a complex 32-bit BFP vector by a complex scalar.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the complex product of \(B_k\), the corresponding element of complex input BFP vector \(\bar B\), and complex scalar \(\alpha\cdot 2^{\alpha\_exp}\), where \(\alpha\) and \(\alpha\_exp\) are the complex mantissa and exponent respectively of parameter `alpha`.

    `a` and `b` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b`.

    Operation Performed

      \[\begin{aligned} \bar{A} \leftarrow \bar{B} \cdot \left( \alpha \cdot 2^{\alpha\_exp} \right) \end{aligned}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - alpha – [in] Complex scalar by which \(\bar B\) is multiplied

  void bfp_complex_s32_add(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Add one complex 32-bit BFP vector to another.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the sum of \(B_k\) and \(C_k\), the corresponding elements of complex input BFP vectors \(\bar B\) and \(\bar C\) respectively.

    `a`, `b` and `c` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b` or `c`.

    Operation Performed

      \[\begin{aligned} \bar{A} \leftarrow \bar{B} + \bar{C} \end{aligned}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_add_scalar(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const float_complex_s32_t c)

    Add a complex scalar to a complex 32-bit BFP vector.

    Add a real scalar \(c\) to input BFP vector \(\bar B\) and store the result in BFP vector \(\bar A\).

    `a`, and `b` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b`.

    Operation Performed

      \[\begin{aligned} \bar{A} \leftarrow \bar{B} + c \end{aligned}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex scalar \(c\)

  void bfp_complex_s32_sub(bfp_complex_s32_t *a, const bfp_complex_s32_t *b, const bfp_complex_s32_t *c)

    Subtract one complex 32-bit BFP vector from another.

    Each complex output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the difference between \(B_k\) and \(C_k\), the corresponding elements of complex input BFP vectors \(\bar B\) and \(\bar C\) respectively.

    `a`, `b` and `c` must have been initialized (see bfp_complex_s32_init()), and must be the same length.

    This operation can be performed safely in-place on `b` or `c`.

    Operation Performed

      \[\begin{aligned} \bar{A} \leftarrow \bar{B} - \bar{C} \end{aligned}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

      - c – [in] Input complex BFP vector \(\bar C\)

  void bfp_complex_s32_to_bfp_complex_s16(bfp_complex_s16_t *a, const bfp_complex_s32_t *b)

    Convert a complex 32-bit BFP vector to a complex 16-bit BFP vector.

    Each complex 16-bit output element \(A_k\) of complex output BFP vector \(\bar A\) is set to the value of \(B_k\), the corresponding element of complex 32-bit input BFP vector \(\bar B\), with its bit-depth reduced to 16 bits.

    `a` and `b` must have been initialized (see bfp_complex_s16_init() and bfp_complex_s32_init()), and must be the same length.

    This function preserves as much precision as possible.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \overset{16-bit}{\longleftarrow} B_k \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output complex 16-bit BFP vector \(\bar A\)

      - b – [in] Input complex 32-bit BFP vector \(\bar B\)

  void bfp_complex_s32_squared_mag(bfp_s32_t *a, const bfp_complex_s32_t *b)

    Get the squared magnitude of each element of a complex 32-bit BFP vector.

    Each element \(A_k\) of real output BFP vector \(\bar A\) is set to the squared magnitude of \(B_k\), the corresponding element of complex input BFP vector \(\bar B\).

    `a` and `b` must have been initialized (see bfp_s32_init() bfp_complex_s32_init()), and must be the same length.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow B_k \cdot (B_k)^* \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B} \\ & \qquad\text{ and } (B_k)^* \text{ is the complex conjugate of } B_k \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output real BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

  void bfp_complex_s32_mag(bfp_s32_t *a, const bfp_complex_s32_t *b)

    Get the magnitude of each element of a complex 32-bit BFP vector.

    Each element \(A_k\) of real output BFP vector \(\bar A\) is set to the magnitude of \(B_k\), the corresponding element of complex input BFP vector \(\bar B\).

    `a` and `b` must have been initialized (see bfp_s32_init() bfp_complex_s32_init()), and must be the same length.

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow \left| B_k \right| \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output real BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

  float_complex_s64_t bfp_complex_s32_sum(const bfp_complex_s32_t *b)

    Get the sum of elements of a complex 32-bit BFP vector.

    The elements of complex input BFP vector \(\bar B\) are summed together. The result is a complex 64-bit floating-point scalar \(a\), which is returned.

    `b` must have been initialized (see bfp_complex_s32_init()).

    Operation Performed

      \[\begin{split}\begin{aligned} & a \leftarrow \sum_{k=0}^{N-1} \left( b_k \cdot 2^{B\_exp} \right) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B} \end{aligned}\end{split}\]
    Parameters:

      - b – [in] Input complex BFP vector \(\bar B\)

    Returns:

      \(a\), the sum of vector \(\bar B\)’s elements

  void bfp_complex_s32_conjugate(bfp_complex_s32_t *a, const bfp_complex_s32_t *b)

    Get the complex conjugate of each element of a complex 32-bit BFP vector.

    Each element \(A_k\) of complex output BFP vector \(\bar A\) is set to the complex conjugate of \(B_k\), the corresponding element of complex input BFP vector \(\bar B\).

    Operation Performed

      \[\begin{split}\begin{aligned} & A_k \leftarrow B_k^* \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B}\text{ and }\bar{C} \\ & \qquad\text{and } B_k^* \text{ is the complex conjugate of } B_k \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output complex BFP vector \(\bar A\)

      - b – [in] Input complex BFP vector \(\bar B\)

  float_s64_t bfp_complex_s32_energy(const bfp_complex_s32_t *b)

    Get the energy of a complex 32-bit BFP vector.

    The energy of a complex 32-bit BFP vector here is the sum of the squared magnitudes of each of the vector’s elements.

    Operation Performed

      \[\begin{split}\begin{aligned} & a \leftarrow \sum_{k=0}^{N-1} \left( \left|b_k \cdot 2^{B\_exp}\right|^2 \right) \\ & \qquad\text{for } k \in 0\ ...\ (N-1) \\ & \qquad\text{where } N \text{ is the length of } \bar{B} \end{aligned}\end{split}\]
    Parameters:

      - b – [in] Input complex BFP vector \(\bar B\)

    Returns:

      \(a\), the energy of vector \(\bar B\)

  void bfp_complex_s32_make(bfp_complex_s32_t *a, const bfp_s32_t *b, const bfp_s32_t *c)

    Create complex 32-bit BFP vector from real and imaginary parts.

    Create a complex 32-bit BFP vector as the sum of a real vector \(\bar B\) and imaginary vector \(\bar{C} i\).

    `a`, `b` and `c` must have been initialized (see bfp_complex_s32_init() and bfp_s32_init()), must be the same length. `&a->data[0]` must be a double-word-aligned address.

    Operation Performed

      \[\begin{aligned} & \bar{A} \leftarrow \bar{B} + \bar{C} i \end{aligned}\]
    Parameters:

      - a – [out] Complex BFP output vector \(\bar A\)

      - b – [in] Real BFP input vector \(\bar B\)

      - c – [in] Real BFP input vector \(\bar C\)

  void bfp_complex_s32_real_part(bfp_s32_t *a, const bfp_complex_s32_t *b)

    Extract the real part of a complex 32-bit BFP vector.

    This function populates the real 32-bit BFP vector \(\bar A\) with the real part of complex 32-bit BFP vector \(\bar B\).

    `&b->data[0]` must be a double-word-aligned address.

    Operation Performed

      \[\begin{aligned} & \bar{A} \leftarrow {Real}\{\bar{B}\} \end{aligned}\]
    Parameters:

      - a – [out] Real BFP output vector \(\bar A\)

      - b – [in] Complex BFP input vector \(\bar B\)

  void bfp_complex_s32_imag_part(bfp_s32_t *a, const bfp_complex_s32_t *b)

    Extract the imaginary part of a complex 32-bit BFP vector.

    This function populates the real 32-bit BFP vector \(\bar A\) with the imaginary part of complex 32-bit BFP vector \(\bar B\).

    `&b->data[0]` must be a double-word-aligned address.

    Operation Performed

      \[\begin{aligned} & \bar{A} \leftarrow {Imag}\{\bar{B}\} \end{aligned}\]
    Parameters:

      - a – [out] Real BFP output vector \(\bar A\)

      - b – [in] Complex BFP input vector \(\bar B\)