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

32-Bit complex BFP API

void bfp_complex_s32_init()​

初始化一个32位复数BFP向量。

该函数初始化了a的每个字段。

与bfp_complex_s16_t不同，32位复数BFP向量使用单个缓冲区来存储每个尾数的实部和虚部，使得第k个元素的虚部在内存中紧随第k个元素的实部之后。data指向用于存储向量元素的内存缓冲区，其长度至少为length * 8字节。

exp是分配给BFP向量的指数。初始化后，第k个复数元素的逻辑值将为 (data2k+i⋅data2k+1)⋅2exp\left(data_{2k} + i\cdot data_{2k+1} \right)\cdot2^{exp}。

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

参数:

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

参考性能:

bfp_complex_s32_init

bfp_complex_s32_t bfp_complex_s32_alloc()​

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

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

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

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

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

参数:

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

返回值:

  • 复数32位BFP向量

参考性能:

bfp_complex_s32_alloc

void bfp_complex_s32_dealloc()​

释放由bfp_complex_s32_alloc()分配的32位复数BFP向量。

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

其尾数缓冲区（成功）动态分配的BFP向量会设置一个标志，表示如此。此函数可安全地应用于任何未手动操作其flags或data的bfp_complex_s32_t，包括：

  • 通过成功调用bfp_complex_s32_alloc()而产生的bfp_complex_s32_t
  • 通过不成功调用bfp_complex_s32_alloc()而产生的bfp_complex_s32_t
  • 通过调用bfp_complex_s32_init()初始化的bfp_complex_s32_t

在后两种情况下，此函数不执行任何操作。在第一种情况下，将清除vector的data、length和flags字段，使其为零。

参数:

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

参考性能:

bfp_complex_s32_dealloc

void bfp_complex_s32_set()​

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

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

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

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

参数:

  • bfp_complex_s32_t* a – [out] 要更新的BFP向量
  • const complex_s32_t b – [in] 每个复数尾数要设置的新值
  • const exponent_t exp – [in] BFP向量的新指数

参考性能:

bfp_complex_s32_set

void bfp_complex_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}，具有复数尾数向量 aˉ\bar{a} 和指数 a_expa\_exp。a 在原地更新，以产生结果BFP向量 A~\tilde{A}，具有复数尾数向量 a~\tilde{a} 和指数 a~_exp\tilde{a}\_exp。

exp 是 a~_exp\tilde{a}\_exp，即所需的指数。Δp=a~_exp−a_exp\Delta{}p = \tilde{a}\_exp - a\_exp 是所需的指数变化。

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

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

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

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

参数:

  • bfp_complex_s32_t* a – [inout] 输入BFP向量 Aˉ\bar{A} / 输出BFP向量 A~\tilde{A}
  • const exponent_t exp – [in] 所需的指数，a~_exp\tilde{a}\_exp

参考性能:

bfp_complex_s32_use_exponent

headroom_t bfp_complex_s32_headroom()​

获取复数32位BFP向量的头空间（headroom）。

复数向量的头空间是指每个元素的实部和虚部可以左移的位数，而不会丢失任何信息。它传递了向量可能包含的值范围的信息，这对于确定如何在可能有损的块浮点运算中保留精度非常有用。

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

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

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

和

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

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

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

和

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

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

参数:

  • bfp_complex_s32_t* b - 要获取头空间的复数BFP向量

返回值:

  • 复数BFP向量 b 的头空间

参考性能:

bfp_complex_s32_headroom

void bfp_complex_s32_shl()​

对复数32位BFP向量的尾数进行左移。

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

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

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

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

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

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

操作:

