วิธีการคำนวณจุดคงที่ at2 บน FPGA

ฉันต้องการคอมพิวเตอร์atan2(x,y)ใน FPGA ที่มีกระแสข้อมูลเข้า / ออกอย่างต่อเนื่อง ฉันจัดการเพื่อใช้มันโดยใช้เมล็ด CORDIC ที่ยังไม่ผ่านการควบคุม แต่เพื่อให้ได้ความแม่นยำที่ฉันต้องการฉันต้องดำเนินการซ้ำ 32 ครั้ง สิ่งนี้นำไปสู่ ​​LUT จำนวนมากที่อุทิศให้กับภารกิจนี้ ฉันพยายามเปลี่ยนโฟลว์เพื่อใช้เมล็ด CORDIC ที่ไม่ได้ควบคุมบางส่วน แต่แล้วฉันต้องการความถี่สัญญาณนาฬิกาคูณเพื่อรันลูปซ้ำ ๆ ในขณะที่ยังคงอินพุต / เอาต์พุตไหลต่อเนื่อง ด้วยสิ่งนี้ฉันไม่สามารถทำตามกำหนดเวลาได้

atan2(x,y)ดังนั้นตอนนี้ฉันกำลังเอื้อมมือออกหาวิธีทางเลือกของการใช้คอมพิวเตอร์

ฉันคิดเกี่ยวกับการใช้ตารางการค้นหา block-RAM พร้อมการแก้ไข แต่เนื่องจากมี 2 ตัวแปรฉันจะต้องใช้ตารางการค้นหา 2 มิติและนี่เป็นทรัพยากรที่ใช้ทรัพยากรมากในแง่ของการใช้งาน block-RAM

ฉันคิดถึงการใช้ความจริงที่atan2(x,y)เกี่ยวข้องatan(x/y)กับการปรับควอดเรน ปัญหาเกี่ยวกับสิ่งนี้คือx/yต้องการการแบ่งที่แท้จริงเนื่องจากyไม่ใช่ค่าคงที่และการแบ่งส่วนบน FPGA นั้นใช้ทรัพยากรอย่างมาก

มีวิธีการใหม่ ๆ ที่จะนำไปใช้atan2(x,y)กับ FPGA ที่จะส่งผลให้การใช้ 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$$\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$

สำหรับการอ้างอิงในภายหลังนี่คือสคริปต์ Python clunky ที่ฉันใช้ในการคำนวณข้อผิดพลาดโดยประมาณ:

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

โดยที่และเป็นต้นฉบับและตารางที่กรองแล้วทั้งสองทอดและน้ำหนักเป็น{16} การปรับสภาพท้าย (แถวแรกและแถวสุดท้ายในสมการข้างต้น) ลดข้อผิดพลาดที่ปลายตารางเมื่อเทียบกับการใช้ตัวอย่างของฟังก์ชันนอกตารางเนื่องจากไม่จำเป็นต้องปรับตัวอย่างแรกและตัวอย่างสุดท้ายเพื่อลดข้อผิดพลาดจากการแก้ไข ระหว่างมันและตัวอย่างอยู่นอกตาราง ตารางย่อยที่มีช่วงการสุ่มตัวอย่างที่แตกต่างกันควรทำการกรองแยกต่างหากล่วงหน้า ค่าของน้ำหนักถูกพบโดยย่อให้เล็กที่สุดเพื่อเพิ่มเลขชี้กำลัง$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.$$

สำหรับ<1 การใช้ prefilter เกี่ยวกับข้อผิดพลาดประมาณครึ่งและง่ายกว่าการทำตารางให้สมบูรณ์$0 \le a < 1$

รูปที่ 4. ข้อผิดพลาดการประมาณของจาก 11 ตัวอย่างที่มีและไม่มีตัวกรองล่วงหน้าและมีและไม่มีการปรับสภาพสิ้นสุด prefilter มีการเข้าถึงค่าของฟังก์ชั่นนอกตาราง$\log_2(a)$

บทความนี้น่าจะนำเสนอขั้นตอนวิธีการที่คล้ายกันมาก: อาร์เตียร์เรสโวลต์และเจ Valls“ FPGA-การดำเนินงานของ Atan (Y / X) ตามการเปลี่ยนแปลงลอการิทึมและเทคนิค LUT ตาม ” วารสารสถาปัตยกรรมระบบฉบับ . 56, 2010 บทคัดย่อกล่าวว่าการติดตั้งของพวกเขาเต้นตามอัลกอริธึมที่ใช้ CORDIC ก่อนหน้านี้ในด้านความเร็วและอัลกอริธึมที่ใช้ LUT ในขนาดรอยเท้า