Skip to main content
欢迎来到PAWPAW技术文档网站，了解更多信息。

32-Bit BFP API

void bfp_s32_init()​

初始化一个32位BFP向量。

该函数会初始化BFP向量 a 中的每个字段。

data指向用于存储向量元素的内存缓冲区，因此它的长度必须至少为length * 4字节，并且必须以字对齐的地址开始。

exp是分配给BFP向量的指数。初始化后，向量的第k个元素关联的逻辑值为 datak⋅2expdata_k \cdot 2^{exp}。

如果calc_hr为false，则a->hr被初始化为0。否则，计算BFP向量的头空间并用其初始化a->hr。

参数：

  • bfp_s32_t *a – [out] 要初始化的BFP向量
  • int32_t *data – [in] 用于支持a的int32_t缓冲区
  • const exponent_t exp – [in] BFP向量的指数
  • const unsigned length– [in] BFP向量中的元素数量
  • const unsigned calc_hr – [in] 表示是否应计算BFP向量的头空间的布尔值

参考性能:

bfp_s32_init

bfp_s32_t bfp_s32_alloc()​

从堆中动态分配一个32位BFP向量。

如果分配失败，返回向量的data字段将为NULL，length字段将为零。否则，data将指向分配的内存，length字段将是用户指定的长度。length参数不能为零。

此函数不会设置BFP指数、头空间或分配的尾数向量的元素。要将BFP向量的元素设置为已知值，请在返回的BFP向量上使用bfp_s32_set()。

使用此函数分配的BFP向量必须使用bfp_s32_dealloc()进行释放，以避免内存泄漏。

要使用静态内存分配初始化BFP向量，请改用bfp_s32_init()。

另请参阅

bfp_s32_dealloc(), bfp_s32_init()

备注

此函数始终分配额外的2个元素，以便可以安全地使用bfp_fft_unpack_mono()函数，但这两个元素不会在返回的向量长度中反映出来。

备注

BFP向量的动态分配依赖于从堆中分配内存，并且对执行时间没有任何保证。在任何时间关键的代码段中使用此函数是不推荐的。

参数:

unsigned length – [in] 要分配的BFP向量的长度（以元素为单位）

返回值:

32位BFP向量

参考性能:

bfp_s32_alloc

void bfp_s32_dealloc()​

释放由bfp_s32_alloc()分配的32位BFP向量。

使用此函数释放bfp_s32_alloc()分配的堆内存。

其尾数缓冲区（成功）动态分配的BFP向量有一个设置的标志，指示这一点。可以在任何未手动操作其flags或data的bfp_s32_t上安全地调用此函数，包括：

对于后两种情况，此函数不执行任何操作。对于前一种情况，将清除vector的data、length和flags字段。

参数:

  • bfp_s32_t *vector – [in] 要释放的BFP向量。

另请参阅:

参考性能:

bfp_s32_dealloc

void bfp_s32_set()​

将32位BFP向量的所有元素设置为指定值。

将a的指数设置为exp，并将每个元素的尾数设置为b。

执行此操作后，所有元素将表示相同的值b⋅2expb \cdot 2^{exp}。

a必须已初始化（参见bfp_s32_init()）。

参数:

  • bfp_s32_t *a – [out] 要更新的BFP向量

  • const int32_t b – [in] 每个尾数要设置的新值

  • const exponent_t exp – [in] BFP向量的新指数

另请参阅:

参考性能:

bfp_s32_set

void bfp_s32_use_exponent()​

将32位BFP向量修改为使用指定的指数。

此函数强制BFP向量 Aˉ\bar{A} 使用指定的指数。尾数向量 aˉ\bar{a} 将根据变化的指数进行左移或右移。

例如，在调用定点算术函数之前，可以使用此函数确保底层尾数向量具有所需的Q格式。另一个例子是在与外设设备（例如通过I2S）通信时，可能需要将样本数据转换为指定的格式。

请注意，这只设置当前的编码，并不会永久固定指数（即后续操作可能会像往常一样更改指数）。

如果所需的定点Q格式为 QX.Y，其中 Y 是结果尾数中的小数位数，则相关的指数（以及参数 exp 的值）为 -Y。

