16-Bit BFP API

void bfp_s16_init()

初始化一个16位BFP向量。

该函数初始化BFP向量a的各个字段。

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

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

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

参数:

• bfp_s16_t *a – [out] 要初始化的BFP向量

• int16_t *data – [in] 用于支持a的int16_t缓冲区

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

• const unsigned length– [in] BFP向量中的元素数量

• const unsigned calc_hr – [in] 表示是否应计算BFP向量的头空间的布尔值

参考性能:

---

bfp_s16_t bfp_s16_alloc()

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

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

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

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

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

注意： BFP向量的动态分配依赖于堆分配，并且对执行时间没有任何保证。强烈不建议在任何时间关键的代码段中使用此函数。

参数：

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

返回：

• bfp_s16_t 16位BFP向量

参考性能:

---

void bfp_s16_dealloc()

释放由bfp_s16_alloc()动态分配的16位BFP向量。

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

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

• bfp_s16_t是通过成功调用bfp_s16_alloc()获得的
• bfp_s16_t是通过未成功调用bfp_s16_alloc()获得的
• bfp_s16_t是通过调用bfp_s16_init()进行初始化的

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

参数：

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

参考性能:

---

void bfp_s16_set()

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

将a的指数设置为exp，并将每个元素的尾数设置为b。执行此操作后，所有元素将表示相同的值 $b \cdot 2^{exp}$。

a必须已经被初始化（参见bfp_s16_init()）。

参数:

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

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

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

参考性能:

---

headroom_t bfp_s16_headroom()

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

向量的头空间是其元素可以左移的位数，而不丢失任何信息。它传达了向量可能包含的值的范围的信息，这对于确定如何在可能有损坏的块浮点操作中保持精度非常有用。

在BFP环境中，头空间仅适用于尾数，而不适用于指数。如果16位尾数向量 $\bar{x}$ 具有 $N$ 位的头空间，则对于 $\bar{x}$ 的任何元素 $x_k$，$-2^{15-N} \le x_k < 2^{15-N}$。

对于复数BFP向量 $\bar{X}$ 的任何元素 $X_k = x_k \cdot 2^{x\_exp}$，$-2^{15 + x\_exp - N} \le X_k < 2^{15 + x\_exp - N}$。

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

参数:

• bfp_s16_t *b – 要获取头空间的BFP向量

返回值:

• BFP向量 b 的头空间

参考性能:

---

void bfp_s16_use_exponent()

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

此函数强制BFP向量 $\bar{A}$ 使用指定的指数。尾数向量 $\bar{a}$ 将被左移或右移以补偿更改的指数。

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

请注意，这设置了_当前_编码，而不是永久地_固定_指数（即后续操作可能像往常一样更改指数）。

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

a 指向输入BFP向量 $\bar{A}$，具有尾数向量 $\bar{a}$ 和指数 $a\_exp$。a 在原地更新，产生结果BFP向量 $\bar{\tilde{A}}$，具有尾数向量 $\bar{\tilde{a}}$ 和指数 $\tilde{a}\_exp$。

exp 是 $\tilde{a}\_exp$，即所需的指数。$\Delta{}p = \tilde{a}\_exp - a\_exp$ 是指数的所需变化量。

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

如果 $\Delta{}p > 0$，则所需的指数大于当前指数，并且将 $\Delta{}p$ 位右移应用于尾数 $\bar{a}$。在应用右移时，通过丢弃 $\Delta{}p$ 位最低有效位可能会丢失精度。

如果 $\Delta{}p < 0$，则所需的指数小于当前指数，并且将 $\Delta{}p$ 位左移应用于尾数 $\bar{a}$。在左移时，将应用饱和逻辑，以使任何不能用新指数准确表示的元素饱和到16位饱和边界。

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

操作:

