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

# Complex 16-bit vector API

group vect_complex_s16_api

  Functions

  headroom_t vect_complex_s16_add(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t b_shr, const right_shift_t c_shr)

    Add one complex 16-bit vector to another.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]`, `b_imag[]`, `c_real[]` and `c_imag[]`.

    `length` is the number of elements in each of the vectors.

    `b_shr` and `c_shr` are the signed arithmetic right-shifts applied to each element of \(\bar b\) and \(\bar c\) respectively.

    Operation Performed

      \[\begin{split}\begin{aligned} & b_k' \leftarrow sat_{16}(\lfloor b_k \cdot 2^{-b\_shr} \rfloor) \\ & c_k' \leftarrow sat_{16}(\lfloor c_k \cdot 2^{-c\_shr} \rfloor) \\ & Re\{a_k\} \leftarrow Re\{b_k'\} + Re\{c_k'\} \\ & Im\{a_k\} \leftarrow Im\{b_k'\} + Im\{c_k'\} \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) and \(\bar c\) are the complex 16-bit mantissas of BFP vectors \( \bar{b} \cdot 2^{b\_exp} \) and \(\bar{c} \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the complex 16-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\).

      In this case, \(b\_shr\) and \(c\_shr\) must be chosen so that \(a\_exp = b\_exp + b\_shr = c\_exp + c\_shr\). Adding or subtracting mantissas only makes sense if they are associated with the same exponent.

      The function vect_complex_s16_add_prepare() can be used to obtain values for \(a\_exp\), \(b\_shr\) and \(c\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_add_prepare

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - b_shr – [in] Right-shift applied to \(\bar b\)

      - c_shr – [in] Right-shift applied to \(\bar c\)

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of output vector \(\bar a\).

  headroom_t vect_complex_s16_add_scalar(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const complex_s16_t c, const unsigned length, const right_shift_t b_shr)

    Add a scalar to a complex 16-bit vector.

    `a[]` and `b[]`represent the complex 16-bit mantissa vectors \(\bar a\) and \(\bar b\) respectively. Each must begin at a word-aligned address. This operation can be performed safely in-place on `b[]`.

    `c` is the complex scalar \(c\)to be added to each element of \(\bar b\).

    `length` is the number of elements in each of the vectors.

    `b_shr` is the signed arithmetic right-shift applied to each element of \(\bar b\).

    Operation Performed

      \[\begin{split}\begin{aligned} & b_k' \leftarrow sat_{16}(\lfloor b_k \cdot 2^{-b\_shr} \rfloor) \\ & Re\{a_k\} \leftarrow Re\{b_k'\} + Re\{c\} \\ & Im\{a_k\} \leftarrow Im\{b_k'\} + Im\{c\} \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If elements of \(\bar b\) are the complex mantissas of BFP vector \( \bar{b} \cdot 2^{b\_exp}\), and \(c\) is the mantissa of floating-point value \(c \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\).

      In this case, \(b\_shr\) and \(c\_shr\) must be chosen so that \(a\_exp = b\_exp + b\_shr = c\_exp + c\_shr\). Adding or subtracting mantissas only makes sense if they are associated with the same exponent.

      The function vect_complex_s16_add_scalar_prepare() can be used to obtain values for \(a\_exp\), \(b\_shr\) and \(c\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

      Note that \(c\_shr\) is an output of `vect_complex_s16_add_scalar_prepare()`, but is not a parameter to this function. The \(c\_shr\) produced by `vect_complex_s16_add_scalar_prepare()` is to be applied by the user, and the result passed as input `c`.

    See also

    vect_complex_s16_add_scalar_prepare

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c – [in] Complex input scalar \(c\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - b_shr – [in] Right-shift applied to \(\bar b\)

    Throws ET_LOAD_STORE:

      Raised if `a` or `b` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of output vector \(\bar a\).

  headroom_t vect_complex_s16_conj_mul(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t a_shr)

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

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]`, `b_imag[]`, `c_real[]` and `c_imag[]`.

    `length` is the number of elements in each of the vectors.

    `a_shr` is the unsigned arithmetic right-shift applied to the 32-bit accumulators holding the penultimate results.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k = \leftarrow Re\{b_k\} \cdot Re\{c_k\} + Im\{b_k\} \cdot Im\{c_k\} \\ & s_k = \leftarrow Im\{b_k\} \cdot Re\{c_k\} - Re\{b_k\} \cdot Im\{c_k\} \\ & Re\{a_k\} \leftarrow round( sat_{16}( v_k \cdot 2^{-a\_shr} ) ) \\ & Im\{a_k\} \leftarrow round( sat_{16}( s_k \cdot 2^{-a\_shr} ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \(\bar{b} \cdot 2^{b\_exp}\) and \(c\) is the complex 16-bit mantissa of floating-point value \(c \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp + c\_exp + a\_shr\).

      The function vect_complex_s16_mul_prepare() can be used to obtain values for \(a\_exp\) and \(a\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_mul_prepare

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - a_shr – [in] Right-shift applied to 32-bit intermediate results.

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_headroom(const int16_t b_real[], const int16_t b_imag[], const unsigned length)

    Calculate the headroom of a complex 16-bit array.

    The headroom of an N-bit integer is the number of bits that the integer’s value may be left-shifted without any information being lost. Equivalently, it is one less than the number of leading sign bits.

    The headroom of a `complex_s16_t` struct is the minimum of the headroom of each of its 16-bit fields, `re` and `im`.

    The headroom of a `complex_s16_t` array is the minimum of the headroom of each of its `complex_s16_t` elements.

    This function efficiently traverses the elements of \(\bar x\) to determine its headroom.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\).

    `length` is the number of elements in `b_real[]` and `b_imag[]`.

    Operation Performed

      \[\begin{aligned} min\!\{ HR_{16}\left(x_0\right), HR_{16}\left(x_1\right), ..., HR_{16}\left(x_{length-1}\right) \} \end{aligned}\]

    See also

    vect_s16_headroom, vect_s32_headroom, vect_complex_s32_headroom

    Parameters:

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - length – [in] Number of elements in \(\bar x\)

    Returns:

      Headroom of vector \(\bar x\)

  headroom_t vect_complex_s16_mag(int16_t a[], const int16_t b_real[], const int16_t b_imag[], const unsigned length, const right_shift_t b_shr, const int16_t *rot_table, const unsigned table_rows)

    Compute the magnitude of each element of a complex 16-bit vector.

    `a[]` represents the real 16-bit output mantissa vector \(\bar a\).

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]` or `b_imag[]`.

    `length` is the number of elements in each of the vectors.

    `b_shr` is the signed arithmetic right-shift applied to elements of \(\bar b\).

    `rot_table` must point to a pre-computed table of complex vectors used in calculating the magnitudes. `table_rows` is the number of rows in the table. This library is distributed with a default version of the required rotation table. The following symbols can be used to refer to it in user code:

        const extern unsigned rot_table16_rows;
        const extern complex_s16_t rot_table16[30][4];

    Faster computation (with reduced precision) can be achieved by generating a smaller version of the table. A python script is provided to generate this table.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k \leftarrow b_k \cdot 2^{-b\_shr} \\ & a_k \leftarrow \sqrt { {\left( Re\{v_k\} \right)}^2 + {\left( Im\{v_k\} \right)}^2 } \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \), then the resulting vector \(\bar a\) are the real 16-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp + b\_shr\).

      The function vect_complex_s16_mag_prepare() can be used to obtain values for \(a\_exp\) and \(b\_shr\) based on the input exponent \(b\_exp\) and headroom \(b\_hr\).

    See also

    vect_complex_s16_mag_prepare

    Parameters:

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

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imag part of complex input vector \(\bar b\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - b_shr – [in] Right-shift appled to \(\bar b\)

      - rot_table – [in] Pre-computed rotation table required for calculating magnitudes

      - table_rows – [in] Number of rows in `rot_table`

    Throws ET_LOAD_STORE:

      Raised if `a`, `b_real` or `b_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\).

  headroom_t vect_complex_s16_macc(int16_t acc_real[], int16_t acc_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t acc_shr, const right_shift_t bc_sat)

    Multiply one complex 16-bit vector element-wise by another, and add the result to an accumulator.

    `acc_real[]` and `acc_imag[]` together represent the complex 16-bit accumulator mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `acc_real[k]`, and each \(Im\{a_k\}\) is `acc_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address.

    `length` is the number of elements in each of the vectors.

    `acc_shr` is the signed arithmetic right-shift applied to the accumulators \(a_k\).

    `bc_sat` is the unsigned arithmetic right-shift applied to the product of \(b_k\) and \(c_k\) before being added to the accumulator.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k \leftarrow Re\{b_k\} \cdot Re\{c_k\} - Im\{b_k\} \cdot Im\{c_k\} \\ & s_k \leftarrow Im\{b_k\} \cdot Re\{c_k\} + Re\{b_k\} \cdot Im\{c_k\} \\ & \hat{a}_k \leftarrow sat_{16}( a_k \cdot 2^{-acc\_shr} ) \\ & Re\{a_k\} \leftarrow sat_{16}( Re\{\hat{a}_k\} + round( sat_{16}( v_k \cdot 2^{-bc\_sat} ) ) ) \\ & Im\{a_k\} \leftarrow sat_{16}( Im\{\hat{a}_k\} + round( sat_{16}( s_k \cdot 2^{-bc\_sat} ) ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If inputs \(\bar b\) and \(\bar c\) are the mantissas of BFP vectors \( \bar{b} \cdot 2^{b\_exp} \) and \(\bar{c} \cdot 2^{c\_exp}\), and input \(\bar a\) is the accumulator BFP vector \(\bar{a} \cdot 2^{a\_exp}\), then the output values of \(\bar a\) have the exponent \(2^{a\_exp + acc\_shr}\).

      For accumulation to make sense mathematically, \(bc\_sat\) must be chosen such that \( a\_exp + acc\_shr = b\_exp + c\_exp + bc\_sat \).

      The function vect_complex_s16_macc_prepare() can be used to obtain values for \(a\_exp\), \(acc\_shr\) and \(bc\_sat\) based on the input exponents \(a\_exp\), \(b\_exp\) and \(c\_exp\) and the input headrooms \(a\_hr\), \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_macc_prepare

    Parameters:

      - acc_real – [inout] Real part of complex accumulator \(\bar a\)

      - acc_imag – [inout] Imaginary aprt of complex accumulator \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - acc_shr – [in] Signed arithmetic right-shift applied to accumulator elements.

      - bc_sat – [in] Unsigned arithmetic right-shift applied to the products of elements \(b_k\) and \(c_k\)

    Throws ET_LOAD_STORE:

      Raised if `acc_real`, `acc_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_nmacc(int16_t acc_real[], int16_t acc_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t acc_shr, const right_shift_t bc_sat)

    Multiply one complex 16-bit vector element-wise by another, and subtract the result from an accumulator.

    `acc_real[]` and `acc_imag[]` together represent the complex 16-bit accumulator mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `acc_real[k]`, and each \(Im\{a_k\}\) is `acc_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address.

    `length` is the number of elements in each of the vectors.

    `acc_shr` is the signed arithmetic right-shift applied to the accumulators \(a_k\).

    `bc_sat` is the unsigned arithmetic right-shift applied to the product of \(b_k\) and \(c_k\) before being subtracted from the accumulator.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k \leftarrow Re\{b_k\} \cdot Re\{c_k\} - Im\{b_k\} \cdot Im\{c_k\} \\ & s_k \leftarrow Im\{b_k\} \cdot Re\{c_k\} + Re\{b_k\} \cdot Im\{c_k\} \\ & \hat{a}_k \leftarrow sat_{16}( a_k \cdot 2^{-acc\_shr} ) \\ & Re\{a_k\} \leftarrow sat_{16}( Re\{\hat{a}_k\} - round( sat_{16}( v_k \cdot 2^{-bc\_sat} ) ) ) \\ & Im\{a_k\} \leftarrow sat_{16}( Im\{\hat{a}_k\} - round( sat_{16}( s_k \cdot 2^{-bc\_sat} ) ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If inputs \(\bar b\) and \(\bar c\) are the mantissas of BFP vectors \( \bar{b} \cdot 2^{b\_exp} \) and \(\bar{c} \cdot 2^{c\_exp}\), and input \(\bar a\) is the accumulator BFP vector \(\bar{a} \cdot 2^{a\_exp}\), then the output values of \(\bar a\) have the exponent \(2^{a\_exp + acc\_shr}\).

      For accumulation to make sense mathematically, \(bc\_sat\) must be chosen such that \( a\_exp + acc\_shr = b\_exp + c\_exp + bc\_sat \).

      The function vect_complex_s16_nmacc_prepare() can be used to obtain values for \(a\_exp\), \(acc\_shr\) and \(bc\_sat\) based on the input exponents \(a\_exp\), \(b\_exp\) and \(c\_exp\) and the input headrooms \(a\_hr\), \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_nmacc_prepare

    Parameters:

      - acc_real – [inout] Real part of complex accumulator \(\bar a\)

      - acc_imag – [inout] Imaginary aprt of complex accumulator \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - acc_shr – [in] Signed arithmetic right-shift applied to accumulator elements.

      - bc_sat – [in] Unsigned arithmetic right-shift applied to the products of elements \(b_k\) and \(c_k\)

    Throws ET_LOAD_STORE:

      Raised if `acc_real`, `acc_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_conj_macc(int16_t acc_real[], int16_t acc_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t acc_shr, const right_shift_t bc_sat)

    Multiply one complex 16-bit vector element-wise by the complex conjugate of another, and add the result to an accumulator.

    `acc_real[]` and `acc_imag[]` together represent the complex 16-bit accumulator mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `acc_real[k]`, and each \(Im\{a_k\}\) is `acc_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address.

    `length` is the number of elements in each of the vectors.

    `acc_shr` is the signed arithmetic right-shift applied to the accumulators \(a_k\).

    `bc_sat` is the unsigned arithmetic right-shift applied to the product of \(b_k\) and \(c_k^*\) before being added to the accumulator.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k \leftarrow Re\{b_k\} \cdot Re\{c_k\} + Im\{b_k\} \cdot Im\{c_k\} \\ & s_k \leftarrow Im\{b_k\} \cdot Re\{c_k\} - Re\{b_k\} \cdot Im\{c_k\} \\ & \hat{a}_k \leftarrow sat_{16}( a_k \cdot 2^{-acc\_shr} ) \\ & Re\{a_k\} \leftarrow sat_{16}( Re\{\hat{a}_k\} + round( sat_{16}( v_k \cdot 2^{-bc\_sat} ) ) ) \\ & Im\{a_k\} \leftarrow sat_{16}( Im\{\hat{a}_k\} + round( sat_{16}( s_k \cdot 2^{-bc\_sat} ) ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If inputs \(\bar b\) and \(\bar c\) are the mantissas of BFP vectors \( \bar{b} \cdot 2^{b\_exp} \) and \(\bar{c} \cdot 2^{c\_exp}\), and input \(\bar a\) is the accumulator BFP vector \(\bar{a} \cdot 2^{a\_exp}\), then the output values of \(\bar a\) have the exponent \(2^{a\_exp + acc\_shr}\).

      For accumulation to make sense mathematically, \(bc\_sat\) must be chosen such that \( a\_exp + acc\_shr = b\_exp + c\_exp + bc\_sat \).

      The function vect_complex_s16_macc_prepare() can be used to obtain values for \(a\_exp\), \(acc\_shr\) and \(bc\_sat\) based on the input exponents \(a\_exp\), \(b\_exp\) and \(c\_exp\) and the input headrooms \(a\_hr\), \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_conj_macc_prepare

    Parameters:

      - acc_real – [inout] Real part of complex accumulator \(\bar a\)

      - acc_imag – [inout] Imaginary aprt of complex accumulator \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - acc_shr – [in] Signed arithmetic right-shift applied to accumulator elements.

      - bc_sat – [in] Unsigned arithmetic right-shift applied to the products of elements \(b_k\) and \(c_k^*\)

    Throws ET_LOAD_STORE:

      Raised if `acc_real`, `acc_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_conj_nmacc(int16_t acc_real[], int16_t acc_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t acc_shr, const right_shift_t bc_sat)

    Multiply one complex 16-bit vector element-wise by the complex conjugate of another, and subtract the result from an accumulator.

    `acc_real[]` and `acc_imag[]` together represent the complex 16-bit accumulator mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `acc_real[k]`, and each \(Im\{a_k\}\) is `acc_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address.

    `length` is the number of elements in each of the vectors.

    `acc_shr` is the signed arithmetic right-shift applied to the accumulators \(a_k\).

    `bc_sat` is the unsigned arithmetic right-shift applied to the product of \(b_k\) and \(c_k^*\) before being subtracted from the accumulator.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k \leftarrow Re\{b_k\} \cdot Re\{c_k\} + Im\{b_k\} \cdot Im\{c_k\} \\ & s_k \leftarrow Im\{b_k\} \cdot Re\{c_k\} - Re\{b_k\} \cdot Im\{c_k\} \\ & \hat{a}_k \leftarrow sat_{16}( a_k \cdot 2^{-acc\_shr} ) \\ & Re\{a_k\} \leftarrow sat_{16}( Re\{\hat{a}_k\} - round( sat_{16}( v_k \cdot 2^{-bc\_sat} ) ) ) \\ & Im\{a_k\} \leftarrow sat_{16}( Im\{\hat{a}_k\} - round( sat_{16}( s_k \cdot 2^{-bc\_sat} ) ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If inputs \(\bar b\) and \(\bar c\) are the mantissas of BFP vectors \( \bar{b} \cdot 2^{b\_exp} \) and \(\bar{c} \cdot 2^{c\_exp}\), and input \(\bar a\) is the accumulator BFP vector \(\bar{a} \cdot 2^{a\_exp}\), then the output values of \(\bar a\) have the exponent \(2^{a\_exp + acc\_shr}\).

      For accumulation to make sense mathematically, \(bc\_sat\) must be chosen such that \( a\_exp + acc\_shr = b\_exp + c\_exp + bc\_sat \).

      The function vect_complex_s16_macc_prepare() can be used to obtain values for \(a\_exp\), \(acc\_shr\) and \(bc\_sat\) based on the input exponents \(a\_exp\), \(b\_exp\) and \(c\_exp\) and the input headrooms \(a\_hr\), \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_conj_nmacc_prepare

    Parameters:

      - acc_real – [inout] Real part of complex accumulator \(\bar a\)

      - acc_imag – [inout] Imaginary aprt of complex accumulator \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - acc_shr – [in] Signed arithmetic right-shift applied to accumulator elements.

      - bc_sat – [in] Unsigned arithmetic right-shift applied to the products of elements \(b_k\) and \(c_k^*\)

    Throws ET_LOAD_STORE:

      Raised if `acc_real`, `acc_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_mul(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t a_shr)

    Multiply one complex 16-bit vector element-wise by another.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]`, `b_imag[]`, `c_real[]` and `c_imag[]`.

    `length` is the number of elements in each of the vectors.

    `a_shr` is the unsigned arithmetic right-shift applied to the 32-bit accumulators holding intermediate results.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k = \leftarrow Re\{b_k\} \cdot Re\{c_k\} - Im\{b_k\} \cdot Im\{c_k\} \\ & s_k = \leftarrow Im\{b_k\} \cdot Re\{c_k\} + Re\{b_k\} \cdot Im\{c_k\} \\ & Re\{a_k\} \leftarrow round( sat_{16}( v_k \cdot 2^{-a\_shr} ) ) \\ & Im\{a_k\} \leftarrow round( sat_{16}( s_k \cdot 2^{-a\_shr} ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \(\bar{b} \cdot 2^{b\_exp}\) and \(c\) is the complex 16-bit mantissa of floating-point value \(c \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp + c\_exp + a\_shr\).

      The function vect_complex_s16_mul_prepare() can be used to obtain values for \(a\_exp\) and \(a\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_mul_prepare

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - a_shr – [in] Right-shift applied to 32-bit intermediate results.

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_real_mul(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const unsigned length, const right_shift_t a_shr)

    Multiply a complex 16-bit vector element-wise by a real 16-bit vector.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` represents the real 16-bit input mantissa vector \(\bar c\).

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]`, `b_imag[]` and `c_real[]`.

    `length` is the number of elements in each of the vectors.

    `a_shr` is the unsigned arithmetic right-shift applied to the 32-bit accumulators holding the penultimate results.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k = \leftarrow Re\{b_k\} \cdot c_k \\ & s_k = \leftarrow Im\{b_k\} \cdot c_k \\ & Re\{a_k\} \leftarrow round( sat_{16}( v_k \cdot 2^{-a\_shr} ) ) \\ & Im\{a_k\} \leftarrow round( sat_{16}( s_k \cdot 2^{-a\_shr} ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \) and \(c\) is the complex 16-bit mantissa of floating-point value \(c \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp + c\_exp + a\_shr\).

      The function vect_s16_real_mul_prepare() can be used to obtain values for \(a\_exp\) and \(a\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_real_mul_prepare

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - a_shr – [in] Right-shift applied to 32-bit intermediate results.

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag` or `c_real` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\).

  headroom_t vect_complex_s16_real_scale(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c, const unsigned length, const right_shift_t a_shr)

    Multiply a complex 16-bit vector by a real scalar.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]` and `b_imag[]`.

    `c` is the real 16-bit input mantissa \(c\).

    `length` is the number of elements in each of the vectors.

    `a_shr` is an unsigned arithmetic right-shift applied to the 32-bit accumulators holding the penultimate results.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k = \leftarrow Re\{b_k\} \cdot c \\ & s_k = \leftarrow Im\{b_k\} \cdot c \\ & Re\{a_k\} \leftarrow round( sat_{16}( v_k \cdot 2^{-a\_shr} ) ) \\ & Im\{a_k\} \leftarrow round( sat_{16}( s_k \cdot 2^{-a\_shr} ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \) and \(c\) is the complex 16-bit mantissa of floating-point value \(c \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp + c\_exp + a\_shr\).

      The function vect_complex_s16_real_scale_prepare() can be used to obtain values for \(a\_exp\) and \(a\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c – [in] Real input scalar \(c\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - a_shr – [in] Right-shift applied to 32-bit intermediate results.

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag` or `c` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\).

  headroom_t vect_complex_s16_scale(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real, const int16_t c_imag, const unsigned length, const right_shift_t a_shr)

    Multiply a complex 16-bit vector by a complex 16-bit scalar.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]` and `b_imag[]`.

    `c_real` and `c_imag` are the real and imaginary parts of the complex 16-bit input mantissa \(c\).

    `length` is the number of elements in each of the vectors.

    `a_shr` is the unsigned arithmetic right-shift applied to the 32-bit accumulators holding the penultimate results.

    Operation Performed

      \[\begin{split}\begin{aligned} & v_k = \leftarrow Re\{b_k\} \cdot Re\{c\} - Im\{b_k\} \cdot Im\{c\} \\ & s_k = \leftarrow Im\{b_k\} \cdot Re\{c\} + Re\{b_k\} \cdot Im\{c\} \\ & Re\{a_k\} \leftarrow round( sat_{16}( v_k \cdot 2^{-a\_shr} ) ) \\ & Im\{a_k\} \leftarrow round( sat_{16}( s_k \cdot 2^{-a\_shr} ) ) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \) and \(c\) is the complex 16-bit mantissa of floating-point value \(c \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp + c\_exp + a\_shr\).

      The function vect_complex_s16_scale_prepare() can be used to obtain values for \(a\_exp\) and \(a\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input scalar \(c\)

      - c_imag – [in] Imaginary part of complex input scalar \(c\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - a_shr – [in] Right-shift applied to 32-bit intermediate results

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\).

  void vect_complex_s16_set(int16_t a_real[], int16_t a_imag[], const int16_t b_real, const int16_t b_imag, const unsigned length)

    Set each element of a complex 16-bit vector to a specified value.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`. Each must begin at a word-aligned address.

    `b_real` and `b_imag` are the real and imaginary parts of the complex 16-bit input mantissa \(b\). Each `a_real[k]` will be set to `b_real`. Each `a_imag[k]` will be set to `b_imag`.

    `length` is the number of elements in `a_real[]` and `a_imag[]`.

    Operation Performed

      \[\begin{split}\begin{aligned} & Re\{a_k\} \leftarrow Re\{b\} \\ & Im\{a_k\} \leftarrow Im\{b\} \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(b\) is the mantissa of floating-point value \(b \cdot 2^{b\_exp}\), then the output vector \(\bar a\) are the mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp\).

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input scalar \(b\)

      - b_imag – [in] Imaginary part of complex input scalar \(b\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

    Throws ET_LOAD_STORE:

      Raised if `a_real` or `a_imag` is not word-aligned (See Note: Vector Alignment)

  headroom_t vect_complex_s16_shl(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const unsigned length, const left_shift_t b_shl)

    Left-shift each element of a complex 16-bit vector by a specified number of bits.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]` and `b_imag[]`.

    `length` is the number of elements in \(\bar a\) and \(\bar b\).

    `b_shl` is the signed arithmetic left-shift applied to each element of \(\bar b\).

    Operation Performed

      \[\begin{split}\begin{aligned} & Re\{a_k\} \leftarrow sat_{16}(\lfloor Re\{b_k\} \cdot 2^{b\_shl} \rfloor) \\ & Im\{a_k\} \leftarrow sat_{16}(\lfloor Im\{b_k\} \cdot 2^{b\_shl} \rfloor) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \), then the resulting vector \(\bar a\) are the complex 16-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(\bar{a} = \bar{b} \cdot 2^{b\_shl}\) and \(a\_exp = b\_exp\).

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - b_shl – [in] Left-shift applied to \(\bar b\)

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real` or `b_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_shr(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const unsigned length, const right_shift_t b_shr)

    Right-shift each element of a complex 16-bit vector by a specified number of bits.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]` and `b_imag[]`.

    `length` is the number of elements in \(\bar a\) and \(\bar b\).

    `b_shr` is the signed arithmetic right-shift applied to each element of \(\bar b\).

    Operation Performed

      \[\begin{split}\begin{aligned} & Re\{a_k\} \leftarrow sat_{16}(\lfloor Re\{b_k\} \cdot 2^{-b\_shr} \rfloor) \\ & Im\{a_k\} \leftarrow sat_{16}(\lfloor Im\{b_k\} \cdot 2^{-b\_shr} \rfloor) \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \), then the resulting vector \(\bar a\) are the complex 16-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(\bar{a} = \bar{b} \cdot 2^{-b\_shr}\) and \(a\_exp = b\_exp\).

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - b_shr – [in] Right-shift applied to \(\bar b\)

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real` or `b_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of the output vector \(\bar a\)

  headroom_t vect_complex_s16_squared_mag(int16_t a[], const int16_t b_real[], const int16_t b_imag[], const unsigned length, const right_shift_t a_shr)

    Get the squared magnitudes of elements of a complex 16-bit vector.

    `a[]` represents the real 16-bit output mantissa vector \(\bar a\).

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    Each of the input vectors must begin at a word-aligned address.

    `length` is the number of elements in each of the vectors.

    `a_shr` is the unsigned arithmetic right-shift applied to the 32-bit accumulators holding the penultimate results.

    Operation Performed

      \[\begin{split}\begin{aligned} & a_k \leftarrow ((Re\{b_k'\})^2 + (Im\{b_k'\})^2)\cdot 2^{-a\_shr} \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \( \bar{b} \cdot 2^{b\_exp} \), then the resulting vector \(\bar a\) are the real 16-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = 2 \cdot b\_exp + a\_shr\).

      The function vect_complex_s16_squared_mag_prepare() can be used to obtain values for \(a\_exp\) and \(a\_shr\) based on the input exponent \(b\_exp\) and headroom \(b\_hr\).

    See also

    vect_complex_s16_squared_mag_prepare

    Parameters:

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

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

      - a_shr – [in] Right-shift appled to 32-bit intermediate results

    Throws ET_LOAD_STORE:

      Raised if `a`, `b_real` or `b_imag` is not word-aligned (See Note: Vector Alignment)

  headroom_t vect_complex_s16_sub(int16_t a_real[], int16_t a_imag[], const int16_t b_real[], const int16_t b_imag[], const int16_t c_real[], const int16_t c_imag[], const unsigned length, const right_shift_t b_shr, const right_shift_t c_shr)

    Subtract one complex 16-bit vector from another.

    `a_real[]` and `a_imag[]` together represent the complex 16-bit output mantissa vector \(\bar a\). Each \(Re\{a_k\}\) is `a_real[k]`, and each \(Im\{a_k\}\) is `a_imag[k]`.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `c_real[]` and `c_imag[]` together represent the complex 16-bit input mantissa vector \(\bar c\). Each \(Re\{c_k\}\) is `c_real[k]`, and each \(Im\{c_k\}\) is `c_imag[k]`.

    Each of the input vectors must begin at a word-aligned address. This operation can be performed safely in-place on inputs `b_real[]`, `b_imag[]`, `c_real[]` and `c_imag[]`.

    `length` is the number of elements in each of the vectors.

    `b_shr` and `c_shr` are the signed arithmetic right-shifts applied to each element of \(\bar b\) and \(\bar c\) respectively.

    Operation Performed

      \[\begin{split}\begin{aligned} & b_k' \leftarrow sat_{16}(\lfloor b_k \cdot 2^{-b\_shr} \rfloor) \\ & c_k' \leftarrow sat_{16}(\lfloor c_k \cdot 2^{-c\_shr} \rfloor) \\ & Re\{a_k\} \leftarrow Re\{b_k'\} - Re\{c_k'\} \\ & Im\{a_k\} \leftarrow Im\{b_k'\} - Im\{c_k'\} \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) and \(\bar c\) are the complex 16-bit mantissas of BFP vectors \( \bar{b} \cdot 2^{b\_exp} \) and \(\bar{c} \cdot 2^{c\_exp}\), then the resulting vector \(\bar a\) are the complex 16-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\).

      In this case, \(b\_shr\) and \(c\_shr\) must be chosen so that \(a\_exp = b\_exp + b\_shr = c\_exp + c\_shr\). Adding or subtracting mantissas only makes sense if they are associated with the same exponent.

      The function vect_complex_s16_sub_prepare() can be used to obtain values for \(a\_exp\), \(b\_shr\) and \(c\_shr\) based on the input exponents \(b\_exp\) and \(c\_exp\) and the input headrooms \(b\_hr\) and \(c\_hr\).

    See also

    vect_complex_s16_sub_prepare

    Parameters:

      - a_real – [out] Real part of complex output vector \(\bar a\)

      - a_imag – [out] Imaginary aprt of complex output vector \(\bar a\)

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - c_real – [in] Real part of complex input vector \(\bar c\)

      - c_imag – [in] Imaginary part of complex input vector \(\bar c\)

      - length – [in] Number of elements in vectors \(\bar a\), \(\bar b\) and \(\bar c\)

      - b_shr – [in] Right-shift applied to \(\bar b\)

      - c_shr – [in] Right-shift applied to \(\bar c\)

    Throws ET_LOAD_STORE:

      Raised if `a_real`, `a_imag`, `b_real`, `b_imag`, `c_real` or `c_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      Headroom of output vector \(\bar a\).

  complex_s32_t vect_complex_s16_sum(const int16_t b_real[], const int16_t b_imag[], const unsigned length)

    Get the sum of elements of a complex 16-bit vector.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\), and must both begin at a word-aligned address. Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    `length` is the number of elements in \(\bar b\).

    Operation Performed

      \[\begin{split}\begin{aligned} & Re\{a\} \leftarrow \sum_{k=0}^{length-1} \left( Re\{b_k\} \right) \\ & Im\{a\} \leftarrow \sum_{k=0}^{length-1} \left( Im\{b_k\} \right) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the mantissas of BFP vector \(\bar{b} \cdot 2^{b\_exp}\), then the returned value \(a\) is the complex 32-bit mantissa of floating-point value \(a \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp\).

    Parameters:

      - b_real – [in] Real part of complex input vector \(\bar b\)

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\)

      - length – [in] Number of elements in vector \(\bar b\).

    Throws ET_LOAD_STORE:

      Raised if `b_real` or `b_imag` is not word-aligned (See Note: Vector Alignment)

    Returns:

      \(a\), the 32-bit complex sum of elements in \(\bar b\).

  void vect_complex_s16_to_vect_complex_s32(complex_s32_t a[], const int16_t b_real[], const int16_t b_imag[], const unsigned length)

    Convert a complex 16-bit vector into a complex 32-bit vector.

    `a[]` represents the complex 32-bit output vector \(\bar a\). It must begin at a double word (8-byte) aligned address.

    `b_real[]` and `b_imag[]` together represent the complex 16-bit input mantissa vector \(\bar b\). Each \(Re\{b_k\}\) is `b_real[k]`, and each \(Im\{b_k\}\) is `b_imag[k]`.

    The parameter `length` is the number of elements in each of the vectors.

    `length` is the number of elements in each of the vectors.

    Operation Performed

      \[\begin{split}\begin{aligned} & Re\{a_k\} \leftarrow Re\{b_k\} \\ & Im\{a_k\} \leftarrow Im\{b_k\} \\ & \qquad\text{ for }k\in 0\ ...\ (length-1) \end{aligned}\end{split}\]

    Block Floating-Point

      If \(\bar b\) are the complex 16-bit mantissas of a BFP vector \(\bar{b} \cdot 2^{b\_exp}\), then the resulting vector \(\bar a\) are the complex 32-bit mantissas of BFP vector \(\bar{a} \cdot 2^{a\_exp}\), where \(a\_exp = b\_exp\).

    Notes

      - The headroom of output vector \(\bar a\) is not returned by this function. The headroom of the output is always 16 bits greater than the headroom of the input.

    Parameters:

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

      - b_real – [in] Real part of complex input vector \(\bar b\).

      - b_imag – [in] Imaginary part of complex input vector \(\bar b\).

      - length – [in] Number of elements in vectors \(\bar a\) and \(\bar b\)

    Throws ET_LOAD_STORE:

      Raised if `a` is not double-word-aligned (See Note: Vector Alignment)