a 指向输入BFP向量 Aˉ\bar{A}，具有尾数向量 aa 和指数 aexpa_{\text{exp}}。a 在原地更新，生成结果BFP向量 A~\tilde{A}，其尾数向量为 a~\tilde{a}，指数为 a~exp\tilde{a}_{\text{exp}}。

exp 是 a~exp\tilde{a}_{\text{exp}}，即所需的指数。Δp=a~exp−aexp\Delta p = \tilde{a}_{\text{exp}} - a_{\text{exp}} 是所需的指数变化量。

如果 Δp=0\Delta p = 0，则不修改BFP向量。

如果 Δp>0\Delta p > 0，所需的指数大于当前指数，将对尾数 aa 进行 Δp\Delta p 位的算术右移。在进行右移时，通过丢弃 Δp\Delta p 个最低有效位可能会丢失精度。

如果 Δp<0\Delta p < 0，所需的指数小于当前指数，则对尾数 aa 进行 Δp\Delta p 位的左移。在左移时，将应用饱和逻辑，使得任何无法用新指数精确表示的元素都会饱和到32位饱和边界。

此函数会更新 a 的指数和头空间。

操作:

Δp=a~_exp−a_expak~←sat32(ak⋅2−Δp)for k∈0 ... (N−1)其中 N 是 Aˉ 的长度（元素个数）\begin{split}\begin{align*} & \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{其中 } N \text{ 是 } \bar{A} \text{ 的长度（元素个数）} && \end{align*}\end{split}

参数:

  • bfp_s32_t *a – [in/out] 输入BFP向量 Aˉ\bar{A} / 输出BFP向量 Aˉ\bar{A}

  • const exponent_t exp – [in] 所需的指数，a~exp\tilde{a}_{\text{exp}}

参考性能:

bfp_s32_use_exponent

headroom_t bfp_s32_headroom()​

获取32位BFP向量的头空间。

向量的头空间是其元素可以左移的位数，而不会丢失任何信息。它提供有关向量可能包含的值范围的信息，有助于确定如何在可能有损的块浮点操作中保持精度。

在BFP上下文中，头空间仅适用于尾数，而不适用于指数。

特别地，如果32位尾数向量 xˉ\bar{x} 具有 NN 位的头空间，则对于 xˉ\bar{x} 的任何元素 xkx_k，

−231−N≤xk<231−N-2^{31-N} \le x_k < 2^{31-N}

对于复数BFP向量 Xˉ\bar{X} 的任何元素 Xk=xk⋅2x_expX_k = x_k \cdot 2^{x\_exp}，

−231+x_exp−N≤Xk<231+x_exp−N-2^{31 + x\_exp - N} \le X_k < 2^{31 + x\_exp - N}

此函数确定 b 的头空间，更新 b->hr 的值，然后返回 b->hr。

参数:

  • bfp_s32_t *b – [in] 要获取头空间的BFP向量 b

返回值:

  • BFP向量 b 的头空间

参考性能:

bfp_s32_headroom

void bfp_s32_shl()​

对32位BFP向量的尾数应用左移。

将输入BFP向量 Bˉ\bar{B} 的每个尾数左移 b_shl 位，并将结果存储在相应的输出BFP向量 Aˉ\bar{A} 的元素中。

此操作可用于向BFP向量添加或删除头空间。

b_shl 是每个尾数将左移的位数。此左移是有符号的算术左移，因此 b_shl 的负值将对尾数进行右移。

a 和 b 必须已经初始化（参见 bfp_s32_init()），并且长度必须相同。

此操作可以安全地就地在 b 上执行。

请注意，此操作绕过了保护调用者免受饱和或下溢的逻辑。输出值饱和到对称的32位范围（开区间 (−231,231)(-2^{31}, 2^{31})）。为避免饱和，b_shl 应不大于 b 的头空间（b->hr）。

操作:

