metodi di calcolo in virgola fissa atan2 su FPGA

Ho bisogno di elaborare atan2(x,y)un FPGA con un flusso continuo di dati di input / output. Sono riuscito a implementarlo usando kernel CORDIC srotolati e pipeline, ma per ottenere l'accuratezza di cui ho bisogno ho dovuto eseguire 32 iterazioni. Ciò ha portato a un numero piuttosto elevato di LUT dedicati a questo compito. Ho provato a cambiare il flusso per usare i kernel CORDIC parzialmente srotolati, ma poi avevo bisogno di una frequenza di clock moltiplicata per eseguire loop ripetuti mantenendo comunque un flusso di input / output continuo. Con questo, non sono riuscito a rispettare i tempi.

Quindi ora sto cercando modi alternativi di elaborazione atan2(x,y).

Ho pensato di utilizzare le tabelle di ricerca della RAM a blocchi con interpolazione, ma dato che ci sono 2 variabili avrei bisogno di 2 dimensioni delle tabelle di ricerca, e questo richiede molte risorse in termini di utilizzo della RAM a blocchi.

Ho quindi pensato di utilizzare il fatto atan2(x,y)relativo alla atan(x/y)regolazione del quadrante. Il problema con questo è che ha x/ybisogno di una vera divisione poiché ynon è una costante e le divisioni sugli FPGA richiedono molta risorse.

Esistono altri modi nuovi di implementare atan2(x,y)su un FPGA che porterebbe a un minore utilizzo di LUT, ma che comunque forniscono una buona precisione?

Puoi usare i logaritmi per sbarazzarti della divisione. Per nel primo quadrante:$(x, y)$

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

Figura 1. Grafico di$\text{atan}(2^z)$

Dovresti approssimare nell'intervallo per ottenere la precisione richiesta di 1E-9. Puoi sfruttare la simmetria o in alternativa assicurarti che è in un ottante noto. Per approssimare :$\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$ può essere calcolato trovando la posizione del bit diverso da zero più significativo. può essere calcolato con un bit shift. Dovresti approssimare nell'intervallo .$c$$\log_2(c)$$1 \le c < 2$

Figura 2. Grafico di$\log_2(c)$

Per i requisiti di precisione, interpolazione lineare e campionamento uniforme, campioni di e campioni di per dovrebbe essere sufficiente. Quest'ultimo tavolo è piuttosto grande. Con esso, l'errore dovuto all'interpolazione dipende molto da :$2^{14} + 1 = 16385$$\log_2(c)$$30\times 2^{12} + 1 = 122881$$\text{atan}(2^z)$$0 < z < 30$$z$

Figura 3. Errore assoluto maggiore approssimazione approssimazione per diversi intervalli di (asse orizzontale) per diversi numeri di campioni (da 32 a 8192) per intervallo di unità di . L'errore assoluto più grande per (omesso) è leggermente inferiore rispetto a .$\text{atan}(2^z)$$z$$z$$0 \le z < 1$$\text{floor}(\log_2(z)) = 0$

La tabella può essere suddivisa in più sottotitoli che corrispondono a e diversi con , che è facile calcolare. Le lunghezze della tabella possono essere scelte come guidato dalla Fig. 3. L'indice all'interno della sottotabella può essere calcolato con una semplice manipolazione della stringa di bit. Per i requisiti di precisione, i avranno un totale di 29217 campioni se si estende l'intervallo di a per semplicità.$\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$

Per riferimento futuro, ecco il grosso script di Python che ho usato per calcolare gli errori di approssimazione:

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

L'errore massimo locale derivante dall'approssimazione di una funzione mediante l'interpolazione lineare di da campioni di , prelevati mediante campionamento uniforme con intervallo di campionamento , può essere approssimato analiticamente mediante:$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},$$

dove è la seconda derivata di e è al massimo locale dell'errore assoluto. Con quanto sopra otteniamo le approssimazioni:$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)}.$$

Poiché le funzioni sono concava e i campioni corrispondono alla funzione, l'errore è sempre in una direzione. L'errore assoluto massimo locale potrebbe essere dimezzato se il segno dell'errore fosse fatto alternare avanti e indietro una volta ogni intervallo di campionamento. Con l'interpolazione lineare, è possibile raggiungere risultati ottimali prefiltrando ogni tabella mediante:

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

dove ed sono l'originale e la tabella filtrata sia attraversa ei pesi sono . Il condizionamento finale (prima e ultima riga dell'equazione precedente) riduce l'errore alle estremità della tabella rispetto all'utilizzo di campioni della funzione all'esterno della tabella, poiché non è necessario regolare il primo e l'ultimo campione per ridurre l'errore di interpolazione tra esso e un campione appena fuori dal tavolo. Sottotitoli con intervalli di campionamento diversi devono essere pre-filtrati separatamente. I valori dei pesi sono stati trovati minimizzando in sequenza per aumentare l'esponente$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$ il valore assoluto massimo dell'errore approssimativo:

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

per le posizioni di interpolazione tra campioni , con una funzione concava o convessa (ad esempio ). i pesi, i valori dei pesi di condizionamento finale sono stati trovati minimizzando allo stesso modo il valore assoluto massimo di:$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.$$

per . L'uso del prefiltro dimezza l'errore di approssimazione ed è più semplice da eseguire rispetto all'ottimizzazione completa delle tabelle.$0 \le a < 1$

Figura 4. Errore di approssimazione di da 11 campioni, con e senza prefiltro e con e senza condizionamento finale. Senza il condizionamento finale il prefiltro ha accesso ai valori della funzione appena fuori dalla tabella.$\log_2(a)$

Questo articolo presenta probabilmente un algoritmo molto simile: R. Gutierrez, V. Torres e J. Valls, " Implementazione FPGA di atan (Y / X) basata sulla trasformazione logaritmica e tecniche basate su LUT " , Journal of Systems Architecture , vol . 56, 2010. L'abstract afferma che la loro implementazione supera i precedenti algoritmi basati su CORDIC in termini di velocità e algoritmi basati su LUT in termini di dimensioni dell'impronta.