$$\begin{split}\begin{align*} & \Delta{}p = \tilde{a}\_exp - a\_exp \\ & 对于 \bar{A} 的每个元素 a_k，\\ & \tilde{a_k} \leftarrow sat_{16}( a_k \cdot 2^{-\Delta{}p} ) \\ & \qquad\text{其中 } k \in 0\ ...\ (N-1) \\ & \qquad\text N 是 \bar{A} 的长度(以元素为单位) && \end{align*}\end{split}$$

参数:

• bfp_s16_t *a – [inout] 输入BFP向量 $\bar{A}$ / 输出BFP向量 $\bar{\tilde{A}}$

• const exponent_t exp – [in] 所需的指数，$\tilde{a}\_exp$

参考性能:

---

void bfp_s16_shl()

对一个16位BFP向量的尾数进行左移操作。

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

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

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

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

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

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

操作：

$$\begin{align*} a_k &\leftarrow \text{sat}_{16}( \lfloor b_k \cdot 2^{b\_shl} \rfloor ) \\ &\text{对于} k \in 0\ ...\ (N-1), \\ &\text{其中} N \text{是} \bar{B} \ \text{的长度，} \\ &b_k \text{和} a_k \text{分别是} \bar{B} \text{和} \bar{A} \text{的第} k \text{个尾数。} \end{align*}$$

参数：

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

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

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

参考性能:

---

void bfp_s16_add()

将两个16位BFP向量相加。

将输入BFP向量 $\bar B$ 和 $\bar C$ 相加，并将结果存储在BFP向量 $\bar A$ 中。

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

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

操作：

$\bar A \leftarrow \bar B + \bar C$

参数：

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

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

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

参考性能:

---

void bfp_s16_add_scalar()

将一个标量加到16位BFP向量中。

将实数标量 $c$ 加到输入BFP向量 $\bar B$ 中，并将结果存储在BFP向量 $\bar A$ 中。

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

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

操作：

$\bar A \leftarrow \bar B + c$

参数：

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

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

• const float c – [in] 输入标量 $c$

参考性能:

---

void bfp_s16_sub()

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

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

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

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

操作：

$\bar{A} \leftarrow \bar{B} - \bar{C}$

参数：

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

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

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

参考性能:

---

void bfp_s16_mul()

逐元素地将一个16位BFP向量与另一个向量相乘。

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

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

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

操作：

$A_k \leftarrow B_k \cdot C_k \quad \text{对于 } k \in 0\ ...\ (N-1) \quad \text{其中 } N \text{ 是 } \bar{B}\text{ 和 }\bar{C}\text{ 的长度}$

参数：

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

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

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

参考性能:

---

void bfp_s16_macc()

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

操作：

$A_k \leftarrow A_k + B_k \cdot C_k \quad \text{对于 } k \in 0\ ...\ (N-1) \quad \text{其中 } N \text{ 是 } \bar{B}\text{ 和 }\bar{C}\text{ 的长度}$

参数：

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

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

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

参考性能:

---

void bfp_s16_nmacc()

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

操作：

$A_k \leftarrow A_k - B_k \cdot C_k \quad \text{对于 } k \in 0\ ...\ (N-1) \quad \text{其中 } N \text{ 是 } \bar{B}\text{ 和 }\bar{C}\text{ 的长度}$

参数：

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

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

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

参考性能:

---

void bfp_s16_scale()

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

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

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

alpha 表示标量 $\alpha \cdot 2^{\alpha\_exp}$，其中 $\alpha$ 是 alpha.mant，$\alpha\_exp$ 是 alpha.exp。

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

操作：

$\bar{A} \leftarrow \bar{B} \cdot \left(\alpha \cdot 2^{\alpha\_exp}\right)$

参数：

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

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

• const float alpha – [in] 用于乘以 $\bar{B}$ 的标量 $\alpha$

参考性能:

---

void bfp_s16_abs()

计算16位BFP向量的元素的绝对值。

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

a和b必须已经初始化（参见bfp_s16_init()），并且长度必须相同。这个操作可以在b上安全地原地执行。

操作：

$A_k \leftarrow \left| B_k \right| \quad \text{对于 } k \in 0\ ...\ (N-1) \quad \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}$

参数：

