def ediff1d(x1, to_end=None, to_begin=None): """ The differences between consecutive elements of an array. For full documentation refer to :obj:`numpy.ediff1d`. Limitations ----------- Parameter ``x1``, ``to_begin``, ``to_end`` are supported as :obj:`dpnp.ndarray`. Otherwise the function will be executed sequentially on CPU. Input array data types are limited by supported DPNP :ref:`Data types`. ..seealso:: :obj:`dpnp.diff` : Calculate the n-th discrete difference along the given axis. Examples -------- >>> import dpnp as np >>> a = np.array([1, 2, 4, 7, 0]) >>> result = np.ediff1d(a) >>> [x for x in result] [1, 2, 3, -7] >>> result = np.ediff1d(a, to_begin=np.array([-99, -88]), to_end=np.array([88, 99])) >>> [x for x in result] [-99, -88, 1, 2, 3, -7, 88, 99] >>> b = np.array([[1, 2, 4], [1, 6, 24]]) >>> result = np.ediff1d(b) >>> [x for x in result] [1, 2, -3, 5, 18] """ if not use_origin_backend(x1): if not isinstance(x1, dparray): pass elif not isinstance(to_end, dparray) and to_end is not None: pass elif not isinstance(to_begin, dparray) and to_begin is not None: pass else: if to_end is None: to_end = dpnp.empty(0, dtype=x1.dtype) if to_begin is None: to_begin = dpnp.empty(0, dtype=x1.dtype) return dpnp_ediff1d(x1, to_end=to_end, to_begin=to_begin) return call_origin(numpy.ediff1d, x1, to_end=to_end, to_begin=to_begin)
def test_invalid_dtype(self, dtype): dp_array = dpnp.arange(10, dtype=dpnp.float64) dp_out = dpnp.empty(10, dtype=dtype) with pytest.raises(ValueError): dpnp.sin(dp_array, out=dp_out)
def test_invalid_shape(self, shape): dp_array = dpnp.arange(10, dtype=dpnp.float64) dp_out = dpnp.empty(shape, dtype=dpnp.float64) with pytest.raises(ValueError): dpnp.arctan2(dp_array, dp_array, out=dp_out)
def test_empty_int_huge_size_fill0(self): a = cupy.empty(2**31, dtype='b') a.fill(0) self.assertTrue((a == 0).all()) # Free huge memory for slow test del a cupy.get_default_memory_pool().free_all_blocks()
def test_empty_huge_size(self): a = cupy.empty((1024, 2048, 1024), dtype='b') a.fill(123) self.assertTrue((a == 123).all()) # Free huge memory for slow test del a cupy.get_default_memory_pool().free_all_blocks()
def test_invalid_shape(self, shape): dp_array1 = dpnp.arange(10, dtype=dpnp.float64) dp_array2 = dpnp.arange(5, 15, dtype=dpnp.float64) dp_out = dpnp.empty(shape, dtype=dpnp.float64) with pytest.raises(ValueError): dpnp.power(dp_array1, dp_array2, out=dp_out)
def test_empty_like_reshape_cupy_only(self, dtype, order): a = testing.shaped_arange((2, 3, 4), cupy, dtype) b = cupy.empty_like(a, shape=self.shape) b.fill(0) c = cupy.empty(self.shape, order=order, dtype=dtype) c.fill(0) testing.assert_array_equal(b, c)
def test_copyto_dtype(in_obj, out_dtype): ndarr = numpy.array(in_obj) expected = numpy.empty(ndarr.size, dtype=out_dtype) numpy.copyto(expected, ndarr) dparr = dpnp.array(in_obj) result = dpnp.empty(dparr.size, dtype=out_dtype) dpnp.copyto(result, dparr) numpy.testing.assert_array_equal(result, expected)
def test_empty_like_reshape_contiguity_cupy_only(self, dtype, order): a = testing.shaped_arange((2, 3, 4), cupy, dtype) b = cupy.empty_like(a, order=order, shape=self.shape) b.fill(0) c = cupy.empty(self.shape) c.fill(0) if order in ['f', 'F']: self.assertTrue(b.flags.f_contiguous) else: self.assertTrue(b.flags.c_contiguous) testing.assert_array_equal(b, c)
def test_empty_like_reshape_contiguity2_cupy_only(self, dtype, order): a = testing.shaped_arange((2, 3, 4), cupy, dtype) a = cupy.asfortranarray(a) b = cupy.empty_like(a, order=order, shape=self.shape) b.fill(0) c = cupy.empty(self.shape) c.fill(0) shape = self.shape if not numpy.isscalar(self.shape) else ( self.shape, ) if (order in ['c', 'C'] or (order in ['k', 'K', None] and len(shape) != a.ndim)): self.assertTrue(b.flags.c_contiguous) else: self.assertTrue(b.flags.f_contiguous) testing.assert_array_equal(b, c)
def trapz(y, x=None, dx=1.0, **kwargs): """ Integrate along the given axis using the composite trapezoidal rule. For full documentation refer to :obj:`numpy.trapz`. Limitations ----------- Parameters ``y`` and ``x`` are supported as :obj:`dpnp.ndarray`. Keyword arguments ``kwargs`` are currently unsupported. Otherwise the functions will be executed sequentially on CPU. Input array data types are limited by supported DPNP :ref:`Data types`. Examples -------- >>> import dpnp as np >>> a = np.array([1, 2, 3]) >>> b = np.array([4, 6, 8]) >>> np.trapz(a) 4.0 >>> np.trapz(a, x=b) 8.0 >>> np.trapz(a, dx=2) 8.0 """ if not use_origin_backend(y): if not isinstance(y, dparray): pass elif not isinstance(x, dparray) and x is not None: pass elif x is not None and y.size != x.size: pass elif x is not None and y.shape != x.shape: pass elif y.ndim > 1: pass else: if x is None: x = dpnp.empty(0, dtype=y.dtype) return dpnp_trapz(y, x, dx) return call_origin(numpy.trapz, y, x=x, dx=dx, **kwargs)
def test_cub_max(self, xp, dtype, axis): a = testing.shaped_random(self.shape, xp, dtype) if self.order in ('c', 'C'): a = xp.ascontiguousarray(a) elif self.order in ('f', 'F'): a = xp.asfortranarray(a) if xp is numpy: return a.max(axis=axis) # xp is cupy, first ensure we really use CUB ret = cupy.empty(()) # Cython checks return type, need to fool it if len(axis) == len(self.shape): func = 'cupy.core._routines_statistics.cub.device_reduce' else: func = 'cupy.core._routines_statistics.cub.device_segmented_reduce' with testing.AssertFunctionIsCalled(func, return_value=ret): a.max(axis=axis) # ...then perform the actual computation return a.max(axis=axis)
def test_isinstance_numpy_copy_wrong_shape(self): for xp in (numpy, cupy): a = numpy.arange(100, dtype=numpy.float64).reshape(10, 10) b = cupy.empty(100, dtype=a.dtype) with pytest.raises(ValueError): b[:] = a
def test_nansum_out_wrong_shape(self): a = testing.shaped_arange(self.shape) a[:, 1] = cupy.nan b = cupy.empty((2, 3)) with self.assertRaises(ValueError): cupy.nansum(a, axis=1, out=b)
def test_sum_out_wrong_shape(self): a = testing.shaped_arange((2, 3, 4)) b = cupy.empty((2, 3)) with self.assertRaises(ValueError): a.sum(axis=1, out=b)
def test_empty_zero_sized_array_strides(self, order): a = numpy.empty((1, 0, 2), dtype='d', order=order) b = cupy.empty((1, 0, 2), dtype='d', order=order) self.assertEqual(b.strides, a.strides)