методы вычисления фиксированной точки atan2 на FPGA

Мне нужны вычисления atan2(x,y)на ПЛИС с непрерывным потоком данных ввода / вывода. Мне удалось реализовать это с использованием развернутых конвейерных ядер CORDIC, но для получения необходимой точности мне пришлось выполнить 32 итерации. Это привело к тому, что довольно большое количество LUT было посвящено этой единственной задаче. Я попытался изменить поток для использования частично развернутых ядер CORDIC, но затем мне потребовалась умноженная тактовая частота для выполнения повторяющихся циклов, при этом поддерживая непрерывный поток ввода / вывода. С этим я не смог уложиться в сроки.

Так что теперь я обращаюсь к альтернативным способам вычислений atan2(x,y).

Я думал об использовании таблиц поиска блочной ОЗУ с интерполяцией, но, поскольку есть две переменные, мне потребуются 2 измерения таблиц поиска, и это очень ресурсоемко с точки зрения использования блочной памяти.

Затем я подумал об использовании того факта, который atan2(x,y)связан atan(x/y)с корректировкой квадранта. Проблема заключается в том, что x/yтребуется истинное деление, поскольку yоно не является постоянным, а деления на ПЛИС очень ресурсоемки.

Существуют ли более новые способы реализации atan2(x,y)на ПЛИС, которые позволили бы снизить использование 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)$

Вам потребуется приблизить $\text{atan}(2^z)$ в диапазоне $-30 < z < 30$ чтобы получить требуемую точность 1E-9. Вы можете воспользоваться симметрией $\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$

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

Для дальнейшего использования вот неуклюжий скрипт 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)$$\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)$

В этой статье, вероятно, представлен очень похожий алгоритм: Р. Гутьеррес, В. Торрес и Дж. Вальс, « FPGA-реализация atan (Y / X), основанная на логарифмическом преобразовании и методах, основанных на LUT », Journal of Systems Architecture , vol. , 56, 2010. В аннотации говорится, что их реализация превосходит предыдущие алгоритмы на основе CORDIC по скорости и алгоритмы на основе LUT по размеру занимаемой площади.