• bfp_s16_t* a – [out] 输出BFP向量$\bar{A}$
• const bfp_s16_t* b – [in] 输入BFP向量$\bar{B}$

参考性能:

---

float_s32_t bfp_s16_sum()

求解16位BFP向量的元素和。

该函数将输入BFP向量$\bar{B}$的元素求和得到结果$A = a \cdot 2^{a\_exp}$，并将其返回。返回值的尾数为32位。

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

操作：

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

参数：

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

返回值：

• $A$，$\bar{B}$的元素和

参考性能:

---

float_s64_t bfp_s16_dot()

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

该函数将输入BFP向量$\bar{B}$和$\bar{C}$的逐元素乘积相加，得到结果$A = a \cdot 2^{a\_exp}$，其中$a$是结果的64位尾数，$a\_exp$是其关联的指数。返回$A$。

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

操作：

$a \cdot 2^{a\_exp} \leftarrow \sum_{k=0}^{N-1} \left( B_k \cdot C_k \right) \quad \text{其中 } N \text{ 是 } \bar{B} \text{ 和 } \bar{C} \text{ 的长度}$

参数：

• const bfp_s16_t* b – [in] 输入BFP向量$\bar{B}$
• const bfp_s16_t* c – [in] 输入BFP向量$\bar{C}$

返回值：

• $A$，向量$\bar{B}$和$\bar{C}$的内积

参考性能:

---

void bfp_s16_clip()

将16位BFP向量的元素夹紧到指定范围。

该函数将输出BFP向量$\bar{A}$的每个元素$A_k$设置为输入BFP向量$\bar{B}$的相应元素$B_k$，如果它在范围$[ L \cdot 2^{bound\_exp}, U \cdot 2^{bound\_exp} ]$内，则设置为该范围内的最近值。

a和b必须已经初始化（参见bfp_s16_init()），并且长度必须相同。这个操作可以在b上安全地原地执行。

操作：

$$A_k \leftarrow \begin{cases} L \cdot 2^{bound\_exp} & \text{如果 } B_k < L \cdot 2^{bound\_exp} \\ U \cdot 2^{bound\_exp} & \text{如果 } B_k > U \cdot 2^{bound\_exp} \\ B_k & \text{否则} \end{cases} \\ \quad \text{对于 } k \in 0\ ...\ (N-1) \quad \text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}$$

参数：

• bfp_s16_t* a – [out] 输出BFP向量$\bar{A}$
• const bfp_s16_t* b – [in] 输入BFP向量$\bar{B}$
• const int16_t lower_bound – [in] 夹紧下界的尾数，$L$
• const int16_t upper_bound – [in] 夹紧上界的尾数，$U$
• const int bound_exp – [in] 夹紧边界的共享指数

参考性能:

---

void bfp_s16_rect()

对一个16位BFP向量进行矩形化处理。

输出BFP向量$\bar{A}$的每个元素$A_k$，如果对应的输入BFP向量$\bar{B}$的元素$B_k$为非负数，则将其设置为$B_k$，否则设置为$0$。

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

这个操作可以安全地在b上进行原地操作。

操作：

$A_k \leftarrow \begin{cases} 0 & B_k < 0 \\ B_k & \text{其他情况} \end{cases} \quad\text{其中 } k \in 0\ ...\ (N-1) \quad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}$

参数：

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

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

参考性能:

---

void bfp_s16_to_bfp_s32()

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

将输入BFP向量$\bar{B}$的每个16位元素$B_k$的位深度增加到32位，并将32位结果存储在输出BFP向量$\bar{A}$的相应元素$A_k$中。

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

操作：

$A_k \overset{32-bit}{\longleftarrow} B_k \quad\text{其中 } k \in 0\ ...\ (N-1) \quad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}$

参数：

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

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

参考性能:

---

void bfp_s16_sqrt()

获取一个16位BFP向量的平方根。

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

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

这个操作可以安全地在b上进行原地操作。

操作：

$A_k \leftarrow \sqrt{B_k} \quad\text{其中 } k \in 0\ ...\ (N-1) \quad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}$

