def test_load_impulse_outputs(self):
"""
Test loading multiple signal files in [t sig1 sig2 ...] format.
Creates signals, saves them, loads them, tests are equal to the
originals.
"""
signal_path = join(self.test_dir, 'file%03d.txt')
for num_paths in [1, 4]:
for num_signals in [1, 2, 4, 5]:
for num_time_steps in [1, 10, 100]:
all_signals_true = np.random.random(
(num_paths, num_time_steps, num_signals))
# Time steps need not be sequential
time_values_true = np.random.random(num_time_steps)
signal_paths = []
# Save signals to file
for path_num in range(num_paths):
signal_paths.append(signal_path % path_num)
data_to_save = np.concatenate( \
(time_values_true.reshape(len(time_values_true), 1),
all_signals_true[path_num]), axis=1)
util.save_array_text(data_to_save,
signal_path % path_num)
time_values, all_signals = util.load_multiple_signals(
signal_paths)
np.testing.assert_allclose(all_signals, all_signals_true)
np.testing.assert_allclose(time_values, time_values_true)
def test_load_save_array_text(self):
"""Test that can read/write text arrays"""
rows = [1, 5, 20]
cols = [1, 4, 5, 23]
array_path = join(self.test_dir, 'test_array.txt')
delimiters = [',', ' ', ';']
for delimiter in delimiters:
for is_complex in [False, True]:
for squeeze in [False, True]:
for num_rows in rows:
for num_cols in cols:
# Generate real and complex arrays
array = np.random.random((num_rows, num_cols))
if is_complex:
array = array + (1j * np.random.random(
(num_rows, num_cols)))
# Check row and column vectors, no squeeze (1, 1)
if squeeze and (num_rows > 1 or num_cols > 1):
array = np.squeeze(array)
util.save_array_text(array,
array_path,
delimiter=delimiter)
array_read = util.load_array_text(
array_path,
delimiter=delimiter,
is_complex=is_complex)
if squeeze:
array_read = np.squeeze(array_read)
np.testing.assert_equal(array_read, array)
def test_load_save_array_text(self):
"""Test that can read/write text matrices"""
#tol = 1e-8
rows = [1, 5, 20]
cols = [1, 4, 5, 23]
mat_path = join(self.test_dir, 'test_matrix.txt')
delimiters = [',', ' ', ';']
for delimiter in delimiters:
for is_complex in [False, True]:
for squeeze in [False, True]:
for num_rows in rows:
for num_cols in cols:
mat_real = np.random.random((num_rows, num_cols))
if is_complex:
mat_imag = np.random.random(
(num_rows, num_cols))
mat = mat_real + 1J * mat_imag
else:
mat = mat_real
# Check row and column vectors, no squeeze (1,1)
if squeeze and (num_rows > 1 or num_cols > 1):
mat = np.squeeze(mat)
util.save_array_text(mat,
mat_path,
delimiter=delimiter)
mat_read = util.load_array_text(
mat_path,
delimiter=delimiter,
is_complex=is_complex)
if squeeze:
mat_read = np.squeeze(mat_read)
np.testing.assert_allclose(mat_read,
mat) #,rtol=tol)
def test_load_impulse_outputs(self):
"""
Test loading multiple signal files in [t sig1 sig2 ...] format.
Creates signals, saves them, loads them, tests are equal to the
originals.
"""
signal_path = join(self.test_dir, 'file%03d.txt')
for num_paths in [1, 4]:
for num_signals in [1, 2, 4, 5]:
for num_time_steps in [1, 10, 100]:
all_signals_true = np.random.random((num_paths,
num_time_steps, num_signals))
# Time steps need not be sequential
time_values_true = np.random.random(num_time_steps)
signal_paths = []
# Save signals to file
for path_num in range(num_paths):
signal_paths.append(signal_path%path_num)
data_to_save = np.concatenate( \
(time_values_true.reshape(len(time_values_true), 1),
all_signals_true[path_num]), axis=1)
util.save_array_text(data_to_save, signal_path%path_num)
time_values, all_signals = util.load_multiple_signals(
signal_paths)
np.testing.assert_allclose(all_signals, all_signals_true)
np.testing.assert_allclose(time_values, time_values_true)
def test_load_save_array_text(self):
"""Test that can read/write text matrices"""
#tol = 1e-8
rows = [1, 5, 20]
cols = [1, 4, 5, 23]
mat_path = join(self.test_dir, 'test_matrix.txt')
delimiters = [',', ' ', ';']
for delimiter in delimiters:
for is_complex in [False, True]:
for squeeze in [False, True]:
for num_rows in rows:
for num_cols in cols:
mat_real = np.random.random((num_rows, num_cols))
if is_complex:
mat_imag = np.random.random((num_rows, num_cols))
mat = mat_real + 1J*mat_imag
else:
mat = mat_real
# Check row and column vectors, no squeeze (1,1)
if squeeze and (num_rows > 1 or num_cols > 1):
mat = np.squeeze(mat)
util.save_array_text(mat, mat_path, delimiter=delimiter)
mat_read = util.load_array_text(mat_path, delimiter=delimiter,
is_complex=is_complex)
if squeeze:
mat_read = np.squeeze(mat_read)
np.testing.assert_allclose(mat_read, mat)#,rtol=tol)
def test_load_save_array_text(self):
"""Test that can read/write text arrays"""
rows = [1, 5, 20]
cols = [1, 4, 5, 23]
array_path = join(self.test_dir, 'test_array.txt')
delimiters = [',', ' ', ';']
for delimiter in delimiters:
for is_complex in [False, True]:
for squeeze in [False, True]:
for num_rows in rows:
for num_cols in cols:
# Generate real and complex arrays
array = np.random.random((num_rows, num_cols))
if is_complex:
array = array + (
1j * np.random.random((num_rows, num_cols)))
# Check row and column vectors, no squeeze (1, 1)
if squeeze and (num_rows > 1 or num_cols > 1):
array = np.squeeze(array)
util.save_array_text(
array, array_path, delimiter=delimiter)
array_read = util.load_array_text(
array_path, delimiter=delimiter,
is_complex=is_complex)
if squeeze:
array_read = np.squeeze(array_read)
np.testing.assert_equal(array_read, array)
def test_compute_inner_product_mat_types(self):
class ArrayTextComplexHandle(V.VecHandleArrayText):
def get(self):
return (1 + 1j)*V.VecHandleArrayText.get(self)
num_row_vecs = 4
num_col_vecs = 6
num_states = 7
row_vec_path = join(self.test_dir, 'row_vec_%03d.txt')
col_vec_path = join(self.test_dir, 'col_vec_%03d.txt')
# generate vecs and save to file
row_vec_array = np.mat(np.random.random((num_states,
num_row_vecs)))
col_vec_array = np.mat(np.random.random((num_states,
num_col_vecs)))
row_vec_paths = []
col_vec_paths = []
for vec_index in range(num_row_vecs):
path = row_vec_path % vec_index
util.save_array_text(row_vec_array[:,vec_index], path)
row_vec_paths.append(path)
for vec_index in range(num_col_vecs):
path = col_vec_path % vec_index
util.save_array_text(col_vec_array[:,vec_index], path)
col_vec_paths.append(path)
# Compute inner product matrix and check type
for handle, dtype in [(V.VecHandleArrayText, float),
(ArrayTextComplexHandle, complex)]:
row_vec_handles = [handle(path) for path in row_vec_paths]
col_vec_handles = [handle(path) for path in col_vec_paths]
inner_product_mat = self.my_vec_ops.compute_inner_product_mat(
row_vec_handles, col_vec_handles)
symm_inner_product_mat = \
self.my_vec_ops.compute_symmetric_inner_product_mat(
row_vec_handles)
self.assertEqual(inner_product_mat.dtype, dtype)
self.assertEqual(symm_inner_product_mat.dtype, dtype)
