def test_select(self):
# check indexing with a tuple of arrays and with 1-level dimensions:
dim1=Dim(['dim'],'dim1')
dim2=Dim([1,2],'dim2')
dim3=Dim([3,4,5],'dim3')
dat=DimArray([[[6,7,8],[9,10,11]]],[dim1,dim2,dim3])
self.assertEquals(dat.select(dim2=dat['dim2']>1,
dim3=dat['dim3']>3).shape,(1,1,2))
def test_select(self):
# check indexing with a tuple of arrays and with 1-level dimensions:
dim1=Dim(['dim'],'dim1')
dim2=Dim([1,2],'dim2')
dim3=Dim([3,4,5],'dim3')
dat=DimArray([[[6,7,8],[9,10,11]]],[dim1,dim2,dim3])
self.assertEquals(dat.select(dim2=dat['dim2']>1,
dim3=dat['dim3']>3).shape,(1,1,2))
def test_find(self):
# check indexing with a tuple of arrays and with 1-level dimensions:
dim1=Dim(['dim'],'dim1')
dim2=Dim([1,2],'dim2')
dim3=Dim([3,4,5],'dim3')
dat=DimArray([[[6,7,8],[9,10,11]]],[dim1,dim2,dim3])
indx = dat.find(dim2=dat['dim2']>1,dim3=dat['dim3']>3)
assert_array_equal(dat.select(dim2=dat['dim2']>1,dim3=dat['dim3']>3),
dat[indx])
def test_find(self):
# check indexing with a tuple of arrays and with 1-level dimensions:
dim1=Dim(['dim'],'dim1')
dim2=Dim([1,2],'dim2')
dim3=Dim([3,4,5],'dim3')
dat=DimArray([[[6,7,8],[9,10,11]]],[dim1,dim2,dim3])
indx = dat.find(dim2=dat['dim2']>1,dim3=dat['dim3']>3)
assert_array_equal(dat.select(dim2=dat['dim2']>1,dim3=dat['dim3']>3),
dat[indx])
def test_get_axis(self):
dat = DimArray(np.random.rand(5,10,3),
dims=[Dim(range(5),name='one'),
Dim(range(10),name='two'),
Dim(range(3),name='three')],test='tst')
self.assertEqual(dat.get_axis(0),0)
self.assertEqual(dat.get_axis(1),1)
self.assertEqual(dat.get_axis(2),2)
self.assertEqual(dat.get_axis('one'),0)
self.assertEqual(dat.get_axis('two'),1)
self.assertEqual(dat.get_axis('three'),2)
def test_reshape(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(5,12,3,1)
dat = DimArray(arr,dims=[Dim(range(5),name='one'),
Dim(range(12),name='two'),
Dim(range(3),name='three'),
Dim(range(1),name='four')],test='tst')
newshapes = [(5,2,2,3,3),(2,3,5,3,2),(15,12),(6,2,15,1,1,1,1,1,1,1),
180,(1,1,1,180,1,1,1)]
for newshape in newshapes:
assert_array_equal(arr.reshape(newshape),dat.reshape(newshape))
assert_array_equal(np.reshape(arr,newshape),
np.reshape(dat,newshape))
def test_reshape(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(5,12,3,1)
dat = DimArray(arr,dims=[Dim(range(5),name='one'),
Dim(range(12),name='two'),
Dim(range(3),name='three'),
Dim(range(1),name='four')],test='tst')
newshapes = [(5,2,2,3,3),(2,3,5,3,2),(15,12),(6,2,15,1,1,1,1,1,1,1),
180,(1,1,1,180,1,1,1)]
for newshape in newshapes:
assert_array_equal(arr.reshape(newshape),dat.reshape(newshape))
assert_array_equal(np.reshape(arr,newshape),
np.reshape(dat,newshape))
def test_ncio():
a = DimArray([1, 2], dims='xx0')
b = DimArray([3, 4, 5], dims='xx1')
fname = os.path.join(testdata, "test.nc")
a.write_nc(fname, "a", mode='w')
b.write_nc(fname, "b", mode='a')
try:
b.write_nc(fname.replace('.nc', 'netcdf3.nc'),
"b",
mode='w',
format='NETCDF3_CLASSIC')
except Exception, msg:
warn(
"writing as NETCDF3_CLASSIC failed (known bug on 64bits systems): {msg}"
.format(msg=repr(msg)))
def __setattr__(self, name, value):
# ensure that tdim is a valid dimension name:
if name == 'tdim':
if not(value in self.dim_names):
raise ValueError(
'Provided time dimension name (tdim) is invalid!\n'+
'Provided value: '+ str(value)+'\nAvailable dimensions: '+
str(self.dim_names))
# ensure that sample rate is a postive float:
elif name == 'samplerate':
value = float(value)
if value <= 0:
raise ValueError(
'Samplerate must be positive! Provided value: '+
str(value))
DimArray.__setattr__(self,name,value)
def __setattr__(self, name, value):
# ensure that tdim is a valid dimension name:
if name == 'tdim':
if not(value in self.dim_names):
raise ValueError(
'Provided time dimension name (tdim) is invalid!\n'+
'Provided value: '+ str(value)+'\nAvailable dimensions: '+
str(self.dim_names))
# ensure that sample rate is a postive float:
elif name == 'samplerate':
value = float(value)
if value <= 0:
raise ValueError(
'Samplerate must be positive! Provided value: '+
str(value))
DimArray.__setattr__(self,name,value)
def test_resize(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(5,12,3,1)
dat = DimArray(arr,dims=[Dim(range(5),name='one'),
Dim(range(12),name='two'),
Dim(range(3),name='three'),
Dim(range(1),name='four')],test='tst')
self.assertRaises(NotImplementedError,dat.resize,(5,2,2,3,3))
def test_add_dim(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(5)
dat = DimArray(arr,dims=[Dim(range(5),name='one')])
# make new dim to add
d = Dim(range(10),name='replicate')
# add it to the dat
ndat = dat.add_dim(d)
# test that it worked
# verify shape
self.assertEquals(len(ndat.shape),len(dat.shape)+1)
self.assertEquals(ndat.shape[0],10)
self.assertEquals(ndat.shape[1],5)
# verify contents (a couple random spots)
assert_array_equal(ndat[4],dat)
assert_array_equal(ndat[7],dat)
assert_array_equal(ndat.dims[0],d)
assert_array_equal(ndat.dims[1],dat.dims[0])
def test_add_dim(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(5)
dat = DimArray(arr,dims=[Dim(range(5),name='one')])
# make new dim to add
d = Dim(range(10),name='replicate')
# add it to the dat
ndat = dat.add_dim(d)
# test that it worked
# verify shape
self.assertEquals(len(ndat.shape),len(dat.shape)+1)
self.assertEquals(ndat.shape[0],10)
self.assertEquals(ndat.shape[1],5)
# verify contents (a couple random spots)
assert_array_equal(ndat[4],dat)
assert_array_equal(ndat[7],dat)
assert_array_equal(ndat.dims[0],d)
assert_array_equal(ndat.dims[1],dat.dims[0])
def test_extend(self):
"""Test the extend method"""
# make ndarrays and DimArrays with identical data
arr1 = np.arange(256).reshape((4,4,4,4))
dat1 = DimArray(arr1,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
arr2 = np.arange(256,512).reshape((4,4,4,4))
dat2 = DimArray(arr2,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4,8),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
# extend
dat1dat2 = dat1.extend(dat2,'three')
arr1arr2 = np.concatenate([arr1,arr2],2)
assert_array_equal(dat1dat2,arr1arr2)
def test_ncio(tmpdir):
fname = tmpdir.join("test.nc").strpath # have test.nc in some temporary directory
a = DimArray([1,2], dims='xx0')
b = DimArray([3,4,5], dims='xx1')
a.write_nc(fname,"a", mode='w')
b.write_nc(fname,"b", mode='a')
try:
b.write_nc(fname.replace('.nc','netcdf3.nc'),"b", mode='w', format='NETCDF3_CLASSIC')
except Exception, msg:
warn("writing as NETCDF3_CLASSIC failed (known bug on 64bits systems): {msg}".format(msg=repr(msg)))
def test_extend(self):
"""Test the extend method"""
# make ndarrays and DimArrays with identical data
arr1 = np.arange(256).reshape((4,4,4,4))
dat1 = DimArray(arr1,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
arr2 = np.arange(256,512).reshape((4,4,4,4))
dat2 = DimArray(arr2,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4,8),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
# extend
dat1dat2 = dat1.extend(dat2,'three')
arr1arr2 = np.concatenate([arr1,arr2],2)
assert_array_equal(dat1dat2,arr1arr2)
def __new__(cls, data, tdim, samplerate, *args, **kwargs):
# make new DimArray with timeseries attributes
ts = DimArray(data, *args, **kwargs)
# ensure that tdim is a valid dimension name:
if not (tdim in ts.dim_names):
raise ValueError(
'Provided time dimension name (tdim) is invalid!\n' +
'Provided value: ' + str(tdim) + '\nAvailable dimensions: ' +
str(ts.dim_names))
ts.tdim = tdim
# ensure that sample rate is a float:
samplerate = float(samplerate)
# ensure that sample rate is postive:
if samplerate <= 0:
raise ValueError('Samplerate must be positive! Provided value: ' +
str(samplerate))
ts.samplerate = samplerate
# convert to TimeSeries and return:
return ts.view(cls)
def __new__(cls, data, tdim, samplerate, *args, **kwargs):
# make new DimArray with timeseries attributes
ts = DimArray(data, *args, **kwargs)
# ensure that tdim is a valid dimension name:
if not(tdim in ts.dim_names):
raise ValueError(
'Provided time dimension name (tdim) is invalid!\n'+
'Provided value: '+ str(tdim)+'\nAvailable dimensions: '+
str(ts.dim_names))
ts.tdim = tdim
# ensure that sample rate is a float:
samplerate = float(samplerate)
# ensure that sample rate is postive:
if samplerate <= 0:
raise ValueError(
'Samplerate must be positive! Provided value: '+
str(samplerate))
ts.samplerate = samplerate
# convert to TimeSeries and return:
return ts.view(cls)
def test_format(dim_array, tmpdir):
fname = tmpdir.join("test.nc").strpath # have test.nc in some temporary directory
a = DimArray([1,2], dims=['xx0'])
b = DimArray([3.,4.,5.], dims=['xx1'])
a.write_nc(fname,"a", mode='w')
b.write_nc(fname,"b", mode='a')
# b.write_nc(fname.replace('.nc','netcdf3.nc'),name="b", mode='w', format='NETCDF3_CLASSIC')
ds = da.Dataset([('a',a),('b',b)])
# NETCDF3_CLASSIC
ds.write_nc(fname.replace('.nc','netcdf3.nc'), mode='w', format='NETCDF3_CLASSIC')
dscheck = da.read_nc(fname.replace('.nc','netcdf3.nc'))
assert_equal_datasets(ds, dscheck)
# # NETCDF3_64bit
# ds.write_nc(fname.replace('.nc','netcdf3_64b.nc'), mode='w', format='NETCDF3_64BIT')
# dscheck = da.read_nc(fname.replace('.nc','netcdf3_64b.nc'))
# assert_equal_datasets(ds, dscheck)
data = read_nc(fname)
assert(np.all(data['a'] == a))
assert(np.all(data['b'] == b))
ds = da.Dataset(a=a, b=b)
for k in ds:
assert(np.all(ds[k] == data[k]))
def test_ufuncs(self):
"""Test the numpy u-functions"""
# make ndarray an Dimaray with identical data
arr = np.random.rand(5)
dat = DimArray(arr,dims=[Dim(range(5),name='one')],
test='tst')
x = np.ones(10) * dat[[0]]
self.assertTrue(isinstance(x,np.ndarray))
x = np.ones(1) * dat[[0]]
self.assertTrue(isinstance(x,DimArray))
x = 22 * dat
self.assertTrue(isinstance(x,DimArray))
assert_array_equal(x,arr*22)
def test_get_axis(self):
dat = DimArray(np.random.rand(5,10,3),
dims=[Dim(range(5),name='one'),
Dim(range(10),name='two'),
Dim(range(3),name='three')],test='tst')
self.assertEqual(dat.get_axis(0),0)
self.assertEqual(dat.get_axis(1),1)
self.assertEqual(dat.get_axis(2),2)
self.assertEqual(dat.get_axis('one'),0)
self.assertEqual(dat.get_axis('two'),1)
self.assertEqual(dat.get_axis('three'),2)
def test_pickle(self):
# make sure we can pickle this thing
dat = DimArray(np.random.rand(4,3))
# dump to string
pstr = pickle.dumps(dat)
# load to new variable
dat2 = pickle.loads(pstr)
# make sure data same
assert_array_equal(dat,dat2)
# make sure has attr and it's correct
self.assertTrue(hasattr(dat2,'_attrs'))
self.assertTrue(hasattr(dat2,'dims'))
assert_array_equal(dat.dims[0],dat2.dims[0])
assert_array_equal(dat.dims[1],dat2.dims[1])
# make sure has required attr
self.assertTrue(hasattr(dat2,'_required_attrs'))
self.assertEquals(dat._required_attrs,dat2._required_attrs)
def test_newaxis(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(5,12,3,1)
dat = DimArray(arr,dims=[Dim(range(5),name='one'),
Dim(range(12),name='two'),
Dim(range(3),name='three'),
Dim(range(1),name='four')],test='tst')
# add a new axis at beginning
d0 = dat[np.newaxis,:]
self.assertEquals(d0.dim_names[0],'newaxis_0')
self.assertEquals(d0.dim_names[-1],'four')
self.assertEquals(len(d0.shape),len(arr.shape)+1)
# add a new axis at end
d0 = dat[:,:,:,:,np.newaxis]
self.assertEquals(d0.dim_names[-1],'newaxis_4')
self.assertEquals(d0.dim_names[0],'one')
self.assertEquals(len(d0.shape),len(arr.shape)+1)
# add two axes at once
d0 = dat[np.newaxis,:,:,:,:,np.newaxis]
self.assertEquals(d0.dim_names[-1],'newaxis_5')
self.assertEquals(d0.dim_names[0],'newaxis_0')
self.assertEquals(len(d0.shape),len(arr.shape)+2)
# make sure the attribute is still there
d0.test = 'tst'
def test_new(self):
# should raise Error if dims contains non-Dim instances:
self.assertRaises(AttributeError,DimArray,np.random.rand(5,10),
dims = np.arange(4))
self.assertRaises(AttributeError,DimArray,np.random.rand(5,10),
dims=[Dim(range(5),name='freqs',unit='Hz'),
AttrArray(range(10),name='time',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(5,10),
dims=[AttrArray(range(5),name='freqs',unit='Hz'),
Dim(range(10),name='time',unit='sec')])
# should throw Error if dims do not match data shape:
self.assertRaises(AttributeError,DimArray,np.random.rand(5,10),
dims=[Dim(range(10),name='freqs',unit='Hz'),
Dim(range(5),name='time',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(5,10),
dims=[Dim(range(5),name='freqs',unit='Hz')])
# should throw Error if 2 dims have the same name:
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='dim1',unit='Hz'),
Dim(range(5),name='dim1',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,3,5),
dims=[Dim(range(10),name='dim1',unit='Hz'),
Dim(range(3),name='dim2',unit='Hz'),
Dim(range(5),name='dim1',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,3,5),
dims=[Dim(range(10),name='dim1',unit='Hz'),
Dim(range(3),name='dim1',unit='Hz'),
Dim(range(5),name='dim1',unit='sec')])
# should throw Error if a dim name is not a valid identifier:
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='dim1',unit='Hz'),
Dim(range(5),name='dim 2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='dim 1',unit='Hz'),
Dim(range(5),name='dim2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='dim 1',unit='Hz'),
Dim(range(5),name='dim 2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='dim1',unit='Hz'),
Dim(range(5),name='dim$2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='$dim1',unit='Hz'),
Dim(range(5),name='dim2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='1dim1',unit='Hz'),
Dim(range(5),name='dim:2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='dim1',unit='Hz'),
Dim(range(5),name='',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='',unit='Hz'),
Dim(range(5),name='dim2',unit='sec')])
self.assertRaises(AttributeError,DimArray,np.random.rand(10,5),
dims=[Dim(range(10),name='',unit='Hz'),
Dim(range(5),name='',unit='sec')])
# this is a proper initialization:
dat = DimArray(np.random.rand(5,10),
dims=[Dim(range(5),name='freqs',unit='Hz'),
Dim(range(10),name='time',unit='sec')])
# should raise Attribute Error if dims is removed:
self.assertRaises(AttributeError,dat.__setattr__,'dims',None)
# ensure dim_names attribute is set properly:
self.assertEquals(dat.dim_names,['freqs','time'])
# ensure proper shape
self.assertEquals(dat.shape,(5,10))
# ensure dims have proper lengths:
self.assertEquals(len(dat.dims[0]),5)
self.assertEquals(len(dat.dims[1]),10)
# ensure that dims attributes are copied properly:
self.assertEquals(dat.dims[0].unit,'Hz')
self.assertEquals(dat.dims[1].unit,'sec')
# check that dims values are preserved:
self.assertEquals(dat.dims[0][-1],4)
self.assertEquals(dat.dims[1][-1],9)
dat = DimArray(np.random.rand(2,4,5),
dims=[Dim(range(2),name='dim1',unit='Hz'),
Dim(range(4),name='dim2',bla='bla'),
Dim(range(5),name='dim3',attr1='attr1',
attr2='attr2')])
# ensure dim_names attribute is set properly:
self.assertEquals(dat.dim_names,['dim1','dim2','dim3'])
# ensure proper shape
self.assertEquals(dat.shape,(2,4,5))
# ensure dims have proper lengths:
self.assertEquals(len(dat.dims[0]),2)
self.assertEquals(len(dat.dims[1]),4)
self.assertEquals(len(dat.dims[2]),5)
# ensure that dims attributes are copied properly:
self.assertEquals(dat.dims[0].unit,'Hz')
self.assertEquals(dat.dims[1].bla,'bla')
self.assertEquals(dat.dims[2].attr1,'attr1')
self.assertEquals(dat.dims[2].attr2,'attr2')
# check that dims values are preserved:
self.assertEquals(dat.dims[0][-1],1)
self.assertEquals(dat.dims[1][-1],3)
self.assertEquals(dat.dims[2][-1],4)
# check filling in of default dims if left out
dat = DimArray(np.random.rand(4,3))
self.assertEquals(dat.dim_names, ['dim1','dim2'])
assert_array_equal(dat['dim1'],np.arange(dat.shape[0]))
assert_array_equal(dat['dim2'],np.arange(dat.shape[1]))
def test_funcs(self):
"""Test the numpy functions"""
# make ndarray an Dimaray with identical data
arr = np.random.rand(5,12,3,1)
dat = DimArray(arr,dims=[Dim(range(5),name='one'),
Dim(range(12),name='two'),
Dim(range(3),name='three'),
Dim(range(1),name='four')],test='tst')
# these are functions that take an axis argument:
funcs = [np.mean,np.all,np.any,np.argmax,np.argmin,np.argsort,
np.cumprod,np.cumsum,np.max,np.mean,np.min,np.prod,
np.ptp,np.std,np.sum,np.var]
# The axes for the ndarray:
axes_arr = [None,0,1,2,3,0,1,2,3]
# The axes for the DimArray (we want to test indexing them by
# number and name):
axes_dat = [None,0,1,2,3,'one','two','three','four']
# loop through the functions and axes:
for func in funcs:
for a in range(len(axes_arr)):
# apply the function to the ndarray and the DimArray
arr_func = func(arr,axis=axes_arr[a])
dat_func = func(dat,axis=axes_dat[a])
# make sure they are the same:
assert_array_equal(arr_func,dat_func)
if not(axes_dat[a] is None):
# ensure we still have a DimArray
self.assertTrue(isinstance(dat_func,DimArray))
# ensure that the attributes are preserved
self.assertEquals(dat_func.test,'tst')
# same tests as above but this time calling the DimArray
# methods directly (this test is necessary because it is in
# principle possible for the numpy function to work and the
# DimArray method not to work (or vice versa):
for a in range(len(axes_arr)):
assert_array_equal(arr.all(axes_arr[a]),
dat.all(axes_dat[a]))
assert_array_equal(arr.any(axes_arr[a]),
dat.any(axes_dat[a]))
assert_array_equal(arr.argmax(axes_arr[a]),
dat.argmax(axes_dat[a]))
assert_array_equal(arr.argmin(axes_arr[a]),
dat.argmin(axes_dat[a]))
assert_array_equal(arr.argsort(axes_arr[a]),
dat.argsort(axes_dat[a]))
assert_array_equal(arr.cumprod(axes_arr[a]),
dat.cumprod(axes_dat[a]))
assert_array_equal(arr.cumsum(axes_arr[a]),
dat.cumsum(axes_dat[a]))
assert_array_equal(arr.max(axes_arr[a]),
dat.max(axes_dat[a]))
assert_array_equal(arr.mean(axes_arr[a]),
dat.mean(axes_dat[a]))
assert_array_equal(arr.min(axes_arr[a]),
dat.min(axes_dat[a]))
assert_array_equal(arr.prod(axes_arr[a]),
dat.prod(axes_dat[a]))
assert_array_equal(arr.ptp(axes_arr[a]),
dat.ptp(axes_dat[a]))
assert_array_equal(arr.std(axes_arr[a]),
dat.std(axes_dat[a]))
assert_array_equal(arr.sum(axes_arr[a]),
dat.sum(axes_dat[a]))
assert_array_equal(arr.var(axes_arr[a]),
dat.var(axes_dat[a]))
if not(axes_dat[a] is None):
self.assertTrue(isinstance(dat.all(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.any(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.argmax(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.argmin(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.argsort(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.cumprod(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.cumsum(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.max(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.mean(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.min(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.prod(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.ptp(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.std(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.sum(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.var(axes_arr[a]),DimArray))
self.assertEquals(dat.all(axes_arr[a]).test,'tst')
self.assertEquals(dat.any(axes_arr[a]).test,'tst')
self.assertEquals(dat.argmax(axes_arr[a]).test,'tst')
self.assertEquals(dat.argmin(axes_arr[a]).test,'tst')
self.assertEquals(dat.argsort(axes_arr[a]).test,'tst')
self.assertEquals(dat.cumprod(axes_arr[a]).test,'tst')
self.assertEquals(dat.cumsum(axes_arr[a]).test,'tst')
self.assertEquals(dat.max(axes_arr[a]).test,'tst')
self.assertEquals(dat.mean(axes_arr[a]).test,'tst')
self.assertEquals(dat.min(axes_arr[a]).test,'tst')
self.assertEquals(dat.prod(axes_arr[a]).test,'tst')
self.assertEquals(dat.ptp(axes_arr[a]).test,'tst')
self.assertEquals(dat.std(axes_arr[a]).test,'tst')
self.assertEquals(dat.sum(axes_arr[a]).test,'tst')
self.assertEquals(dat.var(axes_arr[a]).test,'tst')
# test functions that require function specific input:
for a in range(len(axes_arr)):
if axes_arr[a] is None:
length = len(arr)
else:
length = np.shape(arr)[axes_arr[a]]
cond = np.random.random(length)>0.5
# calling the compress method directly:
arr_func = arr.compress(cond,axis=axes_arr[a])
dat_func = dat.compress(cond,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,DimArray))
self.assertEquals(dat_func.test,'tst')
# calling the numpy compress function:
arr_func = np.compress(cond,arr,axis=axes_arr[a])
dat_func = np.compress(cond,dat,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,DimArray))
self.assertEquals(dat_func.test,'tst')
# the below tests should not run with axis==None:
if axes_arr[a] is None:
continue
reps = np.random.random_integers(low=1, high=10, size=length)
# calling the repeat method directly:
arr_func = arr.repeat(reps,axis=axes_arr[a])
dat_func = dat.repeat(reps,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# calling the numpy repeat function:
arr_func = np.repeat(arr,reps,axis=axes_arr[a])
dat_func = np.repeat(dat,reps,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# skip the last dimension for this test for
# convenience (the last dimension only has 1 level):
if a >= 3:
continue
indcs = np.arange(len(arr.shape))
# calling the take method directly (squeeze, to get rid of
# the last dimension):
arr_func = arr.squeeze().take(indcs,axis=axes_arr[a])
dat_func = dat.squeeze().take(indcs,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a]:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# calling the numpy take function directly (squeeze, to get rid of
# the last dimension):
arr_func = np.take(arr.squeeze(),indcs,axis=axes_arr[a])
dat_func = np.take(dat.squeeze(),indcs,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a]:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# This should work with numpy 1.2 but doesn't
# with 1.1.1 or below (therfore commented out for now):
# arr_func = arr.clip(0.4,0.6)
# dat_func = dat.clip(0.4,0.6)
# assert_array_equal(arr_func,dat_func)
#self.assertTrue(isinstance(dat_func,DimArray))
#self.assertEquals(dat_func.test,'tst')
#arr_func = np.clip(arr,0.4,0.6)
#dat_func = np.clip(dat,0.4,0.6)
#assert_array_equal(arr_func,dat_func)
#self.assertTrue(isinstance(dat_func,DimArray))
#self.assertEquals(dat_func.test,'tst')
# other functions that don't necessarily take return a
# DimArray:
funcs = [np.diagonal,np.nonzero,np.ravel,np.squeeze,
np.sort,np.trace,np.transpose]
for func in funcs:
arr_func = func(arr)
dat_func = func(dat)
assert_array_equal(arr_func,dat_func)
# same tests as above, but calling the methods directly:
assert_array_equal(arr.diagonal(),dat.diagonal())
assert_array_equal(arr.nonzero(),dat.nonzero())
assert_array_equal(arr.ravel(),dat.ravel())
assert_array_equal(arr.squeeze(),dat.squeeze())
assert_array_equal(arr.sort(),dat.sort())
assert_array_equal(arr.trace(),dat.trace())
assert_array_equal(arr.transpose(),dat.transpose())
# there is no numpy.flatten() function, so we only call the
# method directly:
assert_array_equal(arr.flatten(),dat.flatten())
assert_array_equal(arr.swapaxes(0,1),dat.swapaxes(0,1))
self.assertTrue(isinstance(dat.swapaxes(0,1),DimArray))
self.assertEquals(dat.swapaxes(0,1).test,'tst')
assert_array_equal(arr.swapaxes(0,1),dat.swapaxes('one','two'))
self.assertTrue(isinstance(dat.swapaxes('one','two'),DimArray))
self.assertEquals(dat.swapaxes('one','two').test,'tst')
assert_array_equal(arr.swapaxes(1,3),dat.swapaxes(1,3))
self.assertTrue(isinstance(dat.swapaxes(1,3),DimArray))
self.assertEquals(dat.swapaxes(1,3).test,'tst')
assert_array_equal(arr.swapaxes(1,3),dat.swapaxes('two','four'))
self.assertTrue(isinstance(dat.swapaxes('two','four'),DimArray))
self.assertEquals(dat.swapaxes('two','four').test,'tst')
def test_make_bins(self):
"""Test the make_bins method"""
# make ndarray and DimArray with identical data
arr = np.arange(256).reshape((4,4,4,4))
dat = DimArray(arr,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
# test making bins on all dimensions:
test1a = dat.make_bins('one',2,np.mean)
assert_array_equal(test1a.dims[0],np.array([150,350]))
test1b = dat.make_bins(0,2,np.mean,bin_labels='sequential')
assert_array_equal(test1b.dims[0],np.array([0,1]))
assert_array_equal(test1a,test1b)
test2a = dat.make_bins('two',2,np.mean)
assert_array_equal(test2a.dims[1],np.array([35,55]))
test2b = dat.make_bins(1,2,np.mean,bin_labels=['a','b'])
assert_array_equal(test2b.dims[1],np.array(['a','b']))
assert_array_equal(test2a,test2b)
test3a = dat.make_bins('three',2,np.mean,bin_labels='function')
assert_array_equal(test3a.dims[2],np.array([0.5,2.5]))
test3b = dat.make_bins(2,2,np.mean)
assert_array_equal(test3b.dims[2],np.array([0.5,2.5]))
assert_array_equal(test3a,test3b)
test4a = dat.make_bins('four',2,np.mean)
assert_array_equal(test4a.dims[3],np.array([1025,1125]))
test4b = dat.make_bins(3,2,np.mean)
assert_array_equal(test4b.dims[3],np.array([1025,1125]))
assert_array_equal(test4a,test4b)
# test specifiying bins:
test4c = dat.make_bins('four',[[1000,1100],[1100,2000]],np.mean)
test4d = dat.make_bins(3,[[1000,1100],[1100,2000]],np.mean)
assert_array_equal(test4c,test4d)
assert_array_equal(test4a,test4d)
split = np.split
# compare output to reproduced output for ndarray:
test1c = np.array(split(arr,2,axis=0)).mean(1)
assert_array_equal(test1a,test1c)
test2c = np.array(split(arr,2,axis=1)).mean(2).transpose([1,0,2,3])
assert_array_equal(test2a,test2c)
test3c = np.array(split(arr,2,axis=2)).mean(3).transpose([1,2,0,3])
assert_array_equal(test3a,test3c)
test4e = np.array(split(arr,2,axis=3)).mean(4).transpose([1,2,3,0])
assert_array_equal(test4a,test4e)
# compare sequential applications of make_bins to desired output:
test12a = test1a.make_bins('two',2,np.mean)
assert_array_equal(test1a.dims[0],test12a.dims[0])
assert_array_equal(test2a.dims[1],test12a.dims[1])
test21a = test2a.make_bins('one',2,np.mean)
assert_array_equal(test1a.dims[0],test21a.dims[0])
assert_array_equal(test2a.dims[1],test21a.dims[1])
assert_array_equal(test12a,test21a)
test12b = test1a.make_bins(1,2,np.mean)
assert_array_equal(test1a.dims[0],test12b.dims[0])
assert_array_equal(test2a.dims[1],test12b.dims[1])
test21b = test2a.make_bins(0,2,np.mean)
assert_array_equal(test1a.dims[0],test21b.dims[0])
assert_array_equal(test2a.dims[1],test21b.dims[1])
assert_array_equal(test12b,test21b)
# check that attributes are preserved:
for a in dat._attrs:
if a == 'dims': continue
self.assertEqual(dat.__getattribute__(a),
test1a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test1b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test2a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test2b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test3a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test3b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test4a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test4b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test4d.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test12a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test12b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test21a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test21b.__getattribute__(a))
for d,dn in enumerate(dat.dim_names):
self.assertEquals(test1a.dim_names[d],dn)
self.assertEquals(test1b.dim_names[d],dn)
self.assertEquals(test2a.dim_names[d],dn)
self.assertEquals(test2b.dim_names[d],dn)
self.assertEquals(test3a.dim_names[d],dn)
self.assertEquals(test3b.dim_names[d],dn)
self.assertEquals(test4a.dim_names[d],dn)
self.assertEquals(test4b.dim_names[d],dn)
self.assertEquals(test12a.dim_names[d],dn)
self.assertEquals(test12b.dim_names[d],dn)
self.assertEquals(test21a.dim_names[d],dn)
self.assertEquals(test21b.dim_names[d],dn)
# test unequal bins:
arr = np.arange(256).reshape((4,16,4))
dat = DimArray(arr,dims=[Dim(np.arange(4),name='one'),
Dim(np.arange(16),name='two'),
Dim(np.arange(4),name='three')],test='tst')
self.assertRaises(ValueError,dat.make_bins,'two',3,np.mean)
test5a = dat.make_bins('two',3,np.mean,bin_labels=['1st','2nd','3rd'],
error_on_nonexact=False)
test5b = dat.make_bins(1,[[0,6,'1st'],[6,11,'2nd'],[11,16,'3rd']],
np.mean)
assert_array_equal(test5a,test5b)
assert_array_equal(test5a.dims[1],np.array(['1st','2nd','3rd']))
assert_array_equal(test5a.dims[1],test5b.dims[1])
# check that attributes are preserved:
for a in dat._attrs:
if a == 'dims': continue
self.assertEqual(dat.__getattribute__(a),
test5a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test5b.__getattribute__(a))
for d,dn in enumerate(dat.dim_names):
self.assertEquals(test5a.dim_names[d],dn)
self.assertEquals(test5b.dim_names[d],dn)
def test_extend(self):
"""Test the extend method"""
# make ndarrays and DimArrays with identical data
arr1 = np.arange(256).reshape((4,4,4,4))
dat1 = DimArray(arr1,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
arr2 = np.arange(256,512).reshape((4,4,4,4))
dat2 = DimArray(arr2,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4,8),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
# extend with string label for axis
dat1dat2 = dat1.extend(dat2,'three')
arr1arr2 = np.concatenate([arr1,arr2],2)
assert_array_equal(dat1dat2,arr1arr2)
# extend with int label for axis
dat1dat2 = dat1.extend(dat2,2)
arr1arr2 = np.concatenate([arr1,arr2],2)
assert_array_equal(dat1dat2,arr1arr2)
# now the same again for the case when not all dimensions are identical in size:
# make ndarrays and DimArrays with identical data
arr1 = np.arange(256).reshape((8,2,16,1))
dat1 = DimArray(arr1,dims=[Dim(np.arange(100,500,50),name='one'),
Dim(np.arange(30,70,20),name='two'),
Dim(np.arange(16),name='three'),
Dim(np.arange(1000,1200,200),name='four')],
test='tst')
arr2 = np.arange(256,512).reshape((8,2,16,1))
dat2 = DimArray(arr2,dims=[Dim(np.arange(100,500,50),name='one'),
Dim(np.arange(30,70,20),name='two'),
Dim(np.arange(16,32),name='three'),
Dim(np.arange(1000,1200,200),name='four')],
test='tst')
# extend with string label for axis
dat1dat2 = dat1.extend(dat2,'three')
arr1arr2 = np.concatenate([arr1,arr2],2)
assert_array_equal(dat1dat2,arr1arr2)
# extend with int label for axis
dat1dat2 = dat1.extend(dat2,2)
arr1arr2 = np.concatenate([arr1,arr2],2)
assert_array_equal(dat1dat2,arr1arr2)
# now the same again for the case when not all dimensions are identical in size:
# make ndarrays and DimArrays with identical data
arr1 = np.arange(4).reshape((1,1,4))
dat1 = DimArray(arr1,dims=[Dim([100],name='one'),
Dim([30],name='two'),
Dim(np.arange(4),name='three')],
test='tst')
arr2 = np.arange(4,16).reshape((1,3,4))
dat2 = DimArray(arr2,dims=[Dim([100],name='one'),
Dim(np.arange(40,90,20),name='two'),
Dim(np.arange(4),name='three')],
test='tst')
# extend with string label for axis
dat1dat2 = dat1.extend(dat2,'two')
arr1arr2 = np.concatenate([arr1,arr2],1)
assert_array_equal(dat1dat2,arr1arr2)
# extend with int label for axis
dat1dat2 = dat1.extend(dat2,1)
arr1arr2 = np.concatenate([arr1,arr2],1)
assert_array_equal(dat1dat2,arr1arr2)
def test_make_bins(self):
"""Test the make_bins method"""
# make ndarray and DimArray with identical data
arr = np.arange(256).reshape((4,4,4,4))
dat = DimArray(arr,dims=[Dim(np.arange(100,500,100),name='one'),
Dim(np.arange(30,70,10),name='two'),
Dim(np.arange(4),name='three'),
Dim(np.arange(1000,1200,50),name='four')],
test='tst')
# test making bins on all dimensions:
test1a = dat.make_bins('one',2,np.mean)
assert_array_equal(test1a.dims[0],np.array([150,350]))
test1b = dat.make_bins(0,2,np.mean,bin_labels='sequential')
assert_array_equal(test1b.dims[0],np.array([0,1]))
assert_array_equal(test1a,test1b)
test2a = dat.make_bins('two',2,np.mean)
assert_array_equal(test2a.dims[1],np.array([35,55]))
test2b = dat.make_bins(1,2,np.mean,bin_labels=['a','b'])
assert_array_equal(test2b.dims[1],np.array(['a','b']))
assert_array_equal(test2a,test2b)
test3a = dat.make_bins('three',2,np.mean,bin_labels='function')
assert_array_equal(test3a.dims[2],np.array([0.5,2.5]))
test3b = dat.make_bins(2,2,np.mean)
assert_array_equal(test3b.dims[2],np.array([0.5,2.5]))
assert_array_equal(test3a,test3b)
test4a = dat.make_bins('four',2,np.mean)
assert_array_equal(test4a.dims[3],np.array([1025,1125]))
test4b = dat.make_bins(3,2,np.mean)
assert_array_equal(test4b.dims[3],np.array([1025,1125]))
assert_array_equal(test4a,test4b)
# test specifiying bins:
test4c = dat.make_bins('four',[[1000,1100],[1100,2000]],np.mean)
test4d = dat.make_bins(3,[[1000,1100],[1100,2000]],np.mean)
assert_array_equal(test4c,test4d)
assert_array_equal(test4a,test4d)
split = np.split
# compare output to reproduced output for ndarray:
test1c = np.array(split(arr,2,axis=0)).mean(1)
assert_array_equal(test1a,test1c)
test2c = np.array(split(arr,2,axis=1)).mean(2).transpose([1,0,2,3])
assert_array_equal(test2a,test2c)
test3c = np.array(split(arr,2,axis=2)).mean(3).transpose([1,2,0,3])
assert_array_equal(test3a,test3c)
test4e = np.array(split(arr,2,axis=3)).mean(4).transpose([1,2,3,0])
assert_array_equal(test4a,test4e)
# compare sequential applications of make_bins to desired output:
test12a = test1a.make_bins('two',2,np.mean)
assert_array_equal(test1a.dims[0],test12a.dims[0])
assert_array_equal(test2a.dims[1],test12a.dims[1])
test21a = test2a.make_bins('one',2,np.mean)
assert_array_equal(test1a.dims[0],test21a.dims[0])
assert_array_equal(test2a.dims[1],test21a.dims[1])
assert_array_equal(test12a,test21a)
test12b = test1a.make_bins(1,2,np.mean)
assert_array_equal(test1a.dims[0],test12b.dims[0])
assert_array_equal(test2a.dims[1],test12b.dims[1])
test21b = test2a.make_bins(0,2,np.mean)
assert_array_equal(test1a.dims[0],test21b.dims[0])
assert_array_equal(test2a.dims[1],test21b.dims[1])
assert_array_equal(test12b,test21b)
# check that attributes are preserved:
for a in dat._attrs:
if a == 'dims': continue
self.assertEqual(dat.__getattribute__(a),
test1a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test1b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test2a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test2b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test3a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test3b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test4a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test4b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test4d.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test12a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test12b.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test21a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test21b.__getattribute__(a))
for d,dn in enumerate(dat.dim_names):
self.assertEquals(test1a.dim_names[d],dn)
self.assertEquals(test1b.dim_names[d],dn)
self.assertEquals(test2a.dim_names[d],dn)
self.assertEquals(test2b.dim_names[d],dn)
self.assertEquals(test3a.dim_names[d],dn)
self.assertEquals(test3b.dim_names[d],dn)
self.assertEquals(test4a.dim_names[d],dn)
self.assertEquals(test4b.dim_names[d],dn)
self.assertEquals(test12a.dim_names[d],dn)
self.assertEquals(test12b.dim_names[d],dn)
self.assertEquals(test21a.dim_names[d],dn)
self.assertEquals(test21b.dim_names[d],dn)
# test unequal bins:
arr = np.arange(256).reshape((4,16,4))
dat = DimArray(arr,dims=[Dim(np.arange(4),name='one'),
Dim(np.arange(16),name='two'),
Dim(np.arange(4),name='three')],test='tst')
self.assertRaises(ValueError,dat.make_bins,'two',3,np.mean)
test5a = dat.make_bins('two',3,np.mean,bin_labels=['1st','2nd','3rd'],
error_on_nonexact=False)
test5b = dat.make_bins(1,[[0,6,'1st'],[6,11,'2nd'],[11,16,'3rd']],
np.mean)
assert_array_equal(test5a,test5b)
assert_array_equal(test5a.dims[1],np.array(['1st','2nd','3rd']))
assert_array_equal(test5a.dims[1],test5b.dims[1])
# check that attributes are preserved:
for a in dat._attrs:
if a == 'dims': continue
self.assertEqual(dat.__getattribute__(a),
test5a.__getattribute__(a))
self.assertEqual(dat.__getattribute__(a),
test5b.__getattribute__(a))
for d,dn in enumerate(dat.dim_names):
self.assertEquals(test5a.dim_names[d],dn)
self.assertEquals(test5b.dim_names[d],dn)
def test_read_multiple_files(tmpdir):
# take tests from align
fname1 = tmpdir.join("test_multi1.nc").strpath
fname2 = tmpdir.join("test_multi2.nc").strpath
# stack, no need to align
a = DimArray([1,2,3], dims=['x0'])
b = DimArray([11,22,33], dims=['x0'])
a.write_nc(fname1, 'a', mode='w')
b.write_nc(fname2, 'a', mode='w')
c_got = da.read_nc([fname1, fname2], axis='stackdim', keys=['a','b'])
c = DimArray([[ 1, 2, 3],
[11, 22, 33]], axes=[['a', 'b'], [0, 1, 2]], dims=['stackdim', 'x0'])
assert_equal_dimarrays(c_got['a'], c)
# stack + align
a = DimArray([1,2,3], axes=[[0,1,2]], dims=['x0'])
b = DimArray([33,11], axes=[[2,0]], dims=['x0'])
a.write_nc(fname1, 'a', mode='w')
b.write_nc(fname2, 'a', mode='w')
c_got = da.read_nc([fname2, fname1], axis='stackdim', align=True, sort=True, keys=['b','a'])
c = DimArray([[11., np.nan, 33.],
[ 1., 2., 3.]], axes=[['b', 'a'], [0, 1, 2]], dims=['stackdim', 'x0'])
assert_equal_dimarrays(c_got['a'], c)
# concatenate
a = DimArray([1,2,3], dims=['x0'])
b = DimArray([11,22,33], dims=['x0'])
a.write_nc(fname1, 'a', mode='w')
b.write_nc(fname2, 'a', mode='w')
c_got = da.read_nc([fname1, fname2], axis='x0')
c = DimArray([1, 2, 3, 11, 22, 33], axes=[[0, 1, 2, 0, 1, 2]], dims=['x0'])
assert_equal_dimarrays(c_got['a'], c)
# concatenate 2-D
a = DimArray([[ 1, 2, 3],
[11, 22, 33]], axes=[[0,1],[2,1,0]])
b = DimArray([[44, 55, 66],
[4, 5, 6]], axes=[[1,0],[2,1,0]])
a.write_nc(fname1, 'a', mode='w')
b.write_nc(fname2, 'a', mode='w')
# ...first axis
c0_got = da.read_nc([fname1, fname2], axis='x0')
c0 = DimArray([[ 1, 2, 3],
[11, 22, 33],
[44, 55, 66],
[4, 5, 6]], axes=[[0,1,1,0],[2,1,0]])
assert_equal_dimarrays(c0_got['a'], c0)
# axis "x0" is not aligned !
with pytest.raises(ValueError):
c1_got = da.read_nc([fname1, fname2], axis='x1')
print(c1_got)
# ...second axis
c1_dima_got = da.read_nc([fname1, fname2], 'a', axis='x1', align=True, sort=True)
c1_ds_got = da.read_nc([fname1, fname2], axis='x1', align=True, sort=True)
c1 = DimArray([[ 1, 2, 3, 4, 5, 6],
[11, 22, 33, 44, 55, 66]], axes=[[0,1],[2,1,0,2,1,0]])
assert_equal_dimarrays(c1_dima_got, c1)
assert_equal_dimarrays(c1_ds_got['a'], c1)
def __getitem__(self, indices):
if indices is None:
rr = self.dataset.read(self.name)
if rr.getDataType().isNumeric():
ArrayMath.missingToNaN(rr, self.fill_value)
array = MIArray(rr)
data = DimArray(array, self.dims, self.fill_value,
self.dataset.proj)
return data
else:
return rr
if isinstance(indices, str): #metadata
rr = self.dataset.read(self.name)
m = rr.findMember(indices)
data = rr.getArray(0, m)
return MIArray(data)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
return None
origin = []
size = []
stride = []
dims = []
for i in range(0, self.ndim):
dimlen = self.dimlen(i)
k = indices[i]
if isinstance(k, int):
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
eidx = self.dimlen(i) - 1 if k.stop is None else k.stop
step = 1 if k.step is None else k.step
elif isinstance(k, (tuple, list)):
dim = self.variable.getDimension(i)
sidx = dim.getValueIndex(k[0])
if len(k) == 1:
eidx = sidx
step = 1
else:
eidx = dim.getValueIndex(k[1])
if len(k) == 2:
step = 1
else:
step = int(k[2] / dim.getDeltaValue)
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
else:
print k
return None
if eidx >= dimlen:
print 'Index out of range!'
return None
origin.append(sidx)
n = eidx - sidx + 1
size.append(n)
if n > 1:
dim = self.variable.getDimension(i)
if dim.isReverse():
step = -step
dims.append(dim.extract(sidx, eidx, step))
stride.append(step)
rr = self.dataset.read(self.name, origin, size, stride).reduce()
if rr.getSize() == 1:
return rr.getObject(0)
ArrayMath.missingToNaN(rr, self.fill_value)
array = MIArray(rr)
data = DimArray(array, dims, self.fill_value, self.dataset.proj)
return data
def a(ax0, ax1):
values = np.random.randn(ax0.size, ax1.size)
a = DimArray(values, axes=[ax0, ax1])
a.units = 'meters'
a.mutable_att = ['a1','a2']
return a
def _get_weights(self, axis=None, mirror_nans=True, weights=None):
""" Build array of weights based on individual axes' weights attribute
Parameters
----------
axis : int or str, optional
if None a N-D weight is created, otherwise 1-D only
mirror_nans : bool, optional
mirror `values`'s NaNs in created weights (True by default)
{weights}
Returns
-------
full_weights : DimArray of weights, or None
See Also
--------
DimArray.mean, DimArray.var, DimArray.std
Examples
--------
Simpler examples are found Dimarray.mean's doc.
These are mostly meant as doctest.
>>> from dimarray import DimArray
>>> np.random.seed(0) # to make results reproducible
>>> v = DimArray(np.random.rand(3,2), axes=[[-80, 0, 80], [-180, 180]], dims=['lat','lon'])
>>> v._get_weights() # None
>>> w = lambda x : np.cos(np.radians(v.lat))
>>> v.axes['lat'].weights = w
>>> v._get_weights()
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 0.17364818, 0.17364818],
[ 1. , 1. ],
[ 0.17364818, 0.17364818]])
>>> v.axes['lat'].weights = None
>>> v._get_weights() # None
Can pass the weigthts as a dictionary
>>> v._get_weights(weights={{'lat':w}})
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 0.17364818, 0.17364818],
[ 1. , 1. ],
[ 0.17364818, 0.17364818]])
Or by indicating the axis
>>> v._get_weights(weights=w, axis='lat')
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 0.17364818, 0.17364818],
[ 1. , 1. ],
[ 0.17364818, 0.17364818]])
It possible to mix up axis and dict-input weights
>>> v.axes['lat'].weights = w
>>> v._get_weights(weights={{'lon':lambda x:((x+180)/100)**2}})
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 0. , 1.5628336],
[ 0. , 9. ],
[ 0. , 1.5628336]])
But if the transformation is required on one axis only,
weights on other axes are not accounted for since they
would not affect the result of the transformation.
>>> v._get_weights(weights={{'lon':lambda x:((x+180)/100)**2}}, axis='lat')
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 0.17364818, 0.17364818],
[ 1. , 1. ],
[ 0.17364818, 0.17364818]])
What is provided as argument overrides axis attribute.
Here when the weights are provided for one axis only:
>>> v._get_weights(weights=lambda x:((x+180)/100)**2, axis='lat')
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 1., 1.],
[ 1., 1.],
[ 4., 4.]])
Or when the weight is provided as a numpy array
>>> w = np.array([[ 1., 1.],
... [ 1., 1.],
... [ 4., 4.]])
>>> v._get_weights(weights=w)
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 1., 1.],
[ 1., 1.],
[ 4., 4.]])
Or even as DimArray (which will be broadcast with the appropriate shape)
>>> wa = DimArray(w[:,0], axes=[v.axes['lat']])
>>> v._get_weights(weights=wa)
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 1., 1.],
[ 1., 1.],
[ 4., 4.]])
Any nans in the data will induce 0 in the weights,
since the element will then be discarded or the result be NaN anyway.
>>> v.values[1, 0] = np.nan
>>> v._get_weights(weights=w)
dimarray: 6 non-null elements (0 null)
0 / lat (3): -80 to 80
1 / lon (2): -180 to 180
array([[ 1., 1.],
[ 0., 1.],
[ 4., 4.]])
"""
# avoid circular import
from dimarray import DimArray
# dims: axes from which the weights should be computed
if axis is None:
dims = self.dims
elif type(axis) is tuple:
dims = axis
else:
dims = (axis,)
# common case: no weight is provided and no Axis has weights
# if is enough to check on all axes to be reduced, weights on other axes
# make no difference to the reduction transformation
if weights is None and np.all([self.axes[dim].weights is None for dim in dims]):
return None
# for 1-D array, same as axis is None is like axis=0
if axis is None and self.ndim == 1:
axis = 0
# check `weights` type
# special case: if weights is DimArray, just use it as full weight
if isinstance(weights, DimArray):
full_weights = weights.broadcast(self.axes) # broadcast weights on appropriate dimension
# special case II: numpy array of appropriate dimension ==> just use it as full weight
elif isinstance(weights, np.ndarray) and weights.ndim > 1:
assert weights.shape == self.shape, "`weights` must be either 1-D or have same shape as DimArray"
full_weights = DimArray(weights, self.axes)
# make axis weights based by combining single-axis weights (standard form)
else:
array_type = isinstance(weights, np.ndarray) and weights.dim == 1
dict_type = isinstance(weights, dict)
assert weights is None or callable(weights) or array_type or dict_type, "unexpected type for `weights`"
assert weights is None or not (not dict_type and axis is None), "`weights` type incompatible with flattening operation, provide `axis` or use dict-type weights"
assert weights is None or not (not dict_type and type(axis) is tuple), "`weights` type incompatible with flattening operation, use dict-type weights"
# make weights dict-like (operation on single axis)
if not dict_type:
weights = {axis: weights}
# Create weights from the axes (only compute for the axes to be reduced)
full_weights = 1.
for axis in dims:
ax = self.axes[axis]
# get proper weights array: from `Axis` or user-provided on-the-fly
if weights is not None and axis in weights.keys():
axis_weights = weights[axis]
else:
axis_weights = ax.weights
# if weight is None, just skip it
if axis_weights is None:
continue
# broadcast and multiply weights for all axes involved
full_weights = ax._get_weights(axis_weights).reshape(dims) * full_weights
# SPECIAL CASE: NO weights (e.g. weights parameter provided as {} or {'lat':None} and no axis weights attributes):
if full_weights is 1.:
return None
full_weights = full_weights.broadcast(self.axes)
# set 0 in a where there are NaNs.
if mirror_nans and anynan(self.values):
full_weights.values[np.isnan(self.values)] = 0
assert full_weights is not None
return full_weights
def test_getitem(self):
# make ndarray an Dimaray with identical data
arr = np.random.rand(3)
dat = DimArray(arr,dims=[Dim(range(3),name='dim1')])
self.assertEquals(dat[0],dat['dim1==0'])
self.assertEquals(dat[1],dat['dim1==1'])
self.assertEquals(dat[2],dat['dim1==2'])
self.assertEquals(arr[0],dat['dim1==0'])
self.assertEquals(arr[1],dat['dim1==1'])
self.assertEquals(arr[2],dat['dim1==2'])
arr = np.random.rand(3,2)
dat = DimArray(arr,dims=[Dim(range(3),name='dim1'),
Dim(range(2),name='dim2')])
assert_array_equal(dat[:,0],dat['dim2==0'])
assert_array_equal(dat[1],dat['dim1==1'])
assert_array_equal(dat[2],dat['dim1==2'])
assert_array_equal(arr[0],dat['dim1==0'])
assert_array_equal(arr[1],dat['dim1==1'])
assert_array_equal(arr[2],dat['dim1==2'])
assert_array_equal(dat[0,0],dat['dim1==0','dim2==0'])
assert_array_equal(dat[0,1],dat['dim1==0','dim2==1'])
assert_array_equal(dat[1,0],dat['dim1==1','dim2==0'])
assert_array_equal(dat[1,1],dat['dim1==1','dim2==1'])
assert_array_equal(dat[2,0],dat['dim1==2','dim2==0'])
assert_array_equal(dat[2,1],dat['dim1==2','dim2==1'])
bool_indx = np.zeros(arr.shape,np.bool)
bool_indx[2,1] = True
assert_array_equal(dat[2,1],dat[bool_indx])
bool_indx[1,1] = True
assert_array_equal(dat[1:3,1],dat[bool_indx])
# The below test makes sure that one can work with the results
# of a Boolean slice into a DimArray object. Because the
# dimensions get lost with Boolean indices we need to test
# that there are no complaints from dimension checking (the
# result should be upcast as an AttrArray):
test1 = dat[bool_indx] + 1
test2 = dat[1:3,1] + 1
assert_array_equal(test1,test2)
arr = np.random.rand(3)
dat = DimArray(arr)
bool_indx = np.array([True,False,True])
assert_array_equal(dat[bool_indx],arr[bool_indx])
assert_array_equal(dat[bool_indx].dims[0],dat.dims[0][bool_indx])
dat_array = np.random.rand(2,4,5)
dat = DimArray(dat_array,
dims=[Dim(range(2),name='dim1',unit='Hz'),
Dim(range(4),name='dim2',bla='bla'),
Dim(range(5),name='dim3',attr1='attr1',
attr2='attr2')])
# check that the correct elements are returned:
self.assertEquals(dat[0,0,0],dat_array[0,0,0])
self.assertEquals(dat[0,1,2],dat_array[0,1,2])
self.assertEquals(dat[1,0,3],dat_array[1,0,3])
# check that the correct elements are returned:
self.assertEquals(dat['dim1==0','dim2==0','dim3==0'],dat_array[0,0,0])
self.assertEquals(dat['dim1==0','dim2==1','dim3==2'],dat_array[0,1,2])
self.assertEquals(dat['dim1==1','dim2==0','dim3==3'],dat_array[1,0,3])
# check that the returned DimArray and its dims have proper shapes:
self.assertEquals(dat[0].shape,dat_array[0].shape)
self.assertEquals(len(dat[0].dims[0]),dat_array[0].shape[0])
self.assertEquals(len(dat[0].dims[1]),dat_array[0].shape[1])
self.assertEquals(dat[0].dim_names,['dim2','dim3'])
self.assertEquals(dat[1].shape,dat_array[1].shape)
self.assertEquals(len(dat[1].dims[0]),dat_array[1].shape[0])
self.assertEquals(len(dat[1].dims[1]),dat_array[1].shape[1])
self.assertEquals(dat[1].dim_names,['dim2','dim3'])
self.assertEquals(dat[0,0].shape,dat_array[0,0].shape)
self.assertEquals(len(dat[0,0].dims[0]),dat_array[0,0].shape[0])
self.assertEquals(dat[0,0].dim_names,['dim3'])
self.assertEquals(dat[:,:,0].shape,dat_array[:,:,0].shape)
self.assertEquals(len(dat[:,:,0].dims[0]),dat_array[:,:,0].shape[0])
self.assertEquals(len(dat[:,:,0].dims[1]),dat_array[:,:,0].shape[1])
self.assertEquals(dat[:,:,0].dim_names,['dim1','dim2'])
self.assertEquals(dat[0:1,2,0:3].shape,dat_array[0:1,2,0:3].shape)
self.assertEquals(len(dat[0:1,2,0:3].dims[0]),
dat_array[0:1,2,0:3].shape[0])
self.assertEquals(len(dat[0:1,2,0:3].dims[1]),
dat_array[0:1,2,0:3].shape[1])
self.assertEquals(dat[0:1,2,0:3].dim_names,['dim1','dim3'])
self.assertEquals(dat[0:1].shape,dat_array[0:1].shape)
self.assertEquals(len(dat[0:1].dims[0]),
dat_array[0:1].shape[0])
self.assertEquals(len(dat[0:1].dims[1]),
dat_array[0:1].shape[1])
self.assertEquals(dat[0:1].dim_names,['dim1','dim2','dim3'])
self.assertEquals(dat[1].shape,dat_array[1].shape)
self.assertEquals(len(dat[1].dims[0]),dat_array[1].shape[0])
self.assertEquals(len(dat[1].dims[1]),dat_array[1].shape[1])
self.assertEquals(dat[1].dim_names,['dim2','dim3'])
self.assertEquals(dat[0,0].shape,dat_array[0,0].shape)
self.assertEquals(len(dat[0,0].dims[0]),dat_array[0,0].shape[0])
self.assertEquals(dat[0,0].dim_names,['dim3'])
self.assertEquals(dat[:,:,0].shape,dat_array[:,:,0].shape)
self.assertEquals(len(dat[:,:,0].dims[0]),dat_array[:,:,0].shape[0])
self.assertEquals(len(dat[:,:,0].dims[1]),dat_array[:,:,0].shape[1])
self.assertEquals(dat[:,:,0].dim_names,['dim1','dim2'])
self.assertEquals(dat[0:1,2,0:3].shape,dat_array[0:1,2,0:3].shape)
self.assertEquals(len(dat[0:1,2,0:3].dims[0]),
dat_array[0:1,2,0:3].shape[0])
self.assertEquals(len(dat[0:1,2,0:3].dims[1]),
dat_array[0:1,2,0:3].shape[1])
self.assertEquals(dat[0:1,2,0:3].dim_names,['dim1','dim3'])
print dat.dims
print dat['dim2>0'].dims
assert_array_equal(dat['dim2>0'].dims[1],dat.dims[1][1:])
assert_array_equal(dat[1:,1:],dat['dim1>0','dim2>0'])
# when the name of a Dim instance is given, that dim should be
# returned:
self.assertTrue(isinstance(dat['dim1'],Dim))
self.assertTrue(isinstance(dat['dim2'],Dim))
self.assertTrue(isinstance(dat['dim3'],Dim))
self.assertEquals(dat['dim1'].name,'dim1')
self.assertEquals(dat['dim1'].unit,'Hz')
self.assertEquals(dat['dim1'][-1],1)
self.assertEquals(len(dat['dim1']),2)
self.assertEquals(dat['dim2'].name,'dim2')
self.assertEquals(dat['dim2'].bla,'bla')
self.assertEquals(dat['dim2'][-1],3)
self.assertEquals(len(dat['dim2']),4)
self.assertEquals(dat['dim3'].name,'dim3')
self.assertEquals(dat['dim3'].attr1,'attr1')
self.assertEquals(dat['dim3'].attr2,'attr2')
self.assertEquals(dat['dim3'][-1],4)
self.assertEquals(len(dat['dim3']),5)
# when another string is given, it should be evaluated:
self.assertEquals(dat['dim1==0'].shape,(4,5))
self.assertEquals(len(dat['dim1==0'].dims[0]),4)
self.assertEquals(len(dat['dim1==0'].dims[1]),5)
self.assertEquals(dat['dim1==0'].dim_names,['dim2','dim3'])
self.assertEquals(dat['dim2==1'].shape,(2,5))
self.assertEquals(len(dat['dim2==1'].dims[0]),2)
self.assertEquals(len(dat['dim2==1'].dims[1]),5)
self.assertEquals(dat['dim2==1'].dim_names,['dim1','dim3'])
self.assertEquals(dat['dim2<2'].shape,(2,2,5))
self.assertEquals(len(dat['dim2<2'].dims[0]),2)
self.assertEquals(len(dat['dim2<2'].dims[1]),2)
self.assertEquals(len(dat['dim2<2'].dims[2]),5)
self.assertEquals(dat['dim2<2'].dim_names,['dim1','dim2','dim3'])
self.assertEquals(dat['dim3!=2'].shape,(2,4,4))
self.assertEquals(len(dat['dim3!=2'].dims[0]),2)
self.assertEquals(len(dat['dim3!=2'].dims[1]),4)
self.assertEquals(len(dat['dim3!=2'].dims[2]),4)
self.assertEquals(dat['dim3!=2'].dim_names,['dim1','dim2','dim3'])
# check that the right values are returned:
self.assertEquals(dat['dim3!=2'][0,0,0],dat_array[0,0,0])
self.assertEquals(dat['dim3!=2'][1,2,1],dat_array[1,2,1])
self.assertEquals(dat['dim3!=2'][1,2,3],dat_array[1,2,4])
# check indexing with a tuple of arrays and with 1-level dimensions:
dim1=Dim(['dim'],'dim1')
dim2=Dim([1,2],'dim2')
dim3=Dim([3,4,5],'dim3')
dat=DimArray([[[6,7,8],[9,10,11]]],[dim1,dim2,dim3])
self.assertEquals(dat[np.ix_([0],[0,1],[0,1])].shape,(1,2,2))
# test string index returning nothing
# test list index
dim1=Dim(['dim'],'dim1')
dim2=Dim([1,2],'dim2')
dim3=Dim([3,4,5],'dim3')
dat=DimArray([[[6,7,8],[9,10,11]]],[dim1,dim2,dim3])
assert_array_equal(dat[[0]],dat[np.array([0])])
#
# Pythonic fancy indexing of DimArrays!
#
import numpy as np
from dimarray import Dim,DimArray,AttrArray
if __name__ == "__main__":
dims = [Dim(data=np.arange(20), name='time'),
Dim(data=np.arange(10), name='freqs'),
Dim(data=np.arange(30), name='events')]
dat = DimArray(data=np.random.rand(20,10,30), dims=dims)
# select some data
ind = ((dat['time'] > 10) &
((dat['events']<10) | (dat['events']>20)) &
(dat['freqs'].is_in(range(0,10,2))))
subdat = dat[ind]
print dat.shape
print subdat.shape
def test_funcs(self):
"""Test the numpy functions"""
# make ndarray an Dimaray with identical data
arr = np.random.rand(5,12,3,1)
dat = DimArray(arr,dims=[Dim(range(5),name='one'),
Dim(range(12),name='two'),
Dim(range(3),name='three'),
Dim(range(1),name='four')],test='tst')
# these are functions that take an axis argument:
funcs = [np.mean,np.all,np.any,np.argmax,np.argmin,np.argsort,
np.cumprod,np.cumsum,np.max,np.mean,np.min,np.prod,
np.ptp,np.std,np.sum,np.var]
# The axes for the ndarray:
axes_arr = [None,0,1,2,3,0,1,2,3]
# The axes for the DimArray (we want to test indexing them by
# number and name):
axes_dat = [None,0,1,2,3,'one','two','three','four']
# loop through the functions and axes:
for func in funcs:
for a in range(len(axes_arr)):
# apply the function to the ndarray and the DimArray
arr_func = func(arr,axis=axes_arr[a])
dat_func = func(dat,axis=axes_dat[a])
# make sure they are the same:
assert_array_equal(arr_func,dat_func)
if not(axes_dat[a] is None):
# ensure we still have a DimArray
self.assertTrue(isinstance(dat_func,DimArray))
# ensure that the attributes are preserved
self.assertEquals(dat_func.test,'tst')
# same tests as above but this time calling the DimArray
# methods directly (this test is necessary because it is in
# principle possible for the numpy function to work and the
# DimArray method not to work (or vice versa):
for a in range(len(axes_arr)):
assert_array_equal(arr.all(axes_arr[a]),
dat.all(axes_dat[a]))
assert_array_equal(arr.any(axes_arr[a]),
dat.any(axes_dat[a]))
assert_array_equal(arr.argmax(axes_arr[a]),
dat.argmax(axes_dat[a]))
assert_array_equal(arr.argmin(axes_arr[a]),
dat.argmin(axes_dat[a]))
assert_array_equal(arr.argsort(axes_arr[a]),
dat.argsort(axes_dat[a]))
assert_array_equal(arr.cumprod(axes_arr[a]),
dat.cumprod(axes_dat[a]))
assert_array_equal(arr.cumsum(axes_arr[a]),
dat.cumsum(axes_dat[a]))
assert_array_equal(arr.max(axes_arr[a]),
dat.max(axes_dat[a]))
assert_array_equal(arr.mean(axes_arr[a]),
dat.mean(axes_dat[a]))
assert_array_equal(arr.min(axes_arr[a]),
dat.min(axes_dat[a]))
assert_array_equal(arr.prod(axes_arr[a]),
dat.prod(axes_dat[a]))
assert_array_equal(arr.ptp(axes_arr[a]),
dat.ptp(axes_dat[a]))
assert_array_equal(arr.std(axes_arr[a]),
dat.std(axes_dat[a]))
assert_array_equal(arr.sum(axes_arr[a]),
dat.sum(axes_dat[a]))
assert_array_equal(arr.var(axes_arr[a]),
dat.var(axes_dat[a]))
if not(axes_dat[a] is None):
self.assertTrue(isinstance(dat.all(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.any(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.argmax(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.argmin(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.argsort(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.cumprod(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.cumsum(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.max(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.mean(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.min(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.prod(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.ptp(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.std(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.sum(axes_arr[a]),DimArray))
self.assertTrue(isinstance(dat.var(axes_arr[a]),DimArray))
self.assertEquals(dat.all(axes_arr[a]).test,'tst')
self.assertEquals(dat.any(axes_arr[a]).test,'tst')
self.assertEquals(dat.argmax(axes_arr[a]).test,'tst')
self.assertEquals(dat.argmin(axes_arr[a]).test,'tst')
self.assertEquals(dat.argsort(axes_arr[a]).test,'tst')
self.assertEquals(dat.cumprod(axes_arr[a]).test,'tst')
self.assertEquals(dat.cumsum(axes_arr[a]).test,'tst')
self.assertEquals(dat.max(axes_arr[a]).test,'tst')
self.assertEquals(dat.mean(axes_arr[a]).test,'tst')
self.assertEquals(dat.min(axes_arr[a]).test,'tst')
self.assertEquals(dat.prod(axes_arr[a]).test,'tst')
self.assertEquals(dat.ptp(axes_arr[a]).test,'tst')
self.assertEquals(dat.std(axes_arr[a]).test,'tst')
self.assertEquals(dat.sum(axes_arr[a]).test,'tst')
self.assertEquals(dat.var(axes_arr[a]).test,'tst')
# test functions that require function specific input:
for a in range(len(axes_arr)):
if axes_arr[a] is None:
length = len(arr)
else:
length = np.shape(arr)[axes_arr[a]]
cond = np.random.random(length)>0.5
# calling the compress method directly:
arr_func = arr.compress(cond,axis=axes_arr[a])
dat_func = dat.compress(cond,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,DimArray))
self.assertEquals(dat_func.test,'tst')
# calling the numpy compress function:
arr_func = np.compress(cond,arr,axis=axes_arr[a])
dat_func = np.compress(cond,dat,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,DimArray))
self.assertEquals(dat_func.test,'tst')
# the below tests should not run with axis==None:
if axes_arr[a] is None:
continue
reps = np.random.random_integers(low=1, high=10, size=length)
# calling the repeat method directly:
arr_func = arr.repeat(reps,axis=axes_arr[a])
dat_func = dat.repeat(reps,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# calling the numpy repeat function:
arr_func = np.repeat(arr,reps,axis=axes_arr[a])
dat_func = np.repeat(dat,reps,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a] is not None:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# skip the last dimension for this test for
# convenience (the last dimension only has 1 level):
if a >= 3:
continue
indcs = np.arange(len(arr.shape))
# calling the take method directly (squeeze, to get rid of
# the last dimension):
arr_func = arr.squeeze().take(indcs,axis=axes_arr[a])
dat_func = dat.squeeze().take(indcs,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a]:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# calling the numpy take function directly (squeeze, to get rid of
# the last dimension):
arr_func = np.take(arr.squeeze(),indcs,axis=axes_arr[a])
dat_func = np.take(dat.squeeze(),indcs,axis=axes_dat[a])
assert_array_equal(arr_func,dat_func)
if axes_dat[a]:
self.assertTrue(isinstance(dat_func,AttrArray))
self.assertEquals(dat_func.test,'tst')
# This should work with numpy 1.2 but doesn't
# with 1.1.1 or below (therfore commented out for now):
# arr_func = arr.clip(0.4,0.6)
# dat_func = dat.clip(0.4,0.6)
# assert_array_equal(arr_func,dat_func)
#self.assertTrue(isinstance(dat_func,DimArray))
#self.assertEquals(dat_func.test,'tst')
#arr_func = np.clip(arr,0.4,0.6)
#dat_func = np.clip(dat,0.4,0.6)
#assert_array_equal(arr_func,dat_func)
#self.assertTrue(isinstance(dat_func,DimArray))
#self.assertEquals(dat_func.test,'tst')
# other functions that don't necessarily take return a
# DimArray:
funcs = [np.diagonal,np.nonzero,np.ravel,np.squeeze,
np.sort,np.trace,np.transpose]
for func in funcs:
arr_func = func(arr)
dat_func = func(dat)
assert_array_equal(arr_func,dat_func)
# same tests as above, but calling the methods directly:
assert_array_equal(arr.diagonal(),dat.diagonal())
assert_array_equal(arr.nonzero(),dat.nonzero())
assert_array_equal(arr.ravel(),dat.ravel())
assert_array_equal(arr.squeeze(),dat.squeeze())
assert_array_equal(arr.sort(),dat.sort())
assert_array_equal(arr.trace(),dat.trace())
assert_array_equal(arr.transpose(),dat.transpose())
# there is no numpy.flatten() function, so we only call the
# method directly:
assert_array_equal(arr.flatten(),dat.flatten())
assert_array_equal(arr.swapaxes(0,1),dat.swapaxes(0,1))
self.assertTrue(isinstance(dat.swapaxes(0,1),DimArray))
self.assertEquals(dat.swapaxes(0,1).test,'tst')
assert_array_equal(arr.swapaxes(0,1),dat.swapaxes('one','two'))
self.assertTrue(isinstance(dat.swapaxes('one','two'),DimArray))
self.assertEquals(dat.swapaxes('one','two').test,'tst')
assert_array_equal(arr.swapaxes(1,3),dat.swapaxes(1,3))
self.assertTrue(isinstance(dat.swapaxes(1,3),DimArray))
self.assertEquals(dat.swapaxes(1,3).test,'tst')
assert_array_equal(arr.swapaxes(1,3),dat.swapaxes('two','four'))
self.assertTrue(isinstance(dat.swapaxes('two','four'),DimArray))
self.assertEquals(dat.swapaxes('two','four').test,'tst')
