FM / core

/opt/imh-python/lib/python3.9/site-packages/numpy/core/

/opt/imh-python/lib/python3.9/site-packages/numpy/core

Name	Size	Mode	Actions
include/	-	0755	rm
lib/	-	0755	rm
tests/	-	0755	rm
__pycache__/	-	0755	rm
arrayprint.py	63608	0644	edit dl rm
arrayprint.pyi	4428	0644	edit dl rm
cversions.py	347	0644	edit dl rm
defchararray.py	73617	0644	edit dl rm
defchararray.pyi	9216	0644	edit dl rm
einsumfunc.py	51868	0644	edit dl rm
einsumfunc.pyi	4860	0644	edit dl rm
fromnumeric.py	128821	0644	edit dl rm
fromnumeric.pyi	23726	0644	edit dl rm
function_base.py	19836	0644	edit dl rm
function_base.pyi	4725	0644	edit dl rm
getlimits.py	25865	0644	edit dl rm
getlimits.pyi	82	0644	edit dl rm
memmap.py	11771	0644	edit dl rm
memmap.pyi	55	0644	edit dl rm
multiarray.py	56097	0644	edit dl rm
multiarray.pyi	24768	0644	edit dl rm
numeric.py	77014	0644	edit dl rm
numeric.pyi	14315	0644	edit dl rm
numerictypes.py	18098	0644	edit dl rm
numerictypes.pyi	3267	0644	edit dl rm
overrides.py	7093	0644	edit dl rm
records.py	37533	0644	edit dl rm
records.pyi	5692	0644	edit dl rm
shape_base.py	29743	0644	edit dl rm
shape_base.pyi	2774	0644	edit dl rm
umath.py	2040	0644	edit dl rm
umath_tests.py	389	0644	edit dl rm
_add_newdocs.py	208972	0644	edit dl rm
_add_newdocs_scalars.py	12106	0644	edit dl rm
_asarray.py	3884	0644	edit dl rm
_asarray.pyi	1086	0644	edit dl rm
_dtype.py	10606	0644	edit dl rm
_dtype_ctypes.py	3673	0644	edit dl rm
_exceptions.py	5379	0644	edit dl rm
_internal.py	28348	0644	edit dl rm
_internal.pyi	1032	0644	edit dl rm
_machar.py	11565	0644	edit dl rm
_methods.py	8613	0644	edit dl rm
_multiarray_tests.cpython-39-x86_64-linux-gnu.so	151008	0755	edit dl rm
_multiarray_umath.cpython-39-x86_64-linux-gnu.so	7382112	0755	edit dl rm
_operand_flag_tests.cpython-39-x86_64-linux-gnu.so	16728	0755	edit dl rm
_rational_tests.cpython-39-x86_64-linux-gnu.so	59640	0755	edit dl rm
_simd.cpython-39-x86_64-linux-gnu.so	3526664	0755	edit dl rm
_string_helpers.py	2852	0644	edit dl rm
_struct_ufunc_tests.cpython-39-x86_64-linux-gnu.so	16832	0755	edit dl rm
_type_aliases.py	7534	0644	edit dl rm
_type_aliases.pyi	404	0644	edit dl rm
_ufunc_config.py	13944	0644	edit dl rm
_ufunc_config.pyi	1066	0644	edit dl rm
_umath_tests.cpython-39-x86_64-linux-gnu.so	42008	0755	edit dl rm
__init__.py	5780	0644	edit dl rm
__init__.pyi	126	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/numpy/core/_methods.py (8613B)

"""
Array methods which are called by both the C-code for the method
and the Python code for the NumPy-namespace function

"""
import warnings
from contextlib import nullcontext

from numpy.core import multiarray as mu
from numpy.core import umath as um
from numpy.core.multiarray import asanyarray
from numpy.core import numerictypes as nt
from numpy.core import _exceptions
from numpy.core._ufunc_config import _no_nep50_warning
from numpy._globals import _NoValue
from numpy.compat import pickle, os_fspath