ak←sat32(⌊bk⋅2b_shl⌋)for k∈0 ... (N−1)其中 N 是 b 的长度且 bk 和 ak 分别是 b 和 a 中的第 k 个尾数a_k \leftarrow sat_{32}( \lfloor b_k \cdot 2^{b\_shl} \rfloor ) \\ \quad\text{for } k \in 0\ ...\ (N-1) \\ \quad\text{其中 } N \text{ 是 } b \text{ 的长度} \\ \quad\text{且 } b_k \text{ 和 } a_k \text{ 分别是 } b \text{ 和 } a \text{ 中的第 } k \text{ 个尾数}

参数:

  • bfp_s32_t *a – [out] 输出BFP向量 Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

  • const left_shift_t b_shl – [in] 要应用于 Bˉ\bar{B} 尾数的有符号算术左移位数

参考性能:

bfp_s32_shl

void bfp_s32_add()​

将两个32位BFP向量相加。

此函数将两个输入BFP向量 Bˉ\bar{B} 和 Cˉ\bar{C} 相加，并将结果存储在BFP向量 Aˉ\bar{A} 中。

a、b 和 c 必须已经初始化（参见 bfp_s32_init()），并且长度必须相同。

此操作可以安全地就地在 b 或 c 上执行。

操作: Aˉ←Bˉ+Cˉ\bar{A} \leftarrow \bar{B} + \bar{C}

参数:

  • bfp_s32_t *a – [out] 输出BFP向量 Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

  • const bfp_s32_t *c – [in] 输入BFP向量 Cˉ\bar{C}

参考性能:

bfp_s32_add

void bfp_s32_add_scalar()​

向32位BFP向量添加一个标量。

该函数将实数标量cc添加到输入BFP向量Bˉ\bar{B}中，并将结果存储在BFP向量Aˉ\bar{A}中。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b上原地执行。

操作： Aˉ←Bˉ+c\bar{A} \leftarrow \bar{B} + c

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const float_s32_t c – [in] 输入标量cc

参考性能:

bfp_s32_add_scalar

void bfp_s32_sub()​

从另一个32位BFP向量中减去一个32位BFP向量。

该函数从输入BFP向量Bˉ\bar{B}中减去输入BFP向量Cˉ\bar{C}，并将结果存储在BFP向量Aˉ\bar{A}中。

a、b和c必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b或c上原地执行。

操作： Aˉ←Bˉ−Cˉ\bar{A} \leftarrow \bar{B} - \bar{C}

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar{C}

参考性能:

bfp_s32_sub

void bfp_s32_mul()​

逐元素地将一个32位BFP向量乘以另一个32位BFP向量。

将输入BFP向量Bˉ\bar{B}的每个元素与输入BFP向量Cˉ\bar{C}的对应元素逐个相乘，并将结果存储在输出BFP向量Aˉ\bar{A}中。

a、b和c必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b或c上原地执行。

操作：

Ak←Bk⋅Ck对于k∈0 ... (N−1)其中N是Bˉ和Cˉ的长度A_k \leftarrow B_k \cdot C_k\\ \qquad\text{对于} k \in 0\ ...\ (N-1)\\ \qquad\text{其中} N \text{是} \bar{B}\text{和}\bar{C}\text{的长度}

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar{C}

参考性能:

bfp_s32_mul

void bfp_s32_macc()​

逐元素地将一个32位BFP向量乘以另一个32位BFP向量，并将结果加到第三个向量上。

操作：

Ak←Ak+Bk⋅Ck对于k∈0 ... (N−1)其中N是Bˉ和Cˉ的长度A_k \leftarrow A_k + B_k \cdot C_k\\ \qquad\text{对于} k \in 0\ ...\ (N-1)\\ \qquad\text{其中} N \text{是} \bar{B}\text{和}\bar{C}\text{的长度}

参数：

  • bfp_s32_t *acc – [inout] 输入/输出累加器BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar{C}

参考性能:

bfp_s32_macc

void bfp_s32_nmacc()​

逐元素地将一个32位BFP向量乘以另一个32位BFP向量，并从第三个向量中减去结果。

操作：

Ak←Ak−Bk⋅Ck对于k∈0 ... (N−1)其中N是Bˉ和Cˉ的长度A_k \leftarrow A_k - B_k \cdot C_k\\ \qquad\text{对于} k \in 0\ ...\ (N-1)\\ \qquad\text{其中} N \text{是} \bar{B}\text{和}\bar{C}\text{的长度}

