def test_point_point():
p1 = Point(0,0)
p2 = Point(1,1)
ok_(p1.geom_type=='Point', p1.geom_type)
assert_ae(p1.coords[:][0], (0,0))
d = p1.distance(p2)
assert_eq(d, sqrt(2))
def test_2(self):
"""test write FrameArray"""
farray = FrameArray("data/md1_prod.Tc5b.x",
"./data/Tc5b.top",
indices=range(10))
writetraj("test_write_output.x", farray, farray.top, overwrite=True)
writetraj("test_pdb_1.dummyext",
farray[0],
farray.top,
overwrite=True,
fmt='pdb')
# test 'save'
print farray
farray.save("test_write_output_save_method.x", overwrite=True)
# reproduce result?
f0 = mdio.load("test_write_output.x", "./data/Tc5b.top")
f1 = mdio.load("test_write_output_save_method.x", "./data/Tc5b.top")
from numpy.testing import assert_almost_equal as assert_ae
assert_ae(f0[:, :, :], f1[:, :, :])
read_c = f.variables['vc'][:]
read_f = f.variables['vf'][:]
print 'read_c.shape', read_c.shape
print 'read_f.shape', read_f.shape
read_f2 = f.variables['vf'][:].reshape((dim_nx, dim_ny), order='F')
read_f3 = numpy.zeros((dim_nx, dim_ny), order='F')
read_f3[:] = f.variables['vf'][:]
print "read_c.ravel('A')", read_c.ravel('A')
print "read_c.ravel('C')", read_c.ravel('C')
print "read_c.ravel('F')", read_c.ravel('F')
print '-'*80
print "read_f.ravel('A')", read_f.ravel('A')
print "read_f.ravel('C')", read_f.ravel('C')
print "read_f.ravel('F')", read_f.ravel('F')
print '-'*80
print "read_f2.ravel('A')", read_f2.ravel('A')
print "read_f2.ravel('C')", read_f2.ravel('C')
print "read_f2.ravel('F')", read_f2.ravel('F')
print '-'*80
print "read_f3.ravel('A')", read_f3.ravel('A')
print "read_f3.ravel('C')", read_f3.ravel('C')
print "read_f3.ravel('F')", read_f3.ravel('F')
print '-'*80
assert_ae(data_c.ravel('A'), read_c.ravel('A'))
assert_ae(data_f.ravel('A'), read_f3.ravel('A'))
f.close()
def test_combine_misfits(dump=False, reference=None):
source, targets = scenario('wellposed', 'noisefree')
p = ToyProblem(name='toy_problem',
ranges={
'north': gf.Range(start=-10., stop=10.),
'east': gf.Range(start=-10., stop=10.),
'depth': gf.Range(start=0., stop=10.)
},
base_source=source,
targets=targets)
ngx, ngy, ngz = 11, 11, 11
xg = num.zeros((ngz * ngy * ngx, 3))
xbounds = p.get_parameter_bounds()
cx = num.linspace(xbounds[0][0], xbounds[0][1], ngx)
cy = num.linspace(xbounds[1][0], xbounds[1][1], ngy)
cz = num.linspace(xbounds[2][0], xbounds[2][1], ngz)
xg[:, 0] = num.tile(cx, ngy * ngz)
xg[:, 1] = num.tile(num.repeat(cy, ngx), ngz)
xg[:, 2] = num.repeat(cz, ngx * ngy)
misfitss = p.misfits_many(xg)
# misfitss[imodel, itarget, 0], misfitss[imodel, itarget, 1]
gms = p.combine_misfits(misfitss)
gms_contrib = p.combine_misfits(misfitss, get_contributions=True)
# gms[imodel]
# gms_contrib[imodel, itarget]
bweights = num.ones((2, p.ntargets))
gms_2 = p.combine_misfits(misfitss, extra_weights=bweights)
gms_2_contrib = p.combine_misfits(misfitss,
extra_weights=bweights,
get_contributions=True)
if dump:
num.savez(dump, gms, gms_contrib, gms_2)
# gms_2[imodel, ibootstrap]
# gms_2_contrib[imodel, ibootstrap, itarget]
for ix, x in enumerate(xg):
misfits = p.misfits(x)
# misfits[itarget, 0], misfits[itarget, 1]
gm = p.combine_misfits(misfits)
# gm is scalar
t.assert_equal(gm, gms[ix])
gm_contrib = p.combine_misfits(misfits, get_contributions=True)
assert_ae(gms_contrib[ix, :], gm_contrib)
gm_2 = p.combine_misfits(misfits, extra_weights=bweights)
assert gm_2[0] == gm
assert gm_2[1] == gm
assert gms_2[ix, 0] == gm
assert gms_2[ix, 1] == gm
gm_2_contrib = p.combine_misfits(misfits,
extra_weights=bweights,
get_contributions=True)
assert_ae(gm_2_contrib[0, :], gm_contrib)
assert_ae(gm_2_contrib[1, :], gm_contrib)
assert_ae(gms_2_contrib[ix, 0, :], gm_contrib)
assert_ae(gms_2_contrib[ix, 1, :], gm_contrib)
if reference:
ref_data = num.load(reference)
assert_ae(ref_data['arr_0'], gms)
assert_ae(ref_data['arr_1'], gms_contrib)
assert_ae(ref_data['arr_2'], gms_2)
# dataset
h5f.create_dataset('arr_a', data=arr_a, compression='gzip')
h5f.create_dataset('arr_b', data=arr_b, compression='gzip')
h5f.close()
#------------------------------------------------------------------------------
# read a nc file
#------------------------------------------------------------------------------
h5f = h5.File('write_read.h5', 'r')
print '='*80
print 'description', h5f.attrs['description']
print 'size', h5f.attrs['size']
read_a = h5f['arr_a'].value
read_b = h5f['arr_b'].value
print 'read arrays'
pprint(read_a)
pprint(read_b)
# verification
assert_ae(read_a, arr_a)
assert_ae(read_b, arr_b)
h5f.close()
block = (256, 1, 1) grid = (nx // 256 + 1, 1) # ------------------------------------------------------------------------------ # Compare # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ # Multiply print "Multiply" c[:] = a * b # assert_ae(c, c_f90) multiply_f90(a_f90, b_f90, c_f90) assert_ae(c, c_f90) # assert_ae(c, c_from_gpu) multiply_gpu(numpy.int32(nx), a_gpu, b_gpu, c_gpu, block=block, grid=grid) cuda.memcpy_dtoh(c_from_gpu, c_gpu) assert_ae(c, c_from_gpu) # ------------------------------------------------------------------------------ # Add print "Add" c[:] = a + b # assert_ae(c, c_f90) add_f90(a_f90, b_f90, c_f90) assert_ae(c, c_f90)
import numpy from numpy.testing import assert_array_equal as assert_ae from numpy.testing import assert_array_almost_equal as assert_aae TOL = numpy.finfo(numpy.float64).eps #------------------------------------------------------------------------------ # Setup # 4x4 matrix A = numpy.array([[10,-1,2,0], [-1,11,-1,3], [2,-1,10,-1], [0,3,-1,8]]) b = numpy.array([6,25,-11,15]) x_exact = (1,2,-1,1) assert_ae(numpy.dot(A, x_exact), b) #------------------------------------------------------------------------------ # numpy solve x = numpy.linalg.solve(A, b) assert_ae(x, x_exact) #============================================================================== # Gauss-Seidel method #============================================================================== # naive implementation x = numpy.zeros(4)
# setup
nx = 1000000
a = numpy.random.rand(nx)
b = numpy.random.rand(nx)
c = numpy.zeros(nx)
#----------------------------------------------------------------------
# Fortran code
#----------------------------------------------------------------------
src_f90 = '''
SUBROUTINE add(nx, a, b, c)
IMPLICIT NONE
INTEGER, INTENT(IN) :: nx
DOUBLE PRECISION, DIMENSION(nx), INTENT(IN) :: a, b
DOUBLE PRECISION, DIMENSION(nx), INTENT(INOUT) :: c
INTEGER :: ii
DO ii=1,nx
c(ii) = a(ii) + b(ii)
END DO
END SUBROUTINE
'''
mod = get_module_f90(src_f90)
add_f90 = mod.add
add_f90(a, b, c)
assert_ae(a+b, c)
from __future__ import division import numpy from numpy.testing import assert_array_equal as assert_ae # 2x2 A = numpy.array([[3,1], [1,2]]) b = numpy.array([9,8]) x = numpy.linalg.solve(A, b) print x assert_ae(x, (2,3)) assert_ae(numpy.dot(A, x), b) # 4x4 A = numpy.array([[10,-1,2,0], [-1,11,-1,3], [2,-1,10,-1], [0,3,-1,8]]) b = numpy.array([6,25,-11,15]) x = numpy.linalg.solve(A, b) print x assert_ae(x, (1,2,-1,1)) assert_ae(numpy.dot(A, x), b)