def kernapply(x, k, circular=False):
"""Convolve a sequence x with a Kernel k"""
x = flex.double(x).deep_copy()
lenx = len(x)
w = flex.double(lenx, 0.0)
w.set_selected(flex.size_t_range(k.m + 1), k.coef)
sel = lenx -1 - flex.size_t_range(k.m)
w.set_selected(sel, k.coef[1:])
# do convolution in the Fourier domain
fft = fftpack.real_to_complex(lenx)
n = fft.n_real()
m = fft.m_real()
x.extend(flex.double(m-n, 0.))
w.extend(flex.double(m-n, 0.))
conv = fft.forward(x) * fft.forward(w)
# extend result by the reverse conjugate, omitting the DC offset and Nyquist
# frequencies. If fft.n_real() is odd there is no Nyquist term.
end = fft.n_complex() - (fft.n_real() + 1) % 2
conv.extend(flex.conj(conv[1:end]).reversed())
# transform back, take real part and scale
fft = fftpack.complex_to_complex(len(conv))
result = fft.backward(conv).parts()[0] / n
if circular:
return result
else:
return result[(k.m):(lenx-k.m)]
def test_comprehensive_cc_1d(max_transform_size):
for n in range(1, max_transform_size + 1):
fft = fftpack.complex_to_complex(n)
m = n * 2
v_in = flex.double()
for i in range(m):
v_in.append(random.random())
for f, b in ((fft.forward, fft.backward), (fft.backward, fft.forward)):
v_tr = v_in.deep_copy()
f(v_tr)
b(v_tr)
compare_vectors(n, m, v_in, v_tr)
def test_comprehensive_cc_1d(max_transform_size):
for n in xrange(1,max_transform_size+1):
fft = fftpack.complex_to_complex(n)
m = n * 2
v_in = flex.double()
for i in xrange(m):
v_in.append(random.random())
for f,b in ((fft.forward, fft.backward), (fft.backward, fft.forward)):
v_tr = v_in.deep_copy()
f(v_tr)
b(v_tr)
compare_vectors(n, m, v_in, v_tr)
def test_complex_to_complex(verbose):
fft = fftpack.complex_to_complex(5)
vc = flex.complex_double(fft.n())
vd = flex.double(fft.n() * 2)
for i in range(fft.n()):
vc[i] = complex(2. * i, 2. * i + 1.)
vd[2 * i] = 2. * i
vd[2 * i + 1] = 2. * i + 1.
vct = fft.forward(vc)
vdt = fft.forward(vd)
for t in (vct, vdt):
assert t.origin() == (0, )
assert t.all()[0] == fft.n()
assert t.focus()[0] == fft.n()
if (verbose): show_cseq(vc)
assert_complex_eq_real(vc, vd)
vct = fft.backward(vc)
vdt = fft.backward(vd)
for t in (vct, vdt):
assert t.origin() == (0, )
assert t.all()[0] == fft.n()
assert t.focus()[0] == fft.n()
if (verbose): show_cseq(vc)
assert_complex_eq_real(vc, vd)
def test_complex_to_complex(verbose):
fft = fftpack.complex_to_complex(5)
vc = flex.complex_double(fft.n())
vd = flex.double(fft.n() * 2)
for i in xrange(fft.n()):
vc[i] = complex(2.*i, 2.*i+1.)
vd[2*i] = 2.*i
vd[2*i+1] = 2.*i+1.
vct = fft.forward(vc)
vdt = fft.forward(vd)
for t in (vct, vdt):
assert t.origin() == (0,)
assert t.all()[0] == fft.n()
assert t.focus()[0] == fft.n()
if (verbose): show_cseq(vc)
assert_complex_eq_real(vc, vd)
vct = fft.backward(vc)
vdt = fft.backward(vd)
for t in (vct, vdt):
assert t.origin() == (0,)
assert t.all()[0] == fft.n()
assert t.focus()[0] == fft.n()
if (verbose): show_cseq(vc)
assert_complex_eq_real(vc, vd)
def exercise_complex_to_complex():
print "complex_to_complex"
for n in xrange(1,256+1):
dp = (flex.random_double(size=n)*2-1) * flex.polar(
1, flex.random_double(size=n)*2-1)
dw = dp.deep_copy()
fft = fftpack.complex_to_complex(n)
fftw3tbx.complex_to_complex_in_place(data=dw, exp_sign=-1)
fft.forward(dp)
assert flex.max(flex.abs(dw-dp)) < 1.e-6
fftw3tbx.complex_to_complex_in_place(data=dw, exp_sign=+1)
fft.backward(dp)
assert flex.max(flex.abs(dw-dp)) < 1.e-6
for n,n_repeats in [(1200,500), (9600,250)]:
print " factors of %d:" % n, list(fftpack.complex_to_complex(n).factors())
print " repeats:", n_repeats
d0 = (flex.random_double(size=n)*2-1) * flex.polar(
1, flex.random_double(size=n)*2-1)
#
t0 = time.time()
for i_trial in xrange(n_repeats):
d = d0.deep_copy()
overhead = time.time()-t0
print " overhead: %.2f seconds" % overhead
#
t0 = time.time()
for i_trial in xrange(n_repeats):
d = d0.deep_copy()
fftw3tbx.complex_to_complex_in_place(data=d, exp_sign=-1)
fftw3tbx.complex_to_complex_in_place(data=d, exp_sign=+1)
print " fftw: %.2f seconds" % (time.time()-t0-overhead)
#
t0 = time.time()
for i_trial in xrange(n_repeats):
d = d0.deep_copy()
fftpack.complex_to_complex(n).forward(d)
fftpack.complex_to_complex(n).backward(d)
print " fftpack: %.2f seconds" % (time.time()-t0-overhead)
sys.stdout.flush()
