我们从Python开源项目中，提取了以下40个代码示例，用于说明如何使用numpy.ComplexWarning()。
def test_ticket_1539(self): dtypes = [x for x in np.typeDict.values() if (issubclass(x, np.number) and not issubclass(x, np.timedelta64))] a = np.array([], dtypes[0]) failures = [] # ignore complex warnings with warnings.catch_warnings(): warnings.simplefilter('ignore', np.ComplexWarning) for x in dtypes: b = a.astype(x) for y in dtypes: c = a.astype(y) try: np.dot(b, c) except TypeError: failures.append((x, y)) if failures: raise AssertionError("Failures: %r" % failures)
def test_boolean_index_cast_assign(self): # Setup the boolean index and float arrays. shape = (8, 63) bool_index = np.zeros(shape).astype(bool) bool_index[0, 1] = True zero_array = np.zeros(shape) # Assigning float is fine. zero_array[bool_index] = np.array([1]) assert_equal(zero_array[0, 1], 1) # Fancy indexing works, although we get a cast warning. assert_warns(np.ComplexWarning, zero_array.__setitem__, ([0], [1]), np.array([2 + 1j])) assert_equal(zero_array[0, 1], 2) # No complex part # Cast complex to float, throwing away the imaginary portion. assert_warns(np.ComplexWarning, zero_array.__setitem__, bool_index, np.array([1j])) assert_equal(zero_array[0, 1], 0)
def test_dtype_from_dtype(self): mat = np.eye(3) codes = 'efdgFDG' for nf, rf in zip(self.nanfuncs, self.stdfuncs): for c in codes: with suppress_warnings() as sup: if nf in {np.nanstd, np.nanvar} and c in 'FDG': # Giving the warning is a small bug, see gh-8000 sup.filter(np.ComplexWarning) tgt = rf(mat, dtype=np.dtype(c), axis=1).dtype.type res = nf(mat, dtype=np.dtype(c), axis=1).dtype.type assert_(res is tgt) # scalar case tgt = rf(mat, dtype=np.dtype(c), axis=None).dtype.type res = nf(mat, dtype=np.dtype(c), axis=None).dtype.type assert_(res is tgt)
def test_ddof_too_big(self): nanfuncs = [np.nanvar, np.nanstd] stdfuncs = [np.var, np.std] dsize = [len(d) for d in _rdat] for nf, rf in zip(nanfuncs, stdfuncs): for ddof in range(5): with suppress_warnings() as sup: sup.record(RuntimeWarning) sup.filter(np.ComplexWarning) tgt = [ddof >= d for d in dsize] res = nf(_ndat, axis=1, ddof=ddof) assert_equal(np.isnan(res), tgt) if any(tgt): assert_(len(sup.log) == 1) else: assert_(len(sup.log) == 0)
def perform(self, node, inputs, outputs): # Kalbfleisch and Lawless, J. Am. Stat. Assoc. 80 (1985) Equation 3.4 # Kind of... You need to do some algebra from there to arrive at # this expression. (A, gA) = inputs (out,) = outputs w, V = scipy.linalg.eig(A, right=True) U = scipy.linalg.inv(V).T exp_w = numpy.exp(w) X = numpy.subtract.outer(exp_w, exp_w) / numpy.subtract.outer(w, w) numpy.fill_diagonal(X, exp_w) Y = U.dot(V.T.dot(gA).dot(U) * X).dot(V.T) with warnings.catch_warnings(): warnings.simplefilter("ignore", numpy.ComplexWarning) out[0] = Y.astype(A.dtype)
def test_complex_scalar_warning(self): for tp in [np.csingle, np.cdouble, np.clongdouble]: x = tp(1+2j) assert_warns(np.ComplexWarning, float, x) with warnings.catch_warnings(): warnings.simplefilter('ignore') assert_equal(float(x), float(x.real))
def test_iter_buffered_cast_byteswapped(): # Test that buffering can handle a cast which requires swap->cast->swap a = np.arange(10, dtype='f4').newbyteorder().byteswap() i = nditer(a, ['buffered', 'external_loop'], [['readwrite', 'nbo', 'aligned']], casting='same_kind', op_dtypes=[np.dtype('f8').newbyteorder()], buffersize=3) for v in i: v[...] *= 2 assert_equal(a, 2*np.arange(10, dtype='f4')) try: warnings.simplefilter("ignore", np.ComplexWarning) a = np.arange(10, dtype='f8').newbyteorder().byteswap() i = nditer(a, ['buffered', 'external_loop'], [['readwrite', 'nbo', 'aligned']], casting='unsafe', op_dtypes=[np.dtype('c8').newbyteorder()], buffersize=3) for v in i: v[...] *= 2 assert_equal(a, 2*np.arange(10, dtype='f8')) finally: warnings.simplefilter("default", np.ComplexWarning)
def test_complex_warning(self): x = np.array([1, 2]) y = np.array([1-2j, 1+2j]) with warnings.catch_warnings(): warnings.simplefilter("error", np.ComplexWarning) assert_raises(np.ComplexWarning, x.__setitem__, slice(None), y) assert_equal(x, [1, 2])
def test_pad_default(self, xp, dtype): array = xp.array(self.array, dtype=dtype) # Older version of NumPy(<1.12) can emit ComplexWarning def f(): return xp.pad(array, self.pad_width, mode=self.mode) if xp is numpy: with warnings.catch_warnings(): warnings.simplefilter('ignore', numpy.ComplexWarning) return f() else: return f()
def test_pad(self, xp, dtype): array = xp.array(self.array, dtype=dtype) # Older version of NumPy(<1.12) can emit ComplexWarning def f(): return xp.pad(array, self.pad_width, mode=self.mode, constant_values=self.constant_values) if xp is numpy: with warnings.catch_warnings(): warnings.simplefilter('ignore', numpy.ComplexWarning) return f() else: return f()
def test_complex_scalar_warning(self): for tp in [np.csingle, np.cdouble, np.clongdouble]: x = tp(1+2j) assert_warns(np.ComplexWarning, float, x) with suppress_warnings() as sup: sup.filter(np.ComplexWarning) assert_equal(float(x), float(x.real))
def test_iter_buffered_cast_byteswapped(): # Test that buffering can handle a cast which requires swap->cast->swap a = np.arange(10, dtype='f4').newbyteorder().byteswap() i = nditer(a, ['buffered', 'external_loop'], [['readwrite', 'nbo', 'aligned']], casting='same_kind', op_dtypes=[np.dtype('f8').newbyteorder()], buffersize=3) for v in i: v[...] *= 2 assert_equal(a, 2*np.arange(10, dtype='f4')) with suppress_warnings() as sup: sup.filter(np.ComplexWarning) a = np.arange(10, dtype='f8').newbyteorder().byteswap() i = nditer(a, ['buffered', 'external_loop'], [['readwrite', 'nbo', 'aligned']], casting='unsafe', op_dtypes=[np.dtype('c8').newbyteorder()], buffersize=3) for v in i: v[...] *= 2 assert_equal(a, 2*np.arange(10, dtype='f8'))
def conv(self, img, kern, mode="valid", dilation=1): """ Basic slow Python 2D or 3D convolution for DebugMode """ if not imported_scipy_signal: raise NotImplementedError( "AbstractConv perform requires the python package" " for scipy.signal to be installed.") if not (mode in ('valid', 'full')): raise ValueError( 'invalid mode {}, which must be either ' '"valid" or "full"'.format(mode)) if isinstance(dilation, integer_types): dilation = (dilation,) * self.convdim if len(dilation) != self.convdim: raise ValueError( 'invalid dilation {}, expected {} values'.format(dilation, self.convdim)) out_shape = get_conv_output_shape(img.shape, kern.shape, mode, [1] * self.convdim, dilation) out = numpy.zeros(out_shape, dtype=img.dtype) dil_kern_shp = kern.shape[:-self.convdim] + tuple( (kern.shape[-self.convdim + i] - 1) * dilation[i] + 1 for i in range(self.convdim)) dilated_kern = numpy.zeros(dil_kern_shp, dtype=kern.dtype) dilated_kern[(slice(None), slice(None)) + tuple(slice(None, None, dilation[i]) for i in range(self.convdim)) ] = kern if self.convdim == 2: val = _valfrommode(mode) bval = _bvalfromboundary('fill') with warnings.catch_warnings(): warnings.simplefilter('ignore', numpy.ComplexWarning) for b in xrange(img.shape[0]): for n in xrange(kern.shape[0]): for im0 in xrange(img.shape[1]): # some cast generates a warning here out[b, n, ...] += _convolve2d(img[b, im0, ...], dilated_kern[n, im0, ...], 1, val, bval, 0) elif self.convdim == 3: for b in xrange(img.shape[0]): for n in xrange(kern.shape[0]): for im0 in xrange(img.shape[1]): out[b, n, ...] += convolve(img[b, im0, ...], dilated_kern[n, im0, ...], mode) else: raise NotImplementedError('only 2D and 3D convolution are implemented') return out
