def testReallyWorks(self, level=1):
# the solution given masking should be close to the original gradient
(mx,_,_) = util.lin_regression(self.noisy_grad,
mask=self.gmask, axis=-1)
(my,_,_) = util.lin_regression(self.noisy_grad,
mask=self.gmask, axis=-2)
(mz,_,_) = util.lin_regression(self.noisy_grad,
mask=self.gmask, axis=-3)
assert abs(mx.mean() - self.abg[2]) < .099
assert abs(my.mean() - self.abg[1]) < .099
assert abs(mz.mean() - self.abg[0]) < .099
def testReallyWorks(self, level=1):
# the solution given masking should be close to the original gradient
(mx, _, _) = util.lin_regression(self.noisy_grad,
mask=self.gmask,
axis=-1)
(my, _, _) = util.lin_regression(self.noisy_grad,
mask=self.gmask,
axis=-2)
(mz, _, _) = util.lin_regression(self.noisy_grad,
mask=self.gmask,
axis=-3)
assert abs(mx.mean() - self.abg[2]) < .099
assert abs(my.mean() - self.abg[1]) < .099
assert abs(mz.mean() - self.abg[0]) < .099
def doLinRegTests(self, mask=None, sigma=None, axis=-1, test_id='basic'):
gshape = self.noisy_grad.shape
coef_shape = list(gshape)
coef_shape.pop(axis)
m1d, b1d, chi1d = (np.zeros(coef_shape), np.zeros(coef_shape),
np.zeros(coef_shape))
mnd, bnd, chind = util.lin_regression(self.noisy_grad,
mask=mask,
sigma=sigma,
axis=axis)
# these return with a None dim if axis is not -1
mnd, bnd, chind = map(lambda x: np.squeeze(x), (mnd, bnd, chind))
for m in range(coef_shape[0]):
for n in range(coef_shape[1]):
sl = [m, n]
sl.insert(len(gshape) + axis, slice(0, gshape[axis]))
if sigma is None:
sig = sigma
else:
sig = sigma[sl]
if mask is None:
msk = mask
else:
msk = mask[sl]
(m1d[m, n], b1d[m, n],
chi1d[m, n]) = ref_linear_regression(self.noisy_grad[sl],
sigma=sig,
mask=msk)
msg = 'failed with ' + test_id
assert_array_almost_equal(b1d, bnd, decimal=12, err_msg=msg)
assert_array_almost_equal(m1d, mnd, decimal=12, err_msg=msg)
assert_array_almost_equal(chi1d, chind, decimal=12, err_msg=msg)
def doLinRegTests(self, mask=None, sigma=None, axis=-1, test_id='basic'):
gshape = self.noisy_grad.shape
coef_shape = list(gshape)
coef_shape.pop(axis)
m1d,b1d,chi1d = (np.zeros(coef_shape),
np.zeros(coef_shape),
np.zeros(coef_shape))
mnd,bnd,chind = util.lin_regression(self.noisy_grad,
mask=mask,
sigma=sigma,
axis=axis)
# these return with a None dim if axis is not -1
mnd,bnd,chind = map(lambda x: np.squeeze(x), (mnd,bnd,chind))
for m in range(coef_shape[0]):
for n in range(coef_shape[1]):
sl = [m,n]
sl.insert(len(gshape)+axis, slice(0,gshape[axis]))
if sigma is None:
sig = sigma
else:
sig = sigma[sl]
if mask is None:
msk = mask
else:
msk = mask[sl]
(m1d[m,n],
b1d[m,n],
chi1d[m,n]) = ref_linear_regression(self.noisy_grad[sl],
sigma=sig,mask=msk)
msg = 'failed with ' + test_id
assert_array_almost_equal(b1d, bnd, decimal=12, err_msg=msg)
assert_array_almost_equal(m1d, mnd, decimal=12, err_msg=msg)
assert_array_almost_equal(chi1d, chind, decimal=12, err_msg=msg)
def subsampInterp_TD(ts, c, axis=0):
T = ts.shape[axis]
# find ramps and subtract them
ramps = np.empty_like(ts)
rax_shape = [1] * len(ts.shape)
rax_shape[axis] = T
rax = np.arange(T)
rax.shape = rax_shape
(mre, b, r) = lin_regression(ts.real, axis=axis)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes["complex"]:
(mim, b, r) = lin_regression(ts.imag, axis=axis)
ramps.imag[:] = rax * mim
np.subtract(ts, ramps, ts)
# find biases and subtract them
ts_mean = ts.mean(axis=axis)
if len(ts_mean.shape):
mean_shape = list(ts.shape)
mean_shape[axis] = 1
ts_mean.shape = tuple(mean_shape)
np.subtract(ts, ts_mean, ts)
if axis != 0:
ts = np.swapaxes(ts, axis, 0)
snc_ax = np.arange(T)
ts_shape = ts.shape
ts.shape = (T, -1)
snc_kern = np.sinc(snc_ax[None, :] - snc_ax[:, None] + c)
ts_tmp = np.dot(snc_kern, ts)
ts[:] = ts_tmp
ts.shape = ts_shape
del ts_tmp
if axis != 0:
ts = np.swapaxes(ts, axis, 0)
# add back biases and analytically interpolated ramps
np.subtract(rax, c, rax)
# np.add(rax, c, rax)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes["complex"]:
ramps.imag[:] = rax * mim
np.add(ts, ramps, ts)
np.add(ts, ts_mean, ts)
def subsampInterp_TD(ts, c, axis=0):
T = ts.shape[axis]
# find ramps and subtract them
ramps = np.empty_like(ts)
rax_shape = [1] * len(ts.shape)
rax_shape[axis] = T
rax = np.arange(T)
rax.shape = rax_shape
(mre, b, r) = lin_regression(ts.real, axis=axis)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes['complex']:
(mim, b, r) = lin_regression(ts.imag, axis=axis)
ramps.imag[:] = (rax * mim)
np.subtract(ts, ramps, ts)
# find biases and subtract them
ts_mean = ts.mean(axis=axis)
if len(ts_mean.shape):
mean_shape = list(ts.shape)
mean_shape[axis] = 1
ts_mean.shape = tuple(mean_shape)
np.subtract(ts, ts_mean, ts)
if axis != 0:
ts = np.swapaxes(ts, axis, 0)
snc_ax = np.arange(T)
ts_shape = ts.shape
ts.shape = (T, -1)
snc_kern = np.sinc(snc_ax[None, :] - snc_ax[:, None] + c)
ts_tmp = np.dot(snc_kern, ts)
ts[:] = ts_tmp
ts.shape = ts_shape
del ts_tmp
if axis != 0:
ts = np.swapaxes(ts, axis, 0)
# add back biases and analytically interpolated ramps
np.subtract(rax, c, rax)
#np.add(rax, c, rax)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes['complex']:
ramps.imag[:] = rax * mim
np.add(ts, ramps, ts)
np.add(ts, ts_mean, ts)
def subsampInterp(ts, c, axis=-1):
"""Makes a subsample sinc interpolation on an N-D array in a given axis.
This uses sinc interpolation to return ts(t-a), where a is related to
the factor c as described below.
ts : the N-D array with a time series in "axis"
c : the fraction of the sampling interval such that a = c*dt -- note that
c is only useful in the interval (0, 1]
axis : specifies the axis of the time dimension
"""
To = ts.shape[axis]
# find ramps and subtract them
ramps = np.empty_like(ts)
rax_shape = [1] * len(ts.shape)
rax_shape[axis] = To
rax = np.arange(To)
rax.shape = rax_shape
(mre, b, r) = lin_regression(ts.real, axis=axis)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes["complex"]:
(mim, b, r) = lin_regression(ts.imag, axis=axis)
ramps.imag[:] = rax * mim
np.subtract(ts, ramps, ts)
# find biases and subtract them
ts_mean = ts.mean(axis=axis)
if len(ts_mean.shape):
mean_shape = list(ts.shape)
mean_shape[axis] = 1
ts_mean.shape = tuple(mean_shape)
np.subtract(ts, ts_mean, ts)
# put time series in the last dimension
if axis != -1:
ts = np.swapaxes(ts, axis, -1)
ts_buf = circularize(ts)
## ts_buf = ts.copy()
T = ts_buf.shape[-1]
Fn = T / 2 + 1
# make sure the interpolating filter's dtype is complex!
filter_dtype = np.dtype(ts.dtype.char.upper())
phs_shift = np.empty((T,), filter_dtype)
phs_shift[:Fn] = np.exp(-2.0j * np.pi * c * np.arange(Fn) / float(T))
phs_shift[Fn:] = np.conjugate(reverse(phs_shift[1 : T - (Fn - 1)]))
fft(ts_buf, shift=False, inplace=True)
np.multiply(ts_buf, phs_shift, ts_buf)
ifft(ts_buf, shift=False, inplace=True)
ts[:] = ts_buf[..., To - 1 : 2 * To - 1]
## ts[:] = ts_buf[:]
del ts_buf
if axis != -1:
ts = np.swapaxes(ts, axis, -1)
# add back biases and analytically interpolated ramps
np.subtract(rax, c, rax)
# np.add(rax, c, rax)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes["complex"]:
ramps.imag[:] = rax * mim
np.add(ts, ramps, ts)
np.add(ts, ts_mean, ts)
def subsampInterp(ts, c, axis=-1):
"""Makes a subsample sinc interpolation on an N-D array in a given axis.
This uses sinc interpolation to return ts(t-a), where a is related to
the factor c as described below.
ts : the N-D array with a time series in "axis"
c : the fraction of the sampling interval such that a = c*dt -- note that
c is only useful in the interval (0, 1]
axis : specifies the axis of the time dimension
"""
To = ts.shape[axis]
# find ramps and subtract them
ramps = np.empty_like(ts)
rax_shape = [1] * len(ts.shape)
rax_shape[axis] = To
rax = np.arange(To)
rax.shape = rax_shape
(mre, b, r) = lin_regression(ts.real, axis=axis)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes['complex']:
(mim, b, r) = lin_regression(ts.imag, axis=axis)
ramps.imag[:] = (rax * mim)
np.subtract(ts, ramps, ts)
# find biases and subtract them
ts_mean = ts.mean(axis=axis)
if len(ts_mean.shape):
mean_shape = list(ts.shape)
mean_shape[axis] = 1
ts_mean.shape = tuple(mean_shape)
np.subtract(ts, ts_mean, ts)
# put time series in the last dimension
if axis != -1:
ts = np.swapaxes(ts, axis, -1)
ts_buf = circularize(ts)
## ts_buf = ts.copy()
T = ts_buf.shape[-1]
Fn = T / 2 + 1
# make sure the interpolating filter's dtype is complex!
filter_dtype = np.dtype(ts.dtype.char.upper())
phs_shift = np.empty((T, ), filter_dtype)
phs_shift[:Fn] = np.exp(-2.j * np.pi * c * np.arange(Fn) / float(T))
phs_shift[Fn:] = np.conjugate(reverse(phs_shift[1:T - (Fn - 1)]))
fft(ts_buf, shift=False, inplace=True)
np.multiply(ts_buf, phs_shift, ts_buf)
ifft(ts_buf, shift=False, inplace=True)
ts[:] = ts_buf[..., To - 1:2 * To - 1]
## ts[:] = ts_buf[:]
del ts_buf
if axis != -1:
ts = np.swapaxes(ts, axis, -1)
# add back biases and analytically interpolated ramps
np.subtract(rax, c, rax)
#np.add(rax, c, rax)
ramps.real[:] = rax * mre
if ts.dtype.type in np.sctypes['complex']:
ramps.imag[:] = rax * mim
np.add(ts, ramps, ts)
np.add(ts, ts_mean, ts)
