def test_remove_variance(): values = np.random.rand(2, 3) variances = np.random.rand(2, 3) var = sc.Variable(dims=['x', 'y'], values=values, variances=variances) expected = sc.Variable(dims=['x', 'y'], values=values) assert var.variances is not None var.variances = None assert var.variances is None assert sc.is_equal(var, expected)
def test_in_place_binary_with_scalar(): v = sc.Variable(dims=['x'], values=[10.0]) copy = v.copy() v += 2 v *= 2 v -= 4 v /= 2 assert sc.is_equal(v, copy)
def test_coord_setitem(): var = sc.Variable(dims=['x'], values=np.arange(4)) d = sc.Dataset({'a': var}, coords={'x': var}) with pytest.raises(RuntimeError): d['x', 2:3].coords['y'] = sc.Variable(1.0) d.coords['y'] = sc.Variable(1.0) assert len(d) == 1 assert len(d.coords) == 2 assert sc.is_equal(d.coords['y'], sc.Variable(1.0))
def test_iadd_range(): d = sc.Dataset( coords={'x': sc.Variable(dims=['x'], values=np.arange(4, 8))}) d['a'] = sc.Variable(dims=['x'], values=np.arange(4)) with pytest.raises(RuntimeError): d['a']['x', 2:4] += d['a']['x', 1:3] d['a']['x', 2:4] += d['a']['x', 2:4] assert sc.is_equal(d['a'].data, sc.Variable(dims=['x'], values=np.array([0, 1, 4, 6])))
def test_dataset_set_data(): d1 = sc.Dataset( { 'a': sc.Variable(dims=['x', 'y'], values=np.random.rand(2, 3)), 'b': sc.Variable(1.0) }, coords={ 'x': sc.Variable(dims=['x'], values=np.arange(2.0), unit=sc.units.m), 'y': sc.Variable(dims=['y'], values=np.arange(3.0), unit=sc.units.m), 'aux': sc.Variable(dims=['y'], values=np.arange(3)) }) d2 = sc.Dataset( { 'a': sc.Variable(dims=['x', 'y'], values=np.random.rand(2, 3)), 'b': sc.Variable(1.0) }, coords={ 'x': sc.Variable(dims=['x'], values=np.arange(2.0), unit=sc.units.m), 'y': sc.Variable(dims=['y'], values=np.arange(3.0), unit=sc.units.m), 'aux': sc.Variable(dims=['y'], values=np.arange(3)) }) d3 = sc.Dataset() d3['b'] = d1['a'] assert d3['b'].data == d1['a'].data assert d3['b'].coords == d1['a'].coords d1['a'] = d2['a'] d1['c'] = d2['a'] assert d2['a'].data == d1['a'].data assert d2['a'].data == d1['c'].data d = sc.Dataset() d.coords['row'] = sc.Variable(dims=['row'], values=np.arange(10.0)) d['a'] = sc.Variable(dims=['row'], values=np.arange(10.0), variances=np.arange(10.0)) d['b'] = sc.Variable(dims=['row'], values=np.arange(10.0, 20.0)) d1 = d['row', 0:1] d2 = sc.Dataset({'a': d1['a'].data}, coords={'row': d1['a'].coords['row']}) d2['b'] = d1['b'] expected = sc.Dataset() expected.coords['row'] = sc.Variable(dims=['row'], values=np.arange(1.0)) expected['a'] = sc.Variable(dims=['row'], values=np.arange(1.0), variances=np.arange(1.0)) expected['b'] = sc.Variable(dims=['row'], values=np.arange(10.0, 11.0)) assert sc.is_equal(d2, expected)
def test_numpy_self_assign_shift_2d_flip_first(): # Special case of shift combined with negative stride: Essentially we walk # backwards from "begin", but away from "end" since the outer dim has a # positive stride, so a naive range check based does not catch this case. var = sc.Variable(dims=['y', 'x'], values=np.arange(9).reshape(3, 3)) expected = sc.Variable(dims=['y', 'x'], values=np.array([[0, 1, 2], [3, 3, 4], [6, 0, 1]])) var['y', 1:3]['x', 1:3].values = np.flip(var['y', 0:2]['x', 0:2].values, axis=0) assert sc.is_equal(var, expected)
def test_view_in_place_binary_with_scalar(): d = sc.Dataset({'data': sc.Variable(dims=['x'], values=[10.0])}, coords={'x': sc.Variable(dims=['x'], values=[10])}) copy = d.copy() d['x', :] += 2 d['x', :] *= 2 d['x', :] -= 4 d['x', :] /= 2 assert sc.is_equal(d, copy)
def test_in_place_binary_with_dataarray(): da = sc.DataArray( data=sc.Variable(['x'], values=np.arange(1.0, 10.0)), coords={'x': sc.Variable(['x'], values=np.arange(1.0, 10.0))}) orig = da.copy() da += orig da -= orig da *= orig da /= orig assert sc.is_equal(da, orig)
def test_in_place_binary_with_variable(): a = sc.DataArray(data=sc.Variable(['x'], values=np.arange(10.0)), coords={'x': sc.Variable(['x'], values=np.arange(10.0))}) copy = a.copy() a += 2.0 * sc.units.dimensionless a *= 2.0 * sc.units.m a -= 4.0 * sc.units.m a /= 2.0 * sc.units.m assert sc.is_equal(a, copy)
def test_in_place_binary_with_scalar(): a = sc.DataArray(data=sc.Variable(['x'], values=[10.0]), coords={'x': sc.Variable(['x'], values=[10])}) copy = a.copy() a += 2 a *= 2 a -= 4 a /= 2 assert sc.is_equal(a, copy)
def test_dataset_to_dict(): ds = sc.Dataset() ds.coords["x"] = sc.Variable(dims=["x"], values=np.arange(10)) ds.coords["y"] = sc.Variable(dims=["y"], values=np.arange(5), unit=sc.units.m) ds["a"] = sc.Variable(dims=["y", "x"], values=np.random.random([5, 10])) ds["b"] = sc.Variable(dims=["y", "x"], values=np.random.random([5, 10]), variances=np.random.random([5, 10]), unit=sc.units.s) ds["a"].masks["amask"] = sc.Variable( dims=["y"], values=[True, True, False, True, False]) # Note that attributes complicate things here, as they are duplicated in # each entry during the conversion to dict. So for now, we leave attributes # out. ds_dict = sc.to_dict(ds) assert sc.is_equal(sc.from_dict(ds_dict["a"]), ds["a"]) assert sc.is_equal(sc.from_dict(ds_dict["b"]), ds["b"])
def test_init_from_variable_views(): var = sc.Variable(['x'], values=np.arange(5)) a = sc.DataArray(data=var, coords={'x': var}, unaligned_coords={'meta': var}, masks={'mask1': sc.less(var, sc.Variable(value=3))}) b = sc.DataArray(data=a.data, coords={'x': a.coords['x']}, unaligned_coords={'meta': a.unaligned_coords['meta']}, masks={'mask1': a.masks['mask1']}) assert sc.is_equal(a, b) # Ensure mix of Variables and Variable views work c = sc.DataArray(data=a.data, coords={'x': var}, unaligned_coords={'meta': a.unaligned_coords['meta']}, masks={'mask1': a.masks['mask1']}) assert sc.is_equal(a, c)
def test_collapse_dataset(): d = make_dataset() collapsed = sc.collapse(d, keep='tof') # In a Dataset, the order of the dims is not fixed first_key = list(collapsed.keys())[0] if first_key.startswith('x'): dim1 = 'x' dim2 = 'y' else: dim1 = 'y' dim2 = 'x' assert sc.is_equal(collapsed['{}:0-{}:0'.format(dim1, dim2)], d[dim2, 0][dim1, 0]) assert sc.is_equal(collapsed['{}:0-{}:1'.format(dim1, dim2)], d[dim2, 1][dim1, 0]) assert sc.is_equal(collapsed['{}:1-{}:0'.format(dim1, dim2)], d[dim2, 0][dim1, 1]) assert sc.is_equal(collapsed['{}:1-{}:1'.format(dim1, dim2)], d[dim2, 1][dim1, 1])
def test_eq(): da = make_dataarray() assert sc.is_equal(da['x', :], da) assert sc.is_equal(da['y', :], da) assert sc.is_equal(da['y', :]['x', :], da) assert not sc.is_equal(da['y', 1:], da) assert not sc.is_equal(da['x', 1:], da) assert not sc.is_equal(da['y', 1:]['x', :], da) assert not sc.is_equal(da['y', :]['x', 1:], da)
def test_binary_of_item_with_variable(): d = sc.Dataset( {'data': sc.Variable(dims=['x'], values=np.arange(10.0))}, coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))}) copy = d.copy() d['data'] += 2.0 * sc.units.dimensionless d['data'] *= 2.0 * sc.units.m d['data'] -= 4.0 * sc.units.m d['data'] /= 2.0 * sc.units.m assert sc.is_equal(d, copy)
def test_binary__with_dataarray(): da = sc.DataArray( data=sc.Variable(dims=['x'], values=np.arange(1.0, 10.0)), coords={'x': sc.Variable(dims=['x'], values=np.arange(1.0, 10.0))}) ds = sc.Dataset({da.name: da}) orig = ds.copy() ds += da ds -= da ds *= da ds /= da assert sc.is_equal(ds, orig)
def test_bins_arithmetic(): var = sc.Variable(dims=['event'], values=[1.0, 2.0, 3.0, 4.0]) table = sc.DataArray(var, {'x': var}) binned = sc.bin(table, [sc.Variable(dims=['x'], values=[1.0, 5.0])]) hist = sc.DataArray( data=sc.Variable(dims=['x'], values=[1.0, 2.0]), coords={'x': sc.Variable(dims=['x'], values=[1.0, 3.0, 5.0])}) binned.bins *= sc.lookup(func=hist, dim='x') assert sc.is_equal( binned.bins.data.data, sc.Variable(dims=['event'], values=[1.0, 2.0, 6.0, 8.0]))
def test_binary_with_broadcast(): da = sc.DataArray(data=sc.Variable(['x', 'y'], values=np.arange(20).reshape(5, 4)), coords={ 'x': sc.Variable(['x'], values=np.arange(0.0, 0.6, 0.1)), 'y': sc.Variable(['y'], values=np.arange(0.0, 0.5, 0.1)) }) d2 = da - da['x', 0] da -= da['x', 0] assert sc.is_equal(da, d2)
def test_variable_matrix_round_trip(): data = np.array([ np.arange(9.0).reshape(3, 3), np.arange(5.0, 14.0).reshape(3, 3), np.arange(1.0, 10.0).reshape(3, 3), np.arange(2.0, 11.0).reshape(3, 3) ]) var = sc.Variable(['x'], values=data, unit=sc.units.m, dtype=sc.dtype.matrix_3_float64) assert sc.is_equal(var, sc.from_dict(sc.to_dict(var)))
def test_nan_to_num_out_with_multiple_special_replacements(): a = sc.Variable(dims=['x'], values=np.array([1, np.inf, -np.inf, np.nan])) out = sc.Variable(dims=['x'], values=np.zeros(4)) replace = sc.Variable(value=0.0) # just replace nans sc.nan_to_num(a, nan=replace, out=out) expected = sc.Variable(dims=['x'], values=np.array([1, np.inf, -np.inf, replace.value])) assert sc.is_equal(out, expected) # replace neg inf sc.nan_to_num(out, neginf=replace, out=out) expected = sc.Variable(dims=['x'], values=np.array( [1, np.inf, replace.value, replace.value])) assert sc.is_equal(out, expected) # replace pos inf sc.nan_to_num(out, posinf=replace, out=out) expected = sc.Variable(dims=['x'], values=np.array([1] + [replace.value] * 3)) assert sc.is_equal(out, expected)
def test_neutron_beamline(): d = make_dataset_with_beamline() assert sc.is_equal( sc.neutron.source_position(d), sc.Variable(value=np.array([0, 0, -10]), dtype=sc.dtype.vector_3_float64, unit=sc.units.m)) assert sc.is_equal( sc.neutron.sample_position(d), sc.Variable(value=np.array([0, 0, 0]), dtype=sc.dtype.vector_3_float64, unit=sc.units.m)) assert sc.is_equal(sc.neutron.l1(d), 10.0 * sc.units.m) assert sc.is_equal( sc.neutron.l2(d), sc.Variable(dims=['position'], values=np.ones(4), unit=sc.units.m)) two_theta = sc.neutron.two_theta(d) assert two_theta.unit == sc.units.rad assert two_theta.dims == ['position'] assert sc.is_equal(sc.neutron.scattering_angle(d), 0.5 * two_theta)
def test_variable_0D_matrix(): # Use known rotation (180 deg around z) to check correct construction rot = sc.Variable(value=sc.rotation_matrix_from_quaternion_coeffs( [0, 0, 1, 0]), unit=sc.units.one, dtype=sc.dtype.matrix_3_float64) vec = sc.Variable(value=[1, 2, 3], unit=sc.units.m, dtype=sc.dtype.vector_3_float64) rotated = sc.Variable(value=[-1, -2, 3], unit=sc.units.m, dtype=sc.dtype.vector_3_float64) assert sc.is_equal(rot * vec, rotated)
def test_binary_equal(): a, b, a_slice, b_slice, data = make_variables() assert sc.is_equal(a, b) assert sc.is_equal(a, a_slice) assert sc.is_equal(a_slice, b_slice) assert sc.is_equal(b, a) assert sc.is_equal(b_slice, a) assert sc.is_equal(b_slice, a_slice)
def test_data_array_from_dict(): da_dict = { "coords": { "x": { "dims": ["x"], "values": np.arange(10) }, "y": { "dims": ["y"], "values": np.arange(5), "unit": sc.units.m }, }, "masks": { "amask": { "dims": ["y"], "values": [True, True, False, True, False] } }, "attrs": { "attr1": { "dims": ["x"], "values": np.random.random(10) } }, "data": { "dims": ["y", "x"], "values": np.random.random([5, 10]) } } da = sc.from_dict(da_dict) assert sc.is_equal(da.coords["x"], sc.from_dict(da_dict["coords"]["x"])) assert sc.is_equal(da.coords["y"], sc.from_dict(da_dict["coords"]["y"])) assert sc.is_equal(da.masks["amask"], sc.from_dict(da_dict["masks"]["amask"])) assert sc.is_equal(da.attrs["attr1"], sc.from_dict(da_dict["attrs"]["attr1"])) assert sc.is_equal(da.data, sc.from_dict(da_dict["data"]))
def test_sum_masked(): d = sc.Dataset({ 'a': sc.Variable(dims=['x'], values=np.array([1, 5, 4, 5, 1], dtype=np.int64)) }) d['a'].masks['m1'] = sc.Variable(dims=['x'], values=np.array( [False, True, False, True, False])) d_ref = sc.Dataset({'a': sc.Variable(np.int64(6))}) result = sc.sum(d, 'x')['a'] assert sc.is_equal(result, d_ref['a'])
def test_slice(): d = sc.Dataset( { 'a': sc.Variable(dims=['x'], values=np.arange(10.0)), 'b': sc.Variable(1.0) }, coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))}) expected = sc.Dataset({ 'a': sc.DataArray(1.0 * sc.units.one, attrs={'x': 1.0 * sc.units.one}) }) assert sc.is_equal(d['x', 1], expected) assert 'a' in d['x', 1] assert 'b' not in d['x', 1]
def test_data_array_round_trip(): da = sc.DataArray(coords={ "x": sc.Variable(dims=["x"], values=np.arange(10.)), "y": sc.Variable(dims=["y"], values=np.arange(5), unit=sc.units.m), }, masks={ "amask": sc.Variable(dims=["y"], values=[True, True, False, True, False]) }, data=sc.Variable(dims=["y", "x"], values=np.random.random([5, 10]))) assert sc.is_equal(da, sc.from_dict(sc.to_dict(da)))
def test_dataset_round_trip(): ds = sc.Dataset() ds.coords["x"] = sc.Variable(dims=["x"], values=np.arange(10)) ds.coords["y"] = sc.Variable(dims=["y"], values=np.arange(5), unit=sc.units.m) ds["a"] = sc.Variable(dims=["y", "x"], values=np.random.random([5, 10])) ds["b"] = sc.Variable(dims=["y", "x"], values=np.random.random([5, 10]), variances=np.random.random([5, 10]), unit=sc.units.s) ds["a"].masks["amask"] = sc.Variable( dims=["y"], values=[True, True, False, True, False]) # Note that round trip would not work if attrs are present, since they get # become a per-item attribute during the conversion to dict. assert sc.is_equal(ds, sc.from_dict(sc.to_dict(ds)))
def test_EventWorkspace_realign_events(self): import mantid.simpleapi as mantid eventWS = mantid.CloneWorkspace(self.base_event_ws) realigned = mantidcompat.convert_EventWorkspace_to_data_array( eventWS, realign_events=True, load_pulse_times=False) d = mantidcompat.convert_EventWorkspace_to_data_array( eventWS, realign_events=False, load_pulse_times=False) d.realign({'tof': realigned.coords['tof']}) # Removing run and sample due to missing comparison operators del d.unaligned_coords['run'] del d.unaligned_coords['sample'] del realigned.unaligned_coords['run'] del realigned.unaligned_coords['sample'] assert sc.is_equal(realigned, d)
def test_nan_to_nan_with_multiple_special_replacements(): a = sc.Variable(dims=['x'], values=np.array([1, np.nan, np.inf, -np.inf])) replace_nan = sc.Variable(value=-1.0) replace_pos_inf = sc.Variable(value=-2.0) replace_neg_inf = sc.Variable(value=-3.0) b = sc.nan_to_num(a, nan=replace_nan, posinf=replace_pos_inf, neginf=replace_neg_inf) expected = sc.Variable( dims=['x'], values=np.array([1] + [ repl.value for repl in [replace_nan, replace_pos_inf, replace_neg_inf] ])) assert sc.is_equal(b, expected)