def run():
# Here should go some meaningful data sample to test the transform.
# Can you write one?
n = 512
data = numx.zeros((n,))
x = numx.arange(n) * (2 * numx.pi / n)
y = numx.cos(x*5)
#result = transform(y)
wavefreq, resampled = compress(y)
pylab.figure(1)
pylab.hold(0)
pylab.plot(x,y,x,resampled)
pylab.grid(1)
pylab.figure(2)
pylab.hold(0)
pylab.plot(wavefreq[:30], '.-')
pylab.grid(1)
pylab.figure(3)
pylab.hold(0)
pylab.plot(wavefreq[:50], '.-')
pylab.grid(1)
def func(t, y, mu):
#print "--> func", t, y
f = numx.zeros((2, ), Float) * 1.0
f[0] = y[1]
f[1] = -y[0] - mu * y[1] * (y[0]**2 - 1)
#print f
return f
def func(t, y, mu):
#print "--> func", t, y
f = numx.zeros((2,), Float) * 1.0
f[0] = y[1]
f[1] = -y[0] - mu * y[1] * (y[0] ** 2 -1);
#print f
return f
def singlefreq():
n = 4096
data = numx.zeros((n,))
w = wavelet.bspline_centered(208)
#w = wavelet.bspline_centered(309)
#w = wavelet.haar(2)
#w = wavelet.daubechies_centered(20)
#w = wavelet.daubechies_centered(4)
#w = wavelet.daubechies_centered(20)
plots = []
labels = []
m = 8
for i in range(m):
data[i] = 1
#fw = w.transform_forward(data)
iv = w.transform_inverse(data)
labels.append( "%d" % (i,))
plots.extend([iv, '-'])
#pylab.figure(1)
#pylab.hold(0)
#pylab.plot(data, '.-')
pylab.figure(2)
pylab.hold(0)
pylab.plot(*plots)
pylab.legend(labels)
def singlefreq():
n = 4096
data = numx.zeros((n, ))
w = wavelet.bspline_centered(208)
#w = wavelet.bspline_centered(309)
#w = wavelet.haar(2)
#w = wavelet.daubechies_centered(20)
#w = wavelet.daubechies_centered(4)
#w = wavelet.daubechies_centered(20)
plots = []
labels = []
m = 8
for i in range(m):
data[i] = 1
#fw = w.transform_forward(data)
iv = w.transform_inverse(data)
labels.append("%d" % (i, ))
plots.extend([iv, '-'])
#pylab.figure(1)
#pylab.hold(0)
#pylab.plot(data, '.-')
pylab.figure(2)
pylab.hold(0)
pylab.plot(*plots)
pylab.legend(labels)
def run():
# Here should go some meaningful data sample to test the transform.
# Can you write one?
n = 512
data = numx.zeros((n, ))
x = numx.arange(n) * (2 * numx.pi / n)
y = numx.cos(x * 5)
#result = transform(y)
wavefreq, resampled = compress(y)
pylab.figure(1)
pylab.hold(0)
pylab.plot(x, y, x, resampled)
pylab.grid(1)
pylab.figure(2)
pylab.hold(0)
pylab.plot(wavefreq[:30], '.-')
pylab.grid(1)
pylab.figure(3)
pylab.hold(0)
pylab.plot(wavefreq[:50], '.-')
pylab.grid(1)
def func(t, y, mu):
f = Numeric.zeros((2, ), Numeric.Float) * 1.0
f[0] = y[1]
f[1] = -y[0] - mu * y[1] * (y[0]**2 - 1)
#f[0] = y[1]
#f[1] = y[0] * mu
#print "y", y, "f", f
return f
def run():
# Here should go some meaningful data sample to test the transform.
# Can you write one?
n = 512
data = numx.zeros((n, ))
result = transform(data)
print result
def run():
# Here should go some meaningful data sample to test the transform.
# Can you write one?
n = 512
data = numx.zeros((n,))
result = transform(data)
print result
def jac(t, y, mu):
dfdy = numx.ones((2, 2), ) * 1.
dfdy[0, 0] = 0.0
dfdy[0, 1] = 1.0
dfdy[1, 0] = -2.0 * mu * y[0] * y[1] - 1.0
dfdy[1, 1] = -mu * (y[0]**2 - 1.0)
dfdt = numx.zeros((2, ))
return dfdy, dfdt
def func(t, y, mu):
f = Numeric.zeros((2,), Numeric.Float) * 1.0
f[0] = y[1]
f[1] = -y[0] - mu * y[1] * (y[0] ** 2 -1);
#f[0] = y[1]
#f[1] = y[0] * mu
#print "y", y, "f", f
return f
def halfcomplex_radix2_unpack():
n = 32
a = numx.arange(n)
c = numx.zeros((n, ))
c[1:n / 2 + 1] = a[1::2]
c[n / 2 + 1:] = a[-2:1:-2]
print(c)
print(fft.halfcomplex_radix2_unpack(c))
def halfcomplex_radix2_unpack():
n = 32
a = numx.arange(n)
c = numx.zeros((n,))
c[1:n/2+1]=a[1::2]
c[n/2+1:]=a[-2:1:-2]
print c
print fft.halfcomplex_radix2_unpack(c)
def jac(t, y, mu):
dfdy = numx.ones((2,2),) * 1.
dfdy[0, 0] = 0.0
dfdy[0, 1] = 1.0
dfdy[1, 0] = -2.0 * mu * y[0] * y[1] - 1.0
dfdy[1, 1] = -mu * (y[0]**2 - 1.0)
dfdt = numx.zeros((2,))
return dfdy, dfdt
def func(t, y, args):
mu = args
f = numx.zeros(y.shape, numx.float_)
y0 = y[0]
y1 = y[1]
f[0] = y1;
f[1] = -y0 - mu*y1*(y0**2 - 1);
return f
def my_df(v, params):
x = v[0]
y = v[1]
df = numx.zeros(v.shape, ) * 1.
dp = params
df[0] = 20. * (x - dp[0])
df[1] = 40. * (y - dp[1])
return df
def rosenbrock_df(x, params):
a = params[0]
b = params[1]
df = Numeric.zeros((x.shape[0], x.shape[0]), Float)
df[0, 0] = -a
df[0, 1] = 0
df[1, 0] = -2 * b * x[0]
df[1, 1] = b
return df
def jac(t, y, mu):
dfdy = Numeric.ones((2, 2), Numeric.Float)
dfdy[0, 0] = 0.0
dfdy[0, 1] = 1.0
dfdy[1, 0] = -2.0 * mu * y[0] * y[1] - 1.0
dfdy[1, 1] = -mu * (y[0]**2 - 1.0)
dfdt = Numeric.zeros((2, ))
return dfdy, dfdt
def my_df(v, params):
x = v[0]
y = v[1]
df = numx.zeros(v.shape, ) * 1.
dp = params
df[0] = 20. * (x - dp[0])
df[1] = 40. * (y - dp[1])
#print "\t\tx,y ->df", x,y, df
return df
def my_df(v, params):
x = v[0]
y = v[1]
df = Numeric.zeros(v.shape, Float)
dp = params
df[0] = 20. * (x - dp[0])
df[1] = 40. * (y - dp[1])
#print "\t\tx,y ->df", x,y, df
return df
def my_df(v, params):
x = v[0]
y = v[1]
df = numx.zeros(v.shape, ) * 1.
dp = params
df[0] = 20. * (x - dp[0])
df[1] = 40. * (y - dp[1])
#print( "\t\tx,y ->df", x,y, df)
return df
def jac(t, y, args):
mu = args
y0 = y[0]
y1 = y[1]
l = len(y)
dfdy = numx.zeros((l,l), numx.float_)
dfdy[0,0] = 0.0
dfdy[0,1] = 1.0
dfdy[1,0] = - 2.0 * mu * y0 * y1 - 1.0
dfdy[1,1] = - mu * (y0**2 - 1.0)
dfdt = numx.zeros((l,), numx.float_)
dfdt[0] = 0
dfdt[1] = 0
return dfdy, dfdt
def rosenbrock_df(x, params):
a = params[0]
b = params[1]
df = numx.zeros((x.shape[0], x.shape[0])) * 1.
df[0,0] = -a
df[0,1] = 0
df[1,0] = -2 * b * x[0]
df[1,1] = b
return df
def rosenbrock_df(x, params):
a = params[0]
b = params[1]
df = Numeric.zeros((x.shape[0], x.shape[0]), Float)
df[0,0] = -a
df[0,1] = 0
df[1,0] = -2 * b * x[0]
df[1,1] = b
return df
def rosenbrock_df(x, params):
a = params[0]
b = params[1]
df = numx.zeros((x.shape[0], x.shape[0])) * 1.
df[0, 0] = -a
df[0, 1] = 0
df[1, 0] = -2 * b * x[0]
df[1, 1] = b
return df
def jac(t, y, mu):
dfdy = Numeric.ones((2,2), Numeric.Float)
dfdy[0, 0] = 0.0
dfdy[0, 1] = 1.0
dfdy[1, 0] = -2.0 * mu * y[0] * y[1] - 1.0
dfdy[1, 1] = -mu * (y[0]**2 - 1.0)
dfdt = Numeric.zeros((2,))
return dfdy, dfdt
def jac(t, y, mu):
dfdy = Numeric.ones((2,2), Numeric.Float)
dfdy[0, 0] = 0.0
dfdy[0, 1] = 0.0
dfdy[1, 0] = 0.0
dfdy[1, 1] = 0.0
dfdt = Numeric.zeros((2,))
dfdt[0] = 2
dfdt[1] = 3 * 2 * t
return dfdy, dfdt
def taylor(self, xp):
"""
This method converts the internal divided-difference representation of a
polynomial to a Taylor expansion.
input : xp
xp ... point to expand about
"""
w = Numeric.zeros(self.dd.shape, get_typecode(self.dd))
return _poly.gsl_poly_dd_taylor(xp, self.dd, self.xa, w)
def real_example_simple():
n = 1024 * 1024
data = numx.zeros((n, ), numx.Int)
data[n / 3:2 * n / 3] = 1
result = fft.real_transform(data)
#print "Nyqusit ->", result[0]
result[11:] = 0
final = fft.halfcomplex_inverse(result, n)
#print final
return
def taylor(self, xp):
"""
This method converts the internal divided-difference representation of a
polynomial to a Taylor expansion.
input : xp
xp ... point to expand about
"""
w = Numeric.zeros(self.dd.shape, get_typecode(self.dd))
return _poly.gsl_poly_dd_taylor(xp, self.dd, self.xa, w)
def jac(t, y, mu):
dfdy = Numeric.ones((2, 2), Numeric.Float)
dfdy[0, 0] = 0.0
dfdy[0, 1] = 0.0
dfdy[1, 0] = 0.0
dfdy[1, 1] = 0.0
dfdt = Numeric.zeros((2, ))
dfdt[0] = 2
dfdt[1] = 3 * 2 * t
return dfdy, dfdt
def run():
r = rng.rng()
# slope
a = 1.45
# intercept
b = 3.88
# Generate the data
n = 20
i = numx.arange(n - 3)
dx = 10.0 / (n - 1.0)
e = r.uniform(n)
x = -5.0 + i * dx
y = a * x + b
#outliers
xo = numx.array([4.1, 3.5, 4.7])
yo = numx.array([-6.0, -6.7, -8.3])
x = numx.concatenate((x, xo))
y = numx.concatenate((y, yo))
X = numx.array([x * 0 + 1, x]).transpose()
ws = fr.workspace(*((fr.ols, ) + X.shape))
c_ols, cov_ols = ws.fit(X, y)
ws = fr.workspace(*((fr.bisquare, ) + X.shape))
c, cov = ws.fit(X, y)
y_rob = numx.zeros(n, numx.float_)
y_ols = numx.zeros(n, numx.float_)
yerr_rob = numx.zeros(n, numx.float_)
yerr_ols = numx.zeros(n, numx.float_)
pygsl.set_debug_level(0)
fr.est(X[0, :], c, cov)
y_rob, yerr_rob = fr.est_vector(X, c, cov)
pygsl.set_debug_level(0)
y_ols, yerr_ols = fr.est_vector(X, c_ols, cov_ols)
return x, y, (y_rob, yerr_rob), (y_ols, yerr_ols)
def Heigenvectors(a, ws=None):
"""Heigenvectors(a, ws=None) -> (eval, evec)
This function computes the eigenvalues and eigenvectors of the complex
hermitian matrix A.The imaginary parts of the diagonal are assumed to be
zero and are not referenced. The eigenvalues are stored in the vector
eval and are unordered. The corresponding complex eigenvectors are
stored in the columns of the matrix evec. For example, the eigenvector
in the first column corresponds to the first eigenvalue. The
eigenvectors are guaranteed to be mutually orthogonal and normalised to
unit magnitude.
"""
n = a.shape[0]
an = a.astype(_complex)
eval = numx.zeros((n,), _float)
evec = numx.zeros((n,n), _complex)
if ws == None:
ws = gslwrap.gsl_eigen_hermv_workspace(n)
_gslwrap.gsl_eigen_hermv(an, eval, evec, ws)
return (eval, evec)
def eigenvectors(a, ws=None):
"""eigenvectors(a, ws=None) -> (eval, evec)
This function computes the eigenvalues and eigenvectors of the real
symmetric matrix a. The eigenvalues are stored in the vector eval
and are unordered. The corresponding eigenvectors are stored in the
columns of the matrix evec. For example, the eigenvector in the first
column corresponds to the first eigenvalue. The eigenvectors are
guaranteed to be mutually orthogonal and normalised to unit magnitude.
"""
n = a.shape[1]
code = get_typecode(a)
an = array_typed_copy(a, code)
eval = numx.zeros((n,), code)
evec = numx.zeros((n,n), code)
if ws == None:
ws = gslwrap.gsl_eigen_symmv_workspace(n)
_gslwrap.gsl_eigen_symmv(an, eval, evec, ws)
return (eval, evec)
def Heigenvectors(a, ws=None):
"""Heigenvectors(a, ws=None) -> (eval, evec)
This function computes the eigenvalues and eigenvectors of the complex
hermitian matrix A.The imaginary parts of the diagonal are assumed to be
zero and are not referenced. The eigenvalues are stored in the vector
eval and are unordered. The corresponding complex eigenvectors are
stored in the columns of the matrix evec. For example, the eigenvector
in the first column corresponds to the first eigenvalue. The
eigenvectors are guaranteed to be mutually orthogonal and normalised to
unit magnitude.
"""
n = a.shape[0]
an = a.astype(_complex)
eval = numx.zeros((n, ), _float)
evec = numx.zeros((n, n), _complex)
if ws == None:
ws = gslwrap.gsl_eigen_hermv_workspace(n)
_gslwrap.gsl_eigen_hermv(an, eval, evec, ws)
return (eval, evec)
def eigenvectors(a, ws=None):
"""eigenvectors(a, ws=None) -> (eval, evec)
This function computes the eigenvalues and eigenvectors of the real
symmetric matrix a. The eigenvalues are stored in the vector eval
and are unordered. The corresponding eigenvectors are stored in the
columns of the matrix evec. For example, the eigenvector in the first
column corresponds to the first eigenvalue. The eigenvectors are
guaranteed to be mutually orthogonal and normalised to unit magnitude.
"""
n = a.shape[1]
code = get_typecode(a)
an = array_typed_copy(a, code)
eval = numx.zeros((n, ), code)
evec = numx.zeros((n, n), code)
if ws == None:
ws = gslwrap.gsl_eigen_symmv_workspace(n)
_gslwrap.gsl_eigen_symmv(an, eval, evec, ws)
return (eval, evec)
def complex_example():
n = 630
space = fft.complex_workspace(n)
wavetable = fft.complex_wavetable(n)
print space.get_type()
print wavetable.get_type()
print wavetable.get_factors()
data = numx.zeros((630,), numx.Complex)
data[:11] = 1.0
data[11:] = 1.0
d = data[:]
fft.complex_forward(data, space, wavetable)
def complex_example():
n = 630
space = fft.complex_workspace(n)
wavetable = fft.complex_wavetable(n)
print(space.get_type())
print(wavetable.get_type())
print(wavetable.get_factors())
data = numx.zeros((630, ), numx.Complex)
data[:11] = 1.0
data[11:] = 1.0
d = data[:]
fft.complex_forward(data, space, wavetable)
def jac(t, y, mu):
#print "--> jac", t, y
dfdy = numx.ones((2, 2), Float)
dfdy[0, 0] = 0.0
dfdy[0, 1] = 1.0
dfdy[1, 0] = -2.0 * mu * y[0] * y[1] - 1.0
dfdy[1, 1] = -mu * (y[0]**2 - 1.0)
#print "dfdy[0, 0]", dfdy[0, 0]
#print "dfdy[0, 1]", dfdy[0, 1]
#print "dfdy[1, 0]", dfdy[1, 0]
#print "dfdy[1, 1]", dfdy[1, 1]
dfdt = numx.zeros((2, ))
return dfdy, dfdt
def jac(t, y, mu):
#print "--> jac", t, y
dfdy = numx.ones((2,2), Float)
dfdy[0, 0] = 0.0
dfdy[0, 1] = 1.0
dfdy[1, 0] = -2.0 * mu * y[0] * y[1] - 1.0
dfdy[1, 1] = -mu * (y[0]**2 - 1.0)
#print "dfdy[0, 0]", dfdy[0, 0]
#print "dfdy[0, 1]", dfdy[0, 1]
#print "dfdy[1, 0]", dfdy[1, 0]
#print "dfdy[1, 1]", dfdy[1, 1]
dfdt = numx.zeros((2,))
return dfdy, dfdt
def eigenvalues(a, ws=None):
"""eigenvalues(a, ws=None) -> array
This function computes the eigenvalues of the real symmetric matrix a.
The eigenvalues are returned as NumPy array and are unordered.
"""
n = a.shape[1]
code = get_typecode(a)
an = array_typed_copy(a, code)
eval = numx.zeros((n,), code)
if ws == None:
ws = gslwrap.gsl_eigen_symm_workspace(n)
_gslwrap.gsl_eigen_symm(an, eval, ws)
return eval
def eigenvalues(a, ws=None):
"""eigenvalues(a, ws=None) -> array
This function computes the eigenvalues of the real symmetric matrix a.
The eigenvalues are returned as NumPy array and are unordered.
"""
n = a.shape[1]
code = get_typecode(a)
an = array_typed_copy(a, code)
eval = numx.zeros((n, ), code)
if ws == None:
ws = gslwrap.gsl_eigen_symm_workspace(n)
_gslwrap.gsl_eigen_symm(an, eval, ws)
return eval
def Heigenvalues(a, ws=None):
"""Heigenvalues(a, ws=None) -> eval
This function computes the eigenvalues of the complex hermitian matrix a.
The imaginary parts of the diagonal are assumed to be zero and are not
referenced. The eigenvalues are stored in the vector eval and are
unordered.
"""
n = a.shape[1]
an = a.astype(_complex)
eval = numx.zeros((n,), _float)
if ws == None:
ws = gslwrap.gsl_eigen_herm_workspace(n)
_gslwrap.gsl_eigen_herm(an, eval, ws)
return eval
def Heigenvalues(a, ws=None):
"""Heigenvalues(a, ws=None) -> eval
This function computes the eigenvalues of the complex hermitian matrix a.
The imaginary parts of the diagonal are assumed to be zero and are not
referenced. The eigenvalues are stored in the vector eval and are
unordered.
"""
n = a.shape[1]
an = a.astype(_complex)
eval = numx.zeros((n, ), _float)
if ws == None:
ws = gslwrap.gsl_eigen_herm_workspace(n)
_gslwrap.gsl_eigen_herm(an, eval, ws)
return eval
def run():
N = 1024
x = numx.arange(N) * (numx.pi * 2 / N)
y = numx.sin(x)
b = bspline(10, nbreak)
b.knots_uniform(x[0], x[-1])
X = numx.zeros((N, ncoeffs))
X = b.eval_vector(x)
c, cov, chisq = multifit.linear(X, y)
res_x = x[::N / 64]
X = b.eval_vector(res_x)
res_y, res_y_err = multifit.linear_est_matrix(X, c, cov)
pylab.plot(x, y, '-')
pylab.errorbar(res_x, res_y, fmt='g-', xerr=res_y_err)
def run(array):
# Initalise the wavelet and the workspace
w = wavelet.daubechies(4)
ws = wavelet.workspace(len(array))
# Transform forward
result = w.transform_forward(array, ws)
# Select the largest 20 coefficients
abscoeff = numx.absolute(result)
indices = numx.argsort(abscoeff) # ascending order
tmp = numx.zeros(result.shape, numx.float_)
for i in indices[-20:]:
tmp[i] = result[i] # Set all others to zero
# And back
result2 = w.transform_inverse(tmp, ws)
def run(array):
# Initalise the wavelet and the workspace
w = wavelet.daubechies(4)
ws = wavelet.workspace(len(array))
# Transform forward
result = w.transform_forward(array, ws)
# Select the largest 20 coefficients
abscoeff = numx.absolute(result)
indices = numx.argsort(abscoeff) # ascending order
tmp = numx.zeros(result.shape, numx.float_)
for i in indices[-20:]:
tmp[i] = result[i] # Set all others to zero
# And back
result2 = w.transform_inverse(tmp, ws)
def run():
N = 1024
x = numx.arange(N) * (numx.pi * 2 / N)
y = numx.sin(x)
b = bspline(10, nbreak)
b.knots_uniform(x[0], x[-1])
X = numx.zeros((N, ncoeffs))
X = b.eval_vector(x)
c, cov, chisq = multifit.linear(X, y)
res_x = x[::N/64]
X = b.eval_vector(res_x)
res_y, res_y_err = multifit.linear_est_matrix(X, c, cov)
pylab.plot(x,y, '-')
pylab.errorbar(res_x, res_y, fmt='g-', xerr=res_y_err)
def compress(data):
n = len(data)
#w = wavelet.daubechies(4)
#w = wavelet.daubechies(6)
#w = wavelet.daubechies(8)
#w = wavelet.daubechies(10)
#w = wavelet.daubechies(12)
#w = wavelet.daubechies(14)
#w = wavelet.daubechies(16)
#w = wavelet.daubechies(18)
#w = wavelet.daubechies_centered(20)
#w = wavelet.haar(2)
w = wavelet.bspline(103)
w = wavelet.bspline(309)
wavefreq = w.transform_forward(data)
wavefreqred = numx.zeros(wavefreq.shape, wavefreq.dtype)
cutfreq = 16
wavefreqred[:cutfreq] = wavefreq[:cutfreq]
resampled = w.transform_inverse(wavefreqred)
return wavefreq, resampled
def compress(data):
n = len(data)
#w = wavelet.daubechies(4)
#w = wavelet.daubechies(6)
#w = wavelet.daubechies(8)
#w = wavelet.daubechies(10)
#w = wavelet.daubechies(12)
#w = wavelet.daubechies(14)
#w = wavelet.daubechies(16)
#w = wavelet.daubechies(18)
#w = wavelet.daubechies_centered(20)
#w = wavelet.haar(2)
w = wavelet.bspline(103)
w = wavelet.bspline(309)
wavefreq = w.transform_forward(data);
wavefreqred = numx.zeros(wavefreq.shape, wavefreq.dtype)
cutfreq = 16
wavefreqred[:cutfreq] = wavefreq[:cutfreq]
resampled = w.transform_inverse(wavefreqred)
return wavefreq, resampled
def run():
r = rng.rng()
bw = bspline(4, nbreak)
# Data to be fitted
x = 15. / (N - 1) * numx.arange(N)
y = numx.cos(x) * numx.exp(0.1 * x)
sigma = .1
w = 1.0 / sigma**2 * numx.ones(N)
dy = r.gaussian(sigma, N)
y = y + dy
# use uniform breakpoints on [0, 15]
bw.knots_uniform(0.0, 15.0)
X = numx.zeros((N, ncoeffs))
for i in range(N):
B = bw.eval(x[i])
X[i, :] = B
# do the fit
c, cov, chisq = multifit.wlinear(X, w, y,
multifit.linear_workspace(N, ncoeffs))
# output the smoothed curve
res_y = []
res_y_err = []
for i in range(N):
B = bw.eval(x[i])
yi, yi_err = multifit.linear_est(B, c, cov)
res_y.append(yi)
res_y_err.append(yi_err)
#print yi, yerr
res_y = numx.array(res_y)
res_y_err = numx.array(res_y_err)
return (
x,
y,
), (x, res_y), res_y_err
def run():
r = rng.rng()
bw = bspline(4, nbreak)
# Data to be fitted
x = 15. / (N-1) * numx.arange(N)
y = numx.cos(x) * numx.exp(0.1 * x)
sigma = .1
w = 1.0 / sigma**2 * numx.ones(N)
dy = r.gaussian(sigma, N)
y = y + dy
# use uniform breakpoints on [0, 15]
bw.knots_uniform(0.0, 15.0)
X = numx.zeros((N, ncoeffs))
for i in range(N):
B = bw.eval(x[i])
X[i,:] = B
# do the fit
c, cov, chisq = multifit.wlinear(X, w, y, multifit.linear_workspace(N, ncoeffs))
# output the smoothed curve
res_y = []
res_y_err = []
for i in range(N):
B = bw.eval(x[i])
yi, yi_err = multifit.linear_est(B, c, cov)
res_y.append(yi)
res_y_err.append(yi_err)
#print yi, yerr
res_y = numx.array(res_y)
res_y_err = numx.array(res_y_err)
return (x, y,), (x, res_y), res_y_err
def real_example_simple():
n = 1024*1024
data = numx.zeros((n,), numx.Int)
data[n/3:2*n/3] = 1
result = fft.real_transform(data)
#print "Nyqusit ->", result[0]
result[11:] = 0
final = fft.halfcomplex_inverse(result, n)
#print final
return
import Gnuplot
g = Gnuplot.Gnuplot()
g.plot(Gnuplot.Data(data, with='line'),
Gnuplot.Data(final, with='linespoints'),)
raw_input()
def halfcomplex_radix2_unpack():
n = 32
a = numx.arange(n)
c = numx.zeros((n,))
c[1:n/2+1]=a[1::2]
c[n/2+1:]=a[-2:1:-2]
print c
print fft.halfcomplex_radix2_unpack(c)
def doc():
help(fft)
if __name__ == '__main__':
import pygsl
pygsl.set_debug_level(0)
complex_example_simple()
complex_example()
real_example_simple()
real_example_simple1()
halfcomplex_radix2_unpack()
def func(t, y, mu):
f = Numeric.zeros((2,), Numeric.Float) * 1.0
f[0] = 2 * t
f[1] = 3 * t**2
return f
# Census Bureau, at http://www.census.gov/cgi-bin/gazetteer */
cities =(City("Santa Fe", -105.95, 35.68,),
City("Phoenix", -112.07, 33.54,),
City("Albuquerque", -106.62, 35.12,),
City("Clovis", -103.20, 34.41,),
City("Durango", -107.87, 37.29,),
City("Dallas", -96.77, 32.79,),
City("Tesuque", -105.92, 35.77,),
City("Grants", -107.84, 35.15,),
City("Los Alamos", -106.28, 35.89,),
City("Las Cruces", -106.76, 32.34,),
City("Cortez", -108.58, 37.35,),
City("Gallup", -108.74, 35.52,))
n_cities = len(cities)
distance_matrix = numx.zeros((n_cities, n_cities))
cities_vec = numx.array(map(lambda x: x.GetData(), cities))
for i in range(len(cities)):
cities[i].SetNumber(i)
earth_radius = 6375.000
#n_cities = 6
# distance between two cities
def city_distance(c):
la = c[:,0]
lo = c[:,1]
sla = sin(la*pi/180)
cla = cos(la*pi/180)
slo = sin(lo*pi/180)
def func(t, y, mu):
f = numx.zeros((2,), ) * 1.0
f[0] = y[1]
f[1] = -y[0] - mu * y[1] * (y[0] ** 2 -1);
return f