参数：

  • bfp_s32_t *acc – [inout] 输入/输出累加器BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar{C}

参考性能:

bfp_s32_nmacc

void bfp_s32_scale()​

将一个32位BFP向量乘以一个标量。

将输入BFP向量Bˉ\bar{B}乘以标量α⋅2α_exp\alpha \cdot 2^{\alpha\_exp}，并将结果存储在输出BFP向量Aˉ\bar{A}中。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

alpha表示标量α⋅2α_exp\alpha \cdot 2^{\alpha\_exp}，其中α\alpha为alpha.mant，α_exp\alpha\_exp为alpha.exp。

此操作可以安全地在b上原地执行。

操作：

Aˉ←Bˉ⋅(α⋅2α_exp)\bar{A} \leftarrow \bar{B} \cdot (\alpha \cdot 2^{\alpha\_exp})

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const float_s32_t alpha – [in] 乘以Bˉ\bar{B}的标量

参考性能:

bfp_s32_scale

void bfp_s32_abs()​

获取32位BFP向量的绝对值。

计算输入BFP向量Bˉ\bar{B}的每个元素BkB_k的绝对值，并将结果存储在输出BFP向量Aˉ\bar{A}中。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b上原地执行。

操作：

Ak←∣Bk∣对于k∈0,…,N−1其中N是Bˉ的长度A_k \leftarrow | B_k | \quad \text{对于} k \in 0, \ldots, N-1 \quad \text{其中} N \text{是} \bar{B} \text{的长度}

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

参考性能:

bfp_s32_abs

float_s64_t bfp_s32_sum()​

求32位BFP向量的元素和。

将输入BFP向量Bˉ\bar{B}的元素求和，得到结果A=a⋅2a_expA = a \cdot 2^{a\_exp}，并返回该结果。返回值具有64位尾数。

b必须已经初始化（参见bfp_s32_init()）。

操作：

A←∑k=0N−1Bk其中N是Bˉ的长度A \leftarrow \sum_{k=0}^{N-1} B_k \quad \text{其中} N \text{是} \bar{B} \text{的长度}

参数：

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

返回值：

  • AA，向量Bˉ\bar{B}的元素和

参考性能:

bfp_s32_sum

float_s64_t bfp_s32_dot()​

计算两个32位BFP向量的内积。

将输入BFP向量Bˉ\bar{B}和Cˉ\bar{C}的元素逐个相乘，并将结果相加，得到结果A=a⋅2a_expA = a \cdot 2^{a\_exp}，其中aa是结果的64位尾数，a_expa\_exp是其关联的指数。返回AA。

b和c必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

操作： a⋅2a_exp←∑k=0N−1Bk⋅Ck其中N是Bˉ和Cˉ的长度a \cdot 2^{a\_exp} \leftarrow \sum_{k=0}^{N-1} B_k \cdot C_k \quad \text{其中} N \text{是} \bar{B} \text{和} \bar{C} \text{的长度}

参数：

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar{C}

返回值：

  • AA，向量Bˉ\bar{B}和Cˉ\bar{C}的内积

参考性能:

bfp_s32_dot

void bfp_s32_clip()​

将32位BFP向量的元素限制在指定范围内。

输出BFP向量Aˉ\bar A的每个元素AkA_k，如果它在范围[L⋅2bound_exp,U⋅2bound_exp][ L \cdot 2^{bound\_exp}, U \cdot 2^{bound\_exp} ]内，则设置为输入BFP向量Bˉ\bar B的相应元素BkB_k，否则设置为该范围内最接近的值。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b上进行就地操作。

操作:

Ak←{L⋅2bound_expBk<L⋅2bound_expU⋅2bound_expBk>U⋅2bound_expBk其他情况对于 k∈0 ... (N−1)其中 N 是 Bˉ 的长度A_k \leftarrow \begin{cases} L \cdot 2^{bound\_exp} & B_k < L \cdot 2^{bound\_exp} \\ U \cdot 2^{bound\_exp} & B_k > U \cdot 2^{bound\_exp} \\ B_k & \text{其他情况} \end{cases} \\ \text{对于 } k \in 0\ ...\ (N-1) \\ \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}

