def test_extend(self):
# test_arrays is (input_array, pre_extension_length, extension_data,
# post_extension_length, output)
# extension_data = None corresponds to no input
test_arrays = (
([1, 2, 3, 4], 3, None, None, [3, 2, 1, 1, 2, 3, 4, 4, 3, 2]),
([1, 2, 3, 4], 0, None, None, numpy.array([1, 2, 3, 4])),
([1, 2, 3, 4], 3, numpy.array([4, 3, 2, 1]), None,
[3, 2, 1, 1, 2, 3, 4, 4, 3, 2]),
(numpy.array([1, 2, 3, 4]), 3, [8, 7, 6, 5], None,
[7, 6, 5, 1, 2, 3, 4, 8, 7, 6]),
([1, 2, 3, 4], 6, [8, 7, 6, 5], None,
[3, 4, 8, 7, 6, 5, 1, 2, 3, 4, 8, 7, 6, 5, 1, 2]),
([1, 2, 3, 4], 6, [8, 7, 6, 5], 3,
[3, 4, 8, 7, 6, 5, 1, 2, 3, 4, 8, 7, 6]),
([1, 2, 3, 4], 6, [8, 7, 6, 5], 0,
[3, 4, 8, 7, 6, 5, 1, 2, 3, 4]),
([1, 2, 3, 4], 3, [8, 7, 6, 5], 6,
[7, 6, 5, 1, 2, 3, 4, 8, 7, 6, 5, 1, 2]),
([1, 2, 3, 4], 0, [8, 7, 6, 5], 6,
[1, 2, 3, 4, 8, 7, 6, 5, 1, 2]))
for (input_arr, pre_ext_length, ext_data,
post_ext_length, output_arr) in test_arrays:
if ext_data is not None:
output_array = reference.extend_1d(
numpy.array(input_arr), pre_ext_length, ext_data,
post_extension_length=post_ext_length)
else:
output_array = reference.extend_1d(
numpy.array(input_arr), pre_ext_length,
post_extension_length=post_ext_length)
self.assertTrue(numpy.alltrue(output_array == output_arr))
def test_extend(self):
# test_arrays is (input_array, pre_extension_length, extension_data,
# post_extension_length, output)
# extension_data = None corresponds to no input
test_arrays = (([1, 2, 3,
4], 3, None, None, [3, 2, 1, 1, 2, 3, 4, 4, 3,
2]), ([1, 2, 3, 4], 0, None, None,
numpy.array([1, 2, 3, 4])),
([1, 2, 3, 4], 3, numpy.array([4, 3, 2, 1]), None,
[3, 2, 1, 1, 2, 3, 4, 4, 3,
2]), (numpy.array([1, 2, 3, 4]), 3, [8, 7, 6, 5],
None, [7, 6, 5, 1, 2, 3, 4, 8, 7, 6]),
([1, 2, 3, 4], 6, [8, 7, 6, 5], None,
[3, 4, 8, 7, 6, 5, 1, 2, 3, 4, 8, 7, 6, 5, 1,
2]), ([1, 2, 3, 4], 6, [8, 7, 6, 5], 3,
[3, 4, 8, 7, 6, 5, 1, 2, 3, 4, 8, 7,
6]), ([1, 2, 3, 4], 6, [8, 7, 6, 5], 0,
[3, 4, 8, 7, 6, 5, 1, 2, 3, 4]),
([1, 2, 3, 4], 3, [8, 7, 6, 5], 6,
[7, 6, 5, 1, 2, 3, 4, 8, 7, 6, 5, 1,
2]), ([1, 2, 3,
4], 0, [8, 7, 6,
5], 6, [1, 2, 3, 4, 8, 7, 6, 5, 1, 2]))
for (input_arr, pre_ext_length, ext_data, post_ext_length,
output_arr) in test_arrays:
if ext_data is not None:
output_array = reference.extend_1d(
numpy.array(input_arr),
pre_ext_length,
ext_data,
post_extension_length=post_ext_length)
else:
output_array = reference.extend_1d(
numpy.array(input_arr),
pre_ext_length,
post_extension_length=post_ext_length)
self.assertTrue(numpy.alltrue(output_array == output_arr))
def test_extend_and_filter_and_decimate(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array,
# pre_length, post_length)
datasets = (
((128,), 16, None, None, None),
((128,), 15, None, None, None),
((128,), 11, [1, 2, 3], None, None),
((128,), 16, [3, 2, 1], None, None),
((36,), 16, [3, 2, 1], 4, 10),
((36,), 16, [3, 2, 1], 5, 10),
((36,), 16, [3, 2, 1], 11, 5),
((12,), 17, None, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array,
pre_length, post_length) in datasets:
a = numpy.random.randn(*input_shape)
if pre_length is None:
pre_length = (kernel_length-1)//2
if post_length is None:
post_length = kernel_length - pre_length - 1
_a = reference.extend_1d(a, pre_length,
ext_array, post_length)
kernel = numpy.random.randn(kernel_length)
ref_output = numpy.convolve(_a, kernel, mode='valid')
delta_kernel = numpy.concatenate(
(numpy.zeros(post_length), delta,
numpy.zeros(pre_length)))
delta_args = (a, delta_kernel, ext_array, pre_length,
post_length, True)
kernel_args = (a, kernel, ext_array, pre_length,
post_length, True)
delta_output = reference.extend_and_filter(*delta_args)
self.assertTrue(numpy.allclose(a[::2], delta_output))
test_output = reference.extend_and_filter(*kernel_args)
self.assertTrue(numpy.allclose(ref_output[::2], test_output))
def test_extend_and_filter_and_decimate(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array,
# pre_length, post_length)
datasets = (((128, ), 16, None, None,
None), ((128, ), 15, None, None,
None), ((128, ), 11, [1, 2, 3], None, None),
((128, ), 16, [3, 2, 1], None,
None), ((36, ), 16, [3, 2,
1], 4, 10), ((36, ), 16, [3, 2,
1], 5, 10),
((36, ), 16, [3, 2,
1], 11, 5), ((12, ), 17, None, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array, pre_length,
post_length) in datasets:
a = numpy.random.randn(*input_shape)
if pre_length is None:
pre_length = (kernel_length - 1) // 2
if post_length is None:
post_length = kernel_length - pre_length - 1
_a = reference.extend_1d(a, pre_length, ext_array, post_length)
kernel = numpy.random.randn(kernel_length)
ref_output = numpy.convolve(_a, kernel, mode='valid')
delta_kernel = numpy.concatenate(
(numpy.zeros(post_length), delta, numpy.zeros(pre_length)))
delta_args = (a, delta_kernel, ext_array, pre_length, post_length,
True)
kernel_args = (a, kernel, ext_array, pre_length, post_length, True)
delta_output = reference.extend_and_filter(*delta_args)
self.assertTrue(numpy.allclose(a[::2], delta_output))
test_output = reference.extend_and_filter(*kernel_args)
self.assertTrue(numpy.allclose(ref_output[::2], test_output))
def test_extend_and_filter_on_various_sizes(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array_length,
# pre_length, post_length)
datasets = (
((128,), 16, 24, None, None),
((128,), 15, 24, None, None),
((94,), 13, 24, None, None),
((128, 32), 11, 3, None, None),
((128, 32), 16, 3, None, None),
((12, 14), 16, 3, 5, 10),
((36, 18), 16, 3, 11, 5),
((12, 16), 17, 12, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array_length,
pre_length, post_length) in datasets:
extension_array_shape = numpy.array(input_shape)
extension_array_shape[-1] = ext_array_length
_extension_array = numpy.random.randn(*extension_array_shape)
_a = numpy.random.randn(*input_shape)
if self.transpose:
extension_array = (
numpy.atleast_2d(_extension_array).transpose())
a = numpy.atleast_2d(_a).transpose()
else:
extension_array = _extension_array
a = _a
if pre_length is None:
_pre_length = (kernel_length-1)//2
else:
_pre_length = pre_length
if post_length is None:
_post_length = kernel_length - _pre_length - 1
else:
_post_length = post_length
# We test with both a delta and a random kernel
delta_kernel = numpy.concatenate(
(numpy.zeros(_post_length), delta,
numpy.zeros(_pre_length)))
random_kernel = numpy.random.randn(kernel_length)
delta_args = (a, delta_kernel, extension_array, pre_length,
post_length)
random_kernel_args = (a, random_kernel, extension_array,
pre_length, post_length)
delta_output = self._test_function(*delta_args)
test_output = self._test_function(*random_kernel_args)
if self.transpose:
delta_output = delta_output.transpose()
test_output = test_output.transpose()
# In the case of the delta kernel, the output should
# just be the input
self.assertTrue(numpy.allclose(_a, delta_output))
a_2d = numpy.atleast_2d(_a)
extension_array_2d = numpy.atleast_2d(_extension_array)
test_output_2d = numpy.atleast_2d(test_output)
for row, extension_row, test_row in zip(
a_2d, extension_array_2d, test_output_2d):
_row = reference.extend_1d(row, _pre_length, extension_row,
_post_length)
ref_row_output = numpy.convolve(_row, random_kernel,
mode='valid')
self.assertTrue(numpy.allclose(ref_row_output, test_row))
def test_extend_expand_and_filter_on_various_sizes(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array_length,
# pre_length, post_length)
datasets = (
((128,), 16, 24, None, None),
((128,), 15, 24, None, None),
((94,), 13, 24, None, None),
((128, 32), 11, 3, None, None),
((128, 32), 16, 3, None, None),
((12, 14), 16, 3, 5, 10),
((36, 18), 16, 3, 11, 5),
((12, 16), 17, 12, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array_length,
pre_length, post_length) in datasets:
extension_array_shape = numpy.array(input_shape)
extension_array_shape[-1] = ext_array_length
_extension_array = numpy.random.randn(*extension_array_shape)
_a = numpy.random.randn(*input_shape)
if self.transpose:
extension_array = (
numpy.atleast_2d(_extension_array).transpose())
a = numpy.atleast_2d(_a).transpose()
else:
extension_array = _extension_array
a = _a
if pre_length is None:
_pre_length = (kernel_length-1)//2
else:
_pre_length = pre_length
if post_length is None:
_post_length = kernel_length - _pre_length - 1
else:
_post_length = post_length
# We test with both a delta and a random kernel
delta_kernel = numpy.concatenate(
(numpy.zeros(_post_length), delta,
numpy.zeros(_pre_length)))
random_kernel = numpy.random.randn(kernel_length)
for first_sample_zero in (True, False, None):
# Create a _first_sample zero for constructing the
# test arrays. None will mean we don't pass in the arg
# to extend_expand_and_filter, but we still need to create
# the correct test array.
if first_sample_zero == False:
_first_sample_zero = False
else:
# The default, so true for first_sample_zero is None
_first_sample_zero = True
delta_args = (a, delta_kernel, extension_array,
_pre_length, post_length, True)
random_kernel_args = (a, random_kernel, extension_array,
pre_length, post_length, True)
if first_sample_zero is not None:
delta_args += (first_sample_zero,)
random_kernel_args += (first_sample_zero,)
delta_output = self._test_function(*delta_args)
test_output = self._test_function(*random_kernel_args)
if self.transpose:
delta_output = delta_output.transpose()
test_output = test_output.transpose()
a_2d = numpy.atleast_2d(_a)
extension_array_2d = numpy.atleast_2d(_extension_array)
test_output_2d = numpy.atleast_2d(test_output)
delta_output_2d = numpy.atleast_2d(delta_output)
for row, extension_row, test_row, test_delta_row in zip(
a_2d, extension_array_2d, test_output_2d,
delta_output_2d):
# We extend row by pre_length and post_length samples. This
# will result in twice as many extension samples as needed
# after expansion, but allows a simple way to compute the
# correct expanded, extended array.
overextended_row = reference.extend_1d(row, _pre_length,
extension_row, _post_length)
expanded_overextended_row = numpy.zeros(
(len(row) + _pre_length + _post_length)*2)
# Creating the correct alignment is trivial now we have
# a double length array. We can trim it afterwards.
if _first_sample_zero:
expanded_overextended_row[1::2] = overextended_row
else:
expanded_overextended_row[0::2] = overextended_row
# Now we need to trim expanded_row to have the correct
# number of extension samples.
expanded_extended_row = (
expanded_overextended_row[
_pre_length:-_post_length])
# And get back from this just the expanded version
# of the row
expanded_row = expanded_extended_row[
_pre_length:-_post_length]
ref_row_output = numpy.convolve(expanded_extended_row,
random_kernel, mode='valid')
self.assertTrue(
numpy.allclose(expanded_row, test_delta_row))
self.assertTrue(numpy.allclose(ref_row_output, test_row))
def test_extend_expand_and_filter(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array,
# pre_length, post_length)
datasets = (
((128,), 16, None, None, None),
((128,), 15, None, None, None),
((128,), 11, [1, 2, 3], None, None),
((128,), 16, [3, 2, 1], None, None),
((36,), 16, [3, 2, 1], 4, 10),
((36,), 16, [3, 2, 1], 5, 10),
((36,), 16, [3, 2, 1], 11, 5),
((12,), 17, None, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array,
pre_length, post_length) in datasets:
a = numpy.random.randn(*input_shape)
if pre_length is None:
pre_length = (kernel_length-1)//2
if post_length is None:
post_length = kernel_length - pre_length - 1
# We extend a by pre_length and post_length samples. This
# will result in twice as many extension samples as needed
# after expansion, but allows a simple way to compute the
# correct expanded, extended array.
overextended_a = reference.extend_1d(a, pre_length,
ext_array, post_length)
kernel = numpy.random.randn(kernel_length)
for first_sample_zero in (True, False, None):
# Create a _first_sample zero for constructing the
# test arrays. None will mean we don't pass in the arg
# to extend_expand_and_filter, but we still need to create
# the correct test array.
if first_sample_zero == False:
_first_sample_zero = False
else:
# The default, so true for first_sample_zero is None
_first_sample_zero = True
expanded_overextended_a = numpy.zeros(
(len(a) + pre_length + post_length)*2)
# Creating the correct alignment is trivial now we have
# a double length array. We can trim it afterwards.
if _first_sample_zero:
expanded_overextended_a[1::2] = overextended_a
else:
expanded_overextended_a[0::2] = overextended_a
# Now we need to trim expanded_a to have the correct
# number of extension samples.
expanded_extended_a = (
expanded_overextended_a[pre_length:-post_length])
# And get back from this just the expanded version
# of a
expanded_a = expanded_extended_a[pre_length:-post_length]
ref_output = numpy.convolve(expanded_extended_a,
kernel, mode='valid')
delta_kernel = numpy.concatenate(
(numpy.zeros(post_length), delta,
numpy.zeros(pre_length)))
delta_args = (a, delta_kernel, ext_array,
pre_length, post_length)
kernel_args = (a, kernel, ext_array, pre_length,
post_length)
if first_sample_zero is not None:
delta_args += (first_sample_zero,)
kernel_args += (first_sample_zero,)
delta_output = reference.extend_expand_and_filter(*delta_args)
self.assertTrue(numpy.allclose(expanded_a, delta_output))
test_output = reference.extend_expand_and_filter(*kernel_args)
self.assertTrue(numpy.allclose(ref_output, test_output))
def test_extend_expand_and_filter(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array,
# pre_length, post_length)
datasets = (((128, ), 16, None, None,
None), ((128, ), 15, None, None,
None), ((128, ), 11, [1, 2, 3], None, None),
((128, ), 16, [3, 2, 1], None,
None), ((36, ), 16, [3, 2,
1], 4, 10), ((36, ), 16, [3, 2,
1], 5, 10),
((36, ), 16, [3, 2,
1], 11, 5), ((12, ), 17, None, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array, pre_length,
post_length) in datasets:
a = numpy.random.randn(*input_shape)
if pre_length is None:
pre_length = (kernel_length - 1) // 2
if post_length is None:
post_length = kernel_length - pre_length - 1
# We extend a by pre_length and post_length samples. This
# will result in twice as many extension samples as needed
# after expansion, but allows a simple way to compute the
# correct expanded, extended array.
overextended_a = reference.extend_1d(a, pre_length, ext_array,
post_length)
kernel = numpy.random.randn(kernel_length)
for first_sample_zero in (True, False, None):
# Create a _first_sample zero for constructing the
# test arrays. None will mean we don't pass in the arg
# to extend_expand_and_filter, but we still need to create
# the correct test array.
if first_sample_zero == False:
_first_sample_zero = False
else:
# The default, so true for first_sample_zero is None
_first_sample_zero = True
expanded_overextended_a = numpy.zeros(
(len(a) + pre_length + post_length) * 2)
# Creating the correct alignment is trivial now we have
# a double length array. We can trim it afterwards.
if _first_sample_zero:
expanded_overextended_a[1::2] = overextended_a
else:
expanded_overextended_a[0::2] = overextended_a
# Now we need to trim expanded_a to have the correct
# number of extension samples.
expanded_extended_a = (
expanded_overextended_a[pre_length:-post_length])
# And get back from this just the expanded version
# of a
expanded_a = expanded_extended_a[pre_length:-post_length]
ref_output = numpy.convolve(expanded_extended_a,
kernel,
mode='valid')
delta_kernel = numpy.concatenate(
(numpy.zeros(post_length), delta, numpy.zeros(pre_length)))
delta_args = (a, delta_kernel, ext_array, pre_length,
post_length)
kernel_args = (a, kernel, ext_array, pre_length, post_length)
if first_sample_zero is not None:
delta_args += (first_sample_zero, )
kernel_args += (first_sample_zero, )
delta_output = reference.extend_expand_and_filter(*delta_args)
self.assertTrue(numpy.allclose(expanded_a, delta_output))
test_output = reference.extend_expand_and_filter(*kernel_args)
self.assertTrue(numpy.allclose(ref_output, test_output))
def test_extend_and_filter_on_various_sizes(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array_length,
# pre_length, post_length)
datasets = (
((128,), 16, 24, None, None),
((128,), 15, 24, None, None),
((94,), 13, 24, None, None),
((128, 32), 11, 3, None, None),
((128, 32), 16, 3, None, None),
((12, 14), 16, 3, 5, 10),
((36, 18), 16, 3, 11, 5),
((12, 16), 17, 12, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array_length,
pre_length, post_length) in datasets:
extension_array_shape = numpy.array(input_shape)
extension_array_shape[-1] = ext_array_length
_extension_array = numpy.random.randn(*extension_array_shape)
_a = numpy.random.randn(*input_shape)
if self.transpose:
extension_array = (
numpy.atleast_2d(_extension_array).transpose())
a = numpy.atleast_2d(_a).transpose()
else:
extension_array = _extension_array
a = _a
if pre_length is None:
_pre_length = (kernel_length-1)//2
else:
_pre_length = pre_length
if post_length is None:
_post_length = kernel_length - _pre_length - 1
else:
_post_length = post_length
# We test with both a delta and a random kernel
delta_kernel = numpy.concatenate(
(numpy.zeros(_post_length), delta,
numpy.zeros(_pre_length)))
random_kernel = numpy.random.randn(kernel_length)
delta_args = (a, delta_kernel, extension_array, pre_length,
post_length)
random_kernel_args = (a, random_kernel, extension_array,
pre_length, post_length)
delta_output = self._test_function(*delta_args)
test_output = self._test_function(*random_kernel_args)
if self.transpose:
delta_output = delta_output.transpose()
test_output = test_output.transpose()
# In the case of the delta kernel, the output should
# just be the input
self.assertTrue(numpy.allclose(_a, delta_output))
a_2d = numpy.atleast_2d(_a)
extension_array_2d = numpy.atleast_2d(_extension_array)
test_output_2d = numpy.atleast_2d(test_output)
for row, extension_row, test_row in zip(
a_2d, extension_array_2d, test_output_2d):
_row = reference.extend_1d(row, _pre_length, extension_row,
_post_length)
ref_row_output = numpy.convolve(_row, random_kernel,
mode='valid')
self.assertTrue(numpy.allclose(ref_row_output, test_row))
def test_extend_expand_and_filter_on_various_sizes(self):
# a tuple of test specs:
# (input_shape, kernel_length, extension_array_length,
# pre_length, post_length)
datasets = (
((128,), 16, 24, None, None),
((128,), 15, 24, None, None),
((94,), 13, 24, None, None),
((128, 32), 11, 3, None, None),
((128, 32), 16, 3, None, None),
((12, 14), 16, 3, 5, 10),
((36, 18), 16, 3, 11, 5),
((12, 16), 17, 12, None, None))
delta = numpy.array([1])
for (input_shape, kernel_length, ext_array_length,
pre_length, post_length) in datasets:
extension_array_shape = numpy.array(input_shape)
extension_array_shape[-1] = ext_array_length
_extension_array = numpy.random.randn(*extension_array_shape)
_a = numpy.random.randn(*input_shape)
if self.transpose:
extension_array = (
numpy.atleast_2d(_extension_array).transpose())
a = numpy.atleast_2d(_a).transpose()
else:
extension_array = _extension_array
a = _a
if pre_length is None:
_pre_length = (kernel_length-1)//2
else:
_pre_length = pre_length
if post_length is None:
_post_length = kernel_length - _pre_length - 1
else:
_post_length = post_length
# We test with both a delta and a random kernel
delta_kernel = numpy.concatenate(
(numpy.zeros(_post_length), delta,
numpy.zeros(_pre_length)))
random_kernel = numpy.random.randn(kernel_length)
for first_sample_zero in (True, False, None):
# Create a _first_sample zero for constructing the
# test arrays. None will mean we don't pass in the arg
# to extend_expand_and_filter, but we still need to create
# the correct test array.
if first_sample_zero == False:
_first_sample_zero = False
else:
# The default, so true for first_sample_zero is None
_first_sample_zero = True
delta_args = (a, delta_kernel, extension_array,
_pre_length, post_length, True)
random_kernel_args = (a, random_kernel, extension_array,
pre_length, post_length, True)
if first_sample_zero is not None:
delta_args += (first_sample_zero,)
random_kernel_args += (first_sample_zero,)
delta_output = self._test_function(*delta_args)
test_output = self._test_function(*random_kernel_args)
if self.transpose:
delta_output = delta_output.transpose()
test_output = test_output.transpose()
a_2d = numpy.atleast_2d(_a)
extension_array_2d = numpy.atleast_2d(_extension_array)
test_output_2d = numpy.atleast_2d(test_output)
delta_output_2d = numpy.atleast_2d(delta_output)
for row, extension_row, test_row, test_delta_row in zip(
a_2d, extension_array_2d, test_output_2d,
delta_output_2d):
# We extend row by pre_length and post_length samples. This
# will result in twice as many extension samples as needed
# after expansion, but allows a simple way to compute the
# correct expanded, extended array.
overextended_row = reference.extend_1d(row, _pre_length,
extension_row, _post_length)
expanded_overextended_row = numpy.zeros(
(len(row) + _pre_length + _post_length)*2)
# Creating the correct alignment is trivial now we have
# a double length array. We can trim it afterwards.
if _first_sample_zero:
expanded_overextended_row[1::2] = overextended_row
else:
expanded_overextended_row[0::2] = overextended_row
# Now we need to trim expanded_row to have the correct
# number of extension samples.
expanded_extended_row = (
expanded_overextended_row[
_pre_length:-_post_length])
# And get back from this just the expanded version
# of the row
expanded_row = expanded_extended_row[
_pre_length:-_post_length]
ref_row_output = numpy.convolve(expanded_extended_row,
random_kernel, mode='valid')
self.assertTrue(
numpy.allclose(expanded_row, test_delta_row))
self.assertTrue(numpy.allclose(ref_row_output, test_row))
