Révision 300 ETSN/MyDFT_10.py
| MyDFT_10.py (revision 300) | ||
|---|---|---|
| 71 | 71 |
Y=np.zeros(size).astype(np.float32) |
| 72 | 72 |
for i in range(size): |
| 73 | 73 |
for j in range(size): |
| 74 |
X[i]=X[i]+x[j]*cos(2.*pi*i*j/size)-y[j]*sin(2.*pi*i*j/size)
|
|
| 75 |
Y[i]=Y[i]+x[j]*sin(2.*pi*i*j/size)+y[j]*cos(2.*pi*i*j/size)
|
|
| 74 |
X[i]=X[i]+x[j]*cos(2.*pi*i*j/size)+y[j]*sin(2.*pi*i*j/size)
|
|
| 75 |
Y[i]=Y[i]-x[j]*sin(2.*pi*i*j/size)+y[j]*cos(2.*pi*i*j/size)
|
|
| 76 | 76 |
return(X,Y) |
| 77 | 77 |
|
| 78 | 78 |
# Numpy Discrete Fourier Transform |
| ... | ... | |
| 82 | 82 |
Y=np.zeros(size).astype(np.float32) |
| 83 | 83 |
nj=np.multiply(2.0*np.pi/size,np.arange(size)).astype(np.float32) |
| 84 | 84 |
for i in range(size): |
| 85 |
X[i]=np.sum(np.subtract(np.multiply(np.cos(i*nj),x),np.multiply(np.sin(i*nj),y)))
|
|
| 86 |
Y[i]=np.sum(np.add(np.multiply(np.sin(i*nj),x),np.multiply(np.cos(i*nj),y)))
|
|
| 85 |
X[i]=np.sum(np.add(np.multiply(np.cos(i*nj),x),np.multiply(np.sin(i*nj),y)))
|
|
| 86 |
Y[i]=np.sum(-np.subtract(np.multiply(np.sin(i*nj),x),np.multiply(np.cos(i*nj),y)))
|
|
| 87 | 87 |
return(X,Y) |
| 88 | 88 |
|
| 89 | 89 |
# Numba Discrete Fourier Transform |
| ... | ... | |
| 95 | 95 |
Y=np.zeros(size).astype(np.float32) |
| 96 | 96 |
nj=np.multiply(2.0*np.pi/size,np.arange(size)).astype(np.float32) |
| 97 | 97 |
for i in numba.prange(size): |
| 98 |
X[i]=np.sum(np.subtract(np.multiply(np.cos(i*nj),x),np.multiply(np.sin(i*nj),y)))
|
|
| 99 |
Y[i]=np.sum(np.add(np.multiply(np.sin(i*nj),x),np.multiply(np.cos(i*nj),y)))
|
|
| 98 |
X[i]=np.sum(np.add(np.multiply(np.cos(i*nj),x),np.multiply(np.sin(i*nj),y)))
|
|
| 99 |
Y[i]=np.sum(-np.subtract(np.multiply(np.sin(i*nj),x),np.multiply(np.cos(i*nj),y)))
|
|
| 100 | 100 |
return(X,Y) |
| 101 | 101 |
|
| 102 | 102 |
# OpenCL complete operation |
| ... | ... | |
| 145 | 145 |
float A=0.,B=0.; |
| 146 | 146 |
for (uint i=0; i<size;i++) |
| 147 | 147 |
{
|
| 148 |
A+=a_g[i]*cos(2.*PI*(float)(gid*i)/(float)size)-b_g[i]*sin(2.*PI*(float)(gid*i)/(float)size);
|
|
| 149 |
B+=a_g[i]*sin(2.*PI*(float)(gid*i)/(float)size)+b_g[i]*cos(2.*PI*(float)(gid*i)/(float)size); |
|
| 148 |
A+=a_g[i]*cos(2.*PI*(float)(gid*i)/(float)size)+b_g[i]*sin(2.*PI*(float)(gid*i)/(float)size);
|
|
| 149 |
B+=-a_g[i]*sin(2.*PI*(float)(gid*i)/(float)size)+b_g[i]*cos(2.*PI*(float)(gid*i)/(float)size);
|
|
| 150 | 150 |
} |
| 151 | 151 |
A_g[gid]=A; |
| 152 | 152 |
B_g[gid]=B; |
| ... | ... | |
| 231 | 231 |
float A=0.,B=0.; |
| 232 | 232 |
for (uint i=0; i<size;i++) |
| 233 | 233 |
{
|
| 234 |
A+=a_g[i]*cos(2.*PI*(float)(gid*i)/(float)size)-b_g[i]*sin(2.*PI*(float)(gid*i)/(float)size);
|
|
| 235 |
B+=a_g[i]*sin(2.*PI*(float)(gid*i)/(float)size)+b_g[i]*cos(2.*PI*(float)(gid*i)/(float)size); |
|
| 234 |
A+=a_g[i]*cos(2.*PI*(float)(gid*i)/(float)size)+b_g[i]*sin(2.*PI*(float)(gid*i)/(float)size);
|
|
| 235 |
B+=-a_g[i]*sin(2.*PI*(float)(gid*i)/(float)size)+b_g[i]*cos(2.*PI*(float)(gid*i)/(float)size);
|
|
| 236 | 236 |
} |
| 237 | 237 |
A_g[gid]=A; |
| 238 | 238 |
B_g[gid]=B; |
| ... | ... | |
| 283 | 283 |
Device=0 |
| 284 | 284 |
NaiveMethod=False |
| 285 | 285 |
NumpyFFTMethod=True |
| 286 |
OpenCLFFTMethod=True
|
|
| 286 |
OpenCLFFTMethod=False
|
|
| 287 | 287 |
NumpyMethod=False |
| 288 | 288 |
NumbaMethod=False |
| 289 | 289 |
OpenCLMethod=False |
| 290 |
CUDAMethod=False
|
|
| 290 |
CUDAMethod=True
|
|
| 291 | 291 |
Threads=1 |
| 292 | 292 |
|
| 293 | 293 |
import getopt |
| ... | ... | |
| 358 | 358 |
print("Size of complex vector : %i" % SIZE)
|
| 359 | 359 |
print("DFT Naive computation %s " % NaiveMethod )
|
| 360 | 360 |
print("DFT Numpy computation %s " % NumpyMethod )
|
| 361 |
print("FFT Numpy computation %s " % NumpyFFTMethod )
|
|
| 361 | 362 |
print("DFT Numba computation %s " % NumbaMethod )
|
| 362 | 363 |
print("DFT OpenCL computation %s " % OpenCLMethod )
|
| 363 | 364 |
print("DFT CUDA computation %s " % CUDAMethod )
|
| ... | ... | |
| 397 | 398 |
|
| 398 | 399 |
|
| 399 | 400 |
|
| 400 |
a_np = np.ones(SIZE).astype(np.float32) |
|
| 401 |
b_np = np.ones(SIZE).astype(np.float32) |
|
| 401 |
# a_np = np.ones(SIZE).astype(np.float32) |
|
| 402 |
# b_np = np.ones(SIZE).astype(np.float32) |
|
| 403 |
a_np = np.random.rand(SIZE).astype(np.float32) |
|
| 404 |
b_np = np.random.rand(SIZE).astype(np.float32) |
|
| 402 | 405 |
|
| 403 | 406 |
C_np = np.zeros(SIZE).astype(np.float32) |
| 404 | 407 |
D_np = np.zeros(SIZE).astype(np.float32) |
| ... | ... | |
| 483 | 486 |
print("Precision: ",np.linalg.norm(i_np-C_np),
|
| 484 | 487 |
np.linalg.norm(j_np-D_np)) |
| 485 | 488 |
|
| 489 |
<<<<<<< .mine |
|
| 490 |
if OpenCLMethod and NumpyFFTMethod: |
|
| 491 |
print(OpenCLMethod,NumpyFFTMethod) |
|
| 492 |
print("Precision: ",np.linalg.norm(m_np-i_np),
|
|
| 493 |
np.linalg.norm(n_np-j_np)) |
|
| 494 |
print((m_np-i_np),(n_np-j_np)) |
|
| 495 |
print(i_np,j_np) |
|
| 496 |
print(m_np,n_np) |
|
| 497 |
print((i_np-m_np),(j_np-n_np)) |
|
| 498 |
|
|
| 499 |
if CUDAMethod and NumpyFFTMethod: |
|
| 500 |
print(CUDAMethod,NumpyFFTMethod) |
|
| 501 |
print("Precision: ",np.linalg.norm(m_np-k_np),
|
|
| 502 |
np.linalg.norm(n_np-l_np)) |
|
| 503 |
print((m_np-k_np),(n_np-l_np)) |
|
| 504 |
print(k_np,l_np) |
|
| 505 |
print(m_np,n_np) |
|
| 506 |
print((k_np-m_np),(l_np-n_np)) |
|
| 507 |
|
|
| 508 |
if OpenCLMethod and NumpyMethod: |
|
| 509 |
print(OpenCLMethod,NumpyMethod) |
|
| 510 |
print("Precision: ",np.linalg.norm(e_np-i_np),
|
|
| 511 |
np.linalg.norm(f_np-j_np)) |
|
| 512 |
print((e_np-i_np),(f_np-j_np)) |
|
| 513 |
|
|
| 514 |
if NumpyFFTMethod and NumpyMethod: |
|
| 515 |
print(NumpyFFTMethod,NumpyMethod) |
|
| 516 |
print("Precision: ",np.linalg.norm(e_np-m_np),
|
|
| 517 |
np.linalg.norm(f_np-n_np)) |
|
| 518 |
print(e_np,f_np) |
|
| 519 |
print(m_np,n_np) |
|
| 520 |
print((e_np-m_np),(f_np-n_np)) |
|
| 521 |
|
|
| 522 |
if NumpyFFTMethod and NaiveMethod: |
|
| 523 |
print(NumpyFFTMethod,NaiveMethod) |
|
| 524 |
print("Precision: ",np.linalg.norm(c_np-m_np),
|
|
| 525 |
np.linalg.norm(d_np-n_np)) |
|
| 526 |
print(c_np,d_np) |
|
| 527 |
print(m_np,n_np) |
|
| 528 |
print((c_np-m_np),(d_np-n_np)) |
|
| 529 |
|
|
| 530 |
if NumpyFFTMethod and NumbaMethod: |
|
| 531 |
print(NumpyFFTMethod,NumbaMethod) |
|
| 532 |
print("Precision: ",np.linalg.norm(g_np-m_np),
|
|
| 533 |
np.linalg.norm(h_np-n_np)) |
|
| 534 |
print(g_np,h_np) |
|
| 535 |
print(m_np,n_np) |
|
| 536 |
print((g_np-m_np),(h_np-n_np)) |
|
| 537 |
|
|
| 538 |
||||||| .r292 |
|
| 539 |
======= |
|
| 486 | 540 |
if OpenCLFFTMethod and NumpyFFTMethod: |
| 487 | 541 |
print("NumpyOpenCLRatio: %f" % (OpenCLFFTRate/NumpyFFTRate))
|
| 542 |
>>>>>>> .r299 |
|
Formats disponibles : Unified diff