FPGA üzerinde sabit nokta atan2 hesaplama yöntemleri

atan2(x,y)Sürekli giriş / çıkış veri akışına sahip bir FPGA üzerinde hesaplama yapmaya ihtiyacım var . Açılmamış, boru hatlı CORDIC çekirdekleri kullanarak uygulamayı başardım, ancak ihtiyacım olan doğruluğu elde etmek için 32 yineleme yapmak zorunda kaldım. Bu, oldukça büyük miktarda LUT'un bu tek göreve adanmasına yol açtı. Kısmen açılmamış CORDIC çekirdeklerini kullanmak için akışı değiştirmeyi denedim, ancak daha sonra sürekli bir giriş / çıkış akışını korurken tekrarlanan döngüler gerçekleştirmek için çarpılmış bir saat frekansına ihtiyacım vardı. Bununla zamanlamayı karşılayamadım.

Şimdi alternatif bilgi işlem yollarına ulaşıyorum atan2(x,y).

İnterpolasyon ile blok-RAM arama tablolarını kullanmayı düşündüm, ancak 2 değişken olduğundan arama tablolarının 2 boyutuna ihtiyacım olacaktı ve bu blok-RAM kullanımı açısından çok kaynak yoğun.

Daha sonra kadran ayarlamasıyla atan2(x,y)ilgili gerçeği kullanmayı düşündüm atan(x/y). Buradaki sorun, sabit olmadığı için x/ygerçek bir bölünmeye ihtiyaç duyması yve FPGA'larda bölünmeler çok kaynak yoğun.

atan2(x,y)Bir FPGA üzerinde uygulamanın , daha düşük LUT kullanımına neden olacak, ancak yine de iyi bir doğruluk sağlayan daha yeni yolları var mı?

Bölme işleminden kurtulmak için logaritma kullanabilirsiniz. İçin $(x, y)$ birinci kadran:

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

Şekil 1. $\text{atan}(2^z)$

Sen yaklaşık gerekir $\text{atan}(2^z)$ aralığında $-30 < z < 30$ 1E-9'un sizin gerekli doğruluğu almak için. Atanmış simetriden yararlanabilirsiniz ( 2 - z ) = π$\text{atan}(2^{-z}) = \frac{\pi}{2}-\text{atan}(2^z)$veya alternatif olarak$(x, y)$nin bilinen bir oktantta olduğundan emin olun. $\log_2(a)$yaklaşmak için:

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

$b$ , en anlamlı sıfır olmayan bitin yerini bularak hesaplanabilir. $c$ , bir bit kaydırma ile hesaplanabilir. 1 ≤ c < 2 aralığında$\log_2(c)$ ye yaklaşmanız gerekir.$1 \le c < 2$

Şekil 2. Log 2 ( c ) ' nin $\log_2(c)$

Doğruluk gereksinimleriniz için, doğrusal enterpolasyon ve düzgün örnekleme için, 0 < z < 30 için $2^{14} + 1 = 16385$$\log_2(c)$ örnekleri ve $30\times 2^{12} + 1 = 122881$$\text{atan}(2^z)$ örnekleri yeterli olmalıdır. İkinci tablo oldukça büyük. Bununla birlikte, enterpolasyondan kaynaklanan hata büyük ölçüde z'ye bağlıdır :$0 < z < 30$$z$

Şekil 3. $\text{atan}(2^z)$ farklı aralıklarını yaklaşım büyük mutlak hata $z$ birim aralığı başına örneklerin farklı sayıda (8192 32) için (yatay eksen) $z$ . $0 \le z < 1$ (atlanmış) için en büyük mutlak hata, $\text{floor}(\log_2(z)) = 0$ biraz daha azdır ( log 2 ( z ) ) = 0 .

$\text{atan}(2^z)$ Tablo tekabül için birden çok subtables yarık olabilir $0 \le z < 1$ ve farklı $\text{floor}(\log_2(z))$ ile $z \ge 1$ hesaplamak kolaydır. Tablo uzunlukları, Şekil 3'te gösterildiği gibi seçilebilir. İç-alt indeks, basit bir bit dizisi manipülasyonu ile hesaplanabilir. Senin doğruluk gereksinimleri için $\text{atan}(2^z)$ Eğer aralığını uzatmak eğer subtables 29217 numunelerin toplam sahip olacak $z$ için ≤$0 \le z < 32$basitlik için z < 32 .

Daha sonra başvurmak için, yaklaşık hataları hesaplamak için kullandığım hantal Python betiği:

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

Bir fonksiyon yaklaşan yerel maksimum hata $f(x)$ lineer interpolasyon ile f ( x ) numunelerinden f ( x ) , ara örnekleme ile homojen numune alınan Δ X ile analitik olarak yaklaşık olarak hesaplanabilir:$\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},$$

burada , in ikinci türevidir ve , mutlak hatanın yerel maksimumundadır. Yukarıdakilerle yaklaşık değerleri elde ederiz:$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)}.$$

İşlevler içbükey ve örnekler işlevle eşleştiğinden, hata her zaman bir yöndedir. Hatanın işareti her örnekleme aralığında bir kez ileri geri değişmek için yapılırsa, yerel maksimum mutlak hata yarıya indirilebilir. Doğrusal enterpolasyon ile, her tablonun önceden filtrelenmesiyle optimum sonuçlara yakın olarak elde edilebilir:

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

burada ve orijinaldir ve filtrelenmiş tablo hem hem de ağırlıkları . Uç koşullandırma (yukarıdaki denklemdeki ilk ve son satır), tablonun dışındaki fonksiyon örneklerine kıyasla tablonun uçlarındaki hatayı azaltır, çünkü ilk ve son örneğin enterpolasyondan kaynaklanan hatayı azaltmak için ayarlanması gerekmez ve masanın hemen dışındaki bir örnek arasında. Farklı örnekleme aralıklarına sahip alt tablolar ayrı olarak önceden filtrelenmelidir. ağırlıklarının değerleri, üs arttırmak için sırayla en aza bulundu$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$ yaklaşık hatanın maksimum mutlak değeri:

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

örnekler arası enterpolasyon pozisyonları için , içbükey veya dışbükey fonksiyon (örneğin ). Çözülen bu ağırlıklar ile, uç koşullandırma ağırlıklarının maksimum mutlak değerini en aza indirerek bulundu:$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.$$

için . Yaklaşık ön filtrenin kullanılması yaklaşıklık hatasını yarıya indirir ve tabloların tam optimizasyonundan daha kolaydır.$0 \le a < 1$

Şekil 4. 11 numuneden 'nın ön ve filtresiz ve son şartlandırmasız ve sonlandırmasız yaklaşım hatası . Uç koşullandırma olmadan ön filtre, tablonun hemen dışındaki işlevin değerlerine erişebilir.$\log_2(a)$

Bu makale muhtemelen çok benzer bir algoritma sunmaktadır: R. Gutierrez, V. Torres ve J. Valls, “ atanan (Y / X) logaritmik dönüşüm ve LUT tabanlı tekniklere dayalı FPGA uygulaması, ” Journal of Systems Architecture , cilt . Özet, uygulamalarının hızda önceki CORDIC tabanlı algoritmaları ve ayak izi boyutunda LUT tabanlı algoritmaları geçtiğini söylüyor.