newiter = (NpyIter*)PyObject_Malloc(size);

    /* Copy the raw values to the new iterator */
    memcpy(newiter, iter, size);

    /* Take ownership of references to the operands and dtypes */
    objects = NIT_OPERANDS(newiter);
    dtypes = NIT_DTYPES(newiter);
    for (iop = 0; iop < nop; ++iop) {

            

Reported by FlawFinder.

              npyiter_check_op_axes(int nop, int oa_ndim, int **op_axes,
                        const npy_intp *itershape)
{
    char axes_dupcheck[NPY_MAXDIMS];
    int iop, idim;

    if (oa_ndim < 0) {
        /*
         * If `oa_ndim < 0`, `op_axes` and `itershape` are signalled to

            

Reported by FlawFinder.

                      /* Need to fill the first axisdata, even if the iterator is 0-d */
        NAD_SHAPE(axisdata) = 1;
        NAD_INDEX(axisdata) = 0;
        memcpy(NAD_PTRS(axisdata), op_dataptr, NPY_SIZEOF_INTP*nop);
        memset(NAD_STRIDES(axisdata), 0, NPY_SIZEOF_INTP*nop);
    }

    /* Now process the operands, filling in the axisdata */
    for (idim = 0; idim < ndim; ++idim) {

            

Reported by FlawFinder.

              
        NAD_SHAPE(axisdata) = bshape;
        NAD_INDEX(axisdata) = 0;
        memcpy(NAD_PTRS(axisdata), op_dataptr, NPY_SIZEOF_INTP*nop);

        for (iop = 0; iop < nop; ++iop) {
            op_cur = op[iop];

            if (op_axes == NULL || op_axes[iop] == NULL) {

            

Reported by FlawFinder.

                              }
            }

            if (transferinfo[iop].read.func != NULL) {
                if (out_of_memory) {
                    transferinfo[iop].read.func = NULL;  /* No cleanup */
                }
                else {
                    if (NPY_cast_info_copy(&transferinfo[iop].read,

            

Reported by FlawFinder.

              
            if (transferinfo[iop].read.func != NULL) {
                if (out_of_memory) {
                    transferinfo[iop].read.func = NULL;  /* No cleanup */
                }
                else {
                    if (NPY_cast_info_copy(&transferinfo[iop].read,
                                           &transferinfo[iop].read) < 0) {
                        out_of_memory = 1;

            

Reported by FlawFinder.

                                  transferinfo[iop].read.func = NULL;  /* No cleanup */
                }
                else {
                    if (NPY_cast_info_copy(&transferinfo[iop].read,
                                           &transferinfo[iop].read) < 0) {
                        out_of_memory = 1;
                    }
                }
            }

            

Reported by FlawFinder.

                              }
                else {
                    if (NPY_cast_info_copy(&transferinfo[iop].read,
                                           &transferinfo[iop].read) < 0) {
                        out_of_memory = 1;
                    }
                }
            }


            

Reported by FlawFinder.

                      NpyIter_TransferInfo *transferinfo = NBF_TRANSFERINFO(bufferdata);
        /* read bufferdata */
        for (iop = 0; iop < nop; ++iop, ++transferinfo) {
            NPY_cast_info_xfree(&transferinfo->read);
            NPY_cast_info_xfree(&transferinfo->write);
        }
    }

    /*

            

Reported by FlawFinder.

                                                      PyArray_DESCR(op[iop]),
                                        op_dtype[iop],
                                        move_references,
                                        &transferinfo[iop].read,
                                        &needs_api) != NPY_SUCCEED) {
                    iop -= 1;  /* This one cannot be cleaned up yet. */
                    goto fail;
                }
            }

            

Reported by FlawFinder.

                  """Prints new casts, the values given are default "can-cast" values, not
    actual ones.
    """
    from numpy.core._multiarray_tests import get_all_cast_information

    cast_table = {
        0 : "#",  # No cast (classify as equivalent here)
        1 : "#",  # equivalent casting
        2 : "=",  # safe casting

            

Reported by Pylint.

              
"""
import numpy as np
from collections import namedtuple

# Generic object that can be added, but doesn't do anything else
class GenericObject:
    def __init__(self, v):
        self.v = v

            

Reported by Pylint.

              from collections import namedtuple

# Generic object that can be added, but doesn't do anything else
class GenericObject:
    def __init__(self, v):
        self.v = v

    def __add__(self, other):
        return self

            

Reported by Pylint.

              # Generic object that can be added, but doesn't do anything else
class GenericObject:
    def __init__(self, v):
        self.v = v

    def __add__(self, other):
        return self

    def __radd__(self, other):

            

Reported by Pylint.

              
    dtype = np.dtype('O')

def print_cancast_table(ntypes):
    print('X', end=' ')
    for char in ntypes:
        print(char, end=' ')
    print()
    for row in ntypes:

            

Reported by Pylint.

                          print(cast, end=' ')
        print()

def print_coercion_table(ntypes, inputfirstvalue, inputsecondvalue, firstarray, use_promote_types=False):
    print('+', end=' ')
    for char in ntypes:
        print(char, end=' ')
    print()
    for row in ntypes:

            

Reported by Pylint.

                          print(cast, end=' ')
        print()

def print_coercion_table(ntypes, inputfirstvalue, inputsecondvalue, firstarray, use_promote_types=False):
    print('+', end=' ')
    for char in ntypes:
        print(char, end=' ')
    print()
    for row in ntypes:

            

Reported by Pylint.

                          print(cast, end=' ')
        print()

def print_coercion_table(ntypes, inputfirstvalue, inputsecondvalue, firstarray, use_promote_types=False):
    print('+', end=' ')
    for char in ntypes:
        print(char, end=' ')
    print()
    for row in ntypes:

            

Reported by Pylint.

                      print()


def print_new_cast_table(*, can_cast=True, legacy=False, flags=False):
    """Prints new casts, the values given are default "can-cast" values, not
    actual ones.
    """
    from numpy.core._multiarray_tests import get_all_cast_information


            

Reported by Pylint.

                      print()


def print_new_cast_table(*, can_cast=True, legacy=False, flags=False):
    """Prints new casts, the values given are default "can-cast" values, not
    actual ones.
    """
    from numpy.core._multiarray_tests import get_all_cast_information


            

Reported by Pylint.

              
def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    from numpy.distutils.system_info import (
            get_info, system_info, lapack_opt_info, blas_opt_info)
    config = Configuration('linalg', parent_package, top_path)

    config.add_subpackage('tests')


            

Reported by Pylint.

              
def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    from numpy.distutils.system_info import (
            get_info, system_info, lapack_opt_info, blas_opt_info)
    config = Configuration('linalg', parent_package, top_path)

    config.add_subpackage('tests')


            

Reported by Pylint.

              
        lapack_info = numpy_linalg_lapack_lite().get_info(2)

    def get_lapack_lite_sources(ext, build_dir):
        if use_lapack_lite:
            print("### Warning:  Using unoptimized lapack ###")
            return all_sources
        else:
            if sys.platform == 'win32':

            

Reported by Pylint.

              
        lapack_info = numpy_linalg_lapack_lite().get_info(2)

    def get_lapack_lite_sources(ext, build_dir):
        if use_lapack_lite:
            print("### Warning:  Using unoptimized lapack ###")
            return all_sources
        else:
            if sys.platform == 'win32':

            

Reported by Pylint.

              import os
import sys

def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    from numpy.distutils.system_info import (
            get_info, system_info, lapack_opt_info, blas_opt_info)
    config = Configuration('linalg', parent_package, top_path)


            

Reported by Pylint.

              import os
import sys

def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    from numpy.distutils.system_info import (
            get_info, system_info, lapack_opt_info, blas_opt_info)
    config = Configuration('linalg', parent_package, top_path)


            

Reported by Pylint.

              import sys

def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    from numpy.distutils.system_info import (
            get_info, system_info, lapack_opt_info, blas_opt_info)
    config = Configuration('linalg', parent_package, top_path)

    config.add_subpackage('tests')

            

Reported by Pylint.

              
def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    from numpy.distutils.system_info import (
            get_info, system_info, lapack_opt_info, blas_opt_info)
    config = Configuration('linalg', parent_package, top_path)

    config.add_subpackage('tests')


            

Reported by Pylint.

                  if use_lapack_lite:
        # This makes numpy.distutils write the fact that lapack_lite
        # is being used to numpy.__config__
        class numpy_linalg_lapack_lite(system_info):
            def calc_info(self):
                info = {'language': 'c'}
                if sys.maxsize > 2**32:
                    # Build lapack-lite in 64-bit integer mode.
                    # The suffix is arbitrary (lapack_lite symbols follow it),

            

Reported by Pylint.

                  if use_lapack_lite:
        # This makes numpy.distutils write the fact that lapack_lite
        # is being used to numpy.__config__
        class numpy_linalg_lapack_lite(system_info):
            def calc_info(self):
                info = {'language': 'c'}
                if sys.maxsize > 2**32:
                    # Build lapack-lite in 64-bit integer mode.
                    # The suffix is arbitrary (lapack_lite symbols follow it),

            

Reported by Pylint.

              
#define _COPY_N_SIZE(size) \
    for(i=0; i<N; i++) { \
        memcpy(tout, tin, size); \
        tin += instrides; \
        tout += outstrides; \
    } \
    return


            

Reported by FlawFinder.

                            npy_intp srcstrides, int swap)
{
    if ((numitems == 1) || (itemsize == srcstrides)) {
        memcpy(dst, src, itemsize*numitems);
    }
    else {
        npy_intp i;
        char *s1 = (char *)src;
        char *d1 = (char *)dst;

            

Reported by FlawFinder.

                      char *d1 = (char *)dst;

        for (i = 0; i < numitems; i++) {
            memcpy(d1, s1, itemsize);
            d1 += itemsize;
            s1 += srcstrides;
        }
    }


            

Reported by FlawFinder.

                      PyObject *ret;
        npy_intp newdims[2*NPY_MAXDIMS];
        npy_intp *newstrides = NULL;
        memcpy(newdims, dims, nd*sizeof(npy_intp));
        if (strides) {
            newstrides = newdims + NPY_MAXDIMS;
            memcpy(newstrides, strides, nd*sizeof(npy_intp));
        }
        nd =_update_descr_and_dimensions(&descr, newdims,

            

Reported by FlawFinder.

                      memcpy(newdims, dims, nd*sizeof(npy_intp));
        if (strides) {
            newstrides = newdims + NPY_MAXDIMS;
            memcpy(newstrides, strides, nd*sizeof(npy_intp));
        }
        nd =_update_descr_and_dimensions(&descr, newdims,
                                         newstrides, nd);
        ret = PyArray_NewFromDescr_int(
                subtype, descr,

            

Reported by FlawFinder.

                          }
        }
        if (n) {
            memcpy(PyArray_STRIDES(ret), strides, n*sizeof(npy_intp));
        }
    }
    PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL);
    Py_DECREF(iface);
    return (PyObject *)ret;

            

Reported by FlawFinder.

              
    dst_count = *dst_countptr;
    src_count = *src_countptr;
    char *args[2] = {src_dataptr[0], dst_dataptr[0]};
    npy_intp strides[2] = {src_stride, dst_stride};

    int res = 0;
    for(;;) {
        /* Transfer the biggest amount that fits both */

            

Reported by FlawFinder.

                      if (ret == NULL) {
            return NULL;
        }
        memcpy(PyArray_DATA(ret), data, size_to_copy);
    }
    else {
        /* read from character-based string */
        size_t nread = 0;
        char *end;

            

Reported by FlawFinder.

                  int skip_space = 0;
    char *s, *start;

    s = start = malloc(strlen(sep)+3);
    if (s == NULL) {
        PyErr_NoMemory();
        return NULL;
    }
    /* add space to front if there isn't one */

            

Reported by FlawFinder.

                  const char *sep_start = sep;

    while (1) {
        int c = fgetc(*fp);

        if (c == EOF) {
            result = -1;
            break;
        }

            

Reported by FlawFinder.

              
i8 = np.int64()
i4 = np.int32()
u8 = np.uint64()
b_ = np.bool_()
i = int()

f8 = np.float64()


            

Reported by Pylint.

              i8 = np.int64()
i4 = np.int32()
u8 = np.uint64()
b_ = np.bool_()
i = int()

f8 = np.float64()

b_ >> f8  # E: No overload variant

            

Reported by Pylint.

              b_ = np.bool_()
i = int()

f8 = np.float64()

b_ >> f8  # E: No overload variant
i8 << f8  # E: No overload variant
i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant

            

Reported by Pylint.

              i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type

# mypys' error message for `NoReturn` is unfortunately pretty bad
# TODO: Reenable this once we add support for numerical precision for `number`s
# a = u8 | 0  # E: Need type annotation

            

Reported by Pylint.

              
f8 = np.float64()

b_ >> f8  # E: No overload variant
i8 << f8  # E: No overload variant
i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type

            

Reported by Pylint.

              f8 = np.float64()

b_ >> f8  # E: No overload variant
i8 << f8  # E: No overload variant
i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type


            

Reported by Pylint.

              
b_ >> f8  # E: No overload variant
i8 << f8  # E: No overload variant
i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type

# mypys' error message for `NoReturn` is unfortunately pretty bad

            

Reported by Pylint.

              b_ >> f8  # E: No overload variant
i8 << f8  # E: No overload variant
i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type

# mypys' error message for `NoReturn` is unfortunately pretty bad
# TODO: Reenable this once we add support for numerical precision for `number`s

            

Reported by Pylint.

              i8 << f8  # E: No overload variant
i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type

# mypys' error message for `NoReturn` is unfortunately pretty bad
# TODO: Reenable this once we add support for numerical precision for `number`s
# a = u8 | 0  # E: Need type annotation

            

Reported by Pylint.

              i | f8  # E: Unsupported operand types
i8 ^ f8  # E: No overload variant
u8 & f8  # E: No overload variant
~f8  # E: Unsupported operand type

# mypys' error message for `NoReturn` is unfortunately pretty bad
# TODO: Reenable this once we add support for numerical precision for `number`s
# a = u8 | 0  # E: Need type annotation

            

Reported by Pylint.

              

def test():
    np.random.seed(np.arange(10))

    # Create a random array
    ndims = randint(5)+1
    shape = tuple(randint(10)+1 for dim in range(ndims))
    els = reduce(mul, shape)

            

Reported by Pylint.

              
    # Check that each block has at most ``buf_size`` elements
    for block in b:
        assert_(len(block.flat) <= (buf_size or els))

    # Check that all elements are iterated correctly
    assert_(list(b.flat) == list(a.flat))

    # Slice arrayterator

            

Reported by Pylint.

                      assert_(len(block.flat) <= (buf_size or els))

    # Check that all elements are iterated correctly
    assert_(list(b.flat) == list(a.flat))

    # Slice arrayterator
    start = [randint(dim) for dim in shape]
    stop = [randint(dim)+1 for dim in shape]
    step = [randint(dim)+1 for dim in shape]

            

Reported by Pylint.

              
    # Check that each block has at most ``buf_size`` elements
    for block in c:
        assert_(len(block.flat) <= (buf_size or els))

    # Check that the arrayterator is sliced correctly
    assert_(np.all(c.__array__() == d))

    # Check that all elements are iterated correctly

            

Reported by Pylint.

                      assert_(len(block.flat) <= (buf_size or els))

    # Check that the arrayterator is sliced correctly
    assert_(np.all(c.__array__() == d))

    # Check that all elements are iterated correctly
    assert_(list(c.flat) == list(d.flat))

            

Reported by Pylint.

                  assert_(np.all(c.__array__() == d))

    # Check that all elements are iterated correctly
    assert_(list(c.flat) == list(d.flat))

            

Reported by Pylint.

              from operator import mul
from functools import reduce

import numpy as np
from numpy.random import randint
from numpy.lib import Arrayterator
from numpy.testing import assert_



            

Reported by Pylint.

              from numpy.testing import assert_


def test():
    np.random.seed(np.arange(10))

    # Create a random array
    ndims = randint(5)+1
    shape = tuple(randint(10)+1 for dim in range(ndims))

            

Reported by Pylint.

                  ndims = randint(5)+1
    shape = tuple(randint(10)+1 for dim in range(ndims))
    els = reduce(mul, shape)
    a = np.arange(els)
    a.shape = shape

    buf_size = randint(2*els)
    b = Arrayterator(a, buf_size)


            

Reported by Pylint.

                  a.shape = shape

    buf_size = randint(2*els)
    b = Arrayterator(a, buf_size)

    # Check that each block has at most ``buf_size`` elements
    for block in b:
        assert_(len(block.flat) <= (buf_size or els))


            

Reported by Pylint.

              import textwrap
from . import util
from numpy.f2py import crackfortran


class TestAbstractInterface(util.F2PyTest):
    suffix = '.f90'

    skip = ['add1', 'add2']

            

Reported by Pylint.

              import textwrap
from . import util
from numpy.f2py import crackfortran


class TestAbstractInterface(util.F2PyTest):
    suffix = '.f90'

    skip = ['add1', 'add2']

            

Reported by Pylint.

              import textwrap
from . import util
from numpy.f2py import crackfortran


class TestAbstractInterface(util.F2PyTest):
    suffix = '.f90'

    skip = ['add1', 'add2']

            

Reported by Pylint.

              from numpy.f2py import crackfortran


class TestAbstractInterface(util.F2PyTest):
    suffix = '.f90'

    skip = ['add1', 'add2']

    code = textwrap.dedent("""

            

Reported by Pylint.

                      end subroutine
        """)

    def test_abstract_interface(self):
        assert self.module.ops_module.foo(3, 5) == (8, 13)

    def test_parse_abstract_interface(self, tmp_path):
        # Test gh18403
        f_path = tmp_path / "gh18403_mod.f90"

            

Reported by Pylint.

                      """)

    def test_abstract_interface(self):
        assert self.module.ops_module.foo(3, 5) == (8, 13)

    def test_parse_abstract_interface(self, tmp_path):
        # Test gh18403
        f_path = tmp_path / "gh18403_mod.f90"
        with f_path.open('w') as ff:

            

Reported by Bandit.

                  def test_abstract_interface(self):
        assert self.module.ops_module.foo(3, 5) == (8, 13)

    def test_parse_abstract_interface(self, tmp_path):
        # Test gh18403
        f_path = tmp_path / "gh18403_mod.f90"
        with f_path.open('w') as ff:
            ff.write(textwrap.dedent("""\
                module test

            

Reported by Pylint.

                  def test_abstract_interface(self):
        assert self.module.ops_module.foo(3, 5) == (8, 13)

    def test_parse_abstract_interface(self, tmp_path):
        # Test gh18403
        f_path = tmp_path / "gh18403_mod.f90"
        with f_path.open('w') as ff:
            ff.write(textwrap.dedent("""\
                module test

            

Reported by Pylint.

                  def test_parse_abstract_interface(self, tmp_path):
        # Test gh18403
        f_path = tmp_path / "gh18403_mod.f90"
        with f_path.open('w') as ff:
            ff.write(textwrap.dedent("""\
                module test
                  abstract interface
                    subroutine foo()
                    end subroutine

            

Reported by Pylint.

                              end module test
                """))
        mod = crackfortran.crackfortran([str(f_path)])
        assert len(mod) == 1
        assert len(mod[0]['body']) == 1
        assert mod[0]['body'][0]['block'] == 'abstract interface'

            

Reported by Bandit.

              
def check_inline(cmd):
    """Return the inline identifier (may be empty)."""
    cmd._check_compiler()
    body = textwrap.dedent("""
        #ifndef __cplusplus
        static %(inline)s int static_func (void)
        {
            return 0;

            

Reported by Pylint.

              
def check_restrict(cmd):
    """Return the restrict identifier (may be empty)."""
    cmd._check_compiler()
    body = textwrap.dedent("""
        static int static_func (char * %(restrict)s a)
        {
            return 0;
        }

            

Reported by Pylint.

              def check_compiler_gcc(cmd):
    """Check if the compiler is GCC."""

    cmd._check_compiler()
    body = textwrap.dedent("""
        int
        main()
        {
        #if (! defined __GNUC__)

            

Reported by Pylint.

                  """
    Check that the gcc version is at least the specified version."""

    cmd._check_compiler()
    version = '.'.join([str(major), str(minor), str(patchlevel)])
    body = textwrap.dedent("""
        int
        main()
        {

            

Reported by Pylint.

              
def check_gcc_function_attribute(cmd, attribute, name):
    """Return True if the given function attribute is supported."""
    cmd._check_compiler()
    body = textwrap.dedent("""
        #pragma GCC diagnostic error "-Wattributes"
        #pragma clang diagnostic error "-Wattributes"

        int %s %s(void* unused)

            

Reported by Pylint.

                                                              include):
    """Return True if the given function attribute is supported with
    intrinsics."""
    cmd._check_compiler()
    body = textwrap.dedent("""
        #include<%s>
        int %s %s(void)
        {
            %s;

            

Reported by Pylint.

              
def check_gcc_variable_attribute(cmd, attribute):
    """Return True if the given variable attribute is supported."""
    cmd._check_compiler()
    body = textwrap.dedent("""
        #pragma GCC diagnostic error "-Wattributes"
        #pragma clang diagnostic error "-Wattributes"

        int %s foo;

            

Reported by Pylint.

                      }
        #endif""")

    for kw in ['inline', '__inline__', '__inline']:
        st = cmd.try_compile(body % {'inline': kw}, None, None)
        if st:
            return kw

    return ''

            

Reported by Pylint.

                      #endif""")

    for kw in ['inline', '__inline__', '__inline']:
        st = cmd.try_compile(body % {'inline': kw}, None, None)
        if st:
            return kw

    return ''


            

Reported by Pylint.

                      }
        """)

    for kw in ['restrict', '__restrict__', '__restrict']:
        st = cmd.try_compile(body % {'restrict': kw}, None, None)
        if st:
            return kw

    return ''

            

Reported by Pylint.

              def register_func(name, func):
    if name not in __all__:
        raise ValueError("{} not a dual function.".format(name))
    f = sys._getframe(0).f_globals
    _restore_dict[name] = f[name]
    f[name] = func

def restore_func(name):
    if name not in __all__:

            

Reported by Pylint.

                  except KeyError:
        return
    else:
        sys._getframe(0).f_globals[name] = val

def restore_all():
    for name in _restore_dict.keys():
        restore_func(name)

            

Reported by Pylint.

                         'norm', 'inv', 'svd', 'solve', 'det', 'eig', 'eigvals',
           'eigh', 'eigvalsh', 'lstsq', 'pinv', 'cholesky', 'i0']

import numpy.linalg as linpkg
import numpy.fft as fftpkg
from numpy.lib import i0
import sys



            

Reported by Pylint.

                         'eigh', 'eigvalsh', 'lstsq', 'pinv', 'cholesky', 'i0']

import numpy.linalg as linpkg
import numpy.fft as fftpkg
from numpy.lib import i0
import sys


fft = fftpkg.fft

            

Reported by Pylint.

              
import numpy.linalg as linpkg
import numpy.fft as fftpkg
from numpy.lib import i0
import sys


fft = fftpkg.fft
ifft = fftpkg.ifft

            

Reported by Pylint.

              import numpy.linalg as linpkg
import numpy.fft as fftpkg
from numpy.lib import i0
import sys


fft = fftpkg.fft
ifft = fftpkg.ifft
fftn = fftpkg.fftn

            

Reported by Pylint.

              import numpy.linalg as linpkg
import numpy.fft as fftpkg
from numpy.lib import i0
import sys


fft = fftpkg.fft
ifft = fftpkg.ifft
fftn = fftpkg.fftn

            

Reported by Pylint.

              
_restore_dict = {}

def register_func(name, func):
    if name not in __all__:
        raise ValueError("{} not a dual function.".format(name))
    f = sys._getframe(0).f_globals
    _restore_dict[name] = f[name]
    f[name] = func

            

Reported by Pylint.

              def register_func(name, func):
    if name not in __all__:
        raise ValueError("{} not a dual function.".format(name))
    f = sys._getframe(0).f_globals
    _restore_dict[name] = f[name]
    f[name] = func

def restore_func(name):
    if name not in __all__:

            

Reported by Pylint.

                  _restore_dict[name] = f[name]
    f[name] = func

def restore_func(name):
    if name not in __all__:
        raise ValueError("{} not a dual function.".format(name))
    try:
        val = _restore_dict[name]
    except KeyError:

            

Reported by Pylint.

              )


class container:
    """
    container(data, dtype=None, copy=True)

    Standard container-class for easy multiple-inheritance.


            

Reported by Pylint.

                      self.array = array(data, dtype, copy=copy)

    def __repr__(self):
        if self.ndim > 0:
            return self.__class__.__name__ + repr(self.array)[len("array"):]
        else:
            return self.__class__.__name__ + "(" + repr(self.array) + ")"

    def __array__(self, t=None):

            

Reported by Pylint.

                      else:
            return self.__class__.__name__ + "(" + repr(self.array) + ")"

    def __array__(self, t=None):
        if t:
            return self.array.astype(t)
        return self.array

    # Array as sequence

            

Reported by Pylint.

                      return self._rc(invert(self.array))

    def _scalarfunc(self, func):
        if self.ndim == 0:
            return func(self[0])
        else:
            raise TypeError(
                "only rank-0 arrays can be converted to Python scalars.")


            

Reported by Pylint.

                  def __ge__(self, other):
        return self._rc(greater_equal(self.array, other))

    def copy(self):
        ""
        return self._rc(self.array.copy())

    def tostring(self):
        ""

            

Reported by Pylint.

                      ""
        return self._rc(self.array.copy())

    def tostring(self):
        ""
        return self.array.tostring()

    def tobytes(self):
        ""

            

Reported by Pylint.

                      ""
        return self.array.tostring()

    def tobytes(self):
        ""
        return self.array.tobytes()

    def byteswap(self):
        ""

            

Reported by Pylint.

                      ""
        return self.array.tobytes()

    def byteswap(self):
        ""
        return self._rc(self.array.byteswap())

    def astype(self, typecode):
        ""

            

Reported by Pylint.

                      ""
        return self._rc(self.array.byteswap())

    def astype(self, typecode):
        ""
        return self._rc(self.array.astype(typecode))

    def _rc(self, a):
        if len(shape(a)) == 0:

            

Reported by Pylint.

                      ""
        return self._rc(self.array.astype(typecode))

    def _rc(self, a):
        if len(shape(a)) == 0:
            return a
        else:
            return self.__class__(a)


            

Reported by Pylint.