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, 2)  # No complex part
 
        # Cast complex to float,throwing away the imaginary portion.
        assert_warns(np.ComplexWarning, bool_index, np.array([1j]))
        assert_equal(zero_array[0, 0)

def test_ticket_1539(self):
        dtypes = [x for x in np.typeDict.values()
                  if (issubclass(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, 0)

def test_ticket_1539(self):
        dtypes = [x for x in np.typeDict.values()
                  if (issubclass(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, 0)

def test_ticket_1539(self):
        dtypes = [x for x in np.typeDict.values()
                  if (issubclass(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, 0)

def test_ticket_1539(self):
        dtypes = [x for x in np.typeDict.values()
                  if (issubclass(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, 0)

def test_boolean_index_cast_assign(self):
        # Setup the boolean index and float arrays.
        shape = (8, 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, axis=1).dtype.type
                    assert_(res is tgt)
                    # scalar case
                    tgt = rf(mat, axis=None).dtype.type
                    res = nf(mat, 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_ticket_1539(self):
        dtypes = [x for x in np.typeDict.values()
                  if (issubclass(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, 0)

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,
                       [[''readwrite'',
                       casting=''unsafe'',
                       op_dtypes=[np.dtype(''c8'').newbyteorder()],
                       buffersize=3)
        for v in i:
            v[...] *= 2
 
        assert_equal(a, 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, 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, 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, np.ComplexWarning)

def test_complex_warning(self):
        x = np.array([1, 2])

def test_complex_scalar_warning(self):
        for tp in [np.csingle, 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, np.ComplexWarning)

def test_complex_warning(self):
        x = np.array([1, 2])

def test_complex_scalar_warning(self):
        for tp in [np.csingle, 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, np.ComplexWarning)

def test_complex_warning(self):
        x = np.array([1, 2])

def test_complex_scalar_warning(self):
        for tp in [np.csingle, 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, np.ComplexWarning)

def test_complex_warning(self):
        x = np.array([1, 2])

def test_complex_scalar_warning(self):
        for tp in [np.csingle, 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''))
 
    with suppress_warnings() as sup:
        sup.filter(np.ComplexWarning)
 
        a = np.arange(10, dtype=''f8''))

def test_complex_warning(self):
        x = np.array([1, 2])

def test_complex_scalar_warning(self):
        for tp in [np.csingle, 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, np.ComplexWarning)

def test_complex_warning(self):
        x = np.array([1, 2])

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,
                                                          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, ...] += convolve(img[b,
                                                   dilated_kern[n,
                                                   mode)
        else:
            raise NotImplementedError(''only 2D and 3D convolution are implemented'')
        return out