métodos de computação do ponto fixo atan2 no FPGA

Preciso de computação atan2(x,y)em um FPGA com um fluxo contínuo de dados de entrada / saída. Consegui implementá-lo usando kernels CORDIC desenrolados e em pipeline, mas, para obter a precisão necessária, tive que executar 32 iterações. Isso levou a uma quantidade bastante grande de LUTs dedicadas a essa tarefa. Tentei alterar o fluxo para usar kernels CORDIC parcialmente desenrolados, mas então precisei de uma freqüência de relógio multiplicada para executar loops repetidos, mantendo um fluxo contínuo de entrada / saída. Com isso, eu não consegui encontrar o tempo.

Então agora estou buscando formas alternativas de computação atan2(x,y).

Pensei em usar tabelas de pesquisa de RAM de bloco com interpolação, mas como existem 2 variáveis, eu precisaria de 2 dimensões de tabelas de pesquisa, e isso consome muitos recursos em termos de uso de RAM de bloco.

Pensei então em usar o fato atan2(x,y)relacionado ao atan(x/y)ajuste de quadrante. O problema disso é que ele x/yprecisa de uma verdadeira divisão, já que ynão é uma constante, e as divisões nos FPGAs consomem muitos recursos.

Existem novas maneiras de implementar atan2(x,y)em um FPGA que resultariam em menor uso de LUT, mas ainda assim fornecessem boa precisão?

Você pode usar logaritmos para se livrar da divisão. Para $(x, y)$ no primeiro quadrante:

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

Figura 1. Gráfico de $\text{atan}(2^z)$

Você precisaria aproximar $\text{atan}(2^z)$ no intervalo $-30 < z < 30$ para obter a precisão necessária de 1E-9. Você pode tirar proveito da simetria $\text{atan}(2^{-z}) = \frac{\pi}{2}-\text{atan}(2^z)$ou, alternativamente, garantir que$(x, y)$esteja em um octante conhecido. Para aproximar o$\log_2(a)$ :

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

$b$ pode ser calculado encontrando a localização do bit diferente de zero mais significativo. $c$ pode ser calculado com uma mudança de bit. Você precisaria aproximar o$\log_2(c)$ no intervalo$1 \le c < 2$ .

Figura 2. Gráfico do $\log_2(c)$

Para seus requisitos de precisão, interpolação linear e amostragem uniforme, $2^{14} + 1 = 16385$ amostras do $\log_2(c)$ e $30\times 2^{12} + 1 = 122881$ amostras de $\text{atan}(2^z)$ para $0 < z < 30$ devem ser suficientes. A última tabela é bem grande. Com isso, o erro devido à interpolação depende muito de $z$ :

Figura 3. $\text{atan}(2^z)$ aproxima o maior erro absoluto para diferentes faixas de $z$ (eixo horizontal) para diferentes números de amostras (32 a 8192) por unidade de intervalo de $z$ . O maior erro absoluto para $0 \le z < 1$ (omitido) é ligeiramente menor que para o $\text{floor}(\log_2(z)) = 0$ .

A tabela $\text{atan}(2^z)$ pode ser dividida em várias subtabelas que correspondem a $0 \le z < 1$ e piso diferente ( log 2 ( z ) )$\text{floor}(\log_2(z))$ com $z \ge 1$ , o que é fácil de calcular. Os comprimentos da tabela podem ser escolhidos como guiado pela Fig. 3. O índice dentro da subtabela pode ser calculado por uma simples manipulação de cadeia de bits. Para seus requisitos de precisão, as subtabelas $\text{atan}(2^z)$ terão um total de 29217 amostras se você estender o intervalo de $z$ para $0 \le z < 32$ por simplicidade.

Para referência posterior, aqui está o script Python desajeitado que eu usei para calcular os erros de aproximação:

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])    

O erro máximo local de aproximação de uma função $f(x)$ por interpolação linear f ( x ) a partir de amostras de f ( x ) , feita por amostragem uniforme com intervalo de amostragem Δ x , pode ser aproximada analiticamente por:$\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},$$

onde $f''(x)$ é a segunda derivada de $f(x)$ e $x$ está no máximo local do erro absoluto. Com o exposto, obtemos as aproximações:

$$\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)}.$$

Como as funções são côncavas e as amostras correspondem à função, o erro ocorre sempre em uma direção. O erro absoluto máximo local pode ser reduzido pela metade se o sinal do erro for alternado para frente e para trás uma vez a cada intervalo de amostragem. Com interpolação linear, é possível obter resultados próximos ao ideal pré-filtrando cada tabela com:

$$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}}$$

where $x$ and $y$ are the original and the filtered table both spanning $0 \le k \le N$ and the weights are $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}$. The end conditioning (first and last row in the above equation) reduces error at the ends of the table compared to using samples of the function outside of the table, because the first and the last sample need not be adjusted to reduce the error from interpolation between it and a sample just outside the table. Subtables with different sampling intervals should be prefiltered separately. The values of the weights $c_0, c_1$ were found by minimizing sequentially for increasing exponent $N$ the maximum absolute value of the approximate error:

$$(\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.$$

for inter-sample interpolation positions $0 \le a < 1$, with a concave or convex function $f(x)$ (for example $f(x) = e^x$). With those weights solved, the values of the end conditioning weights $b_0, b_1, b_2$ were found by minimizing similarly the maximum absolute value of:

$$(\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.$$

for $0 \le a < 1$. Use of the prefilter about halves the approximation error and is easier to do than full optimization of the tables.

Figure 4. Approximation error of $\log_2(a)$ from 11 samples, with and without prefilter and with and without end conditioning. Without end conditioning the prefilter has access to values of the function just outside of the table.

This article probably presents a very similar algorithm: R. Gutierrez, V. Torres, and J. Valls, “FPGA-implementation of atan(Y/X) based on logarithmic transformation and LUT-based techniques,” Journal of Systems Architecture, vol. 56, 2010. The abstract says their implementation beats previous CORDIC-based algorithms in speed and LUT-based algorithms in footprint size.