Re{ak}←sat32(⌊Re{bk}⋅2b_shl⌋)Im{ak}←sat32(⌊Im{bk}⋅2b_shl⌋)其中k∈0 ... (N−1)，N是Bˉ的长度，bk和ak分别是Bˉ和Aˉ的第k个尾数。\begin{split}\begin{align*} & Re\{a_k\} \leftarrow sat_{32}( \lfloor Re\{b_k\} \cdot 2^{b\_shl} \rfloor ) \\ & Im\{a_k\} \leftarrow sat_{32}( \lfloor Im\{b_k\} \cdot 2^{b\_shl} \rfloor ) \\ & \qquad\text其中 k \in 0\ ...\ (N-1)，N 是 \bar{B} 的长度，b_k 和 a_k 分别是 \bar{B} 和 \bar{A} 的第 k 个尾数。&& \end{align*}\end{split}

参数:

  • bfp_complex_s32_t* a – [out] 输出复数BFP向量 Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量 Bˉ\bar{B}
  • const left_shift_t b_shl – [in] 要应用于 Bˉ\bar{B} 尾数的有符号算术左移。

参考性能:

bfp_complex_s32_shl

void bfp_complex_s32_real_mul()​

逐元素将复数32位BFP向量与实数的32位BFP向量相乘。

复数输出BFP向量 Aˉ\bar{A} 的每个复数输出元素 AkA_k 被设置为复数输入BFP向量 Bˉ\bar{B} 和实数输入BFP向量 Cˉ\bar{C} 的相应元素 BkB_k 和 CkC_k 的复数乘积。

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

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

操作:

Ak←Bk⋅CkA_k \leftarrow B_k \cdot C_k 其中 k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN 是 Bˉ\bar{B} 和 Cˉ\bar{C} 的长度

参数:

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

参考性能:

bfp_complex_s32_real_mul

void bfp_complex_s32_mul()​

逐元素将一个复数型的32位BFP向量与另一个相乘。

复数输出BFP向量Aˉ\bar{A}的每个复数输出元素AkA_k被设置为复数输入BFP向量Bˉ\bar{B}和Cˉ\bar{C}的对应元素BkB_k和CkC_k的复数乘积。

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

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

操作:

Ak←Bk⋅CkA_k \leftarrow B_k \cdot C_k

其中k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN是Bˉ\bar{B}和Cˉ\bar{C}的长度。

参数:

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

参考性能:

bfp_complex_s32_mul

void bfp_complex_s32_conj_mul()​

逐元素将一个复数型的32位BFP向量与另一个的复共轭相乘。

复数输出BFP向量Aˉ\bar{A}的每个复数输出元素AkA_k被设置为复数输入BFP向量Bˉ\bar{B}的对应元素BkB_k和复数输入BFP向量Cˉ\bar{C}的对应元素CkC_k的复数乘积。

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

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

操作:

Ak←Bk⋅(Ck)∗A_k \leftarrow B_k \cdot (C_k)^*

其中k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN是Bˉ\bar{B}和Cˉ\bar{C}的长度，(Ck)∗(C_k)^*是CkC_k的复共轭。

参数:

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

参考性能:

bfp_complex_s32_conj_mul

void bfp_complex_s32_macc()​

逐元素将一个复数型的32位BFP向量与另一个相乘，并将结果加到第三个向量中。

操作:

Ak←Ak+(Bk⋅Ck)A_k \leftarrow A_k + (B_k \cdot C_k)

其中k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN是Bˉ\bar{B}和Cˉ\bar{C}的长度。

参数:

  • bfp_complex_s32_t* acc – [inout] 输入/输出累加器复数BFP向量Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量Bˉ\bar{B}
  • const bfp_complex_s32_t* c – [in] 输入复数BFP向量Cˉ\bar{C}

参考性能:

bfp_complex_s32_macc

void bfp_complex_s32_nmacc()​

逐元素将一个复数型的32位BFP向量与另一个相乘，并将结果从第三个向量中减去。

操作:

Ak←Ak−(Bk⋅Ck)A_k \leftarrow A_k - (B_k \cdot C_k)

其中k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN是Bˉ\bar{B}和Cˉ\bar{C}的长度。

