""" Test printing of scalar types.

"""
import pytest

import numpy as np
from numpy.testing import assert_, assert_raises



            

Reported by Pylint.

              
        # previously caused RecursionError!?
        with pytest.raises(TypeError):
            B1(1.0, 2.0)


class TestCharacter:
    def test_char_radd(self):
        # GH issue 9620, reached gentype_add and raise TypeError

            

Reported by Pylint.

                      np_u = np.unicode_('abc')
        s = b'def'
        u = u'def'
        assert_(np_s.__radd__(np_s) is NotImplemented)
        assert_(np_s.__radd__(np_u) is NotImplemented)
        assert_(np_s.__radd__(s) is NotImplemented)
        assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)

            

Reported by Pylint.

                      s = b'def'
        u = u'def'
        assert_(np_s.__radd__(np_s) is NotImplemented)
        assert_(np_s.__radd__(np_u) is NotImplemented)
        assert_(np_s.__radd__(s) is NotImplemented)
        assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)

            

Reported by Pylint.

                      u = u'def'
        assert_(np_s.__radd__(np_s) is NotImplemented)
        assert_(np_s.__radd__(np_u) is NotImplemented)
        assert_(np_s.__radd__(s) is NotImplemented)
        assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)
        assert_(np_u.__radd__(u) is NotImplemented)

            

Reported by Pylint.

                      assert_(np_s.__radd__(np_s) is NotImplemented)
        assert_(np_s.__radd__(np_u) is NotImplemented)
        assert_(np_s.__radd__(s) is NotImplemented)
        assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)
        assert_(np_u.__radd__(u) is NotImplemented)
        assert_(s + np_s == b'defabc')

            

Reported by Pylint.

                      assert_(np_s.__radd__(np_u) is NotImplemented)
        assert_(np_s.__radd__(s) is NotImplemented)
        assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)
        assert_(np_u.__radd__(u) is NotImplemented)
        assert_(s + np_s == b'defabc')
        assert_(u + np_u == u'defabc')

            

Reported by Pylint.

                      assert_(np_s.__radd__(s) is NotImplemented)
        assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)
        assert_(np_u.__radd__(u) is NotImplemented)
        assert_(s + np_s == b'defabc')
        assert_(u + np_u == u'defabc')


            

Reported by Pylint.

                      assert_(np_s.__radd__(u) is NotImplemented)
        assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)
        assert_(np_u.__radd__(u) is NotImplemented)
        assert_(s + np_s == b'defabc')
        assert_(u + np_u == u'defabc')

        class MyStr(str, np.generic):

            

Reported by Pylint.

                      assert_(np_u.__radd__(np_s) is NotImplemented)
        assert_(np_u.__radd__(np_u) is NotImplemented)
        assert_(np_u.__radd__(s) is NotImplemented)
        assert_(np_u.__radd__(u) is NotImplemented)
        assert_(s + np_s == b'defabc')
        assert_(u + np_u == u'defabc')

        class MyStr(str, np.generic):
            # would segfault

            

Reported by Pylint.

              if major == 0: BadListError = TypeError
else:          BadListError = ValueError

import SuperTensor

######################################################################

class SuperTensorTestCase(unittest.TestCase):


            

Reported by Pylint.

                  def testMax(self):
        "Test max function"
        print(self.typeStr, "... ", file=sys.stderr)
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        supertensor = [[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]]
        self.assertEqual(max(supertensor), 8)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxBadList(self):

            

Reported by Pylint.

                  def testMaxBadList(self):
        "Test max function with bad list"
        print(self.typeStr, "... ", file=sys.stderr)
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        supertensor = [[[[1, "two"], [3, 4]], [[5, "six"], [7, 8]]], [[[1, "two"], [3, 4]], [[5, "six"], [7, 8]]]]
        self.assertRaises(BadListError, max, supertensor)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxNonContainer(self):

            

Reported by Pylint.

                  def testMaxNonContainer(self):
        "Test max function with non-container"
        print(self.typeStr, "... ", file=sys.stderr)
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        self.assertRaises(TypeError, max, None)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxWrongDim(self):
        "Test max function with wrong dimensions"

            

Reported by Pylint.

                  def testMaxWrongDim(self):
        "Test max function with wrong dimensions"
        print(self.typeStr, "... ", file=sys.stderr)
        max = SuperTensor.__dict__[self.typeStr + "Max"]
        self.assertRaises(TypeError, max, [0, -1, 2, -3])

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMin(self):
        "Test min function"

            

