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

# 32-Bit Vector Chunk (8-Element) API

group chunk32_api

  Functions

  int32_t chunk_s32_dot(const int32_t b[VPU_INT32_EPV], const q2_30 c[VPU_INT32_EPV])

    Compute the inner product between two vector chunks.

    This function computes the inner product of two vector chunks, \(\bar b\) and \(\bar c\) .

    Conceptually, elements of \(\bar b\) may have any number of fractional bits (int, fixed-point, mantissas of a BFP vector) so long as they’re all the same. Elements of \(\bar c\) are Q2.30 fixed-point values. Given that, the returned value \(a\) will have the same number of fractional bits as \(\bar b\) .

    Only the lowest 32 bits of the sum \(a\) are returned.

    Operation Performed

      \[\begin{aligned} & a \leftarrow \sum_{k=0}^{\mathtt{VPU\_INT32\_EPV}-1} \left( round\left( \frac{b_k\cdot{}c_k}{2^{30}} \right) \right) \end{aligned}\]
    Parameters:

      - b – [in] Input chunk \(\bar b\)

      - c – [in] Input chunk \(\bar c\)

    Returns:

      \(a\)

  void chunk_s32_log(q8_24 a[VPU_INT32_EPV], const int32_t b[VPU_INT32_EPV], const exponent_t b_exp)

    Compute the natural log of a vector chunk of 32-bit values.

    This function computes the natural logarithm of each of the 8 elements in vector chunk \(\bar b\) . The result is returned as an 8-element chunk \(\bar a\) of Q8.24 values.

    `b_exp` is the exponent associated with elements of \(\bar b\) .

    Any input \(b_k \le 0\) will result in a corresponding output \(a_k = \mathtt{INT32_MIN}\) .

    Operation Performed

      \[\begin{split}\begin{aligned} & a_k \leftarrow \ \begin{cases} log(b_k\cdot{}2^{\mathtt{b\_exp}}) & b_k > 0 \\ \mathtt{INT32\_MIN} & \text{otherwise} \\ \end{cases} \\ & \qquad\text{for }k \in {0..\mathtt{VPU\_INT32\_EPV}-1} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output vector chunk \(\bar a\)

      - b – [in] Input vector chunk \(\bar b\)

      - b_exp – [in] Exponent associated with \(\bar b\)

    Throws ET_LOAD_STORE:

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

  void chunk_float_s32_log(q8_24 a[VPU_INT32_EPV], const float_s32_t b[VPU_INT32_EPV])

    Compute the natural log of a vector chunk of `float_s32_t`.

    This function computes the natural logarithm of each of the `VPU_INT32_EPV` elements in vector chunk \(\bar b\) . The result is returned as an 8-element chunk \(\bar a\) of Q8.24 values.

    Any input \(b_k \le 0\) will result in a corresponding output \(a_k = \mathtt{INT32_MIN}\) .

    Operation Performed

      \[\begin{split}\begin{aligned} & a_k \leftarrow \ \begin{cases} log(b_k) & b_k > 0 \\ \mathtt{INT32\_MIN} & \text{otherwise} \\ \end{cases} \\ & \qquad\text{for }k \in {0..\mathtt{VPU\_INT32\_EPV}-1} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output vector chunk \(\bar a\)

      - b – [in] Input vector chunk \(\bar b\)

    Throws ET_LOAD_STORE:

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

  void chunk_q30_power_series(int32_t a[VPU_INT32_EPV], const q2_30 b[VPU_INT32_EPV], const int32_t c[], const unsigned term_count)

    Compute a power series on a vector chunk of Q2.30 values.

    This function is used to compute a power series summation on a vector chunk (`VPU_INT32_EPV`-element vector) \(\bar b\) . \(\bar b\) contains Q2.30 values. \(\bar c\) is a vector containing coefficients to be multiplied by powers of \(\bar b\) , and may have any associated exponent. The output is vector chunk \(\bar a\) and has the same exponent as \(\bar c\) .

    `c[]` is an array with shape `(term_count, VPU_INT32_EPV)`, where the second axis contains the same value replicated across all `VPU_INT32_EPV` elements. That is, `c[k][i] = c[k][j]` for `i` and `j` in `0..(VPU_INT32_EPV-1)`. This is for performance reasons. (For the purpose of this explanation, \(\bar c\) is considered to be single-dimensional, without redundancy.)

    Operation Performed

      \[\begin{split}\begin{aligned} & b_{k,0} = 2^{30} \\ & b_{k,i} = round\left(\frac{b_{k,i-1}\cdot{}b_k}{2^{30}}\right) \\ & \qquad\text{for }i \in {1..(N-1)} \\ & a_k \leftarrow \sum_{i=0}^{N-1} round\left( \frac{b_{k,i}\cdot c_i}{2^{30}} \right) \\ & \qquad\text{for }k \in {0..\mathtt{VPU\_INT32\_EPV}-1} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output vector chunk \(\bar a\)

      - b – [in] Input vector chunk \(\bar b\)

      - c – [in] Coefficient vector \(\bar c\)

      - term_count – [in] Number of power series terms, \(N\)

  void chunk_q30_exp_small(q2_30 a[VPU_INT32_EPV], const q2_30 b[VPU_INT32_EPV])

    Compute \(e^b\) on a vector chunk of Q2.30 values.

    This function computes \(e^{b_k}\) for each element of a vector chunk (`VPU_INT32_EPV`-element vector) \(\bar b\) of Q2.30 values near \(0\) . The result is computed using the power series approximation of \(e^x\) near zero. It is recommended that this function only be used for \( -0.5 \le b_k\cdot{}2^{-30} \le 0.5\) .

    The output vector chunk \(\bar a\) is also in a Q2.30 format.

    Operation Performed

      \[\begin{split}\begin{aligned} & a_k \leftarrow e^{b_k\cdot{}2^{-30}} \\ & \qquad\text{for }k \in {0..\mathtt{VPU\_INT32\_EPV}} \end{aligned}\end{split}\]
    Parameters:

      - a – [out] Output vector chunk \(\bar a\)

      - b – [in] Input vector chunk \(\bar b\)