参数:

  • bfp_complex_s32_t* acc – [inout] 输入/输出累加器复数BFP向量Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量Bˉ\bar{B}
  • const bfp_complex_s32_t* c – [in] 输入复数BFP向量Cˉ\bar{C}

参考性能:

bfp_complex_s32_nmacc

void bfp_complex_s32_conj_macc()​

逐元素将一个复数型的32位BFP向量与另一个的复共轭相乘，并将结果加到第三个向量中。

操作:

Ak←Ak+(Bk⋅Ck∗)A_k \leftarrow A_k + (B_k \cdot C_k^*)

其中k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN是Bˉ\bar{B}和Cˉ\bar{C}的长度，(Ck)∗(C_k)^*是CkC_k的复共轭。

参数:

  • bfp_complex_s32_t* acc – [inout] 输入/输出累加器复数BFP向量Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量Bˉ\bar{B}
  • const bfp_complex_s32_t* c – [in] 输入复数BFP向量Cˉ\bar{C}

参考性能:

bfp_complex_s32_conj_macc

void bfp_complex_s32_conj_nmacc()​

逐元素将一个复数型的32位BFP向量与另一个的复共轭相乘，并将结果从第三个向量中减去。

操作:

Ak←Ak−(Bk⋅Ck∗)A_k \leftarrow A_k - (B_k \cdot C_k^*)

其中k∈0 ... (N−1)k \in 0\ ...\ (N-1)，NN是Bˉ\bar{B}和Cˉ\bar{C}的长度，(Ck)∗(C_k)^*是CkC_k的复共轭。

参数:

  • bfp_complex_s32_t* acc – [inout] 输入/输出累加器复数BFP向量Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量Bˉ\bar{B}
  • const bfp_complex_s32_t* c – [in] 输入复数BFP向量Cˉ\bar{C}

参考性能:

bfp_complex_s32_conj_nmacc

void bfp_complex_s32_real_scale()​

用一个实数标量乘以一个复数型的32位BFP向量。

复数输出BFP向量Aˉ\bar{A}的每个复数输出元素AkA_k被设置为复数输入BFP向量Bˉ\bar{B}的对应元素BkB_k与实数标量α⋅2α_exp\alpha\cdot 2^{\alpha\_exp}的复数乘积，其中α\alpha和α_exp\alpha\_exp分别是参数alpha的尾数和指数。

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

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

操作:

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

参数:

  • bfp_complex_s32_t* a – [out] 输出复数BFP向量Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量Bˉ\bar{B}
  • const float_s32_t alpha – [in] 与Bˉ\bar{B}相乘的实数标量

参考性能:

bfp_complex_s32_real_scale

void bfp_complex_s32_scale()​

用一个复数标量乘以一个复数型的32位BFP向量。

复数输出BFP向量Aˉ\bar{A}的每个复数输出元素AkA_k被设置为复数输入BFP向量Bˉ\bar{B}的对应元素BkB_k与实数标量α⋅2α_exp\alpha\cdot 2^{\alpha\_exp}的复数乘积，其中α\alpha和α_exp\alpha\_exp分别是参数alpha的尾数和指数。

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

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

操作:

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

参数:

  • bfp_complex_s32_t* a – [out] 输出复数BFP向量Aˉ\bar{A}
  • const bfp_complex_s32_t* b – [in] 输入复数BFP向量Bˉ\bar{B}
  • const float_s32_t alpha – [in] 与Bˉ\bar{B}相乘的复数标量

参考性能:

bfp_complex_s32_real_scale

void bfp_complex_s32_add()​

将一个复数32位BFP向量与另一个相加。

复数输出BFP向量 Aˉ\bar{A} 的每个复数输出元素 AkA_k 设置为复数输入BFP向量 Bˉ\bar{B} 和 Cˉ\bar{C} 对应元素 BkB_k 和 CkC_k 的和。

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

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

操作：

Aˉ←Bˉ+Cˉ\bar{A} \leftarrow \bar{B} + \bar{C}

