基於C語言的Q格式使用詳解

時間 2020-05-12

標籤基於 c語言格式使用詳解简体版

原文原文鏈接

用過DSP的應該都知道Q格式吧；linux

1 前言

Q格式是二進制的定點數格式，相對於浮點數，Q格式指定了相應的小數位數和整數位數，在沒有浮點運算的平臺上，能夠更快地對浮點數據進行處理，以及應用在須要恆定分辨率的程序中（浮點數的精度是會變化的）；須要注意的是Q格式是概念上小數定點，經過選擇常規的二進制數整數位數和小數位數，從而達到所須要的數值範圍和精度，這裏可能有點抽象，下面繼續看介紹。算法

2 Q數據的表示

2.1 範圍和精度

定點數一般表示爲\(Q_{m.n}\)，其中m爲整數個數，n爲小數個數，其中最高位位符號位而且以二進制補碼的形式存儲；安全

範圍：\([-(2^{m-1})，2^{m-1}-2^{-n}]\)
精度：\(2^{-n}\)

無符號的用\(UQ_{m.n}\)表示；函數

範圍：\([0，2^m-2^{-n}]\)
精度：\(2^{-n}\)

2.2 推導

無符號Q格式數據的推導
這裏以一個16位無符號整數爲例，\(UQ_{9.7}\)所能表示的最大數據的二進制形式以下圖所示；大數據

因此不難看出，\(UQ_{9.7}\)的範圍大小和精度；
根據等比數列求和公式獲得，整數域最大值以下：this

\[Sumi = 2^8+2^7+2^6+2^5+2^4+2^3+2^2+2^1+2^0 = 2^9 -1 \]

小數域最大值以下：spa

\[Sumf = 2^{-1}+2^{-2}+2^{-3}+2^{-4}+2^{-5}+2^{-6}+2^{-7}=1-2^{-7} \]

所以\(UQ_{9.7}\)的範圍知足 \([0，2^9-2^{-7}]\)；.net

有符號Q格式數據的推導
這裏以一個16位有符號整數爲例，\(UQ_{9.7}\)所能表示的最大數據的二進制形式以下圖所示；code

因此不難求出，\(UQ_{9.7}\)的範圍大小和精度；
根據等比數列求和公式獲得，整數域最大值以下：orm

\[Sumi = 2^7+2^6+2^5+2^4+2^3+2^2+2^1+2^0 = 2^8 -1 \]

小數域最大值以下：

\[Sumf = 2^{-1}+2^{-2}+2^{-3}+2^{-4}+2^{-5}+2^{-6}+2^{-7}=1-2^{-7} \]

所以\(Q_{9.7}\)最大能表示的數爲： \(2^8-2^{-7}\)；

\(Q_{9.7}\)所能表示的最小數據的二進制形式以下圖所示；

能夠從圖中看到，該數表示爲\(-2^8\)；

補充一下：負數在計算機中是補碼的形式存在的，補碼=反碼+1，符號位爲1則表示爲負數；
那麼-4該如何表示呢？
以8 bit數據爲例，以下所示；
原碼：0B 0000 100
反碼：0B 1111 011
補碼：0B 1111 100

綜上，能夠獲得有符號\(Q_{9.7}\)的範圍是：\([-2^8，2^8-2^{-7}]\)

3 Q數據的運算

3.1 0x7FFF

最大數的十六進制爲0x7FFF，以下圖所示；

3.2 0x8000

最小數的十六進制爲0X8000，以下圖所示；

上述這兩種狀況，下面都會用到。

3.3 加法

加法和減法須要兩個Q格式的數據定標相同，即\(Q_{m_1.n_1}\)和\(Q_{m_2.n_2}\)知足如下條件；

\[\begin{cases} m_1 = m_2 \\ n_1 = n_2 \end{cases}\]

int16_t q_add(int16_t a, int16_t b)
{
    return a + b;
}

上面的程序其實並不安全，在通常的DSP芯片具備防止溢出的指令，可是一般須要作一下溢出檢測，具體以下所示；

int16_t q_add_sat(int16_t a, int16_t b)
{
    int16_t result;
    int32_t tmp;

    tmp = (int32_t)a + (int32_t)b;
    if (tmp > 0x7FFF)
        tmp = 0x7FFF;
    if (tmp < -1 * 0x8000)
        tmp = -1 * 0x8000;
    result = (int16_t)tmp;

    return result;
}

3.4 減法

相似於加法的操做，須要相同定標的兩個Q格式數進行相減，可是不會存在溢出的狀況；

//https://great.blog.csdn.net/
int16_t q_sub(int16_t a, int16_t b)
{
    return a - b;
}