参数:

  • bfp_s32_t* a – [out] 输出BFP向量 Aˉ\bar A

  • const bfp_s32_t* b – [in] 输入BFP向量 Bˉ\bar B

  • const int32_t lower_bound – [in] 下限截取边界的尾数，LL

  • const int32_t upper_bound – [in] 上限截取边界的尾数，UU

  • const int bound_exp – [in] 截取边界的共享指数

参考性能:

bfp_s32_clip

void bfp_s32_rect()​

将32位BFP向量进行整流。

输出BFP向量Aˉ\bar A的每个元素AkA_k，如果它是非负的，则设置为输入BFP向量Bˉ\bar B的相应元素BkB_k，否则设置为00。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b上进行就地操作。

操作:

Ak←{0Bk<0Bk其他情况对于 k∈0 ... (N−1)其中 N 是 Bˉ 的长度A_k \leftarrow \begin{cases} 0 & B_k < 0 \\ B_k & \text{其他情况} \end{cases} \\ \text{对于 } k \in 0\ ...\ (N-1) \\ \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}

参数:

  • bfp_s32_t* a – [out] 输出BFP向量 Aˉ\bar A

  • const bfp_s32_t* b – [in] 输入BFP向量 Bˉ\bar B

参考性能:

bfp_s32_rect

void bfp_s32_to_bfp_s16()​

将32位BFP向量转换为16位BFP向量。

将输入BFP向量Bˉ\bar{B}的每个32位元素BkB_k的位深度减小到16位，并将16位结果存储在输出BFP向量Aˉ\bar{A}的相应元素AkA_k中。

a和b必须已经初始化（参见bfp_s32_init()和bfp_s16_init()），并且长度必须相同。

尽可能保留精度。

操作:

Ak⟵16−bitBk对于 k∈0 ... (N−1)其中 N 是 Bˉ 的长度\begin{split}\begin{align*} & A_k \overset{16-bit}{\longleftarrow} B_k \\ & \qquad\text{对于 } k \in 0\ ...\ (N-1) \\ & \qquad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度} && \end{align*}\end{split}

参数:

  • bfp_s16_t *a – [out] 输出BFP向量 Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

参考性能:

bfp_s32_to_bfp_s16

void bfp_s32_sqrt()​

获取32位BFP向量的平方根。

计算输入BFP向量Bˉ\bar{B}的每个元素BkB_k的平方根，并将结果存储在输出BFP向量Aˉ\bar{A}的相应元素AkA_k中。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b上进行就地操作。

操作:

Ak←Bk对于 k∈0 ... (N−1)其中 N 是 Bˉ 的长度\begin{split}\begin{align*} & A_k \leftarrow \sqrt{B_k} \\ & \qquad\text{对于 } k \in 0\ ...\ (N-1) \\ & \qquad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度} && \end{align*}\end{split}

注解:

  • 仅计算每个结果的XMATH_BFP_SQRT_DEPTH_S32（参见xmath_conf.h）最重要的位。
  • 该函数仅计算实数的平方根。对于任何Bk<0B_k < 0，相应的输出AkA_k设置为00。

参数:

  • bfp_s32_t *a – [out] 输出BFP向量 Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

参考性能:

bfp_s32_sqrt

void bfp_s32_inverse()​

获取32位BFP向量的倒数。

该函数计算输入BFP向量Bˉ\bar{B}的每个元素BkB_k的倒数，并将结果存储在输出BFP向量Aˉ\bar{A}的相应元素AkA_k中。

a和b必须已经初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以安全地在b上进行就地操作。

操作:

Ak←Bk−1对于 k∈0 ... (N−1)其中 N 是 Bˉ 的长度A_k \leftarrow B_k^{-1} \quad \text{对于 } k \in 0\ ...\ (N-1) \quad \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}

参数:

  • bfp_s32_t *a – [out] 输出BFP向量 Aˉ\bar{A}

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

参考性能:

bfp_s32_inverse

float_s64_t bfp_s32_abs_sum()​

计算32位BFP向量元素的绝对值之和。

