FPGA上定点atan2的计算方法

我需要atan2(x,y)在具有连续输入/输出数据流的FPGA上进行计算。我设法使用展开的，流水线的CORDIC内核来实现它，但是要获得所需的精度，我必须执行32次迭代。这导致大量的LUT致力于这一任务。我尝试将流更改为使用部分展开的CORDIC内核，但随后我需要一个倍频的时钟频率以执行重复循环，同时仍保持连续的输入/输出流。因此，我无法满足时机要求。

因此，现在我正在寻求替代的计算方式atan2(x,y)。

我考虑过使用带插值的Block-RAM查找表，但是由于有2个变量，因此我需要2维查找表，这在Block-RAM的使用方面非常耗费资源。

然后，我考虑使用与象限调整atan2(x,y)有关的事实atan(x/y)。问题在于，x/y由于y不是常数，因此需要真正的划分，而FPGA上的划分非常占用资源。

是否有更多新颖的方法可atan2(x,y)在FPGA 上实现，从而降低LUT使用率，但仍提供良好的准确性？

您可以使用对数摆脱除法。对于第一象限中的：$(x, y)$

$$z = \log_2(y)-\log_2(x)\\ \text{atan2}(y, x) = \text{atan}(y/x) = \text{atan}(2^z)$$

图1.$\text{atan}(2^z)$

您可能需要在范围内近似才能获得所需的1E-9精度。您可以利用对称或确保在已知的八分圆中。近似：$\text{atan}(2^z)$$-30 < z < 30$$\text{atan}(2^{-z}) = \frac{\pi}{2}-\text{atan}(2^z)$$(x, y)$$\log_2(a)$

$$b = \text{floor}(\log_2(a))\\ c = \frac{a}{2^b}\\ \log_2(a) = b + \log_2(c)$$

$b$可以通过找到最高有效非零位的位置来计算。可以通过位移来计算。您将需要在范围近似。$c$$\log_2(c)$$1 \le c < 2$

图2.$\log_2(c)$

对于你的精度要求，线性内插和均匀采样，的样品和的样品为应该足够了。后者的桌子很大。有了它，由于插值引起的误差在很大程度上取决于：$2^{14} + 1 = 16385$$\log_2(c)$$30\times 2^{12} + 1 = 122881$$\text{atan}(2^z)$$0 < z < 30$$z$

图3. 对于每单位间隔的不同数量的样本（32至8192），在不同范围（水平轴近似最大绝对误差。（忽略）的最大绝对误差略小于绝对误差。$\text{atan}(2^z)$$z$$z$$0 \le z < 1$$\text{floor}(\log_2(z)) = 0$

所述表可以被分成多个子表对应于和不同与，这是很容易计算。表长度可以选择，如图3所示。子表内索引可以通过简单的位串操作来计算。为了您的准确性要求，如果您将的范围扩展到为简单起见，子表将总共包含29217个样本。$\text{atan}(2^z)$$0 \le z < 1$$\text{floor}(\log_2(z))$$z \ge 1$$\text{atan}(2^z)$$z$$0 \le z < 32$

供以后参考，这是我用来计算近似误差的笨拙的Python脚本：

from numpy import *
from math import *
N = 10
M = 20
x = array(range(N + 1))/double(N) + 1
y = empty(N + 1, double)
for i in range(N + 1):
    y[i] = log(x[i], 2)

maxErr = 0
for i in range(N):
    for j in range(M):
        a = y[i] + (y[i + 1] - y[i])*j/M
        if N*M < 1000: 
            print str((i*M + j)/double(N*M) + 1) + ' ' + str(a)
        b = log((i*M + j)/double(N*M) + 1, 2)
        err = abs(a - b)
        if err > maxErr:
            maxErr = err

print maxErr

y2 = empty(N + 1, double)
for i in range(1, N):
    y2[i] = -1.0/16.0*y[i-1] + 9.0/8.0*y[i] - 1.0/16.0*y[i+1]


y2[0] = -1.0/16.0*log(-1.0/N + 1, 2) + 9.0/8.0*y[0] - 1.0/16.0*y[1]
y2[N] = -1.0/16.0*y[N-1] + 9.0/8.0*y[N] - 1.0/16.0*log((N+1.0)/N + 1, 2)

maxErr = 0
for i in range(N):
    for j in range(M):
        a = y2[i] + (y2[i + 1] - y2[i])*j/M
        b = log((i*M + j)/double(N*M) + 1, 2)
        if N*M < 1000: 
            print a
        err = abs(a - b)
        if err > maxErr:
            maxErr = err

print maxErr

y2[0] = 15.0/16.0*y[0] + 1.0/8.0*y[1] - 1.0/16.0*y[2]
y2[N] = -1.0/16.0*y[N - 2] + 1.0/8.0*y[N - 1] + 15.0/16.0*y[N]

maxErr = 0
for i in range(N):
    for j in range(M):
        a = y2[i] + (y2[i + 1] - y2[i])*j/M
        b = log((i*M + j)/double(N*M) + 1, 2)
        if N*M < 1000: 
            print str(a) + ' ' + str(b)
        err = abs(a - b)
        if err > maxErr:
            maxErr = err

print maxErr

P = 32
NN = 13
M = 8
for k in range(NN):
    N = 2**k
    x = array(range(N*P + 1))/double(N)
    y = empty((N*P + 1, NN), double)
    maxErr = zeros(P)
    for i in range(N*P + 1):
        y[i] = atan(2**x[i])

    for i in range(N*P):
        for j in range(M):
            a = y[i] + (y[i + 1] - y[i])*j/M
            b = atan(2**((i*M + j)/double(N*M)))
            err = abs(a - b)
            if (i*M + j > 0 and err > maxErr[int(i/N)]):
                maxErr[int(i/N)] = err

    print N
    for i in range(P):
        print str(i) + " " + str(maxErr[i])    