Reported by Pylint.

                  def testMin(self):
        "Test min function"
        print(self.typeStr, "... ", file=sys.stderr)
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        supertensor = [[[[9, 8], [7, 6]], [[5, 4], [3, 2]]], [[[9, 8], [7, 6]], [[5, 4], [3, 2]]]]
        self.assertEqual(min(supertensor), 2)

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinBadList(self):

            

Reported by Pylint.

                  def testMinBadList(self):
        "Test min function with bad list"
        print(self.typeStr, "... ", file=sys.stderr)
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        supertensor = [[[["nine", 8], [7, 6]], [["five", 4], [3, 2]]], [[["nine", 8], [7, 6]], [["five", 4], [3, 2]]]]
        self.assertRaises(BadListError, min, supertensor)

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinNonContainer(self):

            

Reported by Pylint.

                  def testMinNonContainer(self):
        "Test min function with non-container"
        print(self.typeStr, "... ", file=sys.stderr)
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        self.assertRaises(TypeError, min, True)

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinWrongDim(self):
        "Test min function with wrong dimensions"

            

Reported by Pylint.

                  def testMinWrongDim(self):
        "Test min function with wrong dimensions"
        print(self.typeStr, "... ", file=sys.stderr)
        min = SuperTensor.__dict__[self.typeStr + "Min"]
        self.assertRaises(TypeError, min, [[1, 3], [5, 7]])

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    def testScale(self):
        "Test scale function"

            

Reported by Pylint.

              #!/usr/bin/env python3
# System imports
import sys
import unittest

# Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError

            

Reported by Pylint.

                  return m[::-1, ...]