该函数计算输入BFP向量Bˉ\bar{B}的元素的绝对值之和，得到结果A=a⋅2a_expA = a \cdot 2^{a\_exp}，其中aa是64位尾数，a_expa\_exp是其关联的指数。返回结果AA。

b必须已经初始化（参见bfp_s32_init())。

操作:

A←∑k=0N−1∣Ak∣其中 N 是 Bˉ 的长度A \leftarrow \sum_{k=0}^{N-1} \left| A_k \right| \quad \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}

参数:

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

返回值:

  • AA，Bˉ\bar{B}的元素的绝对值之和

参考性能:

bfp_s32_abs_sum

float_s32_t bfp_s32_mean()​

获取32位BFP向量的均值。

该函数计算输入BFP向量Bˉ\bar{B}的元素的均值A=a⋅2a_expA = a \cdot 2^{a\_exp}，其中aa是结果的32位尾数，a_expa\_exp是其关联的指数。返回结果AA。

b必须已经初始化（参见bfp_s32_init())。

操作:

A←1N∑k=0N−1(Bk)其中 N 是 Bˉ 的长度A \leftarrow \frac{1}{N} \sum_{k=0}^{N-1} \left( B_k \right) \quad \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}

参数:

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

返回值:

  • AA，Bˉ\bar{B}的均值

参考性能:

bfp_s32_mean

float_s64_t bfp_s32_energy()​

获取32位BFP向量的能量（元素平方和）。

该函数计算输入BFP向量Bˉ\bar{B}的元素的平方和A=a⋅2a_expA = a \cdot 2^{a\_exp}，其中aa是结果的64位尾数，a_expa\_exp是其关联的指数。返回结果AA。

b必须已经初始化（参见bfp_s32_init())。

操作:

A←∑k=0N−1(Bk2)其中 N 是 Bˉ 的长度\begin{split}\begin{align*} & A \leftarrow \sum_{k=0}^{N-1} \left( B_k^2 \right) \\ & \qquad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度} && \end{align*}\end{split}

参数:

  • const bfp_s32_t *b – [in] 输入BFP向量 Bˉ\bar{B}

返回值:

  • AA，Bˉ\bar{B}的能量

参考性能:

bfp_s32_energy

float_s32_t bfp_s32_rms()​

获取32位BFP向量元素的均方根（RMS）值。

该函数计算输入BFP向量Bˉ\bar{B}的元素的均方根值A=a⋅2a_expA = a \cdot 2^{a\_exp}，其中aa是结果的32位尾数，a_expa\_exp是其关联的指数。返回AA的值。

向量的均方根（RMS）值是向量元素平方和的平方根。

b必须已初始化（参见bfp_s32_init()）。

操作：

A←1N∑k=0N−1(Bk2)A \leftarrow \sqrt{\frac{1}{N}\sum_{k=0}^{N-1} \left( B_k^2 \right) }

其中NN是Bˉ\bar{B}的长度。

参数：

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}

返回值：

  • AA，Bˉ\bar{B}元素的均方根（RMS）值

参考性能:

bfp_s32_rms

float_s32_t bfp_s32_max()​

获取32位BFP向量的最大值。

找到输入BFP向量Bˉ\bar{B}的元素中的最大值AA。该函数返回AA。

b必须已初始化（参见bfp_s32_init()）。

操作：

A←max⁡(B0,B1,...,BN−1)其中N是Bˉ的长度A \leftarrow \max(B_0, B_1, ..., B_{N-1}) \\ \text{其中} N \text{是} \bar{B} \text{的长度}

参数：

  • const bfp_s32_t *b – [in] 输入向量

返回值：

  • AA，Bˉ\bar{B}的最大元素的值

参考性能:

bfp_s32_max

void bfp_s32_max_elementwise()​

获取两个32位BFP向量的逐元素最大值。

将输出向量Aˉ\bar{A}的每个元素设置为输入向量Bˉ\bar{B}和Cˉ\bar{C}中相应元素的最大值。

a，b和c必须已初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以在b上安全地原位执行，但不能在c上执行。

操作：

