Python testing.assert_array_equal方法代码示例

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_linear_sum_assignment_input_validation():
    assert_raises(ValueError, linear_sum_assignment, [1, 2, 3])

    C = [[1, 2, 3], [4, 5, 6]]
    assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(np.asarray(C)))
    # assert_array_equal(linear_sum_assignment(C),
    #                    linear_sum_assignment(matrix(C)))

    I = np.identity(3)
    assert_array_equal(linear_sum_assignment(I.astype(np.bool)), linear_sum_assignment(I))
    assert_raises(ValueError, linear_sum_assignment, I.astype(str))

    I[0][0] = np.nan
    assert_raises(ValueError, linear_sum_assignment, I)

    I = np.identity(3)
    I[1][1] = np.inf
    assert_raises(ValueError, linear_sum_assignment, I) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_pickle():
    import pickle
    a = npc.Array.from_ndarray(arr, [lc, lc_add.conj()])
    b = random_Array((20, 15, 10), chinfo2, sort=False)
    a.test_sanity()
    b.test_sanity()
    aflat = a.to_ndarray()
    bflat = b.to_ndarray()
    data = {'a': a, 'b': b}
    stream = pickle.dumps(data)
    data2 = pickle.loads(stream)
    a2 = data2['a']
    b2 = data2['b']
    a.test_sanity()
    b.test_sanity()
    a2.test_sanity()
    b2.test_sanity()
    a2flat = a2.to_ndarray()
    b2flat = b2.to_ndarray()
    npt.assert_array_equal(aflat, a2flat)
    npt.assert_array_equal(bflat, b2flat) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_logsol(self):
        # Test conversion tools related to log solar luminosity
        from astroNN.gaia import fakemag_to_logsol, absmag_to_logsol, logsol_to_absmag, logsol_to_fakemag
        self.assertEqual(logsol_to_fakemag(fakemag_to_logsol(100.)), 100.)
        npt.assert_array_equal(logsol_to_fakemag(fakemag_to_logsol([100., 100.])), [100., 100.])
        npt.assert_array_equal(logsol_to_fakemag(fakemag_to_logsol(np.array([100, 100, 100]))), [100., 100., 100.])
        self.assertEqual(fakemag_to_logsol(MAGIC_NUMBER), MAGIC_NUMBER)
        self.assertEqual(logsol_to_fakemag(fakemag_to_logsol(MAGIC_NUMBER)), MAGIC_NUMBER)
        self.assertEqual(np.any(fakemag_to_logsol([MAGIC_NUMBER, 1000]) == MAGIC_NUMBER), True)

        self.assertEqual(logsol_to_absmag(absmag_to_logsol(99.)), 99.)
        self.assertAlmostEqual(logsol_to_absmag(absmag_to_logsol(-99.)), -99.)
        npt.assert_array_equal(logsol_to_absmag(absmag_to_logsol([99., 99.])), [99., 99.])
        npt.assert_array_almost_equal(logsol_to_absmag(absmag_to_logsol([-99., -99.])), [-99., -99.])
        npt.assert_array_almost_equal(logsol_to_absmag(absmag_to_logsol(np.array([99., 99., 99.]))), [99., 99., 99.])
        self.assertEqual(absmag_to_logsol(MAGIC_NUMBER), MAGIC_NUMBER)
        self.assertEqual(logsol_to_absmag(absmag_to_logsol(MAGIC_NUMBER)), MAGIC_NUMBER)
        self.assertEqual(np.any(absmag_to_logsol([MAGIC_NUMBER, 1000]) == MAGIC_NUMBER), True) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_nio_NCFile_variable_append(self):
        iobackend.set_backend('Nio')
        ncf = iobackend.NCFile(self.ncfaname, mode='a')
        nt = self.ncdims['t']
        t = ncf.variables['t']
        t[nt:] = self.t2
        v = ncf.variables['v']
        v[nt:, :] = self.v2
        ncf.close()
        ncfr = Nio.open_file(self.ncfaname)
        actual = ncfr.variables['t'][:]
        expected = np.concatenate((self.t, self.t2))
        print_test_msg('NCVariable append', actual=actual, expected=expected)
        npt.assert_array_equal(actual, expected, 'NCFile t-variable incorrect')
        actual = ncfr.variables['v'][:]
        expected = np.concatenate((self.v, self.v2))
        print_test_msg('NCVariable append', actual=actual, expected=expected)
        npt.assert_array_equal(
            actual, expected, 'NCFile 2d-variable incorrect')
        ncfr.close() 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_nc4_NCFile_variable_append(self):
        iobackend.set_backend('netCDF4')
        ncf = iobackend.NCFile(self.ncfaname, mode='a')
        nt = self.ncdims['t']
        t = ncf.variables['t']
        t[nt:] = self.t2
        v = ncf.variables['v']
        v[nt:, :] = self.v2
        ncf.close()
        ncfr = Nio.open_file(self.ncfaname)
        actual = ncfr.variables['t'][:]
        expected = np.concatenate((self.t, self.t2))
        print_test_msg('NCVariable append', actual=actual, expected=expected)
        npt.assert_array_equal(actual, expected, 'NCFile t-variable incorrect')
        actual = ncfr.variables['v'][:]
        expected = np.concatenate((self.v, self.v2))
        print_test_msg('NCVariable append', actual=actual, expected=expected)
        npt.assert_array_equal(
            actual, expected, 'NCFile 2d-variable incorrect')
        ncfr.close() 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_distance_mask_grid():
    "Check that the mask works for grid input"
    region = (0, 5, -10, -4)
    shape = (7, 6)
    east, north = grid_coordinates(region, shape=shape)
    coords = {"easting": east[0, :], "northing": north[:, 0]}
    data_vars = {"scalars": (["northing", "easting"], np.ones(shape))}
    grid = xr.Dataset(data_vars, coords=coords)
    masked = distance_mask((2.5, -7.5), maxdist=2, grid=grid)
    true = [
        [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
        [np.nan, np.nan, 1, 1, np.nan, np.nan],
        [np.nan, 1, 1, 1, 1, np.nan],
        [np.nan, 1, 1, 1, 1, np.nan],
        [np.nan, np.nan, 1, 1, np.nan, np.nan],
        [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
        [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
    ]
    npt.assert_array_equal(true, masked.scalars.values) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def check_pow(self, lhs, arith1, rhs):
        ex = 'lhs {0} rhs'.format(arith1)
        expected = self.get_expected_pow_result(lhs, rhs)
        result = pd.eval(ex, engine=self.engine, parser=self.parser)

        if (np.isscalar(lhs) and np.isscalar(rhs) and
                _is_py3_complex_incompat(result, expected)):
            self.assertRaises(AssertionError, assert_array_equal, result,
                              expected)
        else:
            assert_allclose(result, expected)

            ex = '(lhs {0} rhs) {0} rhs'.format(arith1)
            result = pd.eval(ex, engine=self.engine, parser=self.parser)
            expected = self.get_expected_pow_result(
                self.get_expected_pow_result(lhs, rhs), rhs)
            assert_allclose(result, expected) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_split_streamline():
    streamlines = dts.Streamlines([np.array([[1.,2.,3.],
                                    [4.,5.,6.]]),
                                   np.array([[7.,8.,9.],
                                    [10.,11.,12.],
                                    [13., 14., 15.]])])
    assert streamlines == streamlines
    sl_to_split = 1
    split_idx = 1
    new_streamlines = aus.split_streamline(streamlines, sl_to_split, split_idx)
    test_streamlines = dts.Streamlines([np.array([[1., 2., 3.],
                                                  [4., 5., 6.]]),
                                        np.array([[7., 8., 9.]]),
                                        np.array([[10., 11., 12.],
                                                  [13., 14., 15.]])])

    # Test equality of the underlying dict items:
    for k in new_streamlines.__dict__.keys():
        if isinstance(new_streamlines.__dict__[k], np.ndarray):
            npt.assert_array_equal(
                new_streamlines.__dict__[k],
                test_streamlines.__dict__[k]
                )
        else:
            assert new_streamlines.__dict__[k] == test_streamlines.__dict__[k] 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_add_bundles():
    t1 = nib.streamlines.Tractogram(
            [np.array([[0, 0, 0], [0, 0, 0.5], [0, 0, 1], [0, 0, 1.5]]),
             np.array([[0, 0, 0], [0, 0.5, 0.5], [0, 1, 1]])])

    t2 = nib.streamlines.Tractogram(
        [np.array([[0, 0, 0], [0, 0, 0.5], [0, 0, 1], [0, 0, 1.5]]),
            np.array([[0, 0, 0], [0, 0.5, 0.5], [0, 1, 1]])])

    added = aus.add_bundles(t1, t2)
    test_tgram =nib.streamlines.Tractogram(
        [np.array([[0, 0, 0], [0, 0, 0.5], [0, 0, 1], [0, 0, 1.5]]),
            np.array([[0, 0, 0], [0, 0.5, 0.5], [0, 1, 1]]),
            np.array([[0, 0, 0], [0, 0, 0.5], [0, 0, 1], [0, 0, 1.5]]),
            np.array([[0, 0, 0], [0, 0.5, 0.5], [0, 1, 1]])])

    for sl1, sl2 in zip(added.streamlines, test_tgram.streamlines):
        npt.assert_array_equal(sl1, sl2) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_gen_xrf_map_const_1():
    r"""Successful generation of XRF map"""

    element_groups = {"Fe_K": {'area': 800}, "Se_L": {'area': 900}, "W_M": {'area': 1000}}
    background_area = 1000
    nx, ny = 50, 100

    total_area = sum([_["area"] for _ in element_groups.values()])
    total_area += background_area

    xrf_map, xx = gen_xrf_map_const(element_groups, nx=nx, ny=ny,
                                    incident_energy=12.0, background_area=background_area)
    assert xrf_map.shape == (ny, nx, 4096), "Incorrect shape of generated XRF maps"
    assert xx.shape == (4096,), "Incorrect shape of energy axis"
    npt.assert_array_equal(xrf_map[0, 0, :], xrf_map[1, 1, :],
                           err_msg="Elements of XRF map are not equal")
    npt.assert_almost_equal(np.sum(xrf_map[0, 0, :]), total_area,
                            err_msg="Area of the generated spectrum does not match the expected value")

    # Test generation of XRF map with different size spectrum
    xrf_map, xx = gen_xrf_map_const(element_groups, nx=nx, ny=ny, n_spectrum_points=1000,
                                    incident_energy=12.0, background_area=background_area)
    assert xrf_map.shape == (ny, nx, 1000), "Incorrect shape of generated XRF maps"
    assert xx.shape == (1000,), "Incorrect shape of energy axis" 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_chunk_numpy_array(chunk_target, data_shape):
    """Basic functionailty tests for '_chunk_xrf_map_numpy"""

    data = np.random.random(data_shape)
    data_dask = _chunk_numpy_array(data, chunk_target)

    chunksize_expected = tuple([
        min(chunk_target[0], data_shape[0]),
        min(chunk_target[1], data_shape[1]),
        *data_shape[2:]])

    assert data_dask.shape == data.shape, "The shape of the original and chunked array don't match"
    assert data_dask.chunksize == chunksize_expected, \
        "The chunk size of the Dask array doesn't match the desired chunk size"
    npt.assert_array_equal(data_dask.compute(), data,
                           err_msg="The chunked array is different from the original array") 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_bbox_intersection():
    bbox_from_ext = mtrans.Bbox.from_extents
    inter = mtrans.Bbox.intersection

    from numpy.testing import assert_array_equal as assert_a_equal
    def assert_bbox_eq(bbox1, bbox2):
        assert_a_equal(bbox1.bounds, bbox2.bounds)

    r1 = bbox_from_ext(0, 0, 1, 1)
    r2 = bbox_from_ext(0.5, 0.5, 1.5, 1.5)
    r3 = bbox_from_ext(0.5, 0, 0.75, 0.75)
    r4 = bbox_from_ext(0.5, 1.5, 1, 2.5)
    r5 = bbox_from_ext(1, 1, 2, 2)

    # self intersection -> no change
    assert_bbox_eq(inter(r1, r1), r1)
    # simple intersection
    assert_bbox_eq(inter(r1, r2), bbox_from_ext(0.5, 0.5, 1, 1))
    # r3 contains r2
    assert_bbox_eq(inter(r1, r3), r3)
    # no intersection
    assert_equal(inter(r1, r4), None)
    # single point
    assert_bbox_eq(inter(r1, r5), bbox_from_ext(1, 1, 1, 1)) 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_dataframe_to_triples():
    X = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv')
    schema = [('species', 'has_sepal_length', 'sepal_length')]
    npt.assert_array_equal(dataframe_to_triples(X, schema)[0], 
                           np.array(['setosa', 'has_sepal_length', '5.1']))
    
    schema = [('species', 'has_sepal_length', 'abc')]
    try:
        dataframe_to_triples(X, schema)
    except:
        assert True
    
    schema = [('species', 'has_sepal_length', 'sepal_length')]
    try:
        dataframe_to_triples(X, schema)
    except:
        assert True 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_dim_dft(self):
        N = 16
        da = xr.DataArray(np.random.rand(N,N), dims=['x','y'],
                        coords={'x':range(N),'y':range(N)}
                         )
        npt.assert_array_equal(xrft.dft(da, dim='y', shift=False).values,
                              xrft.dft(da, dim=['y'], shift=False).values
                              )
        assert xrft.dft(da, dim='y').dims == ('x','freq_y') 

# 需要导入模块: from numpy import testing [as 别名]
# 或者: from numpy.testing import assert_array_equal [as 别名]
def test_dft_3d_dask(self, dask):
        """Test the discrete Fourier transform on 3D dask array data"""
        N=16
        da = xr.DataArray(np.random.rand(N,N,N), dims=['time','x','y'],
                          coords={'time':range(N),'x':range(N),
                                  'y':range(N)}
                         )
        if dask:
            da = da.chunk({'time': 1})
            daft = xrft.dft(da, dim=['x','y'], shift=False)
            npt.assert_almost_equal(daft.values,
                                   np.fft.fftn(da.chunk({'time': 1}).values,
                                              axes=[1,2])
                                   )
            da = da.chunk({'x': 1})
            with pytest.raises(ValueError):
                xrft.dft(da, dim=['x'])
            with pytest.raises(ValueError):
                xrft.dft(da, dim='x')

            da = da.chunk({'time':N})
            daft = xrft.dft(da, dim=['time'],
                           shift=False, detrend='linear')
            da_prime = sps.detrend(da, axis=0)
            npt.assert_almost_equal(daft.values,
                                   np.fft.fftn(da_prime, axes=[0])
                                   )
            npt.assert_array_equal(daft.values,
                                   xrft.dft(da, dim='time',
                                            shift=False, detrend='linear')
                                   )