# save those O(100) nanoseconds!
umr_maximum = um.maximum.reduce
umr_minimum = um.minimum.reduce
umr_sum = um.add.reduce
umr_prod = um.multiply.reduce
umr_any = um.logical_or.reduce
umr_all = um.logical_and.reduce

# Complex types to -> (2,)float view for fast-path computation in _var()
_complex_to_float = {
    nt.dtype(nt.csingle) : nt.dtype(nt.single),
    nt.dtype(nt.cdouble) : nt.dtype(nt.double),
}
# Special case for windows: ensure double takes precedence
if nt.dtype(nt.longdouble) != nt.dtype(nt.double):
    _complex_to_float.update({
        nt.dtype(nt.clongdouble) : nt.dtype(nt.longdouble),
    })

# avoid keyword arguments to speed up parsing, saves about 15%-20% for very
# small reductions
def _amax(a, axis=None, out=None, keepdims=False,
          initial=_NoValue, where=True):
    return umr_maximum(a, axis, None, out, keepdims, initial, where)

def _amin(a, axis=None, out=None, keepdims=False,
          initial=_NoValue, where=True):
    return umr_minimum(a, axis, None, out, keepdims, initial, where)

def _sum(a, axis=None, dtype=None, out=None, keepdims=False,
         initial=_NoValue, where=True):
    return umr_sum(a, axis, dtype, out, keepdims, initial, where)

def _prod(a, axis=None, dtype=None, out=None, keepdims=False,
          initial=_NoValue, where=True):
    return umr_prod(a, axis, dtype, out, keepdims, initial, where)

def _any(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
    # Parsing keyword arguments is currently fairly slow, so avoid it for now
    if where is True:
        return umr_any(a, axis, dtype, out, keepdims)
    return umr_any(a, axis, dtype, out, keepdims, where=where)

def _all(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
    # Parsing keyword arguments is currently fairly slow, so avoid it for now
    if where is True:
        return umr_all(a, axis, dtype, out, keepdims)
    return umr_all(a, axis, dtype, out, keepdims, where=where)

def _count_reduce_items(arr, axis, keepdims=False, where=True):
    # fast-path for the default case
    if where is True:
        # no boolean mask given, calculate items according to axis
        if axis is None:
            axis = tuple(range(arr.ndim))
        elif not isinstance(axis, tuple):
            axis = (axis,)
        items = 1
        for ax in axis:
            items *= arr.shape[mu.normalize_axis_index(ax, arr.ndim)]
        items = nt.intp(items)
    else:
        # TODO: Optimize case when `where` is broadcast along a non-reduction
        # axis and full sum is more excessive than needed.

# guarded to protect circular imports
        from numpy.lib.stride_tricks import broadcast_to
        # count True values in (potentially broadcasted) boolean mask
        items = umr_sum(broadcast_to(where, arr.shape), axis, nt.intp, None,
                        keepdims)
    return items

def _clip(a, min=None, max=None, out=None, **kwargs):
    if min is None and max is None:
        raise ValueError("One of max or min must be given")

if min is None:
        return um.minimum(a, max, out=out, **kwargs)
    elif max is None:
        return um.maximum(a, min, out=out, **kwargs)
    else:
        return um.clip(a, min, max, out=out, **kwargs)

def _mean(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
    arr = asanyarray(a)

is_float16_result = False

rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where)
    if rcount == 0 if where is True else umr_any(rcount == 0, axis=None):
        warnings.warn("Mean of empty slice.", RuntimeWarning, stacklevel=2)

# Cast bool, unsigned int, and int to float64 by default
    if dtype is None:
        if issubclass(arr.dtype.type, (nt.integer, nt.bool_)):
            dtype = mu.dtype('f8')
        elif issubclass(arr.dtype.type, nt.float16):
            dtype = mu.dtype('f4')
            is_float16_result = True

ret = umr_sum(arr, axis, dtype, out, keepdims, where=where)
    if isinstance(ret, mu.ndarray):
        with _no_nep50_warning():
            ret = um.true_divide(
                    ret, rcount, out=ret, casting='unsafe', subok=False)
        if is_float16_result and out is None:
            ret = arr.dtype.type(ret)
    elif hasattr(ret, 'dtype'):
        if is_float16_result:
            ret = arr.dtype.type(ret / rcount)
        else:
            ret = ret.dtype.type(ret / rcount)
    else:
        ret = ret / rcount

return ret

def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
         where=True):
    arr = asanyarray(a)

rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where)
    # Make this warning show up on top.
    if ddof >= rcount if where is True else umr_any(ddof >= rcount, axis=None):
        warnings.warn("Degrees of freedom <= 0 for slice", RuntimeWarning,
                      stacklevel=2)

