Вы можете использовать логарифмы, чтобы избавиться от деления. Для (x,y) в первом квадранте:
z=log2(y)−log2(x)atan2(y,x)=atan(y/x)=atan(2z)
![Atan (2 ^ г)](https://i.stack.imgur.com/clsf0.png)
Рисунок 1. Участок atan(2z)
Вам потребуется приблизить atan(2z) в диапазоне −30<z<30 чтобы получить требуемую точность 1E-9. Вы можете воспользоваться симметрией atan(2−z)=π2−atan(2z)или, альтернативно, убедитесь, что(x,y)находится в известном октанте. Для приблизительногоlog2(a):
b=floor(log2(a))c=a2blog2(a)=b+log2(c)
b можно рассчитать путем нахождения местоположения старшего значащего ненулевого бита. c может быть рассчитан по сдвигу битов. Вам нужно будет приблизитьlog2(c) в диапазоне1≤c<2 .
![log2 (с)](https://i.stack.imgur.com/GFg87.png)
Рисунок 2. Участок log2(c)
214+1=16385log2(c)30×212+1=122881atan(2z)0<z<30z
![Ошибка приближения atan (2 ^ z)](https://i.stack.imgur.com/efVAz.png)
atan(2z)zz0≤z<1floor(log2(z))=0
atan(2z)0≤z<1floor(log2(z))z≥1atan(2z)z0≤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)f^(x)f(x)Δx
fˆ(x)−f(x)≈(Δx)2limΔx→0f(x)+f(x+Δx)2−f(x+Δx2)(Δx)2=(Δx)2f′′(x)8,
где - вторая производная от а - локальный максимум абсолютной ошибки. С учетом вышеизложенного мы получаем приближения:f′′(x)f(x)x
atanˆ(2z)−atan(2z)≈(Δz)22z(1−4z)ln(2)28(4z+1)2,log2ˆ(a)−log2(a)≈−(Δa)28a2ln(2).
Поскольку функции являются вогнутыми и выборки соответствуют функции, ошибка всегда имеет одно направление. Локальная максимальная абсолютная ошибка может быть уменьшена вдвое, если признак ошибки будет чередоваться назад и вперед один раз в каждом интервале выборки. При линейной интерполяции можно достичь близких к оптимальным результатов, предварительно отфильтровав каждую таблицу:
y[k]=⎧⎩⎨⎪⎪b2x[k−2]c1x[k−1]+b1x[k−1]b0x[k]+c0x[k]+b0x[k]+b1x[k+1]+c1x[k+1]+b2x[k+2]if k=0,if 0<k<N,if k=N,
где и являются исходной и отфильтрованной таблицами, охватывающими а весами являются . Конечная обработка (первая и последняя строка в приведенном выше уравнении) уменьшает погрешность на концах таблицы по сравнению с использованием выборок функции за пределами таблицы, поскольку нет необходимости корректировать первую и последнюю выборку, чтобы уменьшить ошибку от интерполяции между ним и образцом прямо за столом. Субтаблицы с разными интервалами выборки должны предварительно фильтроваться отдельно. Значения весов были найдены путем минимизации последовательно для увеличения показателяxy0≤k≤Nc0=98,c1=−116,b0=1516,b1=18,b2=−116c0,c1N максимальное абсолютное значение приблизительной погрешности:
(Δx)NlimΔx→0(c1f(x−Δx)+c0f(x)+c1f(x+Δx))(1−a)+(c1f(x)+c0f(x+Δx)+c1f(x+2Δx))a−f(x+aΔx)(Δx)N=⎧⎩⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪(c0+2c1−1)f(x)01+a−a2−c02(Δx)2f′′(x)if N=0,∣∣∣c1=1−c02if N=1,if N=2,∣∣∣c0=98
для интерполяционных позиций между выборками , с вогнутой или выпуклой функцией (например, ). После того, как эти весовые коэффициенты были решены, значения конечных весовых коэффициентов были найдены путем минимизации аналогичным образом максимального абсолютного значения:0≤a<1f(x)f(x)=exb0,b1,b2
(Δx)NlimΔx→0(b0f(x)+b1f(x+Δx)+b2f(x+2Δx))(1−a)+(c1f(x)+c0f(x+Δx)+c1f(x+2Δx))a−f(x+aΔx)(Δx)N=⎧⎩⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪(b0+b1+b2−1+a(1−b0−b1−b2))f(x)(a−1)(2b0+b1−2)Δxf′(x)(−12a2+(2316−b0)a+b0−1)(Δx)2f′′(x)if N=0,∣∣∣b2=1−b0−b1if N=1,∣∣∣b1=2−2b0if N=2,∣∣∣b0=1516
для . Использование предварительного фильтра примерно вдвое уменьшает ошибку аппроксимации, и это проще сделать, чем полная оптимизация таблиц.0≤a<1
![Ошибка аппроксимации с предварительным фильтром и без него](https://i.stack.imgur.com/pD3Fu.png)
Рис. 4. Ошибка аппроксимации 11 образцов с предварительным фильтром и без него, а также с конечной обработкой и без нее. Без предварительной обработки префильтр имеет доступ к значениям функции только за пределами таблицы.log2(a)
В этой статье, вероятно, представлен очень похожий алгоритм: Р. Гутьеррес, В. Торрес и Дж. Вальс, « FPGA-реализация atan (Y / X), основанная на логарифмическом преобразовании и методах, основанных на LUT », Journal of Systems Architecture , vol. , 56, 2010. В аннотации говорится, что их реализация превосходит предыдущие алгоритмы на основе CORDIC по скорости и алгоритмы на основе LUT по размеру занимаемой площади.