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))