Ak←max⁡(Bk,Ck)对于k∈0,...,(N−1)其中N是Bˉ和Cˉ的长度A_k \leftarrow \max(B_k, C_k) \\ \text{对于} k \in 0, ..., (N-1) \\ \text{其中} N \text{是} \bar{B} \text{和} \bar{C} \text{的长度}

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar{A}
  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar{B}
  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar{C}

参考性能:

bfp_s32_max_elementwise

float_s32_t bfp_s32_min()​

获取32位BFP向量的最小值。

找到输入BFP向量Bˉ\bar{B}的元素中的最小值AA。该函数返回AA。

b必须已初始化（参见bfp_s32_init()）。

操作：

A←min⁡(B0,B1,...,BN−1)其中N是Bˉ的长度A \leftarrow \min(B_0, B_1, ..., B_{N-1}) \\ \text{其中} N \text{是} \bar{B} \text{的长度}

参数：

  • const bfp_s32_t *b – [in] 输入向量

返回值：

  • AA，Bˉ\bar{B}的最小元素的值

参考性能:

bfp_s32_min

void bfp_s32_min_elementwise()​

获取两个32位BFP向量的逐元素最小值。

将输出向量Aˉ\bar A的每个元素设置为输入向量Bˉ\bar B和Cˉ\bar C中相应元素的最小值。

a，b和c必须已初始化（参见bfp_s32_init()），并且长度必须相同。

此操作可以在b上安全地原位执行，但不能在c上执行。

操作：

Ak←min⁡(Bk,Ck)对于k∈0 ... (N−1)其中N是Bˉ和Cˉ的长度A_k \leftarrow \min(B_k, C_k)\\ \text{对于} k \in 0\ ...\ (N-1)\\ \text{其中} N \text{是} \bar{B} \text{和} \bar{C} \text{的长度}

参数：

  • bfp_s32_t *a – [out] 输出BFP向量Aˉ\bar A

  • const bfp_s32_t *b – [in] 输入BFP向量Bˉ\bar B

  • const bfp_s32_t *c – [in] 输入BFP向量Cˉ\bar C

参考性能:

bfp_s32_min_elementwise

unsigned bfp_s32_argmax()​

获取32位BFP向量的最大值的索引。

找到输入BFP向量Bˉ\bar B的元素中的最大值的索引aa。该函数返回aa。

如果返回值为i，则Bˉ\bar B中的最大值为ldexp(b->data[i], b->exp)。

操作：

a←arg⁡max⁡k(bk)对于k∈0 ... (N−1)其中N是Bˉ的长度a \leftarrow \arg\max_k\left(b_k\right)\\ \text{对于} k \in 0\ ...\ (N-1)\\ \text{其中} N \text{是} \bar{B} \text{的长度}

注意：

  • 如果存在最大值的并列情况，则返回最低的索引。

参数：

  • const bfp_s32_t *b – [in] 输入向量

返回值：

  • aa，Bˉ\bar B中最大值的索引

参考性能:

bfp_s32_argmax

unsigned bfp_s32_argmin()​

获取32位BFP向量的最小值的索引。

找到输入BFP向量Bˉ\bar B的元素中的最小值的索引aa。该函数返回aa。

如果返回值为i，则Bˉ\bar B中的最小值为ldexp(b->data[i], b->exp)。

操作：

a←arg⁡min⁡k(bk)对于k∈0 ... (N−1)其中N是Bˉ的长度a \leftarrow \arg\min_k\left(b_k\right)\\ \text{对于} k \in 0\ ...\ (N-1)\\ \text{其中} N \text{是} \bar{B} \text{的长度}

注意：

  • 如果存在最小值的并列情况，则返回最低的索引。

参数：

  • const bfp_s32_t *b – [in] 输入向量

返回值：

  • aa，Bˉ\bar B中最小值的索引

参考性能:

bfp_s32_argmin

void bfp_s32_convolve_valid()​

将32位BFP向量与短卷积核（"valid"模式）进行卷积。

该函数将输入BFP向量Xˉ\bar X与短定点卷积核bˉ\bar b进行卷积，生成输出BFP向量Yˉ\bar Y。该函数将系数由bˉ\bar b给出的KK阶FIR滤波器应用于输入信号Xˉ\bar X。卷积是“valid”类型，即在滤波器延伸超出输入向量边界的位置不产生输出元素，从而导致输出向量Yˉ\bar Y的长度较短。

