FPGA에서 고정 소수점 atan2를 계산하는 방법

atan2(x,y)지속적인 입 / 출력 데이터 스트림을 사용하여 FPGA 에서 컴퓨팅해야 합니다. 롤링되지 않은 파이프 라인 된 CORDIC 커널을 사용하여 구현했지만 필요한 정확도를 얻으려면 32 번의 반복을 수행해야했습니다. 이로 인해 많은 양의 LUT가이 하나의 작업에 전념하게되었습니다. 부분적으로 롤링되지 않은 CORDIC 커널을 사용하도록 흐름을 변경하려고 시도했지만 계속적인 입력 / 출력 흐름을 유지하면서 반복 루프를 실행하기 위해 곱해진 클럭 주파수가 필요했습니다. 이것으로 타이밍을 맞출 수 없었습니다.

그래서 지금은 다른 컴퓨팅 방법을 찾고 atan2(x,y)있습니다.

보간과 함께 블록 RAM 조회 테이블을 사용하는 것에 대해 생각했지만 2 개의 변수가 있으므로 2 차원의 조회 테이블이 필요하며 이는 블록 RAM 사용 측면에서 리소스를 많이 사용합니다.

그런 다음 사분면 조정과 atan2(x,y)관련된 사실을 사용하는 것에 대해 생각했습니다 atan(x/y). 이것에 대한 문제 는 상수가 아니기 x/y때문에 진정한 분할 이 필요하며 yFPGA의 분할은 매우 자원 집약적이라는 것입니다.

더 atan2(x,y)낮은 LUT 사용을 초래하지만 여전히 우수한 정확도를 제공하는 FPGA 에 구현할 수있는 더 새로운 방법이 있습니까?

로그를 사용하여 나누기를 제거 할 수 있습니다. 옵션 $(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$$\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$

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

나중에 참조 할 수 있도록 근사 오류를 계산하는 데 사용 된 이상한 파이썬 스크립트는 다음과 같습니다.

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

여기서 는 의 2 차 미분 이고 는 절대 오차의 극대값입니다. 위와 같이 근사값을 얻습니다.$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)$

이 문서는 아마 매우 유사한 알고리즘을 제공한다 : R. 레즈, V. 토레스 및 J. 발스 '를 ATAN의 FPGA - 구현 (Y / X), 대수 변환 및 LUT 기반의 기술에 기초하여, " 시스템 아키텍처 저널 , 권 . 초록은 그들의 구현이 이전의 CORDIC 기반 알고리즘 속도보다 빠르며 LUT 기반 알고리즘은 풋 프린트 크기보다 뛰어납니다.