通过对样本进行线性插值来近似函数的局部最大误差，可以通过采样间隔进行均匀采样而得出，可以通过以下方式近似解析：$f(x)$˚F（X ）˚F （X ）Δ X$\hat{f}(x)$$f(x)$$\Delta x$

$$\widehat{f}(x) - f(x) \approx (\Delta x)^2\lim_{\Delta x\rightarrow 0}\frac{\frac{f(x) + f(x + \Delta x)}{2} - f(x + \frac{\Delta x}{2})}{(\Delta x)^2} = \frac{(\Delta x)^2 f''(x)}{8},$$

其中是的二阶导数，并且处于绝对误差的局部最大值。通过以上方法，我们得到了近似值：$f''(x)$$f(x)$$x$

$$\widehat{\text{atan}}(2^z) - \text{atan}(2^z) \approx \frac{(\Delta z)^2 2^z(1 - 4^z)\ln(2)^2}{8(4^z + 1)^2},\\ \widehat{\log_2}(a) - \log_2(a) \approx \frac{-(\Delta a)^2}{8 a^2\ln(2)}.$$

由于这些函数是凹的，并且样本与该函数匹配，因此误差始终在一个方向上。如果使误差的符号在每个采样间隔内来回交替一次，则局部最大绝对误差可以减半。使用线性插值，可以通过以下方式对每个表进行预过滤来获得接近最佳结果：

$$y[k] = \cases{\begin{array}{rrrrrl}&&b_0x[k]&\negthickspace\negthickspace\negthickspace+ b_1x[k+1]&\negthickspace\negthickspace\negthickspace+ b_2x[k+2]&\text{if } k = 0,\\ &c_1x[k-1]&\negthickspace\negthickspace\negthickspace+ c_0x[k]&\negthickspace\negthickspace\negthickspace+ c_1x[k+1]&&\text{if }0 < k < N,\\ b_2x[k-2]&\negthickspace\negthickspace\negthickspace+ b_1x[k-1]&\negthickspace\negthickspace\negthickspace+ b_0x[k]&&&\text{if } k = N, \end{array}}$$

其中和是原始表，并且过滤后的表都跨越，权重为。与使用表外函数的样本相比，结束条件（上式中的第一行和最后一行）减少了表末尾的错误，因为不需要调整第一个和最后一个样本以减少内插误差它和桌子外面的样品之间。具有不同采样间隔的子表应单独进行预过滤。权重的值是通过依次最小化以增加指数$x$$y$$0 \le k \le N$$c_0 = \frac{9}{8}, c_1 = -\frac{1}{16}, b_0 = \frac{15}{16}, b_1 = \frac{1}{8}, b_2 = -\frac{1}{16}$$c_0, c_1$$N$ 近似误差的最大绝对值：

$$(\Delta x)^N\lim_{\Delta x\rightarrow 0}\frac{\left(c_1f(x - \Delta x) + c_0f(x) + c_1f(x + \Delta x)\right)(1-a) + \left(c_1f(x) + c_0f(x + \Delta x) + c_1f(x + 2 \Delta x)\right)a - f(x + a\Delta x)}{(\Delta x)^N} =\left\{\begin{array}{ll}(c_0 + 2c_1 - 1)f(x) &\text{if } N = 0, \bigg| c_1 = \frac{1 - c_0}{2}\\ 0&\text{if }N = 1,\\ \frac{1+a-a^2-c_0}{2}(\Delta x)^2 f''(x)&\text{if }N=2, \bigg|c_0 = \frac{9}{8}\end{array}\right.$$

对于样本间插值位置，具有凹函数或凸函数（例如）。解决了这些权重后，通过类似地最小化以下项的最大绝对值，得出了最终条件权重值：$0 \le a < 1$$f(x)$$f(x) = e^x$$b_0, b_1, b_2$

$$(\Delta x)^N\lim_{\Delta x\rightarrow 0}\frac{\left(b_0f(x) + b_1f(x + \Delta x) + b_2f(x + 2 \Delta x)\right)(1-a) + \left(c_1f(x) + c_0f(x + \Delta x) + c_1f(x + 2 \Delta x)\right)a - f(x + a\Delta x)}{(\Delta x)^N} =\left\{\begin{array}{ll}\left(b_0 + b_1 + b_2 - 1 + a(1 - b_0 - b_1 - b_2)\right)f(x) &\text{if } N = 0, \bigg| b_2 = 1 - b_0 - b_1\\ (a-1)(2b_0+b_1-2)\Delta x f'(x)&\text{if }N = 1,\bigg|b_1=2-2b_0\\ \left(-\frac{1}{2}a^2 + \left(\frac{23}{16} - b_0\right)a + b_0 - 1\right)(\Delta x)^2f''(x)&\text{if }N=2, \bigg|b_0 = \frac{15}{16}\end{array}\right.$$

为。使用预过滤器可使近似误差减半，并且比对表进行全面优化更容易。$0 \le a < 1$

图4. 11个样本的近似误差，带有和不带有预滤波器，带有和不带有端部条件。在没有结束条件的情况下，预过滤器可以访问表外部的函数值。$\log_2(a)$

本文可能提出了一种非常相似的算法：R. Gutierrez，V。Torres和J. Valls，“ 基于对数变换和基于LUT的技术的atan（Y / X）的FPGA实现 ” ，《系统结构学报》， 。2010年5月56日。摘要表示，它们的实现在速度方面击败了先前基于CORDIC的算法，在占用空间方面又优于基于LUT的算法。