该函数支持的最大滤波器阶数KK为77。

参数：

  • bfp_s32_t *y – [out] 输出BFP向量Yˉ\bar Y。如果输入Xˉ\bar X有NN个元素，并且滤波器有KK个系数，则Yˉ\bar Y有N−2PN-2P个元素，其中P=⌊K/2⌋P = \lfloor K / 2 \rfloor。

  • const bfp_s32_t *x – [in] 输入BFP向量Xˉ\bar X，长度为NN，包含元素。

  • const int32_t b_q30[] – [in] 滤波器系数向量bˉ\bar b。bˉ\bar b的系数以Q2.30定点格式编码。第ii个系数的有效值为bi⋅2−30b_i \cdot 2^{-30}。

  • const unsigned b_length – [in] bˉ\bar b的长度KK，以元素为单位（即滤波器系数的数量）。b_length必须是{1,3,5,7}\{ 1, 3, 5, 7 \}中的一个。

操作：

Yk←∑l=0K−1(X(k+l)⋅bl⋅2−30) 对于 k∈0 ... (N−2P) 其中 P=⌊K/2⌋Y_k \leftarrow \sum_{l=0}^{K-1} (X_{(k+l)} \cdot b_l \cdot 2^{-30} ) \quad\text{ 对于 }k\in 0\ ...\ (N-2P) \quad\text{ 其中 }P = \lfloor K/2 \rfloor

参考性能:

bfp_s32_convolve_valid

void bfp_s32_convolve_same()​

将32位BFP向量与短卷积核（"same"模式）进行卷积。

该函数将输入BFP向量Xˉ\bar X与短定点卷积核bˉ\bar b进行卷积，生成输出BFP向量Yˉ\bar Y。该函数将系数由bˉ\bar b给出的KK阶FIR滤波器应用于输入信号Xˉ\bar X。卷积模式为"same"，即输入向量会根据需要进行填充，以使输入和输出向量具有相同的长度。填充行为由pad_mode_e给出。

该函数支持的最大滤波器阶数KK为77。

参数：

  • bfp_s32_t *y – [out] 输出BFP向量Yˉ\bar Y。

  • const bfp_s32_t *x – [in] 输入BFP向量Xˉ\bar X。

  • const int32_t b_q30[] – [in] 滤波器系数向量bˉ\bar b。bˉ\bar b的系数以Q2.30定点格式编码。第ii个系数的有效值为bi⋅2−30b_i \cdot 2^{-30}。

  • const unsigned b_length – [in] bˉ\bar b的长度KK，以元素为单位（即滤波器系数的数量）。b_length必须是{1,3,5,7}\{ 1, 3, 5, 7 \}中的一个。

  • const pad_mode_e padding_mode – [in] pad_mode_e枚举类型中的一个值。填充模式指示滤波器延伸超出输入向量Xˉ\bar X边界的滤波器输入值。有关支持的填充模式和相关行为的列表，请参见pad_mode_e。

操作：

x~i={由填充模式决定i<0由填充模式决定i≥Nxi其他情况yk←∑l=0K−1(x~(k+l−P)⋅bl⋅2−30) 对于 k∈0 ... (N−2P) 其中 P=⌊K/2⌋\begin{split}\begin{align*} & \tilde{x}_i = \begin{cases} \text{由填充模式决定} & i < 0 \\ \text{由填充模式决定} & i \ge N \\ x_i & \text{其他情况} \end{cases} \\ & y_k \leftarrow \sum_{l=0}^{K-1} (\tilde{x}_{(k+l-P)} \cdot b_l \cdot 2^{-30} ) \\ & \qquad\text{ 对于 }k\in 0\ ...\ (N-2P) \\ & \qquad\text{ 其中 }P = \lfloor K/2 \rfloor && \end{align*}\end{split}
备注

与bfp_s32_convolve_valid()不同，该操作不能在x上安全地原位执行。

参考性能:

bfp_s32_convolve_same

编辑此页
本文最后由 Vergil Wong 更新于