# Cast bool, unsigned int, and int to float64 by default
    if dtype is None and issubclass(arr.dtype.type, (nt.integer, nt.bool_)):
        dtype = mu.dtype('f8')

# Compute the mean.
    # Note that if dtype is not of inexact type then arraymean will
    # not be either.
    arrmean = umr_sum(arr, axis, dtype, keepdims=True, where=where)
    # The shape of rcount has to match arrmean to not change the shape of out
    # in broadcasting. Otherwise, it cannot be stored back to arrmean.
    if rcount.ndim == 0:
        # fast-path for default case when where is True
        div = rcount
    else:
        # matching rcount to arrmean when where is specified as array
        div = rcount.reshape(arrmean.shape)
    if isinstance(arrmean, mu.ndarray):
        with _no_nep50_warning():
            arrmean = um.true_divide(arrmean, div, out=arrmean,
                                     casting='unsafe', subok=False)
    elif hasattr(arrmean, "dtype"):
        arrmean = arrmean.dtype.type(arrmean / rcount)
    else:
        arrmean = arrmean / rcount

# Compute sum of squared deviations from mean
    # Note that x may not be inexact and that we need it to be an array,
    # not a scalar.
    x = asanyarray(arr - arrmean)

if issubclass(arr.dtype.type, (nt.floating, nt.integer)):
        x = um.multiply(x, x, out=x)
    # Fast-paths for built-in complex types
    elif x.dtype in _complex_to_float:
        xv = x.view(dtype=(_complex_to_float[x.dtype], (2,)))
        um.multiply(xv, xv, out=xv)
        x = um.add(xv[..., 0], xv[..., 1], out=x.real).real
    # Most general case; includes handling object arrays containing imaginary
    # numbers and complex types with non-native byteorder
    else:
        x = um.multiply(x, um.conjugate(x), out=x).real

ret = umr_sum(x, axis, dtype, out, keepdims=keepdims, where=where)

# Compute degrees of freedom and make sure it is not negative.
    rcount = um.maximum(rcount - ddof, 0)

# divide by degrees of freedom
    if isinstance(ret, mu.ndarray):
        with _no_nep50_warning():
            ret = um.true_divide(
                    ret, rcount, out=ret, casting='unsafe', subok=False)
    elif hasattr(ret, 'dtype'):
        ret = ret.dtype.type(ret / rcount)
    else:
        ret = ret / rcount

return ret

def _std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
         where=True):
    ret = _var(a, axis=axis, dtype=dtype, out=out, ddof=ddof,
               keepdims=keepdims, where=where)

if isinstance(ret, mu.ndarray):
        ret = um.sqrt(ret, out=ret)
    elif hasattr(ret, 'dtype'):
        ret = ret.dtype.type(um.sqrt(ret))
    else:
        ret = um.sqrt(ret)

return ret

def _ptp(a, axis=None, out=None, keepdims=False):
    return um.subtract(
        umr_maximum(a, axis, None, out, keepdims),
        umr_minimum(a, axis, None, None, keepdims),
        out
    )

def _dump(self, file, protocol=2):
    if hasattr(file, 'write'):
        ctx = nullcontext(file)
    else:
        ctx = open(os_fspath(file), "wb")
    with ctx as f:
        pickle.dump(self, f, protocol=protocol)

def _dumps(self, protocol=2):
    return pickle.dumps(self, protocol=protocol)

cmd: