métodos de cálculo de punto fijo atan2 en FPGA

Necesito computar atan2(x,y)en un FPGA con un flujo continuo de datos de entrada / salida. Logré implementarlo usando núcleos CORDIC enrollados y canalizados, pero para obtener la precisión que necesitaba, tuve que realizar 32 iteraciones. Esto llevó a que se dedicara una gran cantidad de LUT a esta tarea. Intenté cambiar el flujo para usar núcleos CORDIC parcialmente desenrollados, pero luego necesitaba una frecuencia de reloj multiplicada para ejecutar bucles repetidos mientras mantenía un flujo continuo de entrada / salida. Con esto, no pude cumplir con el tiempo.

Así que ahora estoy buscando formas alternativas de computación atan2(x,y).

Pensé en usar tablas de búsqueda de RAM en bloque con interpolación, pero dado que hay 2 variables, necesitaría 2 dimensiones de las tablas de búsqueda, y esto requiere muchos recursos en términos de uso de RAM en bloque.

Luego pensé en usar el hecho que atan2(x,y)está relacionado atan(x/y)con el ajuste del cuadrante. El problema con esto es que x/ynecesita una verdadera división ya yque no es una constante, y las divisiones en FPGAs requieren muchos recursos.

¿Hay más formas novedosas de implementar atan2(x,y)en un FPGA que resulten en un menor uso de LUT, pero que aún así proporcionen una buena precisión?

Puedes usar logaritmos para deshacerte de la división. Para $(x, y)$ en el primer cuadrante:

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

Figura 1. Parcela de $\text{atan}(2^z)$

$\text{atan}(2^z)$ aproximar atan ( 2 z ) en el rango $-30 < z < 30$ para obtener la precisión requerida de 1E-9. Puede aprovechar la simetría $\text{atan}(2^{-z}) = \frac{\pi}{2}-\text{atan}(2^z)$o alternativamente asegúrese de que$(x, y)$esté en un octante conocido. Para aproximar el$\log_2(a)$:

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

$b$ se puede calcular encontrando la ubicación del bit distinto de cero más significativo. $c$ puede calcularse mediante un cambio de bit. Debería aproximar el$\log_2(c)$ en el rango$1 \le c < 2$ .

Figura 2. Gráfico del $\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$

Para referencia posterior, aquí está el script torpe de Python que usé para calcular los errores de aproximación:

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

donde es la segunda derivada de y está en un máximo local del error absoluto. Con lo anterior obtenemos las aproximaciones:$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)}.$$

Debido a que las funciones son cóncavas y las muestras coinciden con la función, el error siempre es en una dirección. El error absoluto máximo local podría reducirse a la mitad si el signo del error se alternara una y otra vez cada intervalo de muestreo. Con la interpolación lineal, se pueden lograr resultados casi óptimos filtrando previamente cada tabla de la siguiente manera:

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

donde e son la tabla original y la filtrada que abarcan y los pesos son . El acondicionamiento final (primera y última fila en la ecuación anterior) reduce el error en los extremos de la tabla en comparación con el uso de muestras de la función fuera de la tabla, porque la primera y la última muestra no necesitan ajustarse para reducir el error de la interpolación entre él y una muestra justo afuera de la mesa. Las subtablas con diferentes intervalos de muestreo deben prefiltrarse por separado. Los valores de los pesos se encontraron minimizando secuencialmente para aumentar el exponente$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$ El valor absoluto máximo del error aproximado:

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

para las posiciones de interpolación entre muestras , con una función cóncava o convexa (por ejemplo ). Con esos pesos resueltos, los valores de los pesos de acondicionamiento final se encontraron minimizando de manera similar el valor absoluto máximo 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.$$

para . El uso del prefiltro acerca de la mitad del error de aproximación y es más fácil de hacer que la optimización completa de las tablas.$0 \le a < 1$

Figura 4. Error de aproximación de de 11 muestras, con y sin prefiltro y con y sin acondicionamiento final. Sin el acondicionamiento final, el prefiltro tiene acceso a los valores de la función justo fuera de la tabla.$\log_2(a)$

Este artículo probablemente presenta un algoritmo muy similar: R. Gutiérrez, V. Torres y J. Valls, " Implementación FPGA de atan (Y / X) basada en transformación logarítmica y técnicas basadas en LUT " , Journal of Systems Architecture , vol . 56, 2010. El resumen dice que su implementación supera los algoritmos anteriores basados ​​en CORDIC en velocidad y los algoritmos basados ​​en LUT en tamaño de huella.