3.5 乘法

乘法一樣須要考慮溢出的問題，這裏經過sat16函數，對溢出作了處理；

//https://great.blog.csdn.net/
// precomputed value:
#define K   (1 << (Q - 1))
 
// saturate to range of int16_t
int16_t sat16(int32_t x)
{
	if (x > 0x7FFF) return 0x7FFF;
	else if (x < -0x8000) return -0x8000;
	else return (int16_t)x;
}

int16_t q_mul(int16_t a, int16_t b)
{
    int16_t result;
    int32_t temp;

    temp = (int32_t)a * (int32_t)b; // result type is operand's type
    // Rounding; mid values are rounded up
    temp += K;
    // Correct by dividing by base and saturate result
    result = sat16(temp >> Q);

    return result;
}

3.6 除法

//https://great.blog.csdn.net/
int16_t q_div(int16_t a, int16_t b)
{
    /* pre-multiply by the base (Upscale to Q16 so that the result will be in Q8 format) */
    int32_t temp = (int32_t)a << Q;
    /* Rounding: mid values are rounded up (down for negative values). */
    /* OR compare most significant bits i.e. if (((temp >> 31) & 1) == ((b >> 15) & 1)) */
    if ((temp >= 0 && b >= 0) || (temp < 0 && b < 0)) {   
        temp += b / 2;    /* OR shift 1 bit i.e. temp += (b >> 1); */
    } else {
        temp -= b / 2;    /* OR shift 1 bit i.e. temp -= (b >> 1); */
    }
    return (int16_t)(temp / b);
}

4 常見Q格式的數據範圍

定點數\(X_q\)和浮點數\(X_f\)轉換的關係知足如下公式：

\[\begin{cases} X_q = (int)X_f*2^n \\ \\ X_f = (float)X_f*2^{-n} \end{cases}\]

其中\(X_q\)爲\(Q_{m.n}\)，m表示整數位數，n表示小數位數；

#include <stdio.h>
#include <stdint.h>
#include <math.h>


int main()
{
    // 0111 1111 1111 1111
    int16_t q_max = 32767; // 0x7FFF
    // 1000 0000 0000 0000
    int16_t q_min = -32768; // 0x8000
    float f_max = 0;
    float f_min = 0;
    printf("\r\n");
    for (int8_t i = 15; i>=0; i--) {
        f_max = (float)q_max / pow(2,i);
        f_min = (float)q_min / pow(2,i);

        printf("\t| Q %d | Q %d.%d| %f | %f |\r\n",
               i,(15-i),i,f_max,f_min);
    }

    return 0;
}

運行獲得結果以下所示；

Q 格式	Qmn	Max	Min
Q 15	Q 0.15	0.999969	-1.000000
Q 14	Q 1.14	1.999939	-2.000000
Q 13	Q 2.13	3.999878	-4.000000
Q 12	Q 3.12	7.999756	-8.000000
Q 11	Q 4.11	15.999512	-16.000000
Q 10	Q 5.10	31.999023	-32.000000
Q 9	Q 6.9	63.998047	-64.000000
Q 8	Q 7.8	127.996094	-128.000000
Q 7	Q 8.7	255.992188	-256.000000
Q 6	Q 9.6	511.984375	-512.000000
Q 5	Q 10.5	1023.968750	-1024.000000
Q 4	Q 11.4	2047.937500	-2048.000000
Q 3	Q 12.3	4095.875000	-4096.000000
Q 2	Q 13.2	8191.750000	-8192.000000
Q 1	Q 14.1	16383.500000	-16384.000000
Q 0	Q 15.0	32767.000000	-32768.000000

5 0x5f3759df

Q格式雖然十分抽象，可是且看看這個數字0x5f3759df，感受和Q格式有某種聯繫，它是雷神之錘3中的一個算法的魔數，畢竟遊戲引擎須要充分考慮到效率，具體的由來能夠看一下論文《Fast Inverse Square Root》，下面是源碼中剝出來的快速平方根算法；

float Q_rsqrt( float number )
{
	long i;
	float x2, y;
	const float threehalfs = 1.5F;

	x2 = number * 0.5F;
	y   = number;
	i   = * ( long * ) &y;   // evil floating point bit level hacking
	i   = 0x5f3759df - ( i >> 1 ); // what the fuck?
	y   = * ( float * ) &i;
	y   = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
	// y   = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed

	#ifndef Q3_VM
	#ifdef __linux__
		 assert( !isnan(y) ); // bk010122 - FPE?
	#endif
	#endif
	return y;
}