参数：

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

  • const bfp_complex_s32_t *b – [out] 输入复数BFP向量 Bˉ\bar{B}

  • const bfp_complex_s32_t *c – [out] 输入复数BFP向量 Cˉ\bar{C}

参考性能:

bfp_complex_s32_add

void bfp_complex_s32_add_scalar()​

将复数标量加到复数32位BFP向量中。

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

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

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

操作：

Aˉ←Bˉ+c\bar{A} \leftarrow \bar{B} + c

参数：

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

  • const bfp_complex_s32_t *b – [out] 输入复数BFP向量 Bˉ\bar{B}

  • const float_complex_s32_t c – [out] 输入复数标量 cc

参考性能:

bfp_complex_s32_add_scalar

void bfp_complex_s32_sub()​

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

复数输出BFP向量 Aˉ\bar{A} 的每个复数输出元素 AkA_k 设置为复数输入BFP向量 Bˉ\bar{B} 和 Cˉ\bar{C} 对应元素 BkB_k 和 CkC_k 的差。

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

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

操作：

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

参数：

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

参考性能:

bfp_complex_s32_sub

void bfp_complex_s32_to_bfp_complex_s16()​

将复数的32位BFP向量转换为16位BFP向量。

复数16位输出向量Aˉ\bar A的每个复数16位元素AkA_k被设置为复数32位输入向量Bˉ\bar B的相应元素BkB_k的值，其位深度被减少为16位。

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

此函数尽可能保留精度。

操作：

Ak⟵16位Bk对于k∈0 ... (N−1)其中N是Bˉ的长度A_k \overset{16位}{\longleftarrow} B_k \\ \qquad\text{对于} k \in 0\ ...\ (N-1) \\ \qquad\text{其中} N \text{是} \bar{B} \text{的长度}

参数：

  • bfp_complex_s16_t *a – [out] 输出复数16位BFP向量 Aˉ\bar A
  • const bfp_complex_s32_t *b – [in] 输入复数32位BFP向量 Bˉ\bar B

参考性能:

bfp_complex_s32_to_bfp_complex_s16

void bfp_complex_s32_squared_mag()​

获取复数32位BFP向量的每个元素的平方幅度。

实数输出BFP向量Aˉ\bar A的每个元素AkA_k被设置为复数输入BFP向量Bˉ\bar B的相应元素BkB_k的平方幅度。

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

操作：

Ak←Bk⋅(Bk)∗对于k∈0 ... (N−1)其中N是Bˉ的长度 且(Bk)∗是Bk的复共轭A_k \leftarrow B_k \cdot (B_k)^* \\ \qquad\text{对于} k \in 0\ ...\ (N-1) \\ \qquad\text{其中} N \text{是} \bar{B} \text{的长度} \\ \qquad\text{ 且} (B_k)^* \text{是} B_k \text{的复共轭}

参数：

  • bfp_s32_t *a – [out] 输出实数BFP向量 Aˉ\bar A
  • const bfp_complex_s32_t *b – [in] 输入复数BFP向量 Bˉ\bar B

参考性能:

bfp_complex_s32_squared_mag

void bfp_complex_s32_mag()​

获取复数32位BFP向量的每个元素的幅度。

实数输出BFP向量Aˉ\bar A的每个元素AkA_k被设置为复数输入BFP向量Bˉ\bar B的相应元素BkB_k的幅度。

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

操作：

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

参数：

  • bfp_s32_t *a – [out] 输出实数BFP向量 Aˉ\bar A
  • const bfp_complex_s32_t *b – [in] 输入复数BFP向量 Bˉ\bar B

参考性能:

bfp_complex_s32_mag

float_complex_s64_t bfp_complex_s32_sum()​

获取复数32位BFP向量的元素总和。

将复数输入BFP向量Bˉ\bar B的元素求和。结果是一个复数64位浮点标量aa，返回该值。

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

操作：

