def test_multiple_open(): # Ticket #1039, on Windows: check that files are not left open tmpdir = mkdtemp() try: x = dict(x=np.zeros((2, 2))) fname = pjoin(tmpdir, "a.mat") # Check that file is not left open savemat(fname, x) os.unlink(fname) savemat(fname, x) loadmat(fname) os.unlink(fname) # Check that stream is left open f = open(fname, 'wb') savemat(f, x) f.seek(0) f.close() f = open(fname, 'rb') loadmat(f) f.seek(0) f.close() finally: shutil.rmtree(tmpdir)
def test_compression(): arr = np.zeros(100).reshape((5, 20)) arr[2, 10] = 1 stream = BytesIO() savemat(stream, {'arr': arr}) raw_len = len(stream.getvalue()) vals = loadmat(stream) yield assert_array_equal, vals['arr'], arr stream = BytesIO() savemat(stream, {'arr': arr}, do_compression=True) compressed_len = len(stream.getvalue()) vals = loadmat(stream) yield assert_array_equal, vals['arr'], arr yield assert_, raw_len > compressed_len # Concatenate, test later arr2 = arr.copy() arr2[0, 0] = 1 stream = BytesIO() savemat(stream, {'arr': arr, 'arr2': arr2}, do_compression=False) vals = loadmat(stream) yield assert_array_equal, vals['arr2'], arr2 stream = BytesIO() savemat(stream, {'arr': arr, 'arr2': arr2}, do_compression=True) vals = loadmat(stream) yield assert_array_equal, vals['arr2'], arr2
def test_str_round(): # from report by Angus McMorland on mailing list 3 May 2010 stream = BytesIO() in_arr = np.array(['Hello', 'Foob']) out_arr = np.array(['Hello', 'Foob ']) savemat(stream, dict(a=in_arr)) res = loadmat(stream) # resulted in ['HloolFoa', 'elWrdobr'] assert_array_equal(res['a'], out_arr) stream.truncate(0) stream.seek(0) # Make Fortran ordered version of string in_str = in_arr.tostring(order='F') in_from_str = np.ndarray(shape=a.shape, dtype=in_arr.dtype, order='F', buffer=in_str) savemat(stream, dict(a=in_from_str)) assert_array_equal(res['a'], out_arr) # unicode save did lead to buffer too small error stream.truncate(0) stream.seek(0) in_arr_u = in_arr.astype('U') out_arr_u = out_arr.astype('U') savemat(stream, {'a': in_arr_u}) res = loadmat(stream) assert_array_equal(res['a'], out_arr_u)
def test_warnings(): # This test is an echo of the previous behavior, which was to raise a # warning if the user triggered a search for mat files on the Python system # path. We can remove the test in the next version after upcoming (0.13) fname = pjoin(test_data_path, 'testdouble_7.1_GLNX86.mat') with warnings.catch_warnings(): warnings.simplefilter('error') # This should not generate a warning mres = loadmat(fname, struct_as_record=True) # This neither mres = loadmat(fname, struct_as_record=False)
def test_mat_struct_squeeze(): stream = BytesIO() in_d = {'st': {'one': 1, 'two': 2}} savemat(stream, in_d) # no error without squeeze out_d = loadmat(stream, struct_as_record=False) # previous error was with squeeze, with mat_struct out_d = loadmat( stream, struct_as_record=False, squeeze_me=True, )
def test_unicode_mat4(): # Mat4 should save unicode as latin1 bio = BytesIO() var = {'second_cat': u('Schrödinger')} savemat(bio, var, format='4') var_back = loadmat(bio) assert_equal(var_back['second_cat'], var['second_cat'])
def test_save_dict(): # Test that dict can be saved (as recarray), loaded as matstruct dict_types = ((dict, False), ) try: from collections import OrderedDict except ImportError: pass else: dict_types += ((OrderedDict, True), ) ab_exp = np.array([[(1, 2)]], dtype=[('a', object), ('b', object)]) ba_exp = np.array([[(2, 1)]], dtype=[('b', object), ('a', object)]) for dict_type, is_ordered in dict_types: # Initialize with tuples to keep order for OrderedDict d = dict_type([('a', 1), ('b', 2)]) stream = BytesIO() savemat(stream, {'dict': d}) stream.seek(0) vals = loadmat(stream)['dict'] assert_equal(set(vals.dtype.names), set(['a', 'b'])) if is_ordered: # Input was ordered, output in ab order assert_array_equal(vals, ab_exp) else: # Not ordered input, either order output if vals.dtype.names[0] == 'a': assert_array_equal(vals, ab_exp) else: assert_array_equal(vals, ba_exp)
def test_skip_variable(): # Test skipping over the first of two variables in a MAT file # using mat_reader_factory and put_variables to read them in. # # This is a regression test of a problem that's caused by # using the compressed file reader seek instead of the raw file # I/O seek when skipping over a compressed chunk. # # The problem arises when the chunk is large: this file has # a 256x256 array of random (uncompressible) doubles. # filename = pjoin(test_data_path, 'test_skip_variable.mat') # # Prove that it loads with loadmat # d = loadmat(filename, struct_as_record=True) yield assert_, 'first' in d yield assert_, 'second' in d # # Make the factory # factory = mat_reader_factory(filename, struct_as_record=True) # # This is where the factory breaks with an error in MatMatrixGetter.to_next # d = factory.get_variables('second') yield assert_, 'second' in d factory.close()
def test_fieldnames(): # Check that field names are as expected stream = BytesIO() savemat(stream, {'a': {'a': 1, 'b': 2}}) res = loadmat(stream) field_names = res['a'].dtype.names assert_equal(set(field_names), set(('a', 'b')))
def test_gzip_simple(): xdense = np.zeros((20, 20)) xdense[2, 3] = 2.3 xdense[4, 5] = 4.5 x = SP.csc_matrix(xdense) name = 'gzip_test' expected = {'x': x} format = '4' tmpdir = mkdtemp() try: fname = pjoin(tmpdir, name) mat_stream = gzip.open(fname, mode='wb') savemat(mat_stream, expected, format=format) mat_stream.close() mat_stream = gzip.open(fname, mode='rb') actual = loadmat(mat_stream, struct_as_record=True) mat_stream.close() finally: shutil.rmtree(tmpdir) assert_array_almost_equal(actual['x'].todense(), expected['x'].todense(), err_msg=repr(actual))
def test_scalar_squeeze(): stream = BytesIO() in_d = {'scalar': [[0.1]], 'string': 'my name', 'st': {'one': 1, 'two': 2}} savemat(stream, in_d) out_d = loadmat(stream, squeeze_me=True) assert_(isinstance(out_d['scalar'], float)) assert_(isinstance(out_d['string'], string_types)) assert_(isinstance(out_d['st'], np.ndarray))
def _load_check_case(name, files, case): for file_name in files: matdict = loadmat(file_name, struct_as_record=True) label = "test %s; file %s" % (name, file_name) for k, expected in case.items(): k_label = "%s, variable %s" % (label, k) assert_(k in matdict, "Missing key at %s" % k_label) _check_level(k_label, expected, matdict[k])
def test_multiple_fieldnames(): # Example provided by Dharhas Pothina # Extracted using mio5.varmats_from_mat multi_fname = pjoin(TEST_DATA_PATH, 'nasty_duplicate_fieldnames.mat') vars = loadmat(multi_fname) funny_names = set(vars['Summary'].dtype.names) assert_true( set(['_1_Station_Q', '_2_Station_Q', '_3_Station_Q']) < funny_names)
def test_save_object(): class C(object): pass c = C() c.field1 = 1 c.field2 = 'a string' stream = BytesIO() savemat(stream, {'c': c}) d = loadmat(stream, struct_as_record=False) c2 = d['c'][0, 0] assert_equal(c2.field1, 1) assert_equal(c2.field2, 'a string') d = loadmat(stream, struct_as_record=True) c2 = d['c'][0, 0] assert_equal(c2['field1'], 1) assert_equal(c2['field2'], 'a string')
def test_sparse_in_struct(): # reproduces bug found by DC where Cython code was insisting on # ndarray return type, but getting sparse matrix st = {'sparsefield': SP.coo_matrix(np.eye(4))} stream = BytesIO() savemat(stream, {'a': st}) d = loadmat(stream, struct_as_record=True) yield assert_array_equal, d['a'][0, 0]['sparsefield'].todense(), np.eye(4)
def test_empty_struct(): # ticket 885 filename = pjoin(test_data_path, 'test_empty_struct.mat') # before ticket fix, this would crash with ValueError, empty data # type d = loadmat(filename, struct_as_record=True) a = d['a'] assert_equal(a.shape, (1, 1)) assert_equal(a.dtype, np.dtype(np.object)) assert_(a[0, 0] is None) stream = BytesIO() arr = np.array((), dtype='U') # before ticket fix, this used to give data type not understood savemat(stream, {'arr': arr}) d = loadmat(stream) a2 = d['arr'] assert_array_equal(a2, arr)
def test_1d_shape(): # New 5 behavior is 1D -> row vector arr = np.arange(5) for format in ('4', '5'): # Column is the default stream = BytesIO() savemat(stream, {'oned': arr}, format=format) vals = loadmat(stream) assert_equal(vals['oned'].shape, (1, 5)) # can be explicitly 'column' for oned_as stream = BytesIO() savemat(stream, {'oned': arr}, format=format, oned_as='column') vals = loadmat(stream) assert_equal(vals['oned'].shape, (5, 1)) # but different from 'row' stream = BytesIO() savemat(stream, {'oned': arr}, format=format, oned_as='row') vals = loadmat(stream) assert_equal(vals['oned'].shape, (1, 5))
def test_round_types(): # Check that saving, loading preserves dtype in most cases arr = np.arange(10) stream = BytesIO() for dts in ('f8', 'f4', 'i8', 'i4', 'i2', 'i1', 'u8', 'u4', 'u2', 'u1', 'c16', 'c8'): stream.truncate(0) stream.seek(0) # needed for BytesIO in python 3 savemat(stream, {'arr': arr.astype(dts)}) vars = loadmat(stream) assert_equal(np.dtype(dts), vars['arr'].dtype)
def test_recarray(): # check roundtrip of structured array dt = [('f1', 'f8'), ('f2', 'S10')] arr = np.zeros((2, ), dtype=dt) arr[0]['f1'] = 0.5 arr[0]['f2'] = 'python' arr[1]['f1'] = 99 arr[1]['f2'] = 'not perl' stream = BytesIO() savemat(stream, {'arr': arr}) d = loadmat(stream, struct_as_record=False) a20 = d['arr'][0, 0] yield assert_equal, a20.f1, 0.5 yield assert_equal, a20.f2, 'python' d = loadmat(stream, struct_as_record=True) a20 = d['arr'][0, 0] yield assert_equal, a20['f1'], 0.5 yield assert_equal, a20['f2'], 'python' # structs always come back as object types yield assert_equal, a20.dtype, np.dtype([('f1', 'O'), ('f2', 'O')]) a21 = d['arr'].flat[1] yield assert_equal, a21['f1'], 99 yield assert_equal, a21['f2'], 'not perl'
def test_empty_sparse(): # Can we read empty sparse matrices? sio = BytesIO() import scipy.sparse empty_sparse = scipy.sparse.csr_matrix([[0, 0], [0, 0]]) savemat(sio, dict(x=empty_sparse)) sio.seek(0) res = loadmat(sio) assert_array_equal(res['x'].shape, empty_sparse.shape) assert_array_equal(res['x'].todense(), 0) # Do empty sparse matrices get written with max nnz 1? # See https://github.com/scipy/scipy/issues/4208 sio.seek(0) reader = MatFile5Reader(sio) assert_equal(next(reader._read_iter(info_only=True)).nzmax, 1)
def test_varmats_from_mat(): # Make a mat file with several variables, write it, read it back names_vars = (('arr', mlarr(np.arange(10))), ('mystr', mlarr('a string')), ('mynum', mlarr(10))) # Dict like thing to give variables in defined order class C(object): def items(self): return names_vars stream = BytesIO() savemat(stream, C()) varmats = varmats_from_mat(stream) assert_equal(len(varmats), 3) for i in range(3): name, var_stream = varmats[i] exp_name, exp_res = names_vars[i] assert_equal(name, exp_name) res = loadmat(var_stream) assert_array_equal(res[name], exp_res)
def test_loadmat_varnames(): # Test that we can get just one variable from a mat file using loadmat mat5_sys_names = ['__globals__', '__header__', '__version__'] for eg_file, sys_v_names in ((pjoin(test_data_path, 'testmulti_4.2c_SOL2.mat'), []), (pjoin(test_data_path, 'testmulti_7.4_GLNX86.mat'), mat5_sys_names)): vars = loadmat(eg_file) assert_equal(set(vars.keys()), set(['a', 'theta'] + sys_v_names)) vars = loadmat(eg_file, variable_names='a') assert_equal(set(vars.keys()), set(['a'] + sys_v_names)) vars = loadmat(eg_file, variable_names=['a']) assert_equal(set(vars.keys()), set(['a'] + sys_v_names)) vars = loadmat(eg_file, variable_names=['theta']) assert_equal(set(vars.keys()), set(['theta'] + sys_v_names)) vars = loadmat(eg_file, variable_names=('theta', )) assert_equal(set(vars.keys()), set(['theta'] + sys_v_names)) vnames = ['theta'] vars = loadmat(eg_file, variable_names=vnames) assert_equal(vnames, ['theta'])
def _load_var(ver, name): return loadmat( pjoin(dirname(__file__), "data", "testclass_{}_{}.mat".format(name, ver)))[name]
def test_load_mat4_le(): # We were getting byte order wrong when reading little-endian floa64 dense # matrices on big-endian platforms mat4_fname = pjoin(test_data_path, 'test_mat4_le_floats.mat') vars = loadmat(mat4_fname) assert_array_equal(vars['a'], [[0.1, 1.2]])
def test_jottings(): # example fname = pjoin(test_data_path, 'parabola.mat') loadmat(fname)