注意：

• 仅计算每个结果的XMATH_BFP_SQRT_DEPTH_S16（参见xmath_conf.h）个最高有效位。
• 此函数仅计算实数的平方根。对于任何$B_k < 0$，相应的输出$A_k$设置为$0$。

参数：

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

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

参考性能:

---

void bfp_s16_inverse()

获取一个16位BFP向量的倒数。

计算输入BFP向量$\bar{B}$的每个元素$B_k$的倒数，并将结果存储在输出BFP向量$\bar{A}$中。

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

这个操作可以安全地在b上进行原地操作。

操作：

$A_k \leftarrow B_k^{-1} \quad\text{其中 } k \in 0\ ...\ (N-1) \quad\text{其中 } N \text{ 是 } \bar{B} \text{ 的长度}$

参数：

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

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

参考性能:

---

float_s32_t bfp_s16_abs_sum()

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

该函数对输入的BFP向量$\bar{B}$的元素绝对值进行求和，得到结果$A = a \cdot 2^{a\_exp}$，其中$a$是32位尾数，$a\_exp$是其关联的指数。返回$A$。

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

操作：

$A \leftarrow \sum_{k=0}^{N-1} \left| A_k \right|$，其中$N$是$\bar{B}$的长度。

参数：

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

返回值： $A$，$\bar{B}$元素的绝对值之和

参考性能:

---

float bfp_s16_mean()

获取16位BFP向量的均值。

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

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

操作：

$A \leftarrow \frac{1}{N} \sum_{k=0}^{N-1} \left( B_k \right)$，其中$N$是$\bar{B}$的长度。

参数：

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

返回值： $A$，$\bar{B}$的均值

参考性能:

---

float_s64_t bfp_s16_energy()

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

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

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

操作：

$A \leftarrow \sum_{k=0}^{N-1} \left( B_k^2 \right)$，其中$N$是$\bar{B}$的长度。

参数：

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

返回值： $A$，$\bar{B}$的能量

参考性能:

---

float_s32_t bfp_s16_rms()

获取16位BFP向量的均方根值。

该函数计算输入BFP向量$\bar{B}$的均方根（RMS）值$A = a \cdot 2^{a\_exp}$，其中$a$是结果的32位尾数，$a\_exp$是其关联的指数。返回$A$。

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

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

操作：

$A \leftarrow \sqrt{\frac{1}{N}\sum_{k=0}^{N-1} \left( B_k^2 \right) }$，其中$N$是$\bar{B}$的长度。

参数：

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

返回值： $A$，$\bar{B}$的均方根值

参考性能:

---

float bfp_s16_max()

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

该函数找到输入BFP向量$\bar{B}$中的最大值$A$。该函数返回$A$。

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

操作：

$A \leftarrow max\left(B_0\, B_1\, ...\, B_{N-1} \right)$，其中$N$是$\bar{B}$的长度。

参数：

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

返回值： $A$，$\bar{B}$的最大元素值

参考性能:

---

void bfp_s16_max_elementwise()

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

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

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

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

操作：

对于$k$在$0\ ...\ (N-1)$的范围内，$A_k \leftarrow max(B_k, C_k)$，其中$N$是$\bar{B}$和$\bar{C}$的长度。

参数：

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

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

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

参考性能:

---

float bfp_s16_min()

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

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

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

操作：

$A \leftarrow min\left(B_0\, B_1\, ...\, B_{N-1} \right)$，其中$N$是$\bar{B}$的长度。

参数：

• const bfp_s16_t* b – [out] 输入BFP向量$\bar{B}$

返回值： $\bar{B}$的最小元素值$A$

参考性能:

---

void bfp_s16_min_elementwise()

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

输出向量$\bar{A}$的每个元素被设置为输入向量$\bar{B}$和$\bar{C}$中对应元素的最小值。

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

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

操作：

对于$k$在$0\ ...\ (N-1)$的范围内，$A_k \leftarrow min(B_k, C_k)$，其中$N$是$\bar{B}$和$\bar{C}$的长度。