a←∑k=0N−1(bk⋅2B_exp)对于k∈0 ... (N−1)其中N是Bˉ的长度a \leftarrow \sum_{k=0}^{N-1} \left( b_k \cdot 2^{B\_exp} \right) \\ \qquad\text{对于} k \in 0\ ...\ (N-1) \\ \qquad\text{其中} N \text{是} \bar{B} \text{的长度}

参数：

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

返回值：

  • aa，向量Bˉ\bar B的元素总和

参考性能:

bfp_complex_s32_sum

void bfp_complex_s32_conjugate()​

获取复数32位BFP向量的每个元素的复共轭。

复数输出BFP向量Aˉ\bar A的每个元素AkA_k被设置为复数输入BFP向量Bˉ\bar B的相应元素BkB_k的复共轭。

操作：

Ak←Bk∗对于k∈0 ... (N−1)其中N是Bˉ和Cˉ的长度且Bk∗是Bk的复共轭A_k \leftarrow B_k^* \\ \qquad\text{对于} k \in 0\ ...\ (N-1) \\ \qquad\text{其中} N \text{是} \bar{B}\text{和}\bar{C} \text{的长度} \\ \qquad\text{且} B_k^* \text{是} B_k \text{的复共轭}

参数：

  • bfp_complex_s32_t *a – [out] 输出复数BFP向量 Aˉ\bar A
  • const bfp_complex_s32_t *b – [in] 输入复数BFP向量 Bˉ\bar B

参考性能:

bfp_complex_s32_conjugate

float_s64_t bfp_complex_s32_energy()​

获取复数32位BFP向量的能量。

这里的复数32位BFP向量的能量是向量的每个元素的平方幅度之和。

操作：

a←∑k=0N−1(∣bk⋅2B_exp∣2)对于k∈0 ... (N−1)其中N是Bˉ的长度a \leftarrow \sum_{k=0}^{N-1} \left( \left|b_k \cdot 2^{B\_exp}\right|^2 \right) \\ \qquad\text{对于} k \in 0\ ...\ (N-1) \\ \qquad\text{其中} N \text{是} \bar{B} \text{的长度}

参数：

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

返回值：

  • aa，向量Bˉ\bar B的能量

参考性能:

bfp_complex_s32_energy

void bfp_complex_s32_make()​

从实部和虚部创建复数32位BFP向量。

创建一个复数32位BFP向量，作为实向量Bˉ\bar B和虚向量Cˉi\bar C i的和。

a，b和c必须已经被初始化（参见bfp_complex_s32_init()和bfp_s32_init()），并且长度必须相同。&a->data[0]必须是双字对齐的地址。

操作：

Aˉ←Bˉ+Cˉi\bar{A} \leftarrow \bar{B} + \bar{C} i

参数：

  • bfp_complex_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_complex_s32_make

void bfp_complex_s32_real_part()​

提取复数32位BFP向量的实部。

该函数将复数32位BFP向量Bˉ\bar B的实部填充到实数32位BFP向量Aˉ\bar A中。

&b->data[0]必须是双字对齐的地址。

操作：

Aˉ←Real{Bˉ}\bar{A} \leftarrow {Real}\{\bar{B}\}

参数：

  • bfp_s32_t *a – [out] 实数BFP输出向量Aˉ\bar A
  • const bfp_complex_s32_t *b – [in] 复数BFP输入向量Bˉ\bar B

参考性能:

bfp_complex_s32_real_part

void bfp_complex_s32_imag_part()​

提取复数32位BFP向量的虚部。

该函数将复数32位BFP向量Bˉ\bar B的虚部填充到实数32位BFP向量Aˉ\bar A中。

&b->data[0]必须是双字对齐的地址。

操作：

Aˉ←Imag{Bˉ}\bar{A} \leftarrow {Imag}\{\bar{B}\}

参数：

  • bfp_s32_t *a – [out] 实数BFP输出向量Aˉ\bar A
  • const bfp_complex_s32_t *b – [in] 复数BFP输入向量Bˉ\bar B

参考性能:

bfp_complex_s32_imag_part

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