def test_internal_coherance(axes_i):
sum = Numeric.add.reduce
r = random.uniform
a1, a2, a3 = r(-180,180),r(-180,180),r(-180,180)
angles_i = Numeric.array([a1, a2, a3])
angles_r = angles_i[::-1]
axes_r = axes_i[2], axes_i[1], axes_i[0]
rotdnz_new = ThreeAxisRotation(angles_i/r2d, rotationAxes=axes_i, inversAxesOrder=1)
rotdnz_inv = ThreeAxisRotation(angles_r/r2d, rotationAxes=axes_r, inversAxesOrder=0)
diffmat1 = sum(sum(Numeric.absolute(rotdnz_new.tensor - rotdnz_inv.tensor)))
sol1_new, sol2_new = rotdnz_new.getAngles()
sol1_inv, sol2_inv = rotdnz_inv.getAngles()
diffinit = min(sum(Numeric.absolute(sol1_new*r2d-angles_i)),
sum(Numeric.absolute(sol2_new*r2d-angles_i)))
diffinv = min(sum(Numeric.absolute(sol1_inv[::-1]*r2d-angles_i)),
sum(Numeric.absolute(sol2_inv[::-1]*r2d-angles_i)))
#print rotdnz_new.asQuaternion()
if diffmat1 > 1e-12 or diffinit > 2e-11 or diffinv > 2e-11:
print "I"+3*"%10.2f" % tuple(Numeric.array(angles_i))
print "N"+3*"%10.2f" % tuple(Numeric.array(sol1_new)*r2d)
print "N"+3*"%10.2f" % tuple(Numeric.array(sol2_new)*r2d)
print 'Matrix difference \t%.1e' % diffmat1
print 'Init Angle difference \t%.1e' % diffinit
print 'Inv Angle difference \t%.1e' % diffinv
def get_h0_extrap(ref,d,hexp=1):
nomatch=get_numeric_nomatch_keys()
nomatch.append('ngrid')
d1 = get_matching(ref,d,nomatch)
h_min = []
max_eval=[]
for d2 in d1:
try:
h_min.append(min(d2.grid[1:]-d2.grid[0:-1])**hexp)
except:
h_min.append(1./(d2.data['ngrid']-1)**hexp)
max_eval.append(max(d2.evals.imag))
uh = list(sets.Set(h_min))
min_uh = min(uh)
uuh = []
for uh1 in uh:
if len(Numeric.nonzero(Numeric.absolute(Numeric.array(uuh)-uh1)<1e-8))==0:
uuh.append(uh1)
min_eval=[]
#print Numeric.sort(uuh)
for hm in uuh:
inds = Numeric.nonzero(Numeric.absolute(Numeric.array(h_min)-hm)<1e-8)
min_eval.append(min(Numeric.take(max_eval,inds)))
inds = Numeric.argsort(uuh)
h_min = list(Numeric.take(uuh,inds))
min_eval = list(Numeric.take(min_eval,inds))
if len(min_eval)>1:
m=(min_eval[1]-min_eval[0])/(h_min[1]-h_min[0])
else:
m=0
return min_eval[0]-m*h_min[0]
def test_internal_coherance(axes_i):
sum = Numeric.add.reduce
r = random.uniform
a1, a2, a3 = r(-180, 180), r(-180, 180), r(-180, 180)
angles_i = Numeric.array([a1, a2, a3])
angles_r = angles_i[::-1]
axes_r = axes_i[2], axes_i[1], axes_i[0]
rotdnz_new = ThreeAxisRotation(angles_i / r2d,
rotationAxes=axes_i,
inversAxesOrder=1)
rotdnz_inv = ThreeAxisRotation(angles_r / r2d,
rotationAxes=axes_r,
inversAxesOrder=0)
diffmat1 = sum(sum(Numeric.absolute(rotdnz_new.tensor -
rotdnz_inv.tensor)))
sol1_new, sol2_new = rotdnz_new.getAngles()
sol1_inv, sol2_inv = rotdnz_inv.getAngles()
diffinit = min(sum(Numeric.absolute(sol1_new * r2d - angles_i)),
sum(Numeric.absolute(sol2_new * r2d - angles_i)))
diffinv = min(sum(Numeric.absolute(sol1_inv[::-1] * r2d - angles_i)),
sum(Numeric.absolute(sol2_inv[::-1] * r2d - angles_i)))
#print rotdnz_new.asQuaternion()
if diffmat1 > 1e-12 or diffinit > 2e-11 or diffinv > 2e-11:
print "I" + 3 * "%10.2f" % tuple(Numeric.array(angles_i))
print "N" + 3 * "%10.2f" % tuple(Numeric.array(sol1_new) * r2d)
print "N" + 3 * "%10.2f" % tuple(Numeric.array(sol2_new) * r2d)
print 'Matrix difference \t%.1e' % diffmat1
print 'Init Angle difference \t%.1e' % diffinit
print 'Inv Angle difference \t%.1e' % diffinv
def get_Vmin_gamma(d):
b_vals = []
Vz0 = []
for d1 in d:
b_vals.append(d1.data['b'])
Vz0.append(d1.data['Vz0'])
ub = list(sets.Set(b_vals))
minV=[]
V0 = []
for b in ub:
inds = Numeric.nonzero(Numeric.array(b_vals)==b)
Vb = Numeric.take(Vz0,inds)
minV.append(min(Numeric.absolute(Vb)))
indV0=Numeric.nonzero(Numeric.absolute(Vb)==minV[-1])
V0.append(max(d[inds[indV0[0]]].evals.imag))
return (ub,minV,V0)
def testLinearLeastSquares2(self):
"""
From bug #503733. Failing with dlapack_lite
"""
import LinearAlgebra
d = [0.49910197] + [0.998203938] * 49
d1 = [0.000898030454] * 50
def tridiagonal(sz):
G = Numeric.zeros((sz,sz), Numeric.Float64)
for i in range(sz):
G[i,i] = d[i]
for i in range(0,sz-1):
G[i+1,i] = G[i,i+1] = d1[i]
return G
yfull = Numeric.array(
[4.37016668e+18, 4.09591905e+18, 3.82167167e+18, 4.12952660e+18,
2.60084719e+18, 2.05944452e+18, 1.69850960e+18, 1.51450383e+18,
1.39419275e+18, 1.25264986e+18, 1.18187857e+18, 1.16772440e+18,
1.17126300e+18, 1.13941580e+18, 1.17834000e+18, 1.20664860e+18,
1.18895580e+18, 1.18895580e+18, 1.21726440e+18, 1.24557296e+18,
1.22434149e+18, 1.23495719e+18, 1.24203436e+18, 1.22434160e+18,
1.23495720e+18, 1.21372580e+18, 1.22434160e+18, 1.21018740e+18,
1.22080300e+18, 1.15357020e+18, 1.19957160e+18, 1.18187880e+18,
1.19249440e+18, 1.18895579e+18, 1.28449704e+18, 1.27742021e+18,
1.30218984e+18, 1.30926700e+18, 1.25972716e+18, 1.15003156e+18,
1.17126296e+18, 1.15710876e+18, 1.10756882e+18, 1.20311006e+18,
1.29511286e+18, 1.28449726e+18, 1.29157446e+18, 1.44373273e+18,])
for i in range(20, 40):
G = tridiagonal(i)
y = yfull[:i]
A = LinearAlgebra.linear_least_squares(G, y)[0]
total = Numeric.add.reduce(y)
residual = Numeric.absolute(y - Numeric.dot(G, A))
assert_eq(0.0, Numeric.add.reduce(residual)/total)
def SimplexMaximize(var, err, func, convcrit = 0.001, minerr = 0.001):
var = Numeric.array(var)
simplex = [var]
for i in range(len(var)):
var2 = copy.copy(var)
var2[i] = var[i] + err[i]
simplex.append(var2)
value = []
for i in range(len(simplex)):
value.append(func(simplex[i]))
while 1:
# Determine worst and best
wi = 0
bi = 0
for i in range(len(simplex)):
if value[wi] > value[i]:
wi = i
if value[bi] < value[i]:
bi = i
# Test for convergence
#print "worst, best are",wi,bi,"with",value[wi],value[bi]
if abs(value[bi] - value[wi]) <= convcrit:
return simplex[bi]
# Calculate average of non-worst
ave=Numeric.zeros(len(var), 'd')
for i in range(len(simplex)):
if i != wi:
ave = ave + simplex[i]
ave = ave / (len(simplex) - 1)
worst = Numeric.array(simplex[wi])
# Check for too-small simplex
simsize = Numeric.add.reduce(Numeric.absolute(ave - worst))
if simsize <= minerr:
#print "Size of simplex too small:",simsize
return simplex[bi]
# Invert worst
new = 2 * ave - simplex[wi]
newv = func(new)
if newv <= value[wi]:
# Even worse. Shrink instead
#print "Shrunk simplex"
#print "ave=",repr(ave)
#print "wi=",repr(worst)
new = 0.5 * ave + 0.5 * worst
newv = func(new)
elif newv > value[bi]:
# Better than the best. Expand
new2 = 3 * ave - 2 * worst
newv2 = func(new2)
if newv2 > newv:
# Accept
#print "Expanded simplex"
new = new2
newv = newv2
simplex[wi] = new
value[wi] = newv
def SimplexMaximize(var, err, func, convcrit = 0.001, minerr = 0.001):
var = Numeric.array(var)
simplex = [var]
for i in range(len(var)):
var2 = copy.copy(var)
var2[i] = var[i] + err[i]
simplex.append(var2)
value = []
for i in range(len(simplex)):
value.append(func(simplex[i]))
while 1:
wi = 0
bi = 0
for i in range(len(simplex)):
if value[wi] > value[i]:
wi = i
if value[bi] < value[i]:
bi = i
if abs(value[bi] - value[wi]) <= convcrit:
return simplex[bi]
ave=Numeric.zeros(len(var), 'd')
for i in range(len(simplex)):
if i != wi:
ave = ave + simplex[i]
ave = ave / (len(simplex) - 1)
worst = Numeric.array(simplex[wi])
simsize = Numeric.add.reduce(Numeric.absolute(ave - worst))
if simsize <= minerr:
return simplex[bi]
new = 2 * ave - simplex[wi]
newv = func(new)
if newv <= value[wi]:
new = 0.5 * ave + 0.5 * worst
newv = func(new)
elif newv > value[bi]:
new2 = 3 * ave - 2 * worst
newv2 = func(new2)
if newv2 > newv:
new = new2
newv = newv2
simplex[wi] = new
value[wi] = newv
evec_num = int(round(evec_num+eimag/abs(eimag)))
else:
EV.imag = True
del EV.sevecs
(y1,yl) = EV.get_evec1(coord,evec_num,x)
acoef = EV.get_EVrot(minr=minr,maxr=maxr)
y2 = (acoef*y+1j*acoef*y1).real
y3 = (acoef*y+1j*acoef*y1).imag
#print acoef, y[-1],y1[-1],y2[-1],y3[-1]
norm = EV.get_EVnorm()
y2 = y2*norm
y3 = y3*norm
amp.append(1./((max(y2)+abs(min(y2)))/2.))
try:
x_zero = x[Numeric.nonzero(y2[1:]*y2[:-1]<0)[0]]
ind = Numeric.argmin(Numeric.absolute(EV.grid-x_zero))
zero.append(EV.grid[ind])
except:
zero.append(0)
dr = Gnuplot.Data(x,y2,title='Re',with='lines 3')
di = Gnuplot.Data(x,y3,title='Im',with='lines 2')
inds = Numeric.nonzero((EV.grid>=minx)*(EV.grid<=maxx))
dg = Gnuplot.Data(Numeric.take(EV.grid,inds),0*inds,with='points 1',title='Grid')
d[-1]=[dg,dr,di]
if 'nolegend' in sys.argv:
for i in range(len(d[-1])):
d[-1][i].set_option(title=None)
EV.imag=False
fn = 'plots/%g_var_%s_evec%s_%dunstable.eps'%(num0,var_key,coord,unst_ind)
if 'xr' in sys.argv:
def __abs__(self):
return Numeric.absolute(self.blob.as_array())
def power(numericarray): fft = ffteng.transform(numericarray) amplitude = Numeric.absolute(fft) return amplitude
def test1(*s):
"Test of basic array creation and arithmetic."
x=Numeric.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
y=Numeric.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
a10 = 10.
m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
xm = array(x, mask=m1)
ym = array(y, mask=m2)
z = Numeric.array([-.5, 0., .5, .8])
zm = array(z, mask=[0,1,0,0])
xf = Numeric.where(m1, 1.e+20, x)
xm.set_fill_value(1.e+20)
for item in [x, y, xm, ym, xf]:
item.shape = s
assert isMaskedArray(x) == 0
assert isMaskedArray(xm) == 1
assert shape(xm) == s
assert xm.shape == s
assert size(xm) == reduce(lambda x,y:x*y, s)
assert xm.size() == size(xm)
assert size(xm,0) == s[0]
assert xm.size(0) == size(xm,0)
assert count(xm) == len(m1) - reduce(lambda x,y:x+y, m1)
if rank(xm) > 1:
assert count(xm,0) == size(xm,0) - reduce(lambda x,y:x+y, xm.mask()[0])
alltest(xm, xf)
alltest(filled(xm, 1.e20), xf)
alltest(x, xm)
alltest(-x, -xm)
alltest(x + y, xm + ym)
alltest(x - y, xm - ym)
alltest(x * y, xm * ym)
alltest(x / y, xm / ym)
alltest(a10 + y, a10 + ym)
alltest(a10 - y, a10 - ym)
alltest(a10 * y, a10 * ym)
alltest(a10 / y, a10 / ym)
alltest(x + a10, xm + a10)
alltest(x - a10, xm - a10)
alltest(x * a10, xm * a10)
alltest(x / a10, xm / a10)
a2d = array([[1,2],[0,4]], Float)
a2dm = masked_array(a2d, [[0,0],[1,0]])
alltest (a2d * a2d, a2d * a2dm)
alltest (a2d + a2d, a2d + a2dm)
alltest (a2d - a2d, a2d - a2dm)
alltest(x**2, xm**2)
alltest(abs(x)**2.5, abs(xm) **2.5)
alltest(x**y, xm**ym)
alltest(Numeric.add(x,y), add(xm, ym))
alltest(Numeric.subtract(x,y), subtract(xm, ym))
alltest(Numeric.multiply(x,y), multiply(xm, ym))
alltest(Numeric.divide(x,y), divide(xm, ym))
alltest(Numeric.cos(x), cos(xm))
alltest(Numeric.cosh(x), cosh(xm))
alltest(Numeric.sin(x), sin(xm))
alltest(Numeric.sinh(x), sinh(xm))
alltest(Numeric.tan(x), tan(xm))
alltest(Numeric.tanh(x), tanh(xm))
alltest(Numeric.sqrt(abs(x)), sqrt(xm))
alltest(Numeric.log(abs(x)), log(xm))
alltest(Numeric.log10(abs(x)), log10(xm))
alltest(Numeric.exp(x), exp(xm))
alltest(Numeric.arcsin(z), arcsin(zm))
alltest(Numeric.arccos(z), arccos(zm))
alltest(Numeric.arctan(z), arctan(zm))
alltest(Numeric.arctan2(x, y), arctan2(xm, ym))
alltest(Numeric.absolute(x), absolute(xm))
alltest(Numeric.equal(x,y), equal(xm, ym))
alltest(Numeric.not_equal(x,y), not_equal(xm, ym))
alltest(Numeric.less(x,y), less(xm, ym))
alltest(Numeric.greater(x,y), greater(xm, ym))
alltest(Numeric.less_equal(x,y), less_equal(xm, ym))
alltest(Numeric.greater_equal(x,y), greater_equal(xm, ym))
alltest(Numeric.conjugate(x), conjugate(xm))
alltest(Numeric.concatenate((x,y)), concatenate((xm,ym)))
alltest(Numeric.concatenate((x,y)), concatenate((x,y)))
alltest(Numeric.concatenate((x,y)), concatenate((xm,y)))
alltest(Numeric.concatenate((x,y,x)), concatenate((x,ym,x)))
ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
assert isinstance(count(ott), types.IntType)
alltest(3, count(ott))
alltest(1, count(1))
alltest(0, array(1,mask=[1]))
ott.shape = (2,2)
assert isMaskedArray(count(ott,0))
assert isinstance(count(ott), types.IntType)
alltest(3, count(ott))
assert getmask(count(ott,0)) is None
alltest([1,2],count(ott,0))
xr = Numeric.ravel(x) #max doesn't work if shaped
xmr = ravel(xm)
alltest(max(xr), maximum(xmr)) #true because of careful selection of data
alltest(min(xr), minimum(xmr)) #true because of careful selection of data
alltest(Numeric.add.reduce(x), add.reduce(x))
alltest(Numeric.add.accumulate(x), add.accumulate(x))
alltest(4, sum(array(4)))
alltest(4, sum(array(4), axis=0))
alltest(Numeric.sum(x), sum(x))
alltest(Numeric.sum(filled(xm,0)), sum(xm))
alltest(Numeric.sum(x,0), sum(x,0))
alltest(Numeric.product(x), product(x))
alltest(Numeric.product(x,0), product(x,0))
alltest(Numeric.product(filled(xm,1)), product(xm))
if len(s) > 1:
alltest(Numeric.concatenate((x,y),1), concatenate((xm,ym),1))
alltest(Numeric.add.reduce(x,1), add.reduce(x,1))
alltest(Numeric.sum(x,1), sum(x,1))
alltest(Numeric.product(x,1), product(x,1))
def filter(self, data):
import Numeric
import FFT
if type(data) == type(Numeric.array([])):
fft = Numeric.absolute(FFT.fft(data))
return fft
def power(numericarray):
fft = ffteng.transform(numericarray)
amplitude = Numeric.absolute(fft)
return amplitude
x[0] = x[1]/10000.0
y = Numeric.zeros(len(x),typecode=Numeric.Float)
ygrid = Numeric.zeros(len(xgrid),typecode=Numeric.Float)
dk = data
A = dk['a']**2
s2 = dk['s2']
evals = d.evals.real**2
if data['fe_type'] == 'linconst':
xgrid = xgrid+xgrid[1]/2.
for gamma_ind in range(6):#min(nphi,len(gamma)-1)):#nphi,2):
for i in range(len(x)):
y[i] = sf.bessel_J1(x[i]*gamma[gamma_ind])[0]
for i in range(len(xgrid)):
ygrid[i] = sf.bessel_J1(xgrid[i]*gamma[gamma_ind])[0]
omega1 = dk['Bz0']**2/(2*dk['rho0']*s2/(5./3.)*dk['Bz0']**2*A)*(A*dk['k']**2+gamma[gamma_ind]**2)*(1+s2)*(1-(1-4*s2*A*dk['k']**2/((1+s2)**2*(A*dk['k']**2+gamma[gamma_ind]**2)))**(1./2.))
min_ind = Numeric.argsort(Numeric.absolute(evals-omega1))[0]
print 'min_ind=',min_ind
error = evals[min_ind]-omega1
#EV =get_evec_3(data,3,min_ind)
EV = d.get_evec1('3',min_ind,x).real
fac =((EV[-2]+EV[-2])/2./ygrid[-2])
fac = EV[-1]/y[-1]
if data['fe_type'] == 'linconst':
fac = EV[0]/(ygrid[0]+ygrid[1])*4
g = Gnuplot.Gnuplot(persist=1)
#print 'x=',x,'y=',y,'EV=',EV,'fac=',fac
g.plot(Gnuplot.Data(x,y,with='lines',title='Exact'),Gnuplot.Data(x,EV/fac,title='Computed'),title='{/Symbol w}^2=%g; Analytic=%g'%(evals[min_ind],omega1))
#if gamma_ind < 10:
#g.hardcopy('plots/%s.evecz_slow_%d.eps'%(sys.argv[1],min_ind),eps=True)
sys.exit()
(chanN - NC)] + 1j * x[2 * chanX + 1 + 2 * (chanN - NC)]
waL.append(wa1)
waL.append(wa2)
# Calculate mutual information
lPr = Numeric.zeros(1, Numeric.Complex)
woL = calcOverallWeight_f(wqL, BL, waL, 2)
(y, SigmaY) = calcCovarOutput_f(fbinX, samples, woL, halfBandShift, 2)
det = calcDet22(SigmaY)
iSigmaY = getInverseMat22(SigmaY, det)
sigma_11 = Numeric.sqrt(SigmaY[0][0].real)
sigma_22 = Numeric.sqrt(SigmaY[1][1].real)
for frX in range(frameN):
s = calcS(y[frX], iSigmaY)
abs_y1 = Numeric.absolute(y[frX][0])
abs_y2 = Numeric.absolute(y[frX][1])
x_g21 = calcX_g2(abs_y1 * abs_y1, SigmaY[0][0].real)
x_g22 = calcX_g2(abs_y2 * abs_y2, SigmaY[1][1].real)
x_g4 = calcX_g4(s)
if (x_g21 >= ARGMAX_GAMMA or x_g22 >= ARGMAX_GAMMA
or x_g4 >= ARGMAX_GAMMA):
print 'O %d %e %e %e' % (frX, x_g21, x_g22, x_g4)
continue
lPr += calcLogGamma(s, det, x_g4)
lPr -= calcLogGamma_IC(sigma_11, abs_y1, x_g21)
lPr -= calcLogGamma_IC(sigma_22, abs_y2, x_g22)
mi = lPr * XTIMES / frameN
#mi = lPr
except:
print 'for %d, grid was not available'%(i)
neff = data['ngrid']-1.
var_list.append(1./neff**nexp)
ev_list.append(evals[inds[unst_ind]].imag)
ev1_list.append(evals[inds[unst_ind]].real)
#print matching_files
#print var_list#,ev_list,ev1_list
ux = list(sets.Set(var_list))
x2 = []
y2 = []
z2 = []
uux = []
min_files = []
for uh1 in ux:
if len(Numeric.nonzero(Numeric.absolute(Numeric.array(uux)-uh1)<1e-8))==0:
uux.append(uh1)
for x1 in uux:
x2.append(x1)
inds = Numeric.nonzero(Numeric.absolute(Numeric.array(var_list)-x1)<1e-8)
z2.append(min(Numeric.take(ev_list,inds)))
inds = Numeric.nonzero(Numeric.array(ev_list)==z2[-1])
min_files.append(Numeric.take(matching_files,inds)[0])
y2a = Numeric.take(ev1_list,inds)
y2.append(y2a[0])
var_list = x2
ev_list = z2
ev1_list = y2
#print 1./Numeric.array(var_list)
inds = Numeric.argsort(var_list)
var_list = list(Numeric.take(var_list,inds))
def __abs__(self):
return Numeric.absolute(self.blob.as_array())