def _eye_dispatcher(N, M=None, k=None, dtype=None, order=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return m[::-1, ...]


def _eye_dispatcher(N, M=None, k=None, dtype=None, order=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return m[::-1, ...]


def _eye_dispatcher(N, M=None, k=None, dtype=None, order=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return m[::-1, ...]


def _eye_dispatcher(N, M=None, k=None, dtype=None, order=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return m[::-1, ...]


def _eye_dispatcher(N, M=None, k=None, dtype=None, order=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

              )(eye)


def _diag_dispatcher(v, k=None):
    return (v,)


@array_function_dispatch(_diag_dispatcher)
def diag(v, k=0):

            

Reported by Pylint.

                  return wrap(res)


def _tri_dispatcher(N, M=None, k=None, dtype=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return wrap(res)


def _tri_dispatcher(N, M=None, k=None, dtype=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return wrap(res)


def _tri_dispatcher(N, M=None, k=None, dtype=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

                  return wrap(res)


def _tri_dispatcher(N, M=None, k=None, dtype=None, *, like=None):
    return (like,)


@set_array_function_like_doc
@set_module('numpy')

            

Reported by Pylint.

              import inspect
import sys
import pytest

from numpy.core import arange
from numpy.testing import assert_, assert_equal, assert_raises_regex
from numpy.lib import deprecate, deprecate_with_doc
import numpy.lib.utils as utils


            

Reported by Pylint.

              

def test_deprecate_decorator():
    assert_('deprecated' in old_func.__doc__)


def test_deprecate_decorator_message():
    assert_('Rather use new_func2' in old_func2.__doc__)


            

Reported by Pylint.

              

def test_deprecate_decorator_message():
    assert_('Rather use new_func2' in old_func2.__doc__)


def test_deprecate_fn():
    assert_('old_func3' in new_func3.__doc__)
    assert_('new_func3' in new_func3.__doc__)

            

Reported by Pylint.

              

def test_deprecate_with_doc_decorator_message():
    assert_('Rather use new_func7' in old_func7.__doc__)


@pytest.mark.skipif(sys.flags.optimize == 2, reason="-OO discards docstrings")
@pytest.mark.parametrize('old_func, new_func', [
    (old_func4, new_func4),

            

Reported by Pylint.

                      pass

    class WithPublicMethods:
        def first_method():
            pass

    def _has_method_heading(cls):
        out = StringIO()
        utils.info(cls, output=out)

            

Reported by Pylint.

                  utils.lookfor('eigenvalue', module='numpy', output=out,
                  import_modules=False)
    out = out.getvalue()
    assert_('numpy.linalg.eig' in out)


@deprecate
def old_func(self, x):
    return x

            

Reported by Pylint.

              

@deprecate
def old_func(self, x):
    return x


@deprecate(message="Rather use new_func2")
def old_func2(self, x):

            

Reported by Pylint.

              

@deprecate(message="Rather use new_func2")
def old_func2(self, x):
    return x


def old_func3(self, x):
    return x

            

Reported by Pylint.

                  return x


def old_func3(self, x):
    return x
new_func3 = deprecate(old_func3, old_name="old_func3", new_name="new_func3")


def old_func4(self, x):

            

Reported by Pylint.

              new_func3 = deprecate(old_func3, old_name="old_func3", new_name="new_func3")


def old_func4(self, x):
    """Summary.

    Further info.
    """
    return x

            

Reported by Pylint.

              if major == 0: BadListError = TypeError
else:          BadListError = ValueError

import Matrix

######################################################################

class MatrixTestCase(unittest.TestCase):


            

Reported by Pylint.

                  def testMax(self):
        "Test max function"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Matrix.__dict__[self.typeStr + "Max"]
        matrix = [[6, 5, 4], [3, 2, 1]]
        self.assertEqual(max(matrix), 6)

    # Test (type* IN_ARRAY2, int DIM1, int DIM2) typemap
    def testMaxBadList(self):

            

Reported by Pylint.

                  def testMaxBadList(self):
        "Test max function with bad list"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Matrix.__dict__[self.typeStr + "Max"]
        matrix = [[6, "five", 4], ["three", 2, "one"]]
        self.assertRaises(BadListError, max, matrix)

    # Test (type* IN_ARRAY2, int DIM1, int DIM2) typemap
    def testMaxNonContainer(self):

            

Reported by Pylint.

                  def testMaxNonContainer(self):
        "Test max function with non-container"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Matrix.__dict__[self.typeStr + "Max"]
        self.assertRaises(TypeError, max, None)

    # Test (type* IN_ARRAY2, int DIM1, int DIM2) typemap
    def testMaxWrongDim(self):
        "Test max function with wrong dimensions"

            

Reported by Pylint.

                  def testMaxWrongDim(self):
        "Test max function with wrong dimensions"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Matrix.__dict__[self.typeStr + "Max"]
        self.assertRaises(TypeError, max, [0, 1, 2, 3])

    # Test (int DIM1, int DIM2, type* IN_ARRAY2) typemap
    def testMin(self):
        "Test min function"

            

Reported by Pylint.

                  def testMin(self):
        "Test min function"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Matrix.__dict__[self.typeStr + "Min"]
        matrix = [[9, 8], [7, 6], [5, 4]]
        self.assertEqual(min(matrix), 4)

    # Test (int DIM1, int DIM2, type* IN_ARRAY2) typemap
    def testMinBadList(self):

            

Reported by Pylint.

                  def testMinBadList(self):
        "Test min function with bad list"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Matrix.__dict__[self.typeStr + "Min"]
        matrix = [["nine", "eight"], ["seven", "six"]]
        self.assertRaises(BadListError, min, matrix)

    # Test (int DIM1, int DIM2, type* IN_ARRAY2) typemap
    def testMinWrongDim(self):

            

Reported by Pylint.

                  def testMinWrongDim(self):
        "Test min function with wrong dimensions"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Matrix.__dict__[self.typeStr + "Min"]
        self.assertRaises(TypeError, min, [1, 3, 5, 7, 9])

    # Test (int DIM1, int DIM2, type* IN_ARRAY2) typemap
    def testMinNonContainer(self):
        "Test min function with non-container"

            

Reported by Pylint.

                  def testMinNonContainer(self):
        "Test min function with non-container"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Matrix.__dict__[self.typeStr + "Min"]
        self.assertRaises(TypeError, min, False)

    # Test (type INPLACE_ARRAY2[ANY][ANY]) typemap
    def testScale(self):
        "Test scale function"

            

Reported by Pylint.

              #!/usr/bin/env python3
# System imports
import sys
import unittest

# Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError

            

Reported by Pylint.

              if major == 0: BadListError = TypeError
else:          BadListError = ValueError

import Vector

######################################################################

class VectorTestCase(unittest.TestCase):


            

Reported by Pylint.

                  def testSum(self):
        "Test sum function"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        sum = Vector.__dict__[self.typeStr + "Sum"]
        self.assertEqual(sum([5, 6, 7, 8]), 26)

    # Test the (int DIM1, type* IN_ARRAY1) typemap
    def testSumBadList(self):
        "Test sum function with bad list"

            

Reported by Pylint.

                  def testSumBadList(self):
        "Test sum function with bad list"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        sum = Vector.__dict__[self.typeStr + "Sum"]
        self.assertRaises(BadListError, sum, [3, 4, 5, "pi"])

    # Test the (int DIM1, type* IN_ARRAY1) typemap
    def testSumWrongDim(self):
        "Test sum function with wrong dimensions"

            

Reported by Pylint.

                  def testSumWrongDim(self):
        "Test sum function with wrong dimensions"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        sum = Vector.__dict__[self.typeStr + "Sum"]
        self.assertRaises(TypeError, sum, [[3, 4], [5, 6]])

    # Test the (int DIM1, type* IN_ARRAY1) typemap
    def testSumNonContainer(self):
        "Test sum function with non-container"

            

Reported by Pylint.

                  def testSumNonContainer(self):
        "Test sum function with non-container"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        sum = Vector.__dict__[self.typeStr + "Sum"]
        self.assertRaises(TypeError, sum, True)

    # Test the (type INPLACE_ARRAY1[ANY]) typemap
    def testReverse(self):
        "Test reverse function"

            

Reported by Pylint.

              #!/usr/bin/env python3
# System imports
import sys
import unittest

# Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError

            

Reported by Pylint.

              #!/usr/bin/env python3
# System imports
import sys
import unittest

# Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError

            

Reported by Pylint.

              # Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
if major == 0: BadListError = TypeError
else:          BadListError = ValueError

import Vector

######################################################################

            

Reported by Pylint.

              if major == 0: BadListError = TypeError
else:          BadListError = ValueError

import Vector

######################################################################

class VectorTestCase(unittest.TestCase):


            

Reported by Pylint.

              
######################################################################

class VectorTestCase(unittest.TestCase):

    def __init__(self, methodName="runTest"):
        unittest.TestCase.__init__(self, methodName)
        self.typeStr  = "double"
        self.typeCode = "d"

            

Reported by Pylint.

              if major == 0: BadListError = TypeError
else:          BadListError = ValueError

import Tensor

######################################################################

class TensorTestCase(unittest.TestCase):


            

Reported by Pylint.

                  def testMax(self):
        "Test max function"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Tensor.__dict__[self.typeStr + "Max"]
        tensor = [[[1, 2], [3, 4]],
                  [[5, 6], [7, 8]]]
        self.assertEqual(max(tensor), 8)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap

            

Reported by Pylint.

                  def testMaxBadList(self):
        "Test max function with bad list"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Tensor.__dict__[self.typeStr + "Max"]
        tensor = [[[1, "two"], [3, 4]],
                  [[5, "six"], [7, 8]]]
        self.assertRaises(BadListError, max, tensor)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap

            

Reported by Pylint.

                  def testMaxNonContainer(self):
        "Test max function with non-container"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Tensor.__dict__[self.typeStr + "Max"]
        self.assertRaises(TypeError, max, None)

    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
    def testMaxWrongDim(self):
        "Test max function with wrong dimensions"

            

Reported by Pylint.

                  def testMaxWrongDim(self):
        "Test max function with wrong dimensions"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        max = Tensor.__dict__[self.typeStr + "Max"]
        self.assertRaises(TypeError, max, [0, -1, 2, -3])

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMin(self):
        "Test min function"

            

Reported by Pylint.

                  def testMin(self):
        "Test min function"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Tensor.__dict__[self.typeStr + "Min"]
        tensor = [[[9, 8], [7, 6]],
                  [[5, 4], [3, 2]]]
        self.assertEqual(min(tensor), 2)

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap

            

Reported by Pylint.

                  def testMinBadList(self):
        "Test min function with bad list"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Tensor.__dict__[self.typeStr + "Min"]
        tensor = [[["nine", 8], [7, 6]],
                  [["five", 4], [3, 2]]]
        self.assertRaises(BadListError, min, tensor)

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap

            

Reported by Pylint.

                  def testMinNonContainer(self):
        "Test min function with non-container"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Tensor.__dict__[self.typeStr + "Min"]
        self.assertRaises(TypeError, min, True)

    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
    def testMinWrongDim(self):
        "Test min function with wrong dimensions"

            

Reported by Pylint.

                  def testMinWrongDim(self):
        "Test min function with wrong dimensions"
        print(self.typeStr, "... ", end=' ', file=sys.stderr)
        min = Tensor.__dict__[self.typeStr + "Min"]
        self.assertRaises(TypeError, min, [[1, 3], [5, 7]])

    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
    def testScale(self):
        "Test scale function"

            

Reported by Pylint.

              #!/usr/bin/env python3
# System imports
from   math           import sqrt
import sys
import unittest

# Import NumPy
import numpy as np
major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]

            

Reported by Pylint.

              from .common import Benchmark

import numpy as np


class MA(Benchmark):
    def setup(self):
        self.l100 = range(100)
        self.t100 = ([True] * 100)

            

Reported by Pylint.

              
class MA(Benchmark):
    def setup(self):
        self.l100 = range(100)
        self.t100 = ([True] * 100)

    def time_masked_array(self):
        np.ma.masked_array()


            

Reported by Pylint.

              class MA(Benchmark):
    def setup(self):
        self.l100 = range(100)
        self.t100 = ([True] * 100)

    def time_masked_array(self):
        np.ma.masked_array()

    def time_masked_array_l100(self):

            

Reported by Pylint.

                      x = np.arange(size**ndim).reshape(ndim * (size,))

        if masked:
            self.m = np.ma.array(x, mask=x%2 == 0)
        else:
            self.m = np.ma.array(x)

        self.idx_scalar = (size//2,) * ndim
        self.idx_0d = (size//2,) * ndim + (Ellipsis,)

            

Reported by Pylint.

                      if masked:
            self.m = np.ma.array(x, mask=x%2 == 0)
        else:
            self.m = np.ma.array(x)

        self.idx_scalar = (size//2,) * ndim
        self.idx_0d = (size//2,) * ndim + (Ellipsis,)
        self.idx_1d = (size//2,) * (ndim - 1)


            

Reported by Pylint.

                      else:
            self.m = np.ma.array(x)

        self.idx_scalar = (size//2,) * ndim
        self.idx_0d = (size//2,) * ndim + (Ellipsis,)
        self.idx_1d = (size//2,) * (ndim - 1)

    def time_scalar(self, masked, ndim, size):
        self.m[self.idx_scalar]

            

Reported by Pylint.

                          self.m = np.ma.array(x)

        self.idx_scalar = (size//2,) * ndim
        self.idx_0d = (size//2,) * ndim + (Ellipsis,)
        self.idx_1d = (size//2,) * (ndim - 1)

    def time_scalar(self, masked, ndim, size):
        self.m[self.idx_scalar]


            

Reported by Pylint.

              
        self.idx_scalar = (size//2,) * ndim
        self.idx_0d = (size//2,) * ndim + (Ellipsis,)
        self.idx_1d = (size//2,) * (ndim - 1)

    def time_scalar(self, masked, ndim, size):
        self.m[self.idx_scalar]

    def time_0d(self, masked, ndim, size):

            

Reported by Pylint.

                      self.idx_0d = (size//2,) * ndim + (Ellipsis,)
        self.idx_1d = (size//2,) * (ndim - 1)

    def time_scalar(self, masked, ndim, size):
        self.m[self.idx_scalar]

    def time_0d(self, masked, ndim, size):
        self.m[self.idx_0d]


            

Reported by Pylint.

                      self.idx_0d = (size//2,) * ndim + (Ellipsis,)
        self.idx_1d = (size//2,) * (ndim - 1)

    def time_scalar(self, masked, ndim, size):
        self.m[self.idx_scalar]

    def time_0d(self, masked, ndim, size):
        self.m[self.idx_0d]


            

Reported by Pylint.

              from .common import Benchmark

import numpy as np


class Block(Benchmark):
    params = [1, 10, 100]
    param_names = ['size']


            

Reported by Pylint.

                  param_names = ['size']

    def setup(self, n):
        self.a_2d = np.ones((2 * n, 2 * n))
        self.b_1d = np.ones(2 * n)
        self.b_2d = 2 * self.a_2d

        self.a = np.ones(3 * n)
        self.b = np.ones(3 * n)

            

Reported by Pylint.

              
    def setup(self, n):
        self.a_2d = np.ones((2 * n, 2 * n))
        self.b_1d = np.ones(2 * n)
        self.b_2d = 2 * self.a_2d

        self.a = np.ones(3 * n)
        self.b = np.ones(3 * n)


            

Reported by Pylint.

                  def setup(self, n):
        self.a_2d = np.ones((2 * n, 2 * n))
        self.b_1d = np.ones(2 * n)
        self.b_2d = 2 * self.a_2d

        self.a = np.ones(3 * n)
        self.b = np.ones(3 * n)

        self.one_2d = np.ones((1 * n, 3 * n))

            

Reported by Pylint.

                      self.b_1d = np.ones(2 * n)
        self.b_2d = 2 * self.a_2d

        self.a = np.ones(3 * n)
        self.b = np.ones(3 * n)

        self.one_2d = np.ones((1 * n, 3 * n))
        self.two_2d = np.ones((1 * n, 3 * n))
        self.three_2d = np.ones((1 * n, 6 * n))

            

Reported by Pylint.

                      self.b_2d = 2 * self.a_2d

        self.a = np.ones(3 * n)
        self.b = np.ones(3 * n)

        self.one_2d = np.ones((1 * n, 3 * n))
        self.two_2d = np.ones((1 * n, 3 * n))
        self.three_2d = np.ones((1 * n, 6 * n))
        self.four_1d = np.ones(6 * n)

            

Reported by Pylint.

                      self.a = np.ones(3 * n)
        self.b = np.ones(3 * n)

        self.one_2d = np.ones((1 * n, 3 * n))
        self.two_2d = np.ones((1 * n, 3 * n))
        self.three_2d = np.ones((1 * n, 6 * n))
        self.four_1d = np.ones(6 * n)
        self.five_0d = np.ones(1 * n)
        self.six_1d = np.ones(5 * n)

            

Reported by Pylint.

                      self.b = np.ones(3 * n)

        self.one_2d = np.ones((1 * n, 3 * n))
        self.two_2d = np.ones((1 * n, 3 * n))
        self.three_2d = np.ones((1 * n, 6 * n))
        self.four_1d = np.ones(6 * n)
        self.five_0d = np.ones(1 * n)
        self.six_1d = np.ones(5 * n)
        # avoid np.zeros's lazy allocation that might cause

            

Reported by Pylint.

              
        self.one_2d = np.ones((1 * n, 3 * n))
        self.two_2d = np.ones((1 * n, 3 * n))
        self.three_2d = np.ones((1 * n, 6 * n))
        self.four_1d = np.ones(6 * n)
        self.five_0d = np.ones(1 * n)
        self.six_1d = np.ones(5 * n)
        # avoid np.zeros's lazy allocation that might cause
        # page faults during benchmark

            

Reported by Pylint.

                      self.one_2d = np.ones((1 * n, 3 * n))
        self.two_2d = np.ones((1 * n, 3 * n))
        self.three_2d = np.ones((1 * n, 6 * n))
        self.four_1d = np.ones(6 * n)
        self.five_0d = np.ones(1 * n)
        self.six_1d = np.ones(5 * n)
        # avoid np.zeros's lazy allocation that might cause
        # page faults during benchmark
        self.zero_2d = np.full((2 * n, 6 * n), 0)

            

Reported by Pylint.

              import inspect

import numpy
import nose
from nose.plugins import doctests as npd
from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name

            

Reported by Pylint.

              
import numpy
import nose
from nose.plugins import doctests as npd
from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest

            

Reported by Pylint.

              import numpy
import nose
from nose.plugins import doctests as npd
from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest


            

Reported by Pylint.

              import nose
from nose.plugins import doctests as npd
from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest



            

Reported by Pylint.

              from nose.plugins import doctests as npd
from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest


# Some of the classes in this module begin with 'Numpy' to clearly distinguish

            

Reported by Pylint.

              from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest


# Some of the classes in this module begin with 'Numpy' to clearly distinguish
# them from the plethora of very similar names from nose/unittest/doctest

            

Reported by Pylint.

              from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest


# Some of the classes in this module begin with 'Numpy' to clearly distinguish
# them from the plethora of very similar names from nose/unittest/doctest


            

Reported by Pylint.

                  """

    def prepareTestCase(self, test):
        from numpy.core._multiarray_tests import get_fpu_mode

        def run(result):
            old_mode = get_fpu_mode()
            test.test(result)
            new_mode = get_fpu_mode()

            

Reported by Pylint.

                      to return it to the user, override TestProgram.runTests to retain
        the result
        """
        if self.testRunner is None:
            self.testRunner = nose.core.TextTestRunner(stream=self.config.stream,
                                                       verbosity=self.config.verbosity,
                                                       config=self.config)
        plug_runner = self.config.plugins.prepareTestRunner(self.testRunner)
        if plug_runner is not None:

            

Reported by Pylint.

              from nose.plugins.base import Plugin
from nose.util import src
from .nosetester import get_package_name
from .utils import KnownFailureException, KnownFailureTest


# Some of the classes in this module begin with 'Numpy' to clearly distinguish
# them from the plethora of very similar names from nose/unittest/doctest


            

Reported by Pylint.