def test_filter(self):
samplerate = 200
filtType='stop'
freqRange = [10,20]
order = 4
ts = TimeSeries(self.dat200,'time',samplerate,dims=self.dims200)
ts_filt = ts.filtered(freqRange, filtType, order)
test = filt.buttfilt(self.dat200,freqRange,samplerate,filtType,
order,axis=ts.taxis)
np.testing.assert_array_almost_equal(ts_filt[:],test[:],decimal=6)
def test_filter(self):
samplerate = 200
filtType='stop'
freqRange = [10,20]
order = 4
ts = TimeSeries(self.dat200,'time',samplerate,dims=self.dims200)
ts_filt = ts.filtered(freqRange, filtType, order)
test = filt.buttfilt(self.dat200,freqRange,samplerate,filtType,
order,axis=ts.taxis)
np.testing.assert_array_almost_equal(ts_filt[:],test[:],decimal=6)
def test_resample(self):
ts200 = TimeSeries(self.dat200,'time',200,dims=self.dims200)
ts50 = TimeSeries(
self.dat50,'time',50,dims=self.dims50).remove_buffer(1.0)
ts50_200 = ts200.resampled(50).remove_buffer(1.0)
np.testing.assert_equal(ts50_200.shape[:],ts50.shape[:])
#print type(ts200['time'])
#print type(ts50['time'])
np.testing.assert_array_almost_equal(
ts50_200['time']*1000,ts50['time'],decimal=6)
np.testing.assert_array_almost_equal(ts50_200[:],ts50[:],decimal=6)
def test_resample(self):
ts200 = TimeSeries(self.dat200,'time',200,dims=self.dims200)
ts50 = TimeSeries(
self.dat50,'time',50,dims=self.dims50).remove_buffer(1.0)
ts50_200 = ts200.resampled(50).remove_buffer(1.0)
np.testing.assert_equal(ts50_200.shape[:],ts50.shape[:])
#print type(ts200['time'])
#print type(ts50['time'])
np.testing.assert_array_almost_equal(
ts50_200['time']*1000,ts50['time'],decimal=6)
np.testing.assert_array_almost_equal(ts50_200[:],ts50[:],decimal=6)
def test_remove_buffer(self):
buf = 200
numsamp = 4*200
ts = TimeSeries(self.dat200,'time',200, dims=self.dims200)
ts_nobuff = ts.remove_buffer(1)
self.assertEquals(ts_nobuff.shape[ts_nobuff.taxis],numsamp-2*buf)
self.assertEquals(len(ts_nobuff['time']),numsamp-2*buf)
ts_nobuff = ts.remove_buffer((1,1))
self.assertEquals(ts_nobuff.shape[ts_nobuff.taxis],numsamp-2*buf)
self.assertEquals(len(ts_nobuff['time']),numsamp-2*buf)
# make sure that negative durations throw exception
self.assertRaises(ValueError,ts.remove_buffer,-1)
def test_remove_buffer(self):
buf = 200
numsamp = 4*200
ts = TimeSeries(self.dat200,'time',200, dims=self.dims200)
ts_nobuff = ts.remove_buffer(1)
self.assertEquals(ts_nobuff.shape[ts_nobuff.taxis],numsamp-2*buf)
self.assertEquals(len(ts_nobuff['time']),numsamp-2*buf)
ts_nobuff = ts.remove_buffer((1,1))
self.assertEquals(ts_nobuff.shape[ts_nobuff.taxis],numsamp-2*buf)
self.assertEquals(len(ts_nobuff['time']),numsamp-2*buf)
# make sure that negative durations throw exception
self.assertRaises(ValueError,ts.remove_buffer,-1)
def test_init(self):
# init a TimeSeries with all combos of options and verify that
# the attributes are correct
# fewest params
ts = TimeSeries(self.dat200,'time',200,dims = self.dims200)
np.testing.assert_equal(ts[:], self.dat200[:])
self.assertEquals(ts.shape, self.dat200.shape)
self.assertEquals(ts.taxis, len(self.dat200.shape)-1)
self.assertEquals(ts.samplerate,200)
self.assertRaises(ValueError,TimeSeries,self.dat200,
'bla',200,dims=self.dims200)
self.assertRaises(ValueError,TimeSeries,self.dat200,
'time',-200,dims=self.dims200)
def test_remove_tdim(self):
ts200 = TimeSeries(self.dat200,'time',200,dims=self.dims200)
self.assertTrue(isinstance(ts200.mean('time'),DimArray))
def tsPhasePow(freqs,tseries,width=5,resample=None,keepBuffer=False,
verbose=False,to_return='both',freqDimName='freq'):
"""
Calculate phase and/or power on an TimeSeries, returning new
TimeSeries instances.
"""
if (to_return != 'both') and (to_return != 'pow') and (to_return != 'phase'):
raise ValueError("to_return must be \'pow\', \'phase\', or \'both\' to\
specify whether power, phase, or both should be returned. Invalid\
value for to_return: %s " % to_return)
# first get the phase and power as desired
res = calcPhasePow(freqs,tseries.data,tseries.samplerate,axis=tseries.tdim,
width=width,verbose=verbose,to_return=to_return)
# handle the dims
tsdims = tseries.dims.copy()
# add in frequency dimension
freqDim = Dim(freqDimName,freqs,'Hz')
tsdims.insert(0,freqDim)
# turn them into timeseries
if to_return == 'pow' or to_return == 'both':
# turn into a timeseries
powerAll = TimeSeries(res,tsdims,
tseries.samplerate,unit='XXX get pow unit',
tdim=-1,buf_samp=tseries.buf_samp)
powerAll.data[powerAll.data<=0] = N.finfo(powerAll.data.dtype).eps
# see if resample
if resample:
# must take log before the resample
powerAll.data = N.log10(powerAll.data)
powerAll.resample(resample)
powerAll.data = N.power(10,powerAll.data)
# see if remove buffer
if not keepBuffer:
powerAll.removeBuf()
if to_return == 'phase' or to_return == 'both':
# get the phase matrix
phaseAll = TimeSeries(res,tsdims,
tseries.samplerate,unit='radians',
tdim=-1,buf_samp=tseries.buf_samp)
if resample:
# must unwrap before resampling
phaseAll.data = N.unwrap(phaseAll.data)
phaseAll.resample(resample)
phaseAll.data = N.mod(phaseAll.data+N.pi,2*N.pi)-N.pi;
# see if remove buffer
if not keepBuffer:
phaseAll.removeBuf()
# see what to return
if to_return == 'pow':
return powerAll
elif to_return == 'phase':
return phaseAll
elif to_return == 'both':
return phaseAll,powerAll
def phase_pow_multi(freqs, dat, samplerates=None, widths=5,
to_return='both', time_axis=-1,
conv_dtype=np.complex64, freq_name='freqs',
**kwargs):
"""
Calculate phase and power with wavelets across multiple events.
Calls the morlet_multi() and fconv_multi() functions to convolve
dat with Morlet wavelets. Phase and power over time across all
events are calculated from the results. Time/samples should
include a buffer before onsets and after offsets of the events of
interest to avoid edge effects.
Parameters
----------
freqs : {int, float, array_like of ints or floats}
The frequencies of the Morlet wavelets.
dat : {array_like}
The data to determine the phase and power of. Sample rate(s)
and time dimension must be specified as attributes of dat or
in the key word arguments. The time dimension should include
a buffer to avoid edge effects.
samplerates : {float, array_like of floats}, optional
The sample rate(s) of the signal. Must be specified if dat is
not a TimeSeries instance. If dat is a TimeSeries instance,
any value specified here will be replaced by the value stored
in the samplerate attribute.
widths : {float, array_like of floats},optional
The width(s) of the wavelets in cycles. See docstring of
morlet_multi() for details.
to_return : {'both','power','phase'}, optional
Specify whether to return power, phase, or both.
time_axis : {int},optional
Index of the time/samples dimension in dat. Must be specified
if dat is not a TimeSeries instance. If dat is a TimeSeries
instance any value specified here will be replaced by the
value specified in the tdim attribute.
conv_dtype : {numpy.complex*},optional
Data type for the convolution array. Using a larger dtype
(e.g., numpy.complex128) can increase processing time.
This value influences the dtype of the output array. In case of
numpy.complex64 the dtype of the output array is numpy.float32.
Higher complex dtypes produce higher float dtypes in the output.
freq_name : {string},optional
Name of frequency dimension of the returned TimeSeries object
(only used if dat is a TimeSeries instance).
**kwargs : {**kwargs},optional
Additional key word arguments to be passed on to morlet_multi().
Returns
-------
Array(s) of phase and/or power values as specified in to_return. The
returned array(s) has/have one more dimension than dat. The added
dimension is for the frequencies and is inserted as the first
dimension.
"""
dat_is_ts = False # is dat a TimeSeries instance?
if isinstance(dat,TimeSeries):
samplerates = dat.samplerate
time_axis = dat.get_axis(dat.tdim)
dat_is_ts = True
elif samplerates is None:
raise ValueError('Samplerate must be specified unless you provide a TimeSeries!')
# convert the time_axis to positive index
if time_axis < 0:
time_axis += len(dat.shape)
# ensure proper dimensionality (needed for len call later):
freqs = np.atleast_1d(freqs)
# check input values:
if to_return != 'both' and to_return != 'power' and to_return != 'phase':
raise ValueError("to_return must be \'power\', \'phase\', or \'both\' to "+
"specify whether power, phase, or both are to be "+
"returned. Invalid value: %s " % to_return)
if not np.issubdtype(conv_dtype,np.complex):
raise ValueError("conv_dtype must be a complex data type!\n"+
"Invalid value: "+str(conv_dtype))
# generate list of wavelets:
wavelets = morlet_multi(freqs,widths,samplerates,**kwargs)
# make sure we have at least as many data samples as wavelet samples
if (np.max([len(i) for i in wavelets]) > dat.shape[time_axis]):
raise ValueError("The number of data samples is insufficient compared "+
"to the number of wavelet samples. Try increasing "+
"data samples by using a (longer) buffer.\n data "+
"samples: "+str(dat.shape[time_axis])+"\nmax wavelet "+
"samples: "+str(np.max([len(i) for i in wavelets])))
# reshape the data to 2D with time on the 2nd dimension
origshape = dat.shape
eegdat = reshape_to_2d(dat, time_axis) #.view(np.ndarray)
# for efficiency pre-generate empty array for convolution:
wav_coef = np.empty((eegdat.shape[0]*len(freqs),
eegdat.shape[1]),dtype=conv_dtype)
# populate this array with the convolutions:
i=0
step = len(eegdat)
for wav in wavelets:
wc = fconv_multi(wav,eegdat,'same')
wav_coef[i:i+step] = wc
i+=step
# for ev_dat in eegdat:
# wav_coef[i]=np.convolve(wav,ev_dat,'same')
# #wav_coef[i]=scipy.signal.fftconvolve(ev_dat,wav,'same')
# i+=1
# Determine shape for ouput arrays with added frequency dimension:
newshape = list(origshape)
# freqs must be first for reshape_from_2d to work
newshape.insert(0,len(freqs))
newshape = tuple(newshape)
# must add to the time axis, too
time_axis += 1
if dat_is_ts:
freq_dim = Dim(freqs,freq_name)
dims_with_freq = np.empty(len(dat.dims)+1,dat.dims.dtype)
dims_with_freq[0] = freq_dim
dims_with_freq[1:] = dat.dims[:]
if to_return == 'power' or to_return == 'both':
# calculate power (wav_coef values are complex, so taking the
# absolute value is necessary before taking the power):
power = np.abs(wav_coef)**2
# reshape to new shape:
power = reshape_from_2d(power,time_axis,newshape)
if dat_is_ts:
power = TimeSeries(power, tdim=dat.tdim,
samplerate=dat.samplerate,
dims=dims_with_freq)
if to_return == 'phase' or to_return == 'both':
# normalize the phase estimates to length one taking care of
# instances where they are zero:
norm_factor = np.abs(wav_coef)
ind = norm_factor == 0
norm_factor[ind] = 1.
wav_coef = wav_coef/norm_factor
# wav_coef contains complex numbers, so we need to set these
# to 0 when the absolute value 0.
wav_coef[ind] = 0
# calculate phase:
phase = np.angle(wav_coef)
# reshape to new shape
phase = reshape_from_2d(phase,time_axis,newshape)
if dat_is_ts:
phase = TimeSeries(phase, tdim=dat.tdim,
samplerate=dat.samplerate,
dims=dims_with_freq)
if to_return == 'power':
return power
elif to_return == 'phase':
return phase
elif to_return == 'both':
return phase,power
def test_remove_tdim(self):
ts200 = TimeSeries(self.dat200,'time',200,dims=self.dims200)
self.assertTrue(isinstance(ts200.mean('time'),DimArray))
def tst_setattr(self):
ts = TimeSeries(self.dat200,'time',200,dims=self.dims200)
self.assertRaises(ValueError,ts.__setattr__,'tdim','bla')
self.assertRaises(ValueError,ts.__setattr__,'samplerate',-1)
def test_phase_pow_multi(self):
dat = np.vstack((np.arange(0, 1000), np.arange(0, 1000)))
# make sure errors are raised when not called with enough or
# the right kind of arguments:
self.assertRaises(TypeError, phase_pow_multi)
self.assertRaises(ValueError, phase_pow_multi, [], dat, 100)
self.assertRaises(ValueError,
phase_pow_multi, [1],
dat,
100,
to_return='results')
self.assertRaises(ValueError,
phase_pow_multi, [1],
dat,
100,
conv_dtype=np.float)
dat_short = np.reshape(np.arange(0, 20), (2, 10))
self.assertRaises(ValueError, phase_pow_multi, [1], dat_short, 100)
dat_ts = TimeSeries(dat,
tdim='time',
samplerate=100,
dims=[
Dim(np.arange(2), name='dim1'),
Dim(np.arange(1000), name='time')
])
# make sure errors are raised when not called with enough or
# the right kind of arguments:
self.assertRaises(ValueError, phase_pow_multi, [], dat_ts)
self.assertRaises(ValueError,
phase_pow_multi, [1],
dat_ts,
to_return='results')
self.assertRaises(ValueError,
phase_pow_multi, [1],
dat_ts,
conv_dtype=np.float)
dat_short_ts = TimeSeries(dat_short,
tdim='time',
samplerate=100,
dims=[
Dim(np.arange(2), name='dim1'),
Dim(np.arange(10), name='time')
])
self.assertRaises(ValueError, phase_pow_multi, [1], dat_short_ts)
x = phase_pow_multi(1, dat, 100)
# ensure correct output shape:
self.assertEqual(np.shape(x), (2, 1, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[0][0][0], x[0][0][1])
#print x[0][0][0][:20]
assert_array_equal(x[1][0][0], x[1][0][1])
# ensure valid output values:
phaseTest = np.abs(x[0]) <= np.pi
powerTest = x[1] >= 0
self.assertTrue(phaseTest.all())
self.assertTrue(powerTest.all())
x_ts = phase_pow_multi(1, dat_ts)
# ensure correct output shape:
self.assertEqual(np.shape(x_ts), (2, 1, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[0][0][0], x_ts[0][0][1])
assert_array_equal(x_ts[1][0][0], x_ts[1][0][1])
# ensure valid output values:
phaseTest = np.abs(x_ts[0]) <= np.pi
powerTest = x_ts[1] >= 0
self.assertTrue(phaseTest.all())
self.assertTrue(powerTest.all())
y = phase_pow_multi([1], dat, 100, to_return='phase')
# ensure correct output shape:
self.assertEqual(np.shape(y), (1, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[0][0][0], y[0][1])
# ensure valid output values:
phaseTest = np.abs(y[0]) <= np.pi
self.assertTrue(phaseTest.all())
y_ts = phase_pow_multi([1], dat_ts, to_return='phase')
# ensure correct output shape:
self.assertEqual(np.shape(y_ts), (1, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[0][0][0], y_ts[0][1])
# ensure valid output values:
phaseTest = np.abs(y_ts[0]) <= np.pi
self.assertTrue(phaseTest.all())
z = phase_pow_multi(1, dat, [100], to_return='power')
# ensure correct output shape:
self.assertEqual(np.shape(z), (1, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[1][0][0], z[0][1])
# ensure valid output values:
powerTest = z >= 0
self.assertTrue(powerTest.all())
z_ts = phase_pow_multi(1, dat_ts, to_return='power')
# ensure correct output shape:
self.assertEqual(np.shape(z_ts), (1, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[1][0][0], z_ts[0][1])
# ensure valid output values:
powerTest = z_ts >= 0
self.assertTrue(powerTest.all())
x = phase_pow_multi([1, 2, 3], dat, 100, widths=6)
# ensure correct output shape:
self.assertEqual(np.shape(x), (2, 3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[0][0][0], x[0][0][1])
assert_array_equal(x[1][0][0], x[1][0][1])
assert_array_equal(x[0][1][0], x[0][1][1])
assert_array_equal(x[1][1][0], x[1][1][1])
assert_array_equal(x[0][2][0], x[0][2][1])
assert_array_equal(x[1][2][0], x[1][2][1])
# ensure valid output values:
phaseTest = np.abs(x[0]) <= np.pi
powerTest = x[1] >= 0
self.assertTrue(phaseTest.all())
self.assertTrue(powerTest.all())
x_ts = phase_pow_multi([1, 2, 3], dat_ts, widths=6)
# ensure correct output shape:
self.assertEqual(np.shape(x_ts), (2, 3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[0][0][0], x_ts[0][0][1])
assert_array_equal(x_ts[1][0][0], x_ts[1][0][1])
assert_array_equal(x_ts[0][1][0], x_ts[0][1][1])
assert_array_equal(x_ts[1][1][0], x_ts[1][1][1])
assert_array_equal(x_ts[0][2][0], x_ts[0][2][1])
assert_array_equal(x_ts[1][2][0], x_ts[1][2][1])
# ensure valid output values:
phaseTest = np.abs(x_ts[0]) <= np.pi
powerTest = x_ts[1] >= 0
self.assertTrue(phaseTest.all())
self.assertTrue(powerTest.all())
y = phase_pow_multi([1, 2, 3], dat, [100], widths=6, to_return='phase')
# ensure correct output shape:
self.assertEqual(np.shape(y), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[0][0][0], y[0][1])
assert_array_equal(x[0][1][0], y[1][1])
assert_array_equal(x[0][2][0], y[2][1])
# ensure valid output values:
phaseTest = np.abs(y) <= np.pi
self.assertTrue(phaseTest.all())
y_ts = phase_pow_multi([1, 2, 3],
dat, [100],
widths=6,
to_return='phase')
# ensure correct output shape:
self.assertEqual(np.shape(y_ts), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[0][0][0], y_ts[0][1])
assert_array_equal(x_ts[0][1][0], y_ts[1][1])
assert_array_equal(x_ts[0][2][0], y_ts[2][1])
# ensure valid output values:
phaseTest = np.abs(y_ts) <= np.pi
self.assertTrue(phaseTest.all())
z = phase_pow_multi([1, 2, 3], dat, 100, widths=[6], to_return='power')
# ensure correct output shape:
self.assertEqual(np.shape(z), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[1][0][0], z[0][1])
assert_array_equal(x[1][1][0], z[1][1])
assert_array_equal(x[1][2][0], z[2][1])
# ensure valid output values:
powerTest = z >= 0
self.assertTrue(powerTest.all())
z_ts = phase_pow_multi([1, 2, 3],
dat,
100,
widths=[6],
to_return='power')
# ensure correct output shape:
self.assertEqual(np.shape(z_ts), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[1][0][0], z_ts[0][1])
assert_array_equal(x_ts[1][1][0], z_ts[1][1])
assert_array_equal(x_ts[1][2][0], z_ts[2][1])
# ensure valid output values:
powerTest = z_ts >= 0
self.assertTrue(powerTest.all())
x = phase_pow_multi([4, 9, 8], dat, [100, 200, 300], widths=[6, 5, 4])
# ensure correct output shape:
self.assertEqual(np.shape(x), (2, 3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[0][0][0], x[0][0][1])
assert_array_equal(x[1][0][0], x[1][0][1])
assert_array_equal(x[0][1][0], x[0][1][1])
assert_array_equal(x[1][1][0], x[1][1][1])
assert_array_equal(x[0][2][0], x[0][2][1])
assert_array_equal(x[1][2][0], x[1][2][1])
# ensure valid output values:
phaseTest = np.abs(x[0]) <= np.pi
powerTest = x[1] >= 0
self.assertTrue(phaseTest.all())
self.assertTrue(powerTest.all())
x_ts = phase_pow_multi([4, 9, 8],
dat, [100, 200, 300],
widths=[6, 5, 4])
# ensure correct output shape:
self.assertEqual(np.shape(x_ts), (2, 3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[0][0][0], x_ts[0][0][1])
assert_array_equal(x_ts[1][0][0], x_ts[1][0][1])
assert_array_equal(x_ts[0][1][0], x_ts[0][1][1])
assert_array_equal(x_ts[1][1][0], x_ts[1][1][1])
assert_array_equal(x_ts[0][2][0], x_ts[0][2][1])
assert_array_equal(x_ts[1][2][0], x_ts[1][2][1])
# ensure valid output values:
phaseTest = np.abs(x_ts[0]) <= np.pi
powerTest = x_ts[1] >= 0
self.assertTrue(phaseTest.all())
self.assertTrue(powerTest.all())
y = phase_pow_multi([4, 9, 8],
dat, [100, 200, 300],
widths=[6, 5, 4],
to_return='phase')
# ensure correct output shape:
self.assertEqual(np.shape(y), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[0][0][0], y[0][1])
assert_array_equal(x[0][1][0], y[1][1])
assert_array_equal(x[0][2][0], y[2][1])
# ensure valid output values:
phaseTest = np.abs(y) <= np.pi
self.assertTrue(phaseTest.all())
y_ts = phase_pow_multi([4, 9, 8],
dat, [100, 200, 300],
widths=[6, 5, 4],
to_return='phase')
# ensure correct output shape:
self.assertEqual(np.shape(y_ts), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[0][0][0], y_ts[0][1])
assert_array_equal(x_ts[0][1][0], y_ts[1][1])
assert_array_equal(x_ts[0][2][0], y_ts[2][1])
# ensure valid output values:
phaseTest = np.abs(y_ts) <= np.pi
self.assertTrue(phaseTest.all())
z = phase_pow_multi([4, 9, 8],
dat, [100, 200, 300],
widths=[6, 5, 4],
to_return='power')
# ensure correct output shape:
self.assertEqual(np.shape(z), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x[1][0][0], z[0][1])
assert_array_equal(x[1][1][0], z[1][1])
assert_array_equal(x[1][2][0], z[2][1])
# ensure valid output values:
powerTest = z >= 0
self.assertTrue(powerTest.all())
z_ts = phase_pow_multi([4, 9, 8],
dat, [100, 200, 300],
widths=[6, 5, 4],
to_return='power')
# ensure correct output shape:
self.assertEqual(np.shape(z_ts), (3, 2, 1000))
# dat has two identical rows, ensure output has corresponding
# identities:
assert_array_equal(x_ts[1][0][0], z_ts[0][1])
assert_array_equal(x_ts[1][1][0], z_ts[1][1])
assert_array_equal(x_ts[1][2][0], z_ts[2][1])
# ensure valid output values:
powerTest = z_ts >= 0
self.assertTrue(powerTest.all())
