def test_write(): nd = scp.read_omnic('irdata/nh4y-activation.spg') # API write methods needs an instance of a NDDataset as the first argument with pytest.raises(TypeError): scp.write() # the simplest way to save a dataset, is to use the function write with a filename as argument filename = nd.write('essai.scp') assert filename == cwd / 'essai.scp' nd2 = NDDataset.load(filename) testing.assert_dataset_equal(nd2, nd) filename.unlink() # if the filename is omitted, the a dialog is opened to select a name (and a protocol) filename = nd.write() assert filename is not None assert filename.stem == nd.name assert filename.suffix == '.scp' filename.unlink() # # a write protocole can be specified # filename = nd.write(protocole='json') # assert filename is not None # assert filename.stem == nd.name # assert filename.suffix == '.json' # filename.unlink() irdatadir = pathclean(prefs.datadir) / "irdata" for f in ['essai.scp', 'nh4y-activation.scp']: if (irdatadir / f).is_file(): (irdatadir / f).unlink()
def test_nddataset_slicing_by_index(ref_ds, ds1): da = ds1 ref = ref_ds # case where the index is an integer: the selection is by index starting # at zero assert da.shape == ref.shape coords = da.coordset plane0 = da[0] # should return a dataset of with dimension x of size 1 assert type(plane0) == type(da) assert plane0.ndim == 3 assert plane0.shape == (1, 100, 3) assert plane0.size == 300 assert plane0.dims == ['z', 'y', 'x'] assert_dataset_equal(plane0.z, da.z[0]) da1 = plane0.squeeze() assert da1.shape == (100, 3) assert da1.dims == ['y', 'x'] plane1 = da[:, 0] assert type(plane1) == type(da) assert plane1.ndim == 3 assert plane1.shape == (10, 1, 3) assert plane1.size == 30 assert plane1.dims == ['z', 'y', 'x'] da2 = plane1.squeeze() assert da2.dims == ['z', 'x'] assert_dataset_almost_equal(da2.z, coords[-1], decimal=2) # remember # coordinates # are ordered by name! assert_dataset_almost_equal(da2.x, coords[0]) # another selection row0 = plane0[:, 0] assert type(row0) == type(da) assert row0.shape == (1, 1, 3) # and again selection element = row0[..., 0] assert type(element) == type(da) assert element.dims == ['z', 'y', 'x'] # squeeze row1 = row0.squeeze() assert row1.mask == scp.NOMASK row1[0] = scp.MASKED assert row1.dims == ['x'] assert row1.shape == (3,) assert row1.mask.shape == (3,) element = row1[..., 0] assert element.x == coords[0][0] # now a slicing in multi direction da[1:4, 10:40:2, :2] # now again a slicing in multi direction (full selection) da[:, :, -2] # now again a slicing in multi direction (ellipsis) da[..., -1] da[-1, ...]
def test_issue_227(): # IR spectrum, we want to make a baseline correction on the absorbance vs. time axis: ir = scp.read("irdata/nh4y-activation.spg") # baseline correction along x blc = scp.BaselineCorrection(ir) s1 = blc([5999.0, 3500.0], [1800.0, 1500.0], method="multivariate", interpolation="pchip") # baseline correction the transposed data along x (now on axis 0) -> should produce the same results # baseline correction along axis -1 previuosly blc = scp.BaselineCorrection(ir.T) s2 = blc( [5999.0, 3500.0], [1800.0, 1500.0], dim="x", method="multivariate", interpolation="pchip", ) # compare assert_dataset_equal(s1, s2.T) ir.y = ir.y - ir[0].y irs = ir[:, 2000.0:2020.0] blc = scp.BaselineCorrection(irs) blc.compute(*[[0.0, 2.0e3], [3.0e4, 3.3e4]], dim="y", interpolation="polynomial", order=1, method="sequential") blc.corrected.plot() # MS profiles, we want to make a baseline correction on the ion current vs. time axis: ms = scp.read("msdata/ion_currents.asc", timestamp=False) blc = scp.BaselineCorrection(ms[10.0:20.0, :]) blc.compute(*[[10.0, 11.0], [19.0, 20.0]], dim="y", interpolation="polynomial", order=1, method="sequential") blc.corrected.T.plot() show()
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_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_write(): nd = scp.read_omnic("irdata/nh4y-activation.spg") # API write methods needs an instance of a NDDataset as the first argument with pytest.raises(TypeError): scp.write() # the simplest way to save a dataset, is to use the function write with a filename as argument if (cwd / "essai.scp").exists(): (cwd / "essai.scp").unlink() filename = nd.write("essai.scp") # should not open a DIALOG assert filename == cwd / "essai.scp" assert filename.exists() # try to write it again filename = nd.write("essai.scp") # should open a DIALOG to confirm nd2 = NDDataset.load(filename) testing.assert_dataset_equal(nd2, nd) filename.unlink() # if the filename is omitted, a dialog is opened to select a name (and a protocol) filename = nd.write() assert filename is not None assert filename.stem == nd.name assert filename.suffix == ".scp" filename.unlink() # # a write protocole can be specified # filename = nd.write(protocole='json') # assert filename is not None # assert filename.stem == nd.name # assert filename.suffix == '.json' # filename.unlink() irdatadir = pathclean(prefs.datadir) / "irdata" for f in ["essai.scp", "nh4y-activation.scp"]: if (irdatadir / f).is_file(): (irdatadir / f).unlink()
def test_compare(IR_dataset_1D, simple_project): # dataset comparison nd1 = IR_dataset_1D.copy() nd2 = nd1.copy() testing.assert_dataset_equal(nd1, nd2) nd3 = nd1.copy() nd3.title = 'ddd' with testing.raises(AssertionError): testing.assert_dataset_equal(nd1, nd3) nd4 = nd1.copy() nd4.data += 0.001 with testing.raises(AssertionError): testing.assert_dataset_equal(nd1, nd4) testing.assert_dataset_almost_equal(nd1, nd4, decimal=3) with testing.raises(AssertionError): testing.assert_dataset_almost_equal(nd1, nd4, decimal=4) # project comparison proj1 = simple_project.copy() proj1.name = 'PROJ1' proj2 = proj1.copy() proj2.name = 'PROJ2' testing.assert_project_equal(proj1, proj2) proj3 = proj2.copy() proj3.add_script(Script(content='print()', name='just_a_try')) with testing.raises(AssertionError): testing.assert_project_equal(proj1, proj3)
def test_compare_dataset(IR_dataset_1D): # dataset comparison nd1 = IR_dataset_1D.copy() nd2 = nd1.copy() testing.assert_dataset_equal(nd1, nd2) nd3 = nd1.copy() nd3.title = "ddd" with testing.raises(AssertionError): testing.assert_dataset_equal(nd1, nd3) nd4 = nd1.copy() nd4.data += 0.001 with testing.raises(AssertionError): testing.assert_dataset_equal(nd1, nd4) testing.assert_dataset_almost_equal(nd1, nd4, decimal=3) with testing.raises(AssertionError): testing.assert_dataset_almost_equal(nd1, nd4, decimal=4)
def test_read_omnic(): # Class method opening a dialog (but for test it is preset) nd1 = NDDataset.read_omnic(IRDATA / "nh4y-activation.spg") assert str(nd1) == "NDDataset: [float64] a.u. (shape: (y:55, x:5549))" # API method nd2 = scp.read_omnic(IRDATA / "nh4y-activation.spg") assert nd1 == nd2 # It is also possible to use more specific reader function such as # `read_spg`, `read_spa` or `read_srs` - they are alias of the read_omnic function. l2 = scp.read_spg("wodger.spg", "irdata/nh4y-activation.spg") assert len(l2) == 2 # test read_omnic with byte spg content filename_wodger = "wodger.spg" with open(DATADIR / filename_wodger, "rb") as fil: content = fil.read() nd1 = scp.read_omnic(filename_wodger) nd2 = scp.read_omnic({filename_wodger: content}) assert nd1 == nd2 # Test bytes contents for spa files filename = IRDATA / "subdir" / "7_CZ0-100_Pd_101.SPA" nds = scp.read_spa(filename) with open(IRDATA / "subdir" / filename, "rb") as fil: content = fil.read() nd = NDDataset.read_spa({filename: content}) assert_dataset_equal(nd, nds) nd = scp.read_spa(IRDATA / "subdir" / "20-50" / "7_CZ0-100_Pd_21.SPA") assert str(nd) == "NDDataset: [float64] a.u. (shape: (y:1, x:5549))" nd2 = scp.read_spg( IRDATA / "subdir" / "20-50" / "7_CZ0-100_Pd_21.SPA" ) # wrong protocol but acceptable assert nd2 == nd # test import sample IFG nd = scp.read_spa(IRDATA / "carroucell_samp" / "2-BaSO4_0.SPA", return_ifg="sample") assert str(nd) == "NDDataset: [float64] V (shape: (y:1, x:16384))" # test import background IFG nd = scp.read_spa( IRDATA / "carroucell_samp" / "2-BaSO4_0.SPA", return_ifg="background" ) assert str(nd) == "NDDataset: [float64] V (shape: (y:1, x:16384))" # imùport IFG from file without IFG a = scp.read_spa( IRDATA / "subdir" / "20-50" / "7_CZ0-100_Pd_21.SPA", return_ifg="sample" ) assert a is None # rapid_sca series a = scp.read_srs("irdata/omnic_series/rapid_scan.srs") assert str(a) == "NDDataset: [float64] V (shape: (y:643, x:4160))" # rapid_sca series, import bg a = scp.read_srs("irdata/omnic_series/rapid_scan.srs", return_bg=True) assert str(a) == "NDDataset: [float64] V (shape: (y:1, x:4160))" # non-rapid scan series a = scp.read_srs("irdata/omnic_series/GC_Demo.srs") assert a is None # not rapid scan mode
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_round_docstring_example(): ds = scp.read("wodger.spg") ds_transformed1 = np.round(ds, 3) ds_transformed2 = np.around(ds, 3) ds_transformed3 = scp.around(ds, 3) ds_transformed4 = scp.round(ds, 3) ds_transformed5 = ds.round(3) ds_transformed6 = NDDataset.round(ds, 3) assert_dataset_equal(ds_transformed1, ds_transformed2) assert_dataset_equal(ds_transformed1, ds_transformed3) assert_dataset_equal(ds_transformed1, ds_transformed4) assert_dataset_equal(ds_transformed1, ds_transformed5) assert_dataset_equal(ds_transformed1, ds_transformed6) ds[:, 3000.0:3500.0] = scp.MASKED dsm_transformed1 = np.ma.round(ds) dsm_transformed2 = np.around(ds) dsm_transformed3 = scp.around(ds) dsm_transformed4 = ds.round() assert_dataset_equal(dsm_transformed1, dsm_transformed2) assert_dataset_equal(dsm_transformed1, dsm_transformed3) assert_dataset_equal(dsm_transformed1, dsm_transformed4)
def test_2D_NDDataset(arr): # 2D ds = scp.NDDataset(arr) assert ds.size == arr.size assert ds.shape == arr.shape if ds.size == 0: assert ds.dtype is None assert ds.dims == [] else: assert ds.dtype == np.float64 assert ds.dims == ['y', 'x'][-ds.ndim:] assert ds.title == "<untitled>" assert ds.mask == scp.NOMASK assert ds.meta == {} assert ds.name.startswith("NDDataset") assert ds.author == get_user_and_node() assert not ds.history assert ds.description == "" # force dtype ds = scp.NDDataset(arr, dtype=np.float32) if ds.size == 0: assert ds.dtype is None else: assert ds.dtype == np.float32 if ds.shape[-1] % 2 == 0: # must be even ds = scp.NDDataset(arr, dtype=np.complex) if ds.size == 0: assert ds.dtype is None else: assert ds.dtype == np.complex128 else: with pytest.raises(ValueError): ds = scp.NDDataset(arr, dtype=np.complex) if (arr.shape[-1] % 2) == 0 and (arr.shape[-2] % 2) == 0 and arr.ndim == 2: ds = scp.NDDataset(arr, dtype=np.quaternion) if ds.size == 0: assert ds.dtype is None else: assert ds.dtype == np.quaternion else: with pytest.raises(ValueError): ds = scp.NDDataset(arr, dtype=np.quaternion) # test units ds1 = scp.NDDataset(arr * scp.ur.km) ds2 = scp.NDDataset(arr, units=scp.ur.km) assert ds1.units == scp.ur.km assert ds2.units == scp.ur.km assert_dataset_equal(ds1, ds2) # masking ds1[0] = scp.MASKED assert ds1.is_masked # init with another dataset ds2 = scp.NDDataset(ds1) assert_dataset_equal(ds1, ds2) # check no coordinates assert not ds2.is_complex assert ds2.coordset is None # no coordinates assert ds2.x is None # no coordinates with pytest.raises(AttributeError): ds2.t # dim attributes ds2 = scp.NDDataset(arr, dims=['u', 'w']) assert ds2.ndim == 2 assert ds2.dims == ['u', 'w']