def test_ndcomplex_complex(ndarraycplx): nd = ndarraycplx.copy() ndr = nd.real assert_array_equal(ndr.data, nd.data.real) assert ndr.size == nd.size assert not ndr.is_complex
def test_nmr_manual_1D_phasing(NMR_dataset_1D): dataset1D = NMR_dataset_1D.copy() dataset1D /= dataset1D.real.data.max() # normalize dataset1D.em(10. * ur.Hz) # inplace broadening transf = dataset1D.fft(tdeff=8192, size=2**15) # fft transf.plot() # plot) # manual phasing transfph = transf.pk(verbose=True) # by default pivot = 'auto' transfph.plot(xlim=(20, -20), clear=False, color='r') assert_array_equal(transfph.data, transf.data) # because phc0 already applied transfph3 = transf.pk(pivot=50, verbose=True) transfph3.plot(clear=False, color='r') not assert_array_equal(transfph3.data, transfph.data) # because phc0 already applied # transfph4 = transf.pk(pivot=100, phc0=40., verbose=True) transfph4.plot(xlim=(20, -20), clear=False, color='g') assert transfph4 != transfph transfph4 = transf.pk(pivot=100, verbose=True, inplace=True) (transfph4 - 10).plot(xlim=(20, -20), clear=False, color='r') show()
def test_nddataset_real_imag(): na = np.array( [[1.0 + 2.0j, 2.0 + 0j], [1.3 + 2.0j, 2.0 + 0.5j], [1.0 + 4.2j, 2.0 + 3j]] ) nd = scp.NDDataset(na) # in the last dimension assert_array_equal(nd.real, na.real) assert_array_equal(nd.imag, na.imag)
def test_nddataset_binary_operation_with_other_1D(): coord1 = Coord(np.linspace(0.0, 10.0, 10)) coord2 = Coord(np.linspace(1.0, 5.5, 5)) d1 = NDDataset(np.random.random((10, 5)), coordset=[coord1, coord2]) d2 = d1[0] # this should work independently of the value of the coordinates on dimension y d3 = d1 - d2 assert_array_equal(d3.data, d1.data - d2.data)
def test_ndarray_sort(): # labels and sort d0 = NDArray( np.linspace(4000, 1000, 10), labels="a b c d e f g h i j".split(), units="s", mask=False, title="wavelength", ) assert d0.is_labeled d1 = d0._sort() assert d1.data[0] == 1000 # check inplace d2 = d0._sort(inplace=True) assert d0.data[0] == 1000 assert d2 is d0 # check descend d0._sort(descend=True, inplace=True) assert d0.data[0] == 4000 # check sort using label d3 = d0._sort(by="label", descend=True) assert d3.labels[0] == "j" # multilabels # add a row of labels to d0 d0.labels = "bc cd de ef ab fg gh hi ja ij ".split() d1 = d0._sort() assert d1.data[0] == 1000 assert_array_equal(d1.labels[0], ["j", "ij"]) d1._sort(descend=True, inplace=True) assert d1.data[0] == 4000 assert_array_equal(d1.labels[0], ["a", "bc"]) d1 = d1._sort(by="label[1]", descend=True) assert np.all(d1.labels[0] == ["i", "ja"]) # other way d2 = d1._sort(by="label", pos=1, descend=True) assert np.all(d2.labels[0] == d1.labels[0]) d3 = d1.copy() d3._labels = None d3._sort(by="label", pos=1, descend=True) # no label! generate a warning but no error
def test_ndarray_slice_labels(): # slicing only-label array d0 = NDArray(labels='a b c d e f g h i j'.split(), title='labelled') assert d0.is_labeled assert d0.ndim == 1 assert d0.shape == (10, ) assert d0[1].labels == ['b'] assert d0[1].values == 'b' assert d0['b'].values == 'b' assert d0['c':'d'].shape == (2, ) assert_array_equal(d0['c':'d'].values, np.array(['c', 'd']))
def test_bugs_units_change(): # check for bug on transmittance conversion X = scp.NDDataset([0.0, 0.3, 1.3, 5.0], units="absorbance") # A to T X1 = X.to("transmittance") assert_array_equal(X1.data, 10 ** -np.array([0.0, 0.3, 1.3, 5.0]) * 100) assert X1.title == "transmittance" # T to abs T X2 = X1.to("absolute_transmittance") assert_array_equal(X2.data, 10 ** -np.array([0.0, 0.3, 1.3, 5.0])) assert X2.title == "transmittance" # A to abs T X2b = X.to("absolute_transmittance") assert_array_equal(X2b, X2) assert X2b.title == "transmittance" # abs T to T X3 = X2.to("transmittance") assert_array_equal(X3, X1) assert X3.title == "transmittance" # T to A X4 = X3.to("absorbance") assert_array_almost_equal(X4, X) assert X4.title == "absorbance" # abs T to A X5 = X2.to("absorbance") assert_array_almost_equal(X5, X) assert X5.title == "absorbance"
def test_nddataset_issue_29_mulitlabels(): DS = scp.NDDataset(np.random.rand(3, 4)) with pytest.raises(ValueError): # shape data and label mismatch DS.set_coordset(DS.y, scp.Coord(title='xaxis', units='s', data=[1, 2, 3, 4], labels=['a', 'b', 'c'])) c = scp.Coord(title='xaxis', units='s', data=[1, 2, 3, 4], labels=['a', 'b', 'c', 'd']) DS.set_coordset(x=c) c = scp.Coord(title='xaxis', units='s', data=[1, 2, 3, 4], labels=[['a', 'c', 'b', 'd'], ['e', 'f', 'g', 'h']]) d = DS.y DS.set_coordset(d, c) DS.x.labels = ['alpha', 'beta', 'omega', 'gamma'] assert DS.x.labels.shape == (4, 3) # sort DS1 = DS.sort(axis=1, by='value', descend=True) assert_array_equal(DS1.x, [4, 3, 2, 1]) # sort assert DS.dims == ['y', 'x'] DS1 = DS.sort(dim='x', by='label', descend=False) assert_array_equal(DS1.x, [1, 3, 2, 4]) DS1 = DS.sort(dim='x', by='label', pos=2, descend=False) assert_array_equal(DS1.x, [1, 2, 4, 3]) DS.sort(dim='y') DS.y.labels = ['alpha', 'omega', 'gamma'] DS2 = DS.sort(dim='y') assert_array_equal(DS2.y.labels, ['alpha', 'gamma', 'omega'])
def test_nddataset_fancy_indexing(): # numpy vs dataset rand = np.random.RandomState(42) x = rand.randint(100, size=10) # single value indexing dx = NDDataset(x) assert (dx[3].data, dx[7].data, dx[2].data) == (x[3], x[7], x[2]) # slice indexing assert_array_equal(dx[3:7].data, x[3:7]) # boolean indexingassert assert_array_equal(dx[x > 52].data, x[x > 52]) # fancy indexing ind = [3, 7, 4] assert_array_equal(dx[ind].data, x[ind]) ind = np.array([[3, 7], [4, 5]]) assert_array_equal(dx[ind].data, x[ind]) with RandomSeedContext(1234): a = np.random.random((3, 5)).round(1) c = (np.arange(3), np.arange(5)) nd = NDDataset(a, coordset=c) a = nd[[1, 0, 2]] a = nd[np.array([1, 0])]
def test_ndcomplex_swapdims_quaternion(): np.random.seed(12345) d = np.random.random((4, 3)) * np.exp(.1j) d3 = NDComplexArray(d, units=ur.Hz, mask=[[False, True, False], [True, False, False]], dtype=typequaternion) # quaternion with units & mask assert d3.shape == (2, 3) assert d3._data.shape == (2, 3) assert d3.has_complex_dims assert d3.is_quaternion w, x, y, z = as_float_array(d3.data).T d4 = d3.swapdims(0, 1) assert d4.shape == (3, 2) assert d4._data.shape == (3, 2) assert d4.has_complex_dims assert d4.is_quaternion wt, yt, xt, zt = as_float_array(d4.data).T assert_array_equal(xt, x.T) assert_array_equal(yt, y.T) assert_array_equal(zt, z.T) assert_array_equal(wt, w.T)
def test_nddataset_add_with_masks(): # numpy masked arrays mask the result of binary operations if the # mask of either operand is set. # Does NDData? ndd1 = NDDataset(np.array([1, 2])) ndd2 = NDDataset(np.array([2, 1])) result = ndd1 + ndd2 assert_array_equal(result.data, np.array([3, 3])) ndd1 = NDDataset(np.array([1, 2]), mask=np.array([True, False])) other_mask = ~ndd1.mask ndd2 = NDDataset(np.array([2, 1]), mask=other_mask) result = ndd1 + ndd2 # The result should have all entries masked... assert result.mask.all()
def test_nddataset_quaternion(): na0 = np.array([[1., 2., 2., 0., 0., 0.], [1.3, 2., 2., 0.5, 1., 1.], [1, 4.2, 2., 3., 2., 2.], [5., 4.2, 2., 3., 3., 3.]]) nd = scp.NDDataset(na0) assert nd.shape == (4, 6) nd.dims = ['v', 'u'] nd.set_coordset(v=np.linspace(-1, 1, 4), u=np.linspace(-10., 10., 6)) nd.set_quaternion() # test swapdims nds = nd.swapdims(0, 1) assert_array_equal(nd.data.T, nds.data) assert nd.coordset[0] == nds.coordset[0] # we do not swap the coords # test transpose nds = nd.T assert_array_equal(nd.data.T, nds.data) assert nd.coordset[0] == nds.coordset[0]
def test_ndarray_sort(): # labels and sort d0 = NDArray(np.linspace(4000, 1000, 10), labels='a b c d e f g h i j'.split(), units='s', mask=False, title='wavelength') assert d0.is_labeled d1 = d0._sort() assert (d1.data[0] == 1000) # check inplace d2 = d0._sort(inplace=True) assert (d0.data[0] == 1000) assert d2 is d0 # check descend d0._sort(descend=True, inplace=True) assert (d0.data[0] == 4000) # check sort using label d3 = d0._sort(by='label', descend=True) assert (d3.labels[0] == 'j') # multilabels # add a row of labels to d0 d0.labels = 'bc cd de ef ab fg gh hi ja ij '.split() d1 = d0._sort() assert (d1.data[0] == 1000) assert_array_equal(d1.labels[0], ['j', 'ij']) d1._sort(descend=True, inplace=True) assert (d1.data[0] == 4000) assert_array_equal(d1.labels[0], ['a', 'bc']) d1 = d1._sort(by='label[1]', descend=True) assert np.all(d1.labels[0] == ['i', 'ja']) # other way d2 = d1._sort(by='label', pos=1, descend=True) assert np.all(d2.labels[0] == d1.labels[0])
def test_ndio_generic(NMR_dataset_1D): nmr = NMR_dataset_1D assert nmr.directory == nmrdatadir # save with the default filename or open a dialog if it doesn't exists # ------------------------------------------------------------------------ # save with the default name (equivalent to save_as in this case) # as this file (IR_1D.scp) doesn't yet exist a confirmation dialog is opened f = nmr.save() assert nmr.filename == f.name assert nmr.directory == nmrdatadir # load back this file : the full path f is given so no dialog is opened nd = NDDataset.load(f) assert_dataset_equal(nd, nmr) # as it has been already saved, we should not get dialogs f = nd.save() assert nd.filename == "NMR_1D.scp" # return # now it opens a dialog and the name can be changed f1 = nmr.save_as() assert nmr.filename == f1.name # remove these files f.unlink() f1.unlink() # save in a specified directory nmr.save_as(irdatadir / "essai") # save essai.scp assert nmr.directory == irdatadir assert nmr.filename == "essai.scp" (irdatadir / nmr.filename).unlink() # save in the current directory f = nmr.save_as(cwd / "essai") # try to load without extension specification (will first assume it is scp) dl = NDDataset.load("essai") # assert dl.directory == cwd assert_array_equal(dl.data, nmr.data) f.unlink()
def test_nddataset_masked_array_input(): a = np.random.randn(100) marr = np.ma.masked_where(a > 0, a) nd = scp.NDDataset(marr) # check that masks and data match assert_array_equal(nd.mask, marr.mask) assert_array_equal(nd.data, marr.data) # check that they are both by reference marr.mask[10] = ~marr.mask[10] marr.data[11] = 123456789 assert_array_equal(nd.mask, marr.mask) assert_array_equal(nd.data, marr.data)
def test_coord_slicing(): # slicing by index coord0 = Coord(data=np.linspace(4000, 1000, 10), mask=None, title="wavelength") assert coord0[0] == 4000.0 coord1 = Coord(data=np.linspace(4000, 1000, 10), units="cm^-1", mask=None, title="wavelength") c1 = coord1[0] assert isinstance(c1.values, Quantity) assert coord1[0].values == 4000.0 * (1.0 / ur.cm) # slicing with labels labs = list("abcdefghij") coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=labs, units="cm^-1", mask=None, title="wavelength", ) assert coord0[0].values == 4000.0 * (1.0 / ur.cm) assert isinstance(coord0[0].values, Quantity) assert coord0[2] == coord0["c"] assert coord0["c":"d"] == coord0[2:4] # label included # slicing only-labels coordinates y = list("abcdefghij") a = Coord(labels=y, name="x") assert a.name == "x" assert isinstance(a.labels, np.ndarray) assert_array_equal(a.values, a.labels)
def test_issue417(): X = scp.read_omnic("irdata/nh4y-activation.spg") x = X - X[-1] print("--subtract with ds from read_omnic") print(f"mean x: {np.mean(x.data)}") print(f"var x: {np.var(x.data)}") print("") f = X.write("X.scp") X_r = scp.read("X.scp") f.unlink() assert_array_equal(X.data, X_r.data) assert_dataset_equal(X, X_r) assert_equal_units(X.units, X_r.units) assert_dataset_equal(X[-1], X_r[-1]) x_r = X_r - X_r[-1] print("--subtract after write/read_scp") print(f"mean x_r: {np.mean(x_r.data)}") print(f"var x_r: {np.var(x_r.data)}") print("") x_r2 = X_r - X_r[-1].data print("--subtract with data field") print(f"mean x_r2: {np.mean(x_r2.data)}") print(f"var x_r2: {np.var(x_r2.data)}") assert_array_equal(x.data, x_r2.data) assert_array_equal(x.data, x_r.data) assert_dataset_equal(x, x_r)
def test_coord_slicing(): # slicing by index coord0 = Coord(data=np.linspace(4000, 1000, 10), mask=None, title='wavelength') assert coord0[0] == 4000.0 coord1 = Coord(data=np.linspace(4000, 1000, 10), units='cm^-1', mask=None, title='wavelength') c1 = coord1[0] assert isinstance(c1.values, Quantity) assert coord1[0].values == 4000.0 * (1. / ur.cm) # slicing with labels labs = list('abcdefghij') coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=labs, units='cm^-1', mask=None, title='wavelength') assert coord0[0].values == 4000.0 * (1. / ur.cm) assert isinstance(coord0[0].values, Quantity) assert coord0[2] == coord0['c'] assert coord0['c':'d'] == coord0[2:4] # label included # slicing only-labels coordinates y = list('abcdefghij') a = Coord(labels=y, name='x') assert a.name == 'x' assert isinstance(a.labels, np.ndarray) assert_array_equal(a.values, a.labels)
def test_nddataset_real_imag_quaternion(): na = np.array( [[1.0 + 2.0j, 2.0 + 0j, 1.3 + 2.0j], [2.0 + 0.5j, 1.0 + 4.2j, 2.0 + 3j]] ) nd = scp.NDDataset(na) # in the last dimension assert_array_equal(nd.real, na.real) assert_array_equal(nd.imag, na.imag) # in another dimension nd.set_quaternion(inplace=True) assert nd.is_quaternion assert nd.shape == (1, 3) na = np.array( [ [1.0 + 2.0j, 2.0 + 0j], [1.3 + 2.0j, 2.0 + 0.5j], [1.0 + 4.2j, 2.0 + 3j], [5.0 + 4.2j, 2.0 + 3j], ] ) nd = scp.NDDataset(na) nd.set_quaternion(inplace=True) assert nd.is_quaternion assert_array_equal(nd.real.data, na[::2, :].real) nb = np.array( [ [0.0 + 2.0j, 0.0 + 0j], [1.3 + 2.0j, 2.0 + 0.5j], [0.0 + 4.2j, 0.0 + 3j], [5.0 + 4.2j, 2.0 + 3j], ] ) ndj = scp.NDDataset(nb, dtype=quaternion) assert nd.imag == ndj
def test_ndarray_copy(): d0 = NDArray( np.linspace(4000, 1000, 10), labels="a b c d e f g h i j".split(), units="s", mask=False, title="wavelength", ) d0[5] = MASKED d1 = d0.copy() assert d1 is not d0 assert d1 == d0 assert not (d1 != d0) assert d1.units == d0.units assert_array_equal(d1.labels, d0.labels) assert_array_equal(d1.mask, d0.mask) d0 = NDArray( np.linspace(4000, 1000, 10), labels=[ "a b c d e f g h i j".split(), "bc cd de ef ab fg gh hi ja ij".split(), ], units="s", mask=False, title="wavelength", ) d0[5] = MASKED d1 = d0.copy() assert d1 is not d0 assert d1 == d0 assert d1.units == d0.units assert_array_equal(d1.labels, d0.labels) assert_array_equal(d1.mask, d0.mask) d2 = copy(d0) assert d2 == d0 d3 = deepcopy(d0) assert d3 == d0
def test_ndarray_copy(): d0 = NDArray(np.linspace(4000, 1000, 10), labels='a b c d e f g h i j'.split(), units='s', mask=False, title='wavelength') d0[5] = MASKED d1 = d0.copy() assert d1 is not d0 assert d1 == d0 assert d1.units == d0.units assert_array_equal(d1.labels, d0.labels) assert_array_equal(d1.mask, d0.mask) d0 = NDArray(np.linspace(4000, 1000, 10), labels=[ 'a b c d e f g h i j'.split(), 'bc cd de ef ab fg gh hi ja ij'.split() ], units='s', mask=False, title='wavelength') d0[5] = MASKED d1 = d0.copy() assert d1 is not d0 assert d1 == d0 assert d1.units == d0.units assert_array_equal(d1.labels, d0.labels) assert_array_equal(d1.mask, d0.mask) d2 = copy(d0) assert d2 == d0 d3 = deepcopy(d0) assert d3 == d0
def test_nddataset_issue_29_mulitlabels(): DS = scp.NDDataset(np.random.rand(3, 4)) with pytest.raises(ValueError): # shape data and label mismatch DS.set_coordset( DS.y, scp.Coord( title="xaxis", units="s", data=[1, 2, 3, 4], labels=["a", "b", "c"] ), ) c = scp.Coord( title="xaxis", units="s", data=[1, 2, 3, 4], labels=["a", "b", "c", "d"] ) DS.set_coordset(x=c) c = scp.Coord( title="xaxis", units="s", data=[1, 2, 3, 4], labels=[["a", "c", "b", "d"], ["e", "f", "g", "h"]], ) d = DS.y DS.set_coordset(d, c) DS.x.labels = ["alpha", "beta", "omega", "gamma"] assert DS.x.labels.shape == (4, 3) # sort DS1 = DS.sort(axis=1, by="value", descend=True) assert_array_equal(DS1.x, [4, 3, 2, 1]) # sort assert DS.dims == ["y", "x"] DS1 = DS.sort(dim="x", by="label", descend=False) assert_array_equal(DS1.x, [1, 3, 2, 4]) DS1 = DS.sort(dim="x", by="label", pos=2, descend=False) assert_array_equal(DS1.x, [1, 2, 4, 3]) DS.sort(dim="y") DS.y.labels = ["alpha", "omega", "gamma"] DS2 = DS.sort(dim="y") assert_array_equal(DS2.y.labels, ["alpha", "gamma", "omega"])
def test_ndcomplex_init_quaternion_witharray(): d = np.arange(24).reshape(3, 2, 4) d = as_quat_array(d) d0 = NDComplexArray(d) assert d0.shape == (3, 2) assert_array_equal(d0.real.data, [[0, 4], [8, 12], [16, 20]]) d1 = NDComplexArray(d) d1 = d1.set_quaternion() assert_array_equal(d1.real.data, [[0, 4], [8, 12], [16, 20]]) d1 = d0.swapdims(1, 0) assert d1.shape == (2, 3) assert_array_equal(d1.real.data, [[0, 8, 16], [4, 12, 20]]) assert d1[0, 0].values == quaternion(0, 2, 1, 3)
def test_coord(): # simple coords a = Coord([1, 2, 3], name="x") assert a.id is not None assert not a.is_empty assert not a.is_masked assert_array_equal(a.data, np.array([1, 2, 3])) assert not a.is_labeled assert a.units is None assert a.unitless debug_(a.meta) assert not a.meta assert a.name == "x" # set properties a.title = "xxxx" assert a.title == "xxxx" a.name = "y" assert a.name == "y" a.meta = None a.meta = {"val": 125} # need to be an OrderedDic assert a.meta["val"] == 125 # now with labels x = np.arange(10) y = list("abcdefghij") a = Coord(x, labels=y, title="processors", name="x") assert a.title == "processors" assert isinstance(a.data, np.ndarray) assert isinstance(a.labels, np.ndarray) # any kind of object can be a label assert a.labels.dtype == "O" # even an array a._labels[3] = x assert a._labels[3][2] == 2 # coords can be defined only with labels y = list("abcdefghij") a = Coord(labels=y, title="processors") assert a.title == "processors" assert isinstance(a.labels, np.ndarray) assert_array_equal(a.values, a.labels) # any kind of object can be a label assert a.labels.dtype == "O" # even an array a._labels[3] = range(10) assert a._labels[3][2] == 2 # coords with datetime from datetime import datetime x = np.arange(10) y = [datetime(2017, 6, 2 * (i + 1)) for i in x] a = Coord(x, labels=y, title="time") assert a.title == "time" assert isinstance(a.data, np.ndarray) assert isinstance(a.labels, np.ndarray) a._sort(by="label", descend=True) # but coordinates must be 1D with pytest.raises(ValueError): # should raise an error as coords must be 1D Coord(data=np.ones((2, 10))) # unitless coordinates coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), mask=None, units=None, title="wavelength", ) assert coord0.units is None assert coord0.data[0] == 4000.0 assert repr(coord0) == "Coord: [float64] unitless (size: 10)" # dimensionless coordinates coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), mask=None, units=ur.dimensionless, title="wavelength", ) assert coord0.units.dimensionless assert coord0.units.scaling == 1.0 assert coord0.data[0] == 4000.0 assert repr(coord0) == "Coord: [float64] dimensionless (size: 10)" # scaled dimensionless coordinates coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), mask=None, units="m/km", title="wavelength", ) assert coord0.units.dimensionless assert (coord0.data[0] == 4000.0 ) # <- displayed data to be multiplied by the scale factor assert repr( coord0) == "Coord: [float64] scaled-dimensionless (0.001) (size: 10)" coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), mask=None, units=ur.m / ur.km, title="wavelength", ) assert coord0.units.dimensionless assert (coord0.data[0] == 4000.0 ) # <- displayed data to be multiplied by the scale factor assert repr( coord0) == "Coord: [float64] scaled-dimensionless (0.001) (size: 10)" coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), mask=None, units="m^2/s", title="wavelength", ) assert not coord0.units.dimensionless assert coord0.units.scaling == 1.0 assert coord0.data[0] == 4000.0 assert repr(coord0) == "Coord: [float64] m².s⁻¹ (size: 10)" # comparison coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), mask=None, title="wavelength", ) coord0b = Coord( data=np.linspace(4000, 1000, 10), labels="a b c d e f g h i j".split(), mask=None, title="wavelength", ) coord1 = Coord( data=np.linspace(4000, 1000, 10), labels="a b c d e f g h i j".split(), mask=None, title="titi", ) coord2 = Coord( data=np.linspace(4000, 1000, 10), labels="b c d e f g h i j a".split(), mask=None, title="wavelength", ) coord3 = Coord(data=np.linspace(4000, 1000, 10), labels=None, mask=None, title="wavelength") assert coord0 == coord0b assert coord0 != coord1 # different title assert coord0 != coord2 # different labels assert coord0 != coord3 # one coord has no label # init from another coord coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), units="s", mask=None, title="wavelength", ) coord1 = Coord(coord0) assert coord1._data is coord0._data coord1 = Coord(coord0, copy=True) assert coord1._data is not coord0._data assert_array_equal(coord1._data, coord0._data) assert isinstance(coord0, Coord) assert isinstance(coord1, Coord) # sort coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), units="s", mask=None, title="wavelength", ) assert coord0.is_labeled ax = coord0._sort() assert ax.data[0] == 1000 coord0._sort(descend=True, inplace=True) assert coord0.data[0] == 4000 ax1 = coord0._sort(by="label", descend=True) assert ax1.labels[0] == "j" # copy coord0 = Coord( data=np.linspace(4000, 1000, 10), labels=list("abcdefghij"), units="s", mask=None, title="wavelength", ) coord1 = coord0.copy() assert coord1 is not coord0 assert_array_equal(coord1.data, coord0.data) assert_array_equal(coord1.labels, coord0.labels) assert coord1.units == coord0.units coord2 = copy(coord0) assert coord2 is not coord0 assert_array_equal(coord2.data, coord0.data) assert_array_equal(coord2.labels, coord0.labels) assert coord2.units == coord0.units # automatic reversing for wavenumbers coord0 = Coord(data=np.linspace(4000, 1000, 10), units="cm^-1", mask=None, title="wavenumbers") assert coord0.reversed assert not coord0.is_complex assert not coord0.is_empty assert coord0.T == coord0 assert_array_equal(coord0.masked_data, coord0.data)
def test_ndmath_and_api_methods(IR_dataset_1D, IR_dataset_2D): # CREATION _LIKE METHODS # ---------------------- # from a list x = [1, 2, 3] # _like as an API method ds = NDDataset(x).full_like(2.5, title="empty") ds = scp.full_like(x, 2) assert np.all(ds.data == np.full((3, ), 2)) assert ds.implements("NDDataset") # _like as a classmethod ds = NDDataset.full_like(x, 2) assert np.all(ds.data == np.full((3, ), 2)) assert ds.implements("NDDataset") # _like as an instance method ds = NDDataset(x).full_like(2) assert np.all(ds.data == np.full((3, ), 2)) assert ds.implements("NDDataset") # _like as an instance method ds = NDDataset(x).empty_like(title="empty") assert ds.implements("NDDataset") assert ds.title == "empty" # from an array x = np.array([1, 2, 3]) ds = NDDataset(x).full_like(2) assert np.all(ds.data == np.full((3, ), 2)) assert ds.implements("NDDataset") # from a NDArray subclass with units x = NDDataset([1, 2, 3], units="km") ds = scp.full_like(x, 2) assert np.all(ds.data == np.full((3, ), 2)) assert ds.implements("NDDataset") assert ds.units == ur.km ds1 = scp.full_like(ds, np.nan, dtype=np.double, units="m") assert ds1.units == Unit("m") # change of units is forced ds2 = scp.full_like(ds, 2, dtype=np.double, units="s") assert ds2.units == ur.s # other like creation functions nd = scp.empty_like(ds, dtype=np.double, units="m") assert str(nd) == "NDDataset: [float64] m (size: 3)" assert nd.dtype == np.dtype(np.double) nd = scp.zeros_like(ds, dtype=np.double, units="m") assert str(nd) == "NDDataset: [float64] m (size: 3)" assert np.all(nd.data == np.zeros((3, ))) nd = scp.ones_like(ds, dtype=np.double, units="m") assert str(nd) == "NDDataset: [float64] m (size: 3)" assert np.all(nd.data == np.ones((3, ))) # FULL # ---- ds = NDDataset.full((6, ), 0.1) assert ds.size == 6 assert str(ds) == "NDDataset: [float64] unitless (size: 6)" # ZEROS # ----- ds = NDDataset.zeros((6, ), units="km") assert ds.size == 6 assert str(ds) == "NDDataset: [float64] km (size: 6)" # ONES # ---- ds = NDDataset.ones((6, )) ds = scp.full((6, ), 0.1) assert ds.size == 6 assert str(ds) == "NDDataset: [float64] unitless (size: 6)" ds = NDDataset.ones((6, ), units="absorbance", dtype="complex128") assert ds.size == 3 assert str(ds) == "NDDataset: [complex128] a.u. (size: 3)" assert ds[0].data == 1.0 + 1.0j # LINSPACE # -------- c2 = Coord.linspace(1, 20, 200, units="m", name="mycoord") assert c2.name == "mycoord" assert c2.size == 200 assert c2[-1].data == 20 assert c2[0].values == Quantity(1, "m") # ARANGE # ------- c3 = Coord.arange(1, 20.0001, 1, units="s", name="mycoord") assert c3.name == "mycoord" assert c3.size == 20 assert c3[-1].data == 20 assert c3[0].values == Quantity(1, "s") # EYE # ---- ds1 = scp.NDDataset.eye(2, dtype=int) assert str(ds1) == "NDDataset: [float64] unitless (shape: (y:2, x:2))" ds = scp.eye(3, k=1, units="km") assert (ds.data == np.eye(3, k=1)).all() assert ds.units == ur.km # IDENTITY # -------- ds = scp.identity(3, units="km") assert (ds.data == np.identity(3, )).all() assert ds.units == ur.km # RANDOM # ------ ds = scp.random((3, 3), units="km") assert str(ds) == "NDDataset: [float64] km (shape: (y:3, x:3))" # adding coordset c1 = Coord.linspace(1, 20, 200, units="m", name="axe_x") ds = scp.random((200, ), units="km", coordset=scp.CoordSet(x=c1)) # DIAGONAL # -------- # extract diagonal nd = scp.full((2, 2), 0.5, units="s", title="initial") assert str(nd) == "NDDataset: [float64] s (shape: (y:2, x:2))" ndd = scp.diagonal(nd, title="diag") assert str(ndd) == "NDDataset: [float64] s (size: 2)" assert ndd.units == Unit("s") cx = scp.Coord([0, 1]) cy = scp.Coord([2, 5]) nd = NDDataset.full((2, 2), 0.5, units="s", coordset=scp.CoordSet(cx, cy), title="initial") assert str(nd) == "NDDataset: [float64] s (shape: (y:2, x:2))" ndd = nd.diagonal(title="diag2") assert str(ndd) == "NDDataset: [float64] s (size: 2)" assert ndd.units == Unit("s") assert ndd.title == "diag2" cx = scp.Coord([0, 1, 2]) cy = scp.Coord([2, 5]) nd = NDDataset.full((2, 3), 0.5, units="s", coordset=scp.CoordSet(x=cx, y=cy), title="initial") assert str(nd) == "NDDataset: [float64] s (shape: (y:2, x:3))" ndd = nd.diagonal(title="diag3") assert str(ndd) == "NDDataset: [float64] s (size: 2)" assert ndd.units == Unit("s") assert ndd.title == "diag3" assert_array_equal(nd.x.data[:ndd.x.size], ndd.x.data) ndd = nd.diagonal(title="diag4", dim="y") assert str(ndd) == "NDDataset: [float64] s (size: 2)" assert ndd.units == Unit("s") assert ndd.title == "diag4" assert_array_equal(nd.y.data[:ndd.y.size], ndd.y.data) # DIAG # ---- ref = NDDataset(np.diag((3, 3.4, 2.3)), units="m", title="something") # Three forms should return the same NDDataset ds = scp.diag((3, 3.4, 2.3), units="m", title="something") assert_dataset_equal(ds, ref) ds = NDDataset.diag((3, 3.4, 2.3), units="m", title="something") assert_dataset_equal(ds, ref) ds = NDDataset((3, 3.4, 2.3)).diag(units="m", title="something") assert_dataset_equal(ds, ref) # and this too ds1 = NDDataset((3, 3.4, 2.3), units="s", title="another") ds = scp.diag(ds1, units="m", title="something") assert_dataset_equal(ds, ref) ds = ds1.diag(units="m", title="something") assert_dataset_equal(ds, ref) # BOOL : ALL and ANY # ------------------ ds = NDDataset([[True, False], [True, True]]) b = np.all(ds) assert not b b = scp.all(ds) assert not b b = ds.all() assert not b b = NDDataset.any(ds) assert b b = ds.all(dim="y") assert_array_equal(b, np.array([True, False])) b = ds.any(dim="y") assert_array_equal(b, np.array([True, True])) # ARGMAX, MAX # ----------- nd1 = IR_dataset_1D.copy() nd1[1290.0:890.0] = MASKED assert nd1.is_masked assert str(nd1) == "NDDataset: [float64] a.u. (size: 5549)" idx = nd1.argmax() assert idx == 3122 mx = nd1.max() # alternative mx = scp.max(nd1) mx = NDDataset.max(nd1) assert mx == Quantity(3.8080601692199707, "absorbance") mxk = nd1.max(keepdims=True) assert isinstance(mxk, NDDataset) assert str(mxk) == "NDDataset: [float64] a.u. (size: 1)" assert mxk.values == mx # test on a 2D NDDataset nd2 = IR_dataset_2D.copy() nd2[:, 1290.0:890.0] = MASKED mx = nd2.max() # no axis specified assert mx == Quantity(3.8080601692199707, "absorbance") mxk = nd2.max(keepdims=True) assert str(mxk) == "NDDataset: [float64] a.u. (shape: (y:1, x:1))" nd2m = nd2.max("y") # axis selected ax = nd2m.plot() nd2[0].plot(ax=ax, clear=False) nd2m2 = nd2.max("x") # axis selected nd2m2.plot() nd2m = nd2.max("y", keepdims=True) assert nd2m.shape == (1, 5549) nd2m = nd2.max("x", keepdims=True) assert nd2m.shape == (55, 1) mx = nd2.min() # no axis specified assert mx == Quantity(-0.022955093532800674, "absorbance") mxk = nd2.min(keepdims=True) assert str(mxk) == "NDDataset: [float64] a.u. (shape: (y:1, x:1))" nd2m = nd2.min("y") # axis selected ax = nd2m.plot() nd2[0].plot(ax=ax, clear=False) nd2m2 = nd2.min("x") # axis selected nd2m2.plot() nd2m = nd2.min("y", keepdims=True) assert nd2m.shape == (1, 5549) nd2m = nd2.min("x", keepdims=True) assert nd2m.shape == (55, 1) # CLIP # ---- nd3 = nd2 - 2.0 assert nd3.units == nd2.units nd3c = nd3.clip(-0.5, 1.0) assert nd3c.max().m == 1.0 assert nd3c.min().m == -0.5 # COORDMIN AND COORDMAX # --------------------- cm = nd2.coordmin() assert np.around(cm["x"], 3) == Quantity(1290.165, "cm^-1") cm = nd2.coordmin(dim="y") assert cm.size == 1 cm = nd2.coordmax(dim="y") assert cm.size == 1 cm = nd2.coordmax(dim="x") assert cm.size == 1 # ABS # ---- nd2a = scp.abs(nd2) mxa = nd2a.min() assert mxa > 0 nd2a = NDDataset.abs(nd2) mxa = nd2a.min() assert mxa > 0 nd2a = np.abs(nd2) mxa = nd2a.min() assert mxa > 0 ndd = NDDataset([1.0, 2.0 + 1j, 3.0]) val = np.abs(ndd) val = ndd[1] * 1.2 - 10.0 val = np.abs(val) # FROMFUNCTION # ------------ # 1D def func1(t, v): d = v * t return d time = Coord.linspace( 0, 9, 10, ) distance = NDDataset.fromfunction(func1, v=134, coordset=CoordSet(t=time)) assert distance.dims == ["t"] assert_array_equal(distance.data, np.fromfunction(func1, (10, ), v=134)) time = Coord.linspace(0, 90, 10, units="min") distance = NDDataset.fromfunction(func1, v=Quantity(134, "km/hour"), coordset=CoordSet(t=time)) assert distance.dims == ["t"] assert_array_equal(distance.data, np.fromfunction(func1, (10, ), v=134) * 10 / 60) # 2D def func2(x, y): d = x + 1 / y return d c0 = Coord.linspace(0, 9, 3) c1 = Coord.linspace(10, 20, 2) # implicit ordering of coords (y,x) distance = NDDataset.fromfunction(func2, coordset=CoordSet(c1, c0)) assert distance.shape == (2, 3) assert distance.dims == ["y", "x"] # or equivalent distance = NDDataset.fromfunction(func2, coordset=[c1, c0]) assert distance.shape == (2, 3) assert distance.dims == ["y", "x"] # explicit ordering of coords (y,x) # distance = NDDataset.fromfunction(func2, coordset=CoordSet(u=c0, v=c1)) assert distance.shape == (2, 3) assert distance.dims == ["v", "u"] assert distance[0, 2].data == distance.u[2].data + 1.0 / distance.v[0].data # with units def func3(x, y): d = x + y return d c0u = Coord.linspace(0, 9, 3, units="km") c1u = Coord.linspace(10, 20, 2, units="m") distance = NDDataset.fromfunction(func3, coordset=CoordSet(u=c0u, v=c1u)) assert distance.shape == (2, 3) assert distance.dims == ["v", "u"] assert distance[0, 2].values == distance.u[2].values + distance.v[0].values c0u = Coord.linspace(0, 9, 3, units="km") c1u = Coord.linspace(10, 20, 2, units="m^-1") distance = NDDataset.fromfunction(func2, coordset=CoordSet(u=c0u, v=c1u)) assert distance.shape == (2, 3) assert distance.dims == ["v", "u"] assert distance[ 0, 2].values == distance.u[2].values + 1.0 / distance.v[0].values # FROMITER # -------- iterable = (x * x for x in range(5)) nit = scp.fromiter(iterable, float, units="km") assert str(nit) == "NDDataset: [float64] km (size: 5)" assert_array_equal(nit.data, np.array([0, 1, 4, 9, 16])) # MEAN, AVERAGE # ----- nd = IR_dataset_2D.copy() m = scp.mean(nd) assert m.shape == () assert m == Quantity(np.mean(nd.data), "absorbance") m = scp.average(nd) assert m.shape == () assert m == Quantity(np.average(nd.data), "absorbance") mx = scp.mean(nd, keepdims=True) assert mx.shape == (1, 1) mxd = scp.mean(nd, dim="y") assert str(mxd) == "NDDataset: [float64] a.u. (size: 5549)" assert str(mxd.x) == "LinearCoord: [float64] cm⁻¹ (size: 5549)" # ---- nd2 = NDDataset([[0, 1, 2], [3, 4, 5]]) # no coord (check issues m = scp.mean(nd2) assert m.shape == () assert m == np.mean(nd2.data) assert m == 2.5 m = scp.mean(nd2, keepdims=True) assert m.shape == (1, 1) assert m.data == [[2.5]] m = scp.mean(nd2, dim="y") assert m.shape == (3, ) assert_array_equal(m.data, [1.5, 2.5, 3.5]) assert str(m) == "NDDataset: [float64] unitless (size: 3)" m = scp.mean(nd2, dim=0, keepdims=True) assert m.shape == (1, 3) assert_array_equal(m.data, [[1.5, 2.5, 3.5]]) assert str(m) == "NDDataset: [float64] unitless (shape: (y:1, x:3))" m = nd2.mean(dim="y") assert m.shape == (3, ) assert_array_equal(m.data, [1.5, 2.5, 3.5]) assert str(m) == "NDDataset: [float64] unitless (size: 3)"
def test_ndarray_init(refarray, refmask, ndarray, ndarraymask): # initialisation with null array d0 = NDArray(description='testing ndarray') assert d0.implements('NDArray') assert d0.implements() == 'NDArray' assert isinstance(d0, NDArray) assert d0.is_empty assert d0.shape == () assert d0.id.startswith('NDArray') assert d0.name == d0.id assert d0.title == '<untitled>' assert d0.ndim == 0 assert d0.size is None assert not d0.is_masked assert d0.dtype is None assert d0.unitless assert not d0.dims assert not d0.meta assert hash(d0) is not None assert (repr(d0) == 'NDArray: empty (size: 0)') # assignement to basic write allowed properties d0.data = [1, 2, 3] # put some data assert_array_equal(d0.data, np.array([1, 2, 3])) assert d0.dtype in TYPE_INTEGER assert d0.date.date() == datetime.now(timezone.utc).date() d0.date = datetime(2005, 10, 12) d0.date = "25/12/2025" assert d0.date == datetime(2025, 12, 25, 0, 0) d0.name = 'xxxx' assert d0.name == 'xxxx' d0.title = 'yyyy' assert d0.title == "yyyy" d0.meta = [] d0.meta.something = "a_value" assert d0.meta.something == "a_value" assert d0[1].value == 2 # only a single element so we get a squeezed array d0.units = 'absorbance' assert d0.units == ur.absorbance assert d0[2] == 3 * ur.absorbance assert d0.dims == ['x'] # initialisation with a scalar quantity d1 = NDArray(25) assert d1.data == np.array(25) assert d1.data.dtype in TYPE_INTEGER d1 = NDArray(13. * ur.tesla) assert d1.data == np.array(13.) assert d1.data.dtype in TYPE_FLOAT assert d1.shape == () assert d1.ndim == 0 assert not d1.dims assert d1.units == 'tesla' assert d1.values == 13. * ur.tesla # initialisation with a 1D array quantity d2 = NDArray([13.] * ur.tesla) assert d2.data == np.array([13.]) assert d2.shape == (1, ) assert d2.ndim == 1 assert d2.dims == ['x'] assert d2.units == 'tesla' assert d2.values == 13. * ur.tesla # initialisation with a 1D vector quantity d3 = NDArray([[13., 20.]] * ur.tesla) assert_array_equal(d3.data, np.array([[13., 20.]])) assert d3.shape == (1, 2) assert d3.ndim == 2 assert d3.dims == ['y', 'x'] assert d3.units == 'tesla' # initialisation with a sequence d4 = NDArray((2, 3, 4)) assert d4.shape == (3, ) assert d4.size == 3 assert d4.dims == ['x'] assert not d4.is_masked # initialization with an array d5 = NDArray(refarray) assert d5.shape == refarray.shape assert d5.size == refarray.size assert not d5.is_masked # initialization with an NDArray object d6 = NDArray(ndarraymask) assert d6.title == '<untitled>' assert d6.shape == refarray.shape assert d6.dims == ['y', 'x'] assert d6.size == refarray.size assert_array_equal(d6.data, refarray) assert d6._data is ndarraymask._data # by default we do not copy # d6.data and ndarraym ask.data are however different due to the addition of un offset assert d6.is_masked assert_array_equal(d6.mask, refmask) assert d6.mask is ndarraymask.mask # no copy by default # initialization with an NDArray object with copy d7 = NDArray(ndarraymask, copy=True) assert_array_equal(d7.data, refarray) assert d7.data is not ndarraymask.data # by default we do not copy assert_array_equal(d7.mask, refmask) assert d7.mask is not ndarraymask.mask # no copy by default # initialisation with a sequence and a mask d0mask = NDArray([2, 3, 4, 5], mask=[1, 0, 0, 0], dtype='int64') assert d0mask.shape == (4, ) assert d0mask.is_masked assert d0mask.mask.shape == d0mask.shape # initialisation with a sequence and a mask d1mask = NDArray([2., 3., 4., 5.1], mask=[1, 0, 0, 0]) assert d1mask.shape == (4, ) assert d1mask.is_masked assert d1mask.mask.shape == d1mask.shape # dtype specified d8 = NDArray(ndarraymask, desc='with mask', dtype=np.int64) assert d8.shape == refarray.shape assert d8.data.dtype == np.int64 assert d8.dims == ['y', 'x'] assert d8.title == '<untitled>' assert d8.description == 'with mask' assert d8.desc == d8.description assert len(ndarraymask.history) == 1 # one line already in assert len(d8.history) == 2 # copy added # intialisation with only labels d9 = NDArray(labels='a b c d e f g h i j'.split(), title='labeled') assert d9.is_labeled # changing dims name d11 = NDArray(labels='a b c d e f g h i j'.split(), title='labeled', dims=['q'], author='Blake', history='Created from scratch') assert d11.dims == ['q'] assert d11.author == 'Blake' assert '[ a b ... i j]' in d11._repr_html_() # comparison
def test_coord(): # simple coords a = Coord([1, 2, 3], name='x') assert a.id is not None assert not a.is_empty assert not a.is_masked assert_array_equal(a.data, np.array([1, 2, 3])) assert not a.is_labeled assert a.units is None assert a.unitless debug_(a.meta) assert not a.meta assert a.name == 'x' # set properties a.title = 'xxxx' assert a.title == 'xxxx' a.name = 'y' assert a.name == 'y' a.meta = None a.meta = {'val': 125} # need to be an OrderedDic assert a.meta['val'] == 125 # now with labels x = np.arange(10) y = list('abcdefghij') a = Coord(x, labels=y, title='processors', name='x') assert a.title == 'processors' assert isinstance(a.data, np.ndarray) assert isinstance(a.labels, np.ndarray) # any kind of object can be a label assert a.labels.dtype == 'O' # even an array a._labels[3] = x assert a._labels[3][2] == 2 # coords can be defined only with labels y = list('abcdefghij') a = Coord(labels=y, title='processors') assert a.title == 'processors' assert isinstance(a.labels, np.ndarray) assert_array_equal(a.values, a.labels) # any kind of object can be a label assert a.labels.dtype == 'O' # even an array a._labels[3] = range(10) assert a._labels[3][2] == 2 # coords with datetime from datetime import datetime x = np.arange(10) y = [datetime(2017, 6, 2 * (i + 1)) for i in x] a = Coord(x, labels=y, title='time') assert a.title == 'time' assert isinstance(a.data, np.ndarray) assert isinstance(a.labels, np.ndarray) a._sort(by='label', descend=True) # but coordinates must be 1D with pytest.raises(ValueError): # should raise an error as coords must be 1D Coord(data=np.ones((2, 10))) # unitless coordinates coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), mask=None, units=None, title='wavelength') assert coord0.units is None assert coord0.data[0] == 4000. assert repr(coord0) == 'Coord: [float64] unitless (size: 10)' # dimensionless coordinates coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), mask=None, units=ur.dimensionless, title='wavelength') assert coord0.units.dimensionless assert coord0.units.scaling == 1. assert coord0.data[0] == 4000. assert repr(coord0) == 'Coord: [float64] (size: 10)' # scaled dimensionless coordinates coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), mask=None, units='m/km', title='wavelength') assert coord0.units.dimensionless assert coord0.data[ 0] == 4000. # <- displayed data to be multiplied by the scale factor assert repr( coord0) == 'Coord: [float64] scaled-dimensionless (0.001) (size: 10)' coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), mask=None, units=ur.m / ur.km, title='wavelength') assert coord0.units.dimensionless assert coord0.data[ 0] == 4000. # <- displayed data to be multiplied by the scale factor assert repr( coord0) == 'Coord: [float64] scaled-dimensionless (0.001) (size: 10)' coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), mask=None, units="m^2/s", title='wavelength') assert not coord0.units.dimensionless assert coord0.units.scaling == 1. assert coord0.data[0] == 4000. assert repr(coord0) == 'Coord: [float64] m^2.s^-1 (size: 10)' # comparison coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), mask=None, title='wavelength') coord0b = Coord(data=np.linspace(4000, 1000, 10), labels='a b c d e f g h i j'.split(), mask=None, title='wavelength') coord1 = Coord(data=np.linspace(4000, 1000, 10), labels='a b c d e f g h i j'.split(), mask=None, title='titi') coord2 = Coord(data=np.linspace(4000, 1000, 10), labels='b c d e f g h i j a'.split(), mask=None, title='wavelength') coord3 = Coord(data=np.linspace(4000, 1000, 10), labels=None, mask=None, title='wavelength') assert coord0 == coord0b assert coord0 != coord1 # different title assert coord0 != coord2 # different labels assert coord0 != coord3 # one coord has no label # init from another coord coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), units='s', mask=None, title='wavelength') coord1 = Coord(coord0) assert coord1._data is coord0._data coord1 = Coord(coord0, copy=True) assert coord1._data is not coord0._data assert_array_equal(coord1._data, coord0._data) assert isinstance(coord0, Coord) assert isinstance(coord1, Coord) # sort coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), units='s', mask=None, title='wavelength') assert coord0.is_labeled ax = coord0._sort() assert (ax.data[0] == 1000) coord0._sort(descend=True, inplace=True) assert (coord0.data[0] == 4000) ax1 = coord0._sort(by='label', descend=True) assert (ax1.labels[0] == 'j') # copy coord0 = Coord(data=np.linspace(4000, 1000, 10), labels=list('abcdefghij'), units='s', mask=None, title='wavelength') coord1 = coord0.copy() assert coord1 is not coord0 assert_array_equal(coord1.data, coord0.data) assert_array_equal(coord1.labels, coord0.labels) assert coord1.units == coord0.units coord2 = copy(coord0) assert coord2 is not coord0 assert_array_equal(coord2.data, coord0.data) assert_array_equal(coord2.labels, coord0.labels) assert coord2.units == coord0.units # automatic reversing for wavenumbers coord0 = Coord(data=np.linspace(4000, 1000, 10), units='cm^-1', mask=None, title='wavenumbers') assert coord0.reversed
def test_ndarray_methods(refarray, ndarray, ndarrayunit): ref = refarray nd = ndarray.copy() assert nd.data.size == ref.size assert nd.shape == ref.shape assert nd.size == ref.size assert nd.ndim == 2 assert nd.data[1, 1] == ref[1, 1] assert nd.dims == ['y', 'x'] assert nd.unitless # no units assert not nd.dimensionless # no unit so dimensionless has no sense with catch_warnings() as w: # try to change to an array with units nd.to('m') # should not change anything (but raise a warning) assert w[-1].category == SpectroChemPyWarning assert nd.unitless nd.units = 'm' assert nd.units == ur.meter nd1 = nd.to('km') assert nd.units != ur.kilometer # not inplace assert nd1.units == ur.kilometer nd.ito('m') assert nd.units == ur.meter # change of units - ok if it can be casted to the current one nd.units = 'cm' # cannot change to incompatible units with pytest.raises(TypeError): nd.units = 'radian' # we can force them nd.ito('radian', force=True) # check dimensionless and scaling assert 1 * nd.units == 1. * ur.dimensionless assert nd.units.dimensionless assert nd.dimensionless with raises(DimensionalityError): nd1 = nd1.ito('km/s') # should raise an error nd.units = 'm/km' assert nd.units.dimensionless assert nd.units.scaling == 0.001 nd.to(1 * ur.m, force=True) assert nd.dims == ['y', 'x'] # check units compatibility nd.ito('m', force=True) nd2 = ndarray.copy() assert nd2.dims == ['y', 'x'] nd2.units = 'km' assert nd.is_units_compatible(nd2) nd2.ito('radian', force=True) assert not nd.is_units_compatible(nd2) # check masking assert not nd.is_masked repr(nd) assert repr(nd).startswith('NDArray: ') nd[0] = MASKED assert nd.is_masked assert nd.dims == ['y', 'x'] # check len and size assert len(nd) == ref.shape[0] assert nd.shape == ref.shape assert nd.size == ref.size assert nd.ndim == 2 assert nd.dims == ['y', 'x'] # a vector is a 1st rank tensor. Internally (it will always be represented # as a 1D matrix. v = NDArray([[1., 2., 3.]]) assert v.ndim == 2 assert v.shape == (1, 3) assert v.dims == ['y', 'x'] assert_array_equal(v.data, np.array([[1., 2., 3.]])) vt = v.transpose() assert vt.shape == (3, 1) assert vt.dims == ['x', 'y'] assert_array_equal(vt.data, np.array([[1.], [2.], [3.]])) # test repr nd = ndarrayunit.copy() h, w = ref.shape assert nd.__repr__( ) == f"NDArray: [float64] m.s^-1 (shape: (y:{h}, x:{w}))" nd[1] = MASKED assert nd.is_masked # test repr_html assert '<table style=\'background:transparent\'>' in nd._repr_html_() # test iterations nd = ndarrayunit.copy() nd[1] = MASKED # force units to change np.random.seed(12345) ndd = NDArray(data=np.random.random((3, 3)), mask=[[True, False, False], [False, True, False], [False, False, True]], units='meters') with raises(Exception): ndd.to('second') ndd.to('second', force=True) # swapdims np.random.seed(12345) d = np.random.random((4, 3)) d3 = NDArray(d, units=ur.Hz, mask=[[False, True, False], [False, True, False], [False, True, False], [True, False, False]]) # with units & mask assert d3.shape == (4, 3) assert d3._data.shape == (4, 3) assert d3.dims == ['y', 'x'] d4 = d3.swapdims(0, 1) assert d4.dims == ['x', 'y'] assert d4.shape == (3, 4) assert d4._data.shape == (3, 4) # test iter for i, item in enumerate(ndd): assert item == ndd[i] ndz = NDArray() assert not list(item for item in ndz) assert str(ndz) == repr(ndz) == 'NDArray: empty (size: 0)'
def test_ndarray_slicing(refarray, ndarray): ref = refarray nd = ndarray.copy() assert not nd.is_masked assert nd.dims == ['y', 'x'] # slicing is different in scpy than with numpy. We always return # unsqueezed dimensions, except for array of size 1, which are considered as scalar nd1 = nd[0, 0] assert_equal(nd1.data, nd.data[0:1, 0:1]) assert nd1 is not nd[0, 0] assert nd1.ndim == 2 # array not reduced assert nd1.size == 1 assert nd1.shape == (1, 1) assert isinstance(nd1, NDArray) assert isinstance(nd1.data, np.ndarray) assert isinstance(nd1.values, TYPE_FLOAT) nd1b, id = nd.__getitem__((0, 0), return_index=True) assert nd1b == nd1 nd1a = nd[0, 0:2] assert_equal(nd1a.data, nd.data[0:1, 0:2]) assert nd1a is not nd[0, 0:2] assert nd1a.ndim == 2 assert nd1a.size == 2 assert nd1a.shape == (1, 2) assert isinstance(nd1a, NDArray) assert nd1a.dims == ['y', 'x'] # returning none if empty when slicing nd1b = nd[11:, 11:] assert nd1b is None # nd has been changed, restore it before continuing nd = ndarray.copy() nd2 = nd[7:10] assert_equal(nd2.data, nd.data[7:10]) assert not nd.is_masked nd3 = nd2[1] assert nd3.shape == (1, ref.shape[1]) assert nd3.dims == ['y', 'x'] nd4 = nd2[:, 1] assert nd4.shape == (3, 1) assert nd4.dims == ['y', 'x'] # squezzing nd5 = nd4.squeeze() assert nd5.shape == (3, ) assert nd5.dims == ['y'] # set item nd[1] = 2. assert nd[1, 0] == 2 # set item mask nd[1] = MASKED assert nd.is_masked # boolean indexing nd = ndarray.copy() nd[nd.data > 0] # fancy indexing df = nd.data[[-1, 1]] ndf = nd[[-1, 1]] assert_array_equal(ndf.data, df) ndf = nd[[ -1, 1 ], INPLACE] # TODO: check utility of this (I remember it should be related to setitem) assert_array_equal(ndf.data, df) # use with selection from other numpy functions am = np.argmax(nd.data, axis=1) assert_array_equal(am, np.array([7, 3])) amm = nd.data[..., am] assert_array_equal(nd[..., am].data, amm)
def test_nddataset_sorting(ds1): # ds1 is defined in conftest dataset = ds1[:3, :3, 0].copy() dataset.sort(inplace=True, dim='z') labels = np.array(list('abc')) assert_array_equal(dataset.coordset['z'].labels, labels) # nochange because the axis is naturally iversed to force it # we need to specify descend dataset.sort(inplace=True, descend=False, dim='z') # order value in increasing order labels = np.array(list('cba')) assert_array_equal(dataset.coordset['z'].labels, labels) dataset.sort(inplace=True, dim='z') new = dataset.copy() new = new.sort(descend=False, inplace=False, dim='z') assert_array_equal(new.data, dataset.data[::-1]) assert (new[0, 0] == dataset[-1, 0]) assert_array_equal(new.coordset['z'].labels, labels) assert_array_equal(new.coordset["z"].data, dataset.coordset['z'].data[::-1]) # check for another dimension dataset = ds1.copy() new = ds1.copy() new.sort(dim='y', inplace=True, descend=False) assert_array_equal(new.data, dataset.data) assert (new[0, 0, 0] == dataset[0, 0, 0]) new = dataset.copy() new.sort(dim='y', inplace=True, descend=True) assert_array_equal(new.data, dataset.data[:, ::-1, :]) assert (new[0, -1, 0] == dataset[0, 0, 0])