参数：

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

• const bfp_s16_t* b – [out] 输入BFP向量$\bar{B}$

• const bfp_s16_t* c – [out] 输入BFP向量$\bar{C}$

参考性能:

---

unsigned bfp_s16_argmax()

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

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

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

操作：

对于$k$在$0\ ...\ (N-1)$的范围内，$a \leftarrow argmax_k\left(b_k\right)$，其中$N$是$\bar{B}$的长度。

注：

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

参数：

• const bfp_s16_t* b – [out] 输入BFP向量$\bar{B}$

返回值： $\bar{B}$中最大值的索引$a$

参考性能:

---

unsigned bfp_s16_argmin()

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

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

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

操作：

对于$k$在$0\ ...\ (N-1)$的范围内，$a \leftarrow argmin_k\left(b_k\right)$，其中$N$是$\bar{B}$的长度。

注：

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

参数：

• const bfp_s16_t* b – [out] 输入BFP向量$\bar{B}$

返回值： $\bar{B}$中最小值的索引$a$

参考性能:

---

headroom_t bfp_s16_accumulate()

将一个16位BFP向量累加到一个32位累加器向量中。

该函数用于高效地将一系列16位BFP向量累加到一个32位向量中。每次调用该函数都会将BFP向量$\bar{B}$累加到持久的32位累加器向量$\bar{A}$中。

最终，$\bar{A}$的值将被用于除了简单累加之外的其他用途，这需要将其从split_acc_s32_t结构给出的XS3本地分割累加器表示形式转换为标准的int32_t向量。可以使用vect_s32_merge_accs()来完成这个转换。然后，如果需要，可以使用vect_s32_to_vect_s16()将int32_t向量转换为16位向量。

注意，为了使该操作正常工作，$b\_exp - a\_exp$不能大于$14$。

该函数执行的操作可以表示为：

$\bar{A} \leftarrow \bar{A} + \bar{B}$

用法：

正确使用该函数需要调用者进行一些记录。特别是，调用者有责任跟踪指数并监视累加器向量$\bar{A}$的头空间。

要开始一系列的累加，首先将$\bar{A}$的内容清零为全零。然后，必须选择适当的$\bar{A}$的指数。唯一的硬性约束是累加器的指数$a\_exp$必须在离$\bar{B}$的指数$b\_exp$不超过$14$的范围内。如果$b\_exp$未知，则调用者可以选择在第一个$\bar{B}$可用之前等待初始化$a\_exp$。

当使用多次调用该函数将向量累加到$\bar{A}$中时，$\bar{A}$的某些元素可能会饱和。每次调用该函数将返回$\bar{A}$的头空间（注意：最多报告15位的头空间）。如果$\bar{A}$至少有1位的头空间，则保证调用该函数不会饱和。

$a\_exp$相对于每个$b\_exp$越大，就可以在可能出现饱和之前累加更多的16位向量（因此累加效率更高）。另一方面，只要$a\_exp \le b\_exp$，在累加过程中就不会出现精度损失。调用者有责任管理这种权衡。

如果该函数报告$\bar{A}$的头空间为0，如果需要进一步累加，调用者可以通过增加$a\_exp$来处理。增加$a\_exp$将要求右移尾数向量$\bar{a}$的内容，以避免破坏$\bar{A}$的值，并为进一步累加腾出空间。可以通过调用vect_split_acc_s32_shr()来实现对分割累加器的移位操作。

最后，当累加完成或累加器的值必须在其他地方使用时，可以通过调用vect_s32_merge_accs()将分割累加器向量转换为简单的int32_t向量。

参数：

• split_acc_s32_t a[] – [in/out] 累加器向量$\bar{A}$的尾数

• const exponent_t a_exp – [out] 累加器向量$\bar{A}$的指数

• const bfp_s16_t* b – [out] 输入向量$\bar{B}$

返回值：

$\bar{A}$的头空间（最多15位）

参考性能:

---