méthodes de calcul du point fixe atan2 sur FPGA

J'ai besoin de calculer atan2(x,y)sur un FPGA avec un flux continu de données d'entrée / sortie. J'ai réussi à l'implémenter à l'aide de noyaux CORDIC déroulés et pipelinés, mais pour obtenir la précision dont j'avais besoin, j'ai dû effectuer 32 itérations. Cela a conduit à consacrer une assez grande quantité de LUT à cette seule tâche. J'ai essayé de changer le flux pour utiliser des noyaux CORDIC partiellement déroulés, mais j'avais ensuite besoin d'une fréquence d'horloge multipliée pour exécuter des boucles répétées tout en maintenant un flux d'entrée / sortie continu. Avec cela, je ne pouvais pas respecter le calendrier.

Alors maintenant, je cherche des moyens de calcul alternatifs atan2(x,y).

J'ai pensé à utiliser des tables de recherche de bloc-RAM avec interpolation, mais comme il y a 2 variables, j'aurais besoin de 2 dimensions de tables de recherche, ce qui nécessite beaucoup de ressources en termes d'utilisation de bloc-RAM.

J'ai alors pensé à utiliser le fait atan2(x,y)lié à l' atan(x/y)ajustement quadrant. Le problème avec cela est qu'il a x/ybesoin d'une vraie division car ce yn'est pas une constante, et les divisions sur les FPGA sont très gourmandes en ressources.

Existe-t-il d'autres façons nouvelles d'implémenter atan2(x,y)sur un FPGA qui entraîneraient une utilisation moindre des LUT, mais fourniraient toujours une bonne précision?

Vous pouvez utiliser des logarithmes pour vous débarrasser de la division. Pour $(x, y)$ dans le premier quadrant:

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

Figure 1. Diagramme d' $\text{atan}(2^z)$

Vous auriez besoin d'approximativement un $\text{atan}(2^z)$ dans la plage $-30 < z < 30$ pour obtenir la précision requise de 1E-9. Vous pouvez profiter de la symétrie $\text{atan}(2^{-z}) = \frac{\pi}{2}-\text{atan}(2^z)$ou bien assurez-vous que$(x, y)$est dans un octant connu. Pour approximer le$\log_2(a)$:

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

$b$ peut être calculé en trouvant l'emplacement du bit non nul le plus significatif. $c$ peut être calculé par un décalage de bits. Vous devez approximer$\log_2(c)$ dans la plage$1 \le c < 2$ .

Figure 2. Diagramme du $\log_2(c)$

$2^{14} + 1 = 16385$$\log_2(c)$$30\times 2^{12} + 1 = 122881$$\text{atan}(2^z)$$0 < z < 30$$z$

$\text{atan}(2^z)$$z$$z$$0 \le z < 1$$\text{floor}(\log_2(z)) = 0$

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

Pour référence ultérieure, voici le script Python maladroit que j'ai utilisé pour calculer les erreurs d'approximation:

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

où est la dérivée seconde de et est à un maximum local de l'erreur absolue. Avec ce qui précède, nous obtenons les approximations:$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)}.$$

Étant donné que les fonctions sont concaves et que les échantillons correspondent à la fonction, l'erreur se produit toujours dans une direction. L'erreur absolue maximale locale pourrait être réduite de moitié si le signe de l'erreur était alterné d'avant en arrière une fois à chaque intervalle d'échantillonnage. Avec une interpolation linéaire, des résultats proches de l'optimisation peuvent être obtenus en préfiltrant chaque table en:

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

où et sont l'original et la table filtrée s'étendant sur et les poids sont . Le conditionnement final (première et dernière ligne de l'équation ci-dessus) réduit l'erreur aux extrémités du tableau par rapport à l'utilisation d'échantillons de la fonction en dehors du tableau, car le premier et le dernier échantillon n'ont pas besoin d'être ajustés pour réduire l'erreur d'interpolation entre elle et un échantillon juste à l'extérieur de la table. Les sous-tables avec différents intervalles d'échantillonnage doivent être préfiltrées séparément. Les valeurs des poids ont été trouvées en minimisant séquentiellement pour augmenter l'exposant$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$ la valeur absolue maximale de l'erreur approximative:

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

pour les positions d'interpolation entre échantillons , avec une fonction concave ou convexe (par exemple ). Une fois ces poids résolus, les valeurs des poids de conditionnement d'extrémité ont été trouvées en minimisant de manière similaire la valeur absolue maximale de:$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.$$

pour . L'utilisation du préfiltre réduit de moitié l'erreur d'approximation et est plus facile à faire que l'optimisation complète des tableaux.$0 \le a < 1$

Figure 4. Erreur d'approximation de partir de 11 échantillons, avec et sans préfiltre et avec et sans conditionnement d'extrémité. Sans conditionnement final, le préfiltre a accès aux valeurs de la fonction juste à l'extérieur du tableau.$\log_2(a)$

Cet article présente probablement un algorithme très similaire: R. Gutierrez, V. Torres et J. Valls, « FPGA-implementation of atan (Y / X) based on logarithmic transformation and LUT-based techniques », Journal of Systems Architecture , vol . 56, 2010. Le résumé indique que leur mise en œuvre bat les précédents algorithmes basés sur CORDIC en vitesse et les algorithmes basés sur LUT en taille d'encombrement.