virtuelle Umgebung teil20b
This commit is contained in:
179
teil20b/lib/python3.11/site-packages/numpy/core/__init__.py
Normal file
179
teil20b/lib/python3.11/site-packages/numpy/core/__init__.py
Normal file
@@ -0,0 +1,179 @@
|
||||
"""
|
||||
Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.
|
||||
|
||||
Please note that this module is private. All functions and objects
|
||||
are available in the main ``numpy`` namespace - use that instead.
|
||||
|
||||
"""
|
||||
|
||||
from numpy.version import version as __version__
|
||||
|
||||
import os
|
||||
import warnings
|
||||
|
||||
# disables OpenBLAS affinity setting of the main thread that limits
|
||||
# python threads or processes to one core
|
||||
env_added = []
|
||||
for envkey in ['OPENBLAS_MAIN_FREE', 'GOTOBLAS_MAIN_FREE']:
|
||||
if envkey not in os.environ:
|
||||
os.environ[envkey] = '1'
|
||||
env_added.append(envkey)
|
||||
|
||||
try:
|
||||
from . import multiarray
|
||||
except ImportError as exc:
|
||||
import sys
|
||||
msg = """
|
||||
|
||||
IMPORTANT: PLEASE READ THIS FOR ADVICE ON HOW TO SOLVE THIS ISSUE!
|
||||
|
||||
Importing the numpy C-extensions failed. This error can happen for
|
||||
many reasons, often due to issues with your setup or how NumPy was
|
||||
installed.
|
||||
|
||||
We have compiled some common reasons and troubleshooting tips at:
|
||||
|
||||
https://numpy.org/devdocs/user/troubleshooting-importerror.html
|
||||
|
||||
Please note and check the following:
|
||||
|
||||
* The Python version is: Python%d.%d from "%s"
|
||||
* The NumPy version is: "%s"
|
||||
|
||||
and make sure that they are the versions you expect.
|
||||
Please carefully study the documentation linked above for further help.
|
||||
|
||||
Original error was: %s
|
||||
""" % (sys.version_info[0], sys.version_info[1], sys.executable,
|
||||
__version__, exc)
|
||||
raise ImportError(msg)
|
||||
finally:
|
||||
for envkey in env_added:
|
||||
del os.environ[envkey]
|
||||
del envkey
|
||||
del env_added
|
||||
del os
|
||||
|
||||
from . import umath
|
||||
|
||||
# Check that multiarray,umath are pure python modules wrapping
|
||||
# _multiarray_umath and not either of the old c-extension modules
|
||||
if not (hasattr(multiarray, '_multiarray_umath') and
|
||||
hasattr(umath, '_multiarray_umath')):
|
||||
import sys
|
||||
path = sys.modules['numpy'].__path__
|
||||
msg = ("Something is wrong with the numpy installation. "
|
||||
"While importing we detected an older version of "
|
||||
"numpy in {}. One method of fixing this is to repeatedly uninstall "
|
||||
"numpy until none is found, then reinstall this version.")
|
||||
raise ImportError(msg.format(path))
|
||||
|
||||
from . import numerictypes as nt
|
||||
multiarray.set_typeDict(nt.sctypeDict)
|
||||
from . import numeric
|
||||
from .numeric import *
|
||||
from . import fromnumeric
|
||||
from .fromnumeric import *
|
||||
from . import defchararray as char
|
||||
from . import records
|
||||
from . import records as rec
|
||||
from .records import record, recarray, format_parser
|
||||
# Note: module name memmap is overwritten by a class with same name
|
||||
from .memmap import *
|
||||
from .defchararray import chararray
|
||||
from . import function_base
|
||||
from .function_base import *
|
||||
from . import _machar
|
||||
from . import getlimits
|
||||
from .getlimits import *
|
||||
from . import shape_base
|
||||
from .shape_base import *
|
||||
from . import einsumfunc
|
||||
from .einsumfunc import *
|
||||
del nt
|
||||
|
||||
from .numeric import absolute as abs
|
||||
|
||||
# do this after everything else, to minimize the chance of this misleadingly
|
||||
# appearing in an import-time traceback
|
||||
from . import _add_newdocs
|
||||
from . import _add_newdocs_scalars
|
||||
# add these for module-freeze analysis (like PyInstaller)
|
||||
from . import _dtype_ctypes
|
||||
from . import _internal
|
||||
from . import _dtype
|
||||
from . import _methods
|
||||
|
||||
__all__ = ['char', 'rec', 'memmap']
|
||||
__all__ += numeric.__all__
|
||||
__all__ += ['record', 'recarray', 'format_parser']
|
||||
__all__ += ['chararray']
|
||||
__all__ += function_base.__all__
|
||||
__all__ += getlimits.__all__
|
||||
__all__ += shape_base.__all__
|
||||
__all__ += einsumfunc.__all__
|
||||
|
||||
# We used to use `np.core._ufunc_reconstruct` to unpickle. This is unnecessary,
|
||||
# but old pickles saved before 1.20 will be using it, and there is no reason
|
||||
# to break loading them.
|
||||
def _ufunc_reconstruct(module, name):
|
||||
# The `fromlist` kwarg is required to ensure that `mod` points to the
|
||||
# inner-most module rather than the parent package when module name is
|
||||
# nested. This makes it possible to pickle non-toplevel ufuncs such as
|
||||
# scipy.special.expit for instance.
|
||||
mod = __import__(module, fromlist=[name])
|
||||
return getattr(mod, name)
|
||||
|
||||
|
||||
def _ufunc_reduce(func):
|
||||
# Report the `__name__`. pickle will try to find the module. Note that
|
||||
# pickle supports for this `__name__` to be a `__qualname__`. It may
|
||||
# make sense to add a `__qualname__` to ufuncs, to allow this more
|
||||
# explicitly (Numba has ufuncs as attributes).
|
||||
# See also: https://github.com/dask/distributed/issues/3450
|
||||
return func.__name__
|
||||
|
||||
|
||||
def _DType_reconstruct(scalar_type):
|
||||
# This is a work-around to pickle type(np.dtype(np.float64)), etc.
|
||||
# and it should eventually be replaced with a better solution, e.g. when
|
||||
# DTypes become HeapTypes.
|
||||
return type(dtype(scalar_type))
|
||||
|
||||
|
||||
def _DType_reduce(DType):
|
||||
# As types/classes, most DTypes can simply be pickled by their name:
|
||||
if not DType._legacy or DType.__module__ == "numpy.dtypes":
|
||||
return DType.__name__
|
||||
|
||||
# However, user defined legacy dtypes (like rational) do not end up in
|
||||
# `numpy.dtypes` as module and do not have a public class at all.
|
||||
# For these, we pickle them by reconstructing them from the scalar type:
|
||||
scalar_type = DType.type
|
||||
return _DType_reconstruct, (scalar_type,)
|
||||
|
||||
|
||||
def __getattr__(name):
|
||||
# Deprecated 2022-11-22, NumPy 1.25.
|
||||
if name == "MachAr":
|
||||
warnings.warn(
|
||||
"The `np.core.MachAr` is considered private API (NumPy 1.24)",
|
||||
DeprecationWarning, stacklevel=2,
|
||||
)
|
||||
return _machar.MachAr
|
||||
raise AttributeError(f"Module {__name__!r} has no attribute {name!r}")
|
||||
|
||||
|
||||
import copyreg
|
||||
|
||||
copyreg.pickle(ufunc, _ufunc_reduce)
|
||||
copyreg.pickle(type(dtype), _DType_reduce, _DType_reconstruct)
|
||||
|
||||
# Unclutter namespace (must keep _*_reconstruct for unpickling)
|
||||
del copyreg
|
||||
del _ufunc_reduce
|
||||
del _DType_reduce
|
||||
|
||||
from numpy._pytesttester import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
@@ -0,0 +1,2 @@
|
||||
# NOTE: The `np.core` namespace is deliberately kept empty due to it
|
||||
# being private (despite the lack of leading underscore)
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
7080
teil20b/lib/python3.11/site-packages/numpy/core/_add_newdocs.py
Normal file
7080
teil20b/lib/python3.11/site-packages/numpy/core/_add_newdocs.py
Normal file
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,372 @@
|
||||
"""
|
||||
This file is separate from ``_add_newdocs.py`` so that it can be mocked out by
|
||||
our sphinx ``conf.py`` during doc builds, where we want to avoid showing
|
||||
platform-dependent information.
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
from numpy.core import dtype
|
||||
from numpy.core import numerictypes as _numerictypes
|
||||
from numpy.core.function_base import add_newdoc
|
||||
|
||||
##############################################################################
|
||||
#
|
||||
# Documentation for concrete scalar classes
|
||||
#
|
||||
##############################################################################
|
||||
|
||||
def numeric_type_aliases(aliases):
|
||||
def type_aliases_gen():
|
||||
for alias, doc in aliases:
|
||||
try:
|
||||
alias_type = getattr(_numerictypes, alias)
|
||||
except AttributeError:
|
||||
# The set of aliases that actually exist varies between platforms
|
||||
pass
|
||||
else:
|
||||
yield (alias_type, alias, doc)
|
||||
return list(type_aliases_gen())
|
||||
|
||||
|
||||
possible_aliases = numeric_type_aliases([
|
||||
('int8', '8-bit signed integer (``-128`` to ``127``)'),
|
||||
('int16', '16-bit signed integer (``-32_768`` to ``32_767``)'),
|
||||
('int32', '32-bit signed integer (``-2_147_483_648`` to ``2_147_483_647``)'),
|
||||
('int64', '64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``)'),
|
||||
('intp', 'Signed integer large enough to fit pointer, compatible with C ``intptr_t``'),
|
||||
('uint8', '8-bit unsigned integer (``0`` to ``255``)'),
|
||||
('uint16', '16-bit unsigned integer (``0`` to ``65_535``)'),
|
||||
('uint32', '32-bit unsigned integer (``0`` to ``4_294_967_295``)'),
|
||||
('uint64', '64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``)'),
|
||||
('uintp', 'Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``'),
|
||||
('float16', '16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa'),
|
||||
('float32', '32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa'),
|
||||
('float64', '64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa'),
|
||||
('float96', '96-bit extended-precision floating-point number type'),
|
||||
('float128', '128-bit extended-precision floating-point number type'),
|
||||
('complex64', 'Complex number type composed of 2 32-bit-precision floating-point numbers'),
|
||||
('complex128', 'Complex number type composed of 2 64-bit-precision floating-point numbers'),
|
||||
('complex192', 'Complex number type composed of 2 96-bit extended-precision floating-point numbers'),
|
||||
('complex256', 'Complex number type composed of 2 128-bit extended-precision floating-point numbers'),
|
||||
])
|
||||
|
||||
|
||||
def _get_platform_and_machine():
|
||||
try:
|
||||
system, _, _, _, machine = os.uname()
|
||||
except AttributeError:
|
||||
system = sys.platform
|
||||
if system == 'win32':
|
||||
machine = os.environ.get('PROCESSOR_ARCHITEW6432', '') \
|
||||
or os.environ.get('PROCESSOR_ARCHITECTURE', '')
|
||||
else:
|
||||
machine = 'unknown'
|
||||
return system, machine
|
||||
|
||||
|
||||
_system, _machine = _get_platform_and_machine()
|
||||
_doc_alias_string = f":Alias on this platform ({_system} {_machine}):"
|
||||
|
||||
|
||||
def add_newdoc_for_scalar_type(obj, fixed_aliases, doc):
|
||||
# note: `:field: value` is rST syntax which renders as field lists.
|
||||
o = getattr(_numerictypes, obj)
|
||||
|
||||
character_code = dtype(o).char
|
||||
canonical_name_doc = "" if obj == o.__name__ else \
|
||||
f":Canonical name: `numpy.{obj}`\n "
|
||||
if fixed_aliases:
|
||||
alias_doc = ''.join(f":Alias: `numpy.{alias}`\n "
|
||||
for alias in fixed_aliases)
|
||||
else:
|
||||
alias_doc = ''
|
||||
alias_doc += ''.join(f"{_doc_alias_string} `numpy.{alias}`: {doc}.\n "
|
||||
for (alias_type, alias, doc) in possible_aliases if alias_type is o)
|
||||
|
||||
docstring = f"""
|
||||
{doc.strip()}
|
||||
|
||||
:Character code: ``'{character_code}'``
|
||||
{canonical_name_doc}{alias_doc}
|
||||
"""
|
||||
|
||||
add_newdoc('numpy.core.numerictypes', obj, docstring)
|
||||
|
||||
|
||||
add_newdoc_for_scalar_type('bool_', [],
|
||||
"""
|
||||
Boolean type (True or False), stored as a byte.
|
||||
|
||||
.. warning::
|
||||
|
||||
The :class:`bool_` type is not a subclass of the :class:`int_` type
|
||||
(the :class:`bool_` is not even a number type). This is different
|
||||
than Python's default implementation of :class:`bool` as a
|
||||
sub-class of :class:`int`.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('byte', [],
|
||||
"""
|
||||
Signed integer type, compatible with C ``char``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('short', [],
|
||||
"""
|
||||
Signed integer type, compatible with C ``short``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('intc', [],
|
||||
"""
|
||||
Signed integer type, compatible with C ``int``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('int_', [],
|
||||
"""
|
||||
Signed integer type, compatible with Python `int` and C ``long``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('longlong', [],
|
||||
"""
|
||||
Signed integer type, compatible with C ``long long``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('ubyte', [],
|
||||
"""
|
||||
Unsigned integer type, compatible with C ``unsigned char``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('ushort', [],
|
||||
"""
|
||||
Unsigned integer type, compatible with C ``unsigned short``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('uintc', [],
|
||||
"""
|
||||
Unsigned integer type, compatible with C ``unsigned int``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('uint', [],
|
||||
"""
|
||||
Unsigned integer type, compatible with C ``unsigned long``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('ulonglong', [],
|
||||
"""
|
||||
Signed integer type, compatible with C ``unsigned long long``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('half', [],
|
||||
"""
|
||||
Half-precision floating-point number type.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('single', [],
|
||||
"""
|
||||
Single-precision floating-point number type, compatible with C ``float``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('double', ['float_'],
|
||||
"""
|
||||
Double-precision floating-point number type, compatible with Python `float`
|
||||
and C ``double``.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('longdouble', ['longfloat'],
|
||||
"""
|
||||
Extended-precision floating-point number type, compatible with C
|
||||
``long double`` but not necessarily with IEEE 754 quadruple-precision.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('csingle', ['singlecomplex'],
|
||||
"""
|
||||
Complex number type composed of two single-precision floating-point
|
||||
numbers.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('cdouble', ['cfloat', 'complex_'],
|
||||
"""
|
||||
Complex number type composed of two double-precision floating-point
|
||||
numbers, compatible with Python `complex`.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('clongdouble', ['clongfloat', 'longcomplex'],
|
||||
"""
|
||||
Complex number type composed of two extended-precision floating-point
|
||||
numbers.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('object_', [],
|
||||
"""
|
||||
Any Python object.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('str_', ['unicode_'],
|
||||
r"""
|
||||
A unicode string.
|
||||
|
||||
This type strips trailing null codepoints.
|
||||
|
||||
>>> s = np.str_("abc\x00")
|
||||
>>> s
|
||||
'abc'
|
||||
|
||||
Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its
|
||||
contents as UCS4:
|
||||
|
||||
>>> m = memoryview(np.str_("abc"))
|
||||
>>> m.format
|
||||
'3w'
|
||||
>>> m.tobytes()
|
||||
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('bytes_', ['string_'],
|
||||
r"""
|
||||
A byte string.
|
||||
|
||||
When used in arrays, this type strips trailing null bytes.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('void', [],
|
||||
r"""
|
||||
np.void(length_or_data, /, dtype=None)
|
||||
|
||||
Create a new structured or unstructured void scalar.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
length_or_data : int, array-like, bytes-like, object
|
||||
One of multiple meanings (see notes). The length or
|
||||
bytes data of an unstructured void. Or alternatively,
|
||||
the data to be stored in the new scalar when `dtype`
|
||||
is provided.
|
||||
This can be an array-like, in which case an array may
|
||||
be returned.
|
||||
dtype : dtype, optional
|
||||
If provided the dtype of the new scalar. This dtype must
|
||||
be "void" dtype (i.e. a structured or unstructured void,
|
||||
see also :ref:`defining-structured-types`).
|
||||
|
||||
..versionadded:: 1.24
|
||||
|
||||
Notes
|
||||
-----
|
||||
For historical reasons and because void scalars can represent both
|
||||
arbitrary byte data and structured dtypes, the void constructor
|
||||
has three calling conventions:
|
||||
|
||||
1. ``np.void(5)`` creates a ``dtype="V5"`` scalar filled with five
|
||||
``\0`` bytes. The 5 can be a Python or NumPy integer.
|
||||
2. ``np.void(b"bytes-like")`` creates a void scalar from the byte string.
|
||||
The dtype itemsize will match the byte string length, here ``"V10"``.
|
||||
3. When a ``dtype=`` is passed the call is roughly the same as an
|
||||
array creation. However, a void scalar rather than array is returned.
|
||||
|
||||
Please see the examples which show all three different conventions.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.void(5)
|
||||
void(b'\x00\x00\x00\x00\x00')
|
||||
>>> np.void(b'abcd')
|
||||
void(b'\x61\x62\x63\x64')
|
||||
>>> np.void((5, 3.2, "eggs"), dtype="i,d,S5")
|
||||
(5, 3.2, b'eggs') # looks like a tuple, but is `np.void`
|
||||
>>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)])
|
||||
(3, 3) # looks like a tuple, but is `np.void`
|
||||
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('datetime64', [],
|
||||
"""
|
||||
If created from a 64-bit integer, it represents an offset from
|
||||
``1970-01-01T00:00:00``.
|
||||
If created from string, the string can be in ISO 8601 date
|
||||
or datetime format.
|
||||
|
||||
>>> np.datetime64(10, 'Y')
|
||||
numpy.datetime64('1980')
|
||||
>>> np.datetime64('1980', 'Y')
|
||||
numpy.datetime64('1980')
|
||||
>>> np.datetime64(10, 'D')
|
||||
numpy.datetime64('1970-01-11')
|
||||
|
||||
See :ref:`arrays.datetime` for more information.
|
||||
""")
|
||||
|
||||
add_newdoc_for_scalar_type('timedelta64', [],
|
||||
"""
|
||||
A timedelta stored as a 64-bit integer.
|
||||
|
||||
See :ref:`arrays.datetime` for more information.
|
||||
""")
|
||||
|
||||
add_newdoc('numpy.core.numerictypes', "integer", ('is_integer',
|
||||
"""
|
||||
integer.is_integer() -> bool
|
||||
|
||||
Return ``True`` if the number is finite with integral value.
|
||||
|
||||
.. versionadded:: 1.22
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.int64(-2).is_integer()
|
||||
True
|
||||
>>> np.uint32(5).is_integer()
|
||||
True
|
||||
"""))
|
||||
|
||||
# TODO: work out how to put this on the base class, np.floating
|
||||
for float_name in ('half', 'single', 'double', 'longdouble'):
|
||||
add_newdoc('numpy.core.numerictypes', float_name, ('as_integer_ratio',
|
||||
"""
|
||||
{ftype}.as_integer_ratio() -> (int, int)
|
||||
|
||||
Return a pair of integers, whose ratio is exactly equal to the original
|
||||
floating point number, and with a positive denominator.
|
||||
Raise `OverflowError` on infinities and a `ValueError` on NaNs.
|
||||
|
||||
>>> np.{ftype}(10.0).as_integer_ratio()
|
||||
(10, 1)
|
||||
>>> np.{ftype}(0.0).as_integer_ratio()
|
||||
(0, 1)
|
||||
>>> np.{ftype}(-.25).as_integer_ratio()
|
||||
(-1, 4)
|
||||
""".format(ftype=float_name)))
|
||||
|
||||
add_newdoc('numpy.core.numerictypes', float_name, ('is_integer',
|
||||
f"""
|
||||
{float_name}.is_integer() -> bool
|
||||
|
||||
Return ``True`` if the floating point number is finite with integral
|
||||
value, and ``False`` otherwise.
|
||||
|
||||
.. versionadded:: 1.22
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.{float_name}(-2.0).is_integer()
|
||||
True
|
||||
>>> np.{float_name}(3.2).is_integer()
|
||||
False
|
||||
"""))
|
||||
|
||||
for int_name in ('int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32',
|
||||
'int64', 'uint64', 'int64', 'uint64', 'int64', 'uint64'):
|
||||
# Add negative examples for signed cases by checking typecode
|
||||
add_newdoc('numpy.core.numerictypes', int_name, ('bit_count',
|
||||
f"""
|
||||
{int_name}.bit_count() -> int
|
||||
|
||||
Computes the number of 1-bits in the absolute value of the input.
|
||||
Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.{int_name}(127).bit_count()
|
||||
7""" +
|
||||
(f"""
|
||||
>>> np.{int_name}(-127).bit_count()
|
||||
7
|
||||
""" if dtype(int_name).char.islower() else "")))
|
134
teil20b/lib/python3.11/site-packages/numpy/core/_asarray.py
Normal file
134
teil20b/lib/python3.11/site-packages/numpy/core/_asarray.py
Normal file
@@ -0,0 +1,134 @@
|
||||
"""
|
||||
Functions in the ``as*array`` family that promote array-likes into arrays.
|
||||
|
||||
`require` fits this category despite its name not matching this pattern.
|
||||
"""
|
||||
from .overrides import (
|
||||
array_function_dispatch,
|
||||
set_array_function_like_doc,
|
||||
set_module,
|
||||
)
|
||||
from .multiarray import array, asanyarray
|
||||
|
||||
|
||||
__all__ = ["require"]
|
||||
|
||||
|
||||
POSSIBLE_FLAGS = {
|
||||
'C': 'C', 'C_CONTIGUOUS': 'C', 'CONTIGUOUS': 'C',
|
||||
'F': 'F', 'F_CONTIGUOUS': 'F', 'FORTRAN': 'F',
|
||||
'A': 'A', 'ALIGNED': 'A',
|
||||
'W': 'W', 'WRITEABLE': 'W',
|
||||
'O': 'O', 'OWNDATA': 'O',
|
||||
'E': 'E', 'ENSUREARRAY': 'E'
|
||||
}
|
||||
|
||||
|
||||
@set_array_function_like_doc
|
||||
@set_module('numpy')
|
||||
def require(a, dtype=None, requirements=None, *, like=None):
|
||||
"""
|
||||
Return an ndarray of the provided type that satisfies requirements.
|
||||
|
||||
This function is useful to be sure that an array with the correct flags
|
||||
is returned for passing to compiled code (perhaps through ctypes).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
a : array_like
|
||||
The object to be converted to a type-and-requirement-satisfying array.
|
||||
dtype : data-type
|
||||
The required data-type. If None preserve the current dtype. If your
|
||||
application requires the data to be in native byteorder, include
|
||||
a byteorder specification as a part of the dtype specification.
|
||||
requirements : str or sequence of str
|
||||
The requirements list can be any of the following
|
||||
|
||||
* 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
|
||||
* 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
|
||||
* 'ALIGNED' ('A') - ensure a data-type aligned array
|
||||
* 'WRITEABLE' ('W') - ensure a writable array
|
||||
* 'OWNDATA' ('O') - ensure an array that owns its own data
|
||||
* 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
|
||||
${ARRAY_FUNCTION_LIKE}
|
||||
|
||||
.. versionadded:: 1.20.0
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray
|
||||
Array with specified requirements and type if given.
|
||||
|
||||
See Also
|
||||
--------
|
||||
asarray : Convert input to an ndarray.
|
||||
asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
|
||||
ascontiguousarray : Convert input to a contiguous array.
|
||||
asfortranarray : Convert input to an ndarray with column-major
|
||||
memory order.
|
||||
ndarray.flags : Information about the memory layout of the array.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The returned array will be guaranteed to have the listed requirements
|
||||
by making a copy if needed.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> x = np.arange(6).reshape(2,3)
|
||||
>>> x.flags
|
||||
C_CONTIGUOUS : True
|
||||
F_CONTIGUOUS : False
|
||||
OWNDATA : False
|
||||
WRITEABLE : True
|
||||
ALIGNED : True
|
||||
WRITEBACKIFCOPY : False
|
||||
|
||||
>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
|
||||
>>> y.flags
|
||||
C_CONTIGUOUS : False
|
||||
F_CONTIGUOUS : True
|
||||
OWNDATA : True
|
||||
WRITEABLE : True
|
||||
ALIGNED : True
|
||||
WRITEBACKIFCOPY : False
|
||||
|
||||
"""
|
||||
if like is not None:
|
||||
return _require_with_like(
|
||||
like,
|
||||
a,
|
||||
dtype=dtype,
|
||||
requirements=requirements,
|
||||
)
|
||||
|
||||
if not requirements:
|
||||
return asanyarray(a, dtype=dtype)
|
||||
|
||||
requirements = {POSSIBLE_FLAGS[x.upper()] for x in requirements}
|
||||
|
||||
if 'E' in requirements:
|
||||
requirements.remove('E')
|
||||
subok = False
|
||||
else:
|
||||
subok = True
|
||||
|
||||
order = 'A'
|
||||
if requirements >= {'C', 'F'}:
|
||||
raise ValueError('Cannot specify both "C" and "F" order')
|
||||
elif 'F' in requirements:
|
||||
order = 'F'
|
||||
requirements.remove('F')
|
||||
elif 'C' in requirements:
|
||||
order = 'C'
|
||||
requirements.remove('C')
|
||||
|
||||
arr = array(a, dtype=dtype, order=order, copy=False, subok=subok)
|
||||
|
||||
for prop in requirements:
|
||||
if not arr.flags[prop]:
|
||||
return arr.copy(order)
|
||||
return arr
|
||||
|
||||
|
||||
_require_with_like = array_function_dispatch()(require)
|
42
teil20b/lib/python3.11/site-packages/numpy/core/_asarray.pyi
Normal file
42
teil20b/lib/python3.11/site-packages/numpy/core/_asarray.pyi
Normal file
@@ -0,0 +1,42 @@
|
||||
from collections.abc import Iterable
|
||||
from typing import Any, TypeVar, Union, overload, Literal
|
||||
|
||||
from numpy import ndarray
|
||||
from numpy._typing import DTypeLike, _SupportsArrayFunc
|
||||
|
||||
_ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
|
||||
|
||||
_Requirements = Literal[
|
||||
"C", "C_CONTIGUOUS", "CONTIGUOUS",
|
||||
"F", "F_CONTIGUOUS", "FORTRAN",
|
||||
"A", "ALIGNED",
|
||||
"W", "WRITEABLE",
|
||||
"O", "OWNDATA"
|
||||
]
|
||||
_E = Literal["E", "ENSUREARRAY"]
|
||||
_RequirementsWithE = Union[_Requirements, _E]
|
||||
|
||||
@overload
|
||||
def require(
|
||||
a: _ArrayType,
|
||||
dtype: None = ...,
|
||||
requirements: None | _Requirements | Iterable[_Requirements] = ...,
|
||||
*,
|
||||
like: _SupportsArrayFunc = ...
|
||||
) -> _ArrayType: ...
|
||||
@overload
|
||||
def require(
|
||||
a: object,
|
||||
dtype: DTypeLike = ...,
|
||||
requirements: _E | Iterable[_RequirementsWithE] = ...,
|
||||
*,
|
||||
like: _SupportsArrayFunc = ...
|
||||
) -> ndarray[Any, Any]: ...
|
||||
@overload
|
||||
def require(
|
||||
a: object,
|
||||
dtype: DTypeLike = ...,
|
||||
requirements: None | _Requirements | Iterable[_Requirements] = ...,
|
||||
*,
|
||||
like: _SupportsArrayFunc = ...
|
||||
) -> ndarray[Any, Any]: ...
|
369
teil20b/lib/python3.11/site-packages/numpy/core/_dtype.py
Normal file
369
teil20b/lib/python3.11/site-packages/numpy/core/_dtype.py
Normal file
@@ -0,0 +1,369 @@
|
||||
"""
|
||||
A place for code to be called from the implementation of np.dtype
|
||||
|
||||
String handling is much easier to do correctly in python.
|
||||
"""
|
||||
import numpy as np
|
||||
|
||||
|
||||
_kind_to_stem = {
|
||||
'u': 'uint',
|
||||
'i': 'int',
|
||||
'c': 'complex',
|
||||
'f': 'float',
|
||||
'b': 'bool',
|
||||
'V': 'void',
|
||||
'O': 'object',
|
||||
'M': 'datetime',
|
||||
'm': 'timedelta',
|
||||
'S': 'bytes',
|
||||
'U': 'str',
|
||||
}
|
||||
|
||||
|
||||
def _kind_name(dtype):
|
||||
try:
|
||||
return _kind_to_stem[dtype.kind]
|
||||
except KeyError as e:
|
||||
raise RuntimeError(
|
||||
"internal dtype error, unknown kind {!r}"
|
||||
.format(dtype.kind)
|
||||
) from None
|
||||
|
||||
|
||||
def __str__(dtype):
|
||||
if dtype.fields is not None:
|
||||
return _struct_str(dtype, include_align=True)
|
||||
elif dtype.subdtype:
|
||||
return _subarray_str(dtype)
|
||||
elif issubclass(dtype.type, np.flexible) or not dtype.isnative:
|
||||
return dtype.str
|
||||
else:
|
||||
return dtype.name
|
||||
|
||||
|
||||
def __repr__(dtype):
|
||||
arg_str = _construction_repr(dtype, include_align=False)
|
||||
if dtype.isalignedstruct:
|
||||
arg_str = arg_str + ", align=True"
|
||||
return "dtype({})".format(arg_str)
|
||||
|
||||
|
||||
def _unpack_field(dtype, offset, title=None):
|
||||
"""
|
||||
Helper function to normalize the items in dtype.fields.
|
||||
|
||||
Call as:
|
||||
|
||||
dtype, offset, title = _unpack_field(*dtype.fields[name])
|
||||
"""
|
||||
return dtype, offset, title
|
||||
|
||||
|
||||
def _isunsized(dtype):
|
||||
# PyDataType_ISUNSIZED
|
||||
return dtype.itemsize == 0
|
||||
|
||||
|
||||
def _construction_repr(dtype, include_align=False, short=False):
|
||||
"""
|
||||
Creates a string repr of the dtype, excluding the 'dtype()' part
|
||||
surrounding the object. This object may be a string, a list, or
|
||||
a dict depending on the nature of the dtype. This
|
||||
is the object passed as the first parameter to the dtype
|
||||
constructor, and if no additional constructor parameters are
|
||||
given, will reproduce the exact memory layout.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
short : bool
|
||||
If true, this creates a shorter repr using 'kind' and 'itemsize', instead
|
||||
of the longer type name.
|
||||
|
||||
include_align : bool
|
||||
If true, this includes the 'align=True' parameter
|
||||
inside the struct dtype construction dict when needed. Use this flag
|
||||
if you want a proper repr string without the 'dtype()' part around it.
|
||||
|
||||
If false, this does not preserve the
|
||||
'align=True' parameter or sticky NPY_ALIGNED_STRUCT flag for
|
||||
struct arrays like the regular repr does, because the 'align'
|
||||
flag is not part of first dtype constructor parameter. This
|
||||
mode is intended for a full 'repr', where the 'align=True' is
|
||||
provided as the second parameter.
|
||||
"""
|
||||
if dtype.fields is not None:
|
||||
return _struct_str(dtype, include_align=include_align)
|
||||
elif dtype.subdtype:
|
||||
return _subarray_str(dtype)
|
||||
else:
|
||||
return _scalar_str(dtype, short=short)
|
||||
|
||||
|
||||
def _scalar_str(dtype, short):
|
||||
byteorder = _byte_order_str(dtype)
|
||||
|
||||
if dtype.type == np.bool_:
|
||||
if short:
|
||||
return "'?'"
|
||||
else:
|
||||
return "'bool'"
|
||||
|
||||
elif dtype.type == np.object_:
|
||||
# The object reference may be different sizes on different
|
||||
# platforms, so it should never include the itemsize here.
|
||||
return "'O'"
|
||||
|
||||
elif dtype.type == np.bytes_:
|
||||
if _isunsized(dtype):
|
||||
return "'S'"
|
||||
else:
|
||||
return "'S%d'" % dtype.itemsize
|
||||
|
||||
elif dtype.type == np.str_:
|
||||
if _isunsized(dtype):
|
||||
return "'%sU'" % byteorder
|
||||
else:
|
||||
return "'%sU%d'" % (byteorder, dtype.itemsize / 4)
|
||||
|
||||
# unlike the other types, subclasses of void are preserved - but
|
||||
# historically the repr does not actually reveal the subclass
|
||||
elif issubclass(dtype.type, np.void):
|
||||
if _isunsized(dtype):
|
||||
return "'V'"
|
||||
else:
|
||||
return "'V%d'" % dtype.itemsize
|
||||
|
||||
elif dtype.type == np.datetime64:
|
||||
return "'%sM8%s'" % (byteorder, _datetime_metadata_str(dtype))
|
||||
|
||||
elif dtype.type == np.timedelta64:
|
||||
return "'%sm8%s'" % (byteorder, _datetime_metadata_str(dtype))
|
||||
|
||||
elif np.issubdtype(dtype, np.number):
|
||||
# Short repr with endianness, like '<f8'
|
||||
if short or dtype.byteorder not in ('=', '|'):
|
||||
return "'%s%c%d'" % (byteorder, dtype.kind, dtype.itemsize)
|
||||
|
||||
# Longer repr, like 'float64'
|
||||
else:
|
||||
return "'%s%d'" % (_kind_name(dtype), 8*dtype.itemsize)
|
||||
|
||||
elif dtype.isbuiltin == 2:
|
||||
return dtype.type.__name__
|
||||
|
||||
else:
|
||||
raise RuntimeError(
|
||||
"Internal error: NumPy dtype unrecognized type number")
|
||||
|
||||
|
||||
def _byte_order_str(dtype):
|
||||
""" Normalize byteorder to '<' or '>' """
|
||||
# hack to obtain the native and swapped byte order characters
|
||||
swapped = np.dtype(int).newbyteorder('S')
|
||||
native = swapped.newbyteorder('S')
|
||||
|
||||
byteorder = dtype.byteorder
|
||||
if byteorder == '=':
|
||||
return native.byteorder
|
||||
if byteorder == 'S':
|
||||
# TODO: this path can never be reached
|
||||
return swapped.byteorder
|
||||
elif byteorder == '|':
|
||||
return ''
|
||||
else:
|
||||
return byteorder
|
||||
|
||||
|
||||
def _datetime_metadata_str(dtype):
|
||||
# TODO: this duplicates the C metastr_to_unicode functionality
|
||||
unit, count = np.datetime_data(dtype)
|
||||
if unit == 'generic':
|
||||
return ''
|
||||
elif count == 1:
|
||||
return '[{}]'.format(unit)
|
||||
else:
|
||||
return '[{}{}]'.format(count, unit)
|
||||
|
||||
|
||||
def _struct_dict_str(dtype, includealignedflag):
|
||||
# unpack the fields dictionary into ls
|
||||
names = dtype.names
|
||||
fld_dtypes = []
|
||||
offsets = []
|
||||
titles = []
|
||||
for name in names:
|
||||
fld_dtype, offset, title = _unpack_field(*dtype.fields[name])
|
||||
fld_dtypes.append(fld_dtype)
|
||||
offsets.append(offset)
|
||||
titles.append(title)
|
||||
|
||||
# Build up a string to make the dictionary
|
||||
|
||||
if np.core.arrayprint._get_legacy_print_mode() <= 121:
|
||||
colon = ":"
|
||||
fieldsep = ","
|
||||
else:
|
||||
colon = ": "
|
||||
fieldsep = ", "
|
||||
|
||||
# First, the names
|
||||
ret = "{'names'%s[" % colon
|
||||
ret += fieldsep.join(repr(name) for name in names)
|
||||
|
||||
# Second, the formats
|
||||
ret += "], 'formats'%s[" % colon
|
||||
ret += fieldsep.join(
|
||||
_construction_repr(fld_dtype, short=True) for fld_dtype in fld_dtypes)
|
||||
|
||||
# Third, the offsets
|
||||
ret += "], 'offsets'%s[" % colon
|
||||
ret += fieldsep.join("%d" % offset for offset in offsets)
|
||||
|
||||
# Fourth, the titles
|
||||
if any(title is not None for title in titles):
|
||||
ret += "], 'titles'%s[" % colon
|
||||
ret += fieldsep.join(repr(title) for title in titles)
|
||||
|
||||
# Fifth, the itemsize
|
||||
ret += "], 'itemsize'%s%d" % (colon, dtype.itemsize)
|
||||
|
||||
if (includealignedflag and dtype.isalignedstruct):
|
||||
# Finally, the aligned flag
|
||||
ret += ", 'aligned'%sTrue}" % colon
|
||||
else:
|
||||
ret += "}"
|
||||
|
||||
return ret
|
||||
|
||||
|
||||
def _aligned_offset(offset, alignment):
|
||||
# round up offset:
|
||||
return - (-offset // alignment) * alignment
|
||||
|
||||
|
||||
def _is_packed(dtype):
|
||||
"""
|
||||
Checks whether the structured data type in 'dtype'
|
||||
has a simple layout, where all the fields are in order,
|
||||
and follow each other with no alignment padding.
|
||||
|
||||
When this returns true, the dtype can be reconstructed
|
||||
from a list of the field names and dtypes with no additional
|
||||
dtype parameters.
|
||||
|
||||
Duplicates the C `is_dtype_struct_simple_unaligned_layout` function.
|
||||
"""
|
||||
align = dtype.isalignedstruct
|
||||
max_alignment = 1
|
||||
total_offset = 0
|
||||
for name in dtype.names:
|
||||
fld_dtype, fld_offset, title = _unpack_field(*dtype.fields[name])
|
||||
|
||||
if align:
|
||||
total_offset = _aligned_offset(total_offset, fld_dtype.alignment)
|
||||
max_alignment = max(max_alignment, fld_dtype.alignment)
|
||||
|
||||
if fld_offset != total_offset:
|
||||
return False
|
||||
total_offset += fld_dtype.itemsize
|
||||
|
||||
if align:
|
||||
total_offset = _aligned_offset(total_offset, max_alignment)
|
||||
|
||||
if total_offset != dtype.itemsize:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _struct_list_str(dtype):
|
||||
items = []
|
||||
for name in dtype.names:
|
||||
fld_dtype, fld_offset, title = _unpack_field(*dtype.fields[name])
|
||||
|
||||
item = "("
|
||||
if title is not None:
|
||||
item += "({!r}, {!r}), ".format(title, name)
|
||||
else:
|
||||
item += "{!r}, ".format(name)
|
||||
# Special case subarray handling here
|
||||
if fld_dtype.subdtype is not None:
|
||||
base, shape = fld_dtype.subdtype
|
||||
item += "{}, {}".format(
|
||||
_construction_repr(base, short=True),
|
||||
shape
|
||||
)
|
||||
else:
|
||||
item += _construction_repr(fld_dtype, short=True)
|
||||
|
||||
item += ")"
|
||||
items.append(item)
|
||||
|
||||
return "[" + ", ".join(items) + "]"
|
||||
|
||||
|
||||
def _struct_str(dtype, include_align):
|
||||
# The list str representation can't include the 'align=' flag,
|
||||
# so if it is requested and the struct has the aligned flag set,
|
||||
# we must use the dict str instead.
|
||||
if not (include_align and dtype.isalignedstruct) and _is_packed(dtype):
|
||||
sub = _struct_list_str(dtype)
|
||||
|
||||
else:
|
||||
sub = _struct_dict_str(dtype, include_align)
|
||||
|
||||
# If the data type isn't the default, void, show it
|
||||
if dtype.type != np.void:
|
||||
return "({t.__module__}.{t.__name__}, {f})".format(t=dtype.type, f=sub)
|
||||
else:
|
||||
return sub
|
||||
|
||||
|
||||
def _subarray_str(dtype):
|
||||
base, shape = dtype.subdtype
|
||||
return "({}, {})".format(
|
||||
_construction_repr(base, short=True),
|
||||
shape
|
||||
)
|
||||
|
||||
|
||||
def _name_includes_bit_suffix(dtype):
|
||||
if dtype.type == np.object_:
|
||||
# pointer size varies by system, best to omit it
|
||||
return False
|
||||
elif dtype.type == np.bool_:
|
||||
# implied
|
||||
return False
|
||||
elif dtype.type is None:
|
||||
return True
|
||||
elif np.issubdtype(dtype, np.flexible) and _isunsized(dtype):
|
||||
# unspecified
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def _name_get(dtype):
|
||||
# provides dtype.name.__get__, documented as returning a "bit name"
|
||||
|
||||
if dtype.isbuiltin == 2:
|
||||
# user dtypes don't promise to do anything special
|
||||
return dtype.type.__name__
|
||||
|
||||
if dtype.kind == '\x00':
|
||||
name = type(dtype).__name__
|
||||
elif issubclass(dtype.type, np.void):
|
||||
# historically, void subclasses preserve their name, eg `record64`
|
||||
name = dtype.type.__name__
|
||||
else:
|
||||
name = _kind_name(dtype)
|
||||
|
||||
# append bit counts
|
||||
if _name_includes_bit_suffix(dtype):
|
||||
name += "{}".format(dtype.itemsize * 8)
|
||||
|
||||
# append metadata to datetimes
|
||||
if dtype.type in (np.datetime64, np.timedelta64):
|
||||
name += _datetime_metadata_str(dtype)
|
||||
|
||||
return name
|
117
teil20b/lib/python3.11/site-packages/numpy/core/_dtype_ctypes.py
Normal file
117
teil20b/lib/python3.11/site-packages/numpy/core/_dtype_ctypes.py
Normal file
@@ -0,0 +1,117 @@
|
||||
"""
|
||||
Conversion from ctypes to dtype.
|
||||
|
||||
In an ideal world, we could achieve this through the PEP3118 buffer protocol,
|
||||
something like::
|
||||
|
||||
def dtype_from_ctypes_type(t):
|
||||
# needed to ensure that the shape of `t` is within memoryview.format
|
||||
class DummyStruct(ctypes.Structure):
|
||||
_fields_ = [('a', t)]
|
||||
|
||||
# empty to avoid memory allocation
|
||||
ctype_0 = (DummyStruct * 0)()
|
||||
mv = memoryview(ctype_0)
|
||||
|
||||
# convert the struct, and slice back out the field
|
||||
return _dtype_from_pep3118(mv.format)['a']
|
||||
|
||||
Unfortunately, this fails because:
|
||||
|
||||
* ctypes cannot handle length-0 arrays with PEP3118 (bpo-32782)
|
||||
* PEP3118 cannot represent unions, but both numpy and ctypes can
|
||||
* ctypes cannot handle big-endian structs with PEP3118 (bpo-32780)
|
||||
"""
|
||||
|
||||
# We delay-import ctypes for distributions that do not include it.
|
||||
# While this module is not used unless the user passes in ctypes
|
||||
# members, it is eagerly imported from numpy/core/__init__.py.
|
||||
import numpy as np
|
||||
|
||||
|
||||
def _from_ctypes_array(t):
|
||||
return np.dtype((dtype_from_ctypes_type(t._type_), (t._length_,)))
|
||||
|
||||
|
||||
def _from_ctypes_structure(t):
|
||||
for item in t._fields_:
|
||||
if len(item) > 2:
|
||||
raise TypeError(
|
||||
"ctypes bitfields have no dtype equivalent")
|
||||
|
||||
if hasattr(t, "_pack_"):
|
||||
import ctypes
|
||||
formats = []
|
||||
offsets = []
|
||||
names = []
|
||||
current_offset = 0
|
||||
for fname, ftyp in t._fields_:
|
||||
names.append(fname)
|
||||
formats.append(dtype_from_ctypes_type(ftyp))
|
||||
# Each type has a default offset, this is platform dependent for some types.
|
||||
effective_pack = min(t._pack_, ctypes.alignment(ftyp))
|
||||
current_offset = ((current_offset + effective_pack - 1) // effective_pack) * effective_pack
|
||||
offsets.append(current_offset)
|
||||
current_offset += ctypes.sizeof(ftyp)
|
||||
|
||||
return np.dtype(dict(
|
||||
formats=formats,
|
||||
offsets=offsets,
|
||||
names=names,
|
||||
itemsize=ctypes.sizeof(t)))
|
||||
else:
|
||||
fields = []
|
||||
for fname, ftyp in t._fields_:
|
||||
fields.append((fname, dtype_from_ctypes_type(ftyp)))
|
||||
|
||||
# by default, ctypes structs are aligned
|
||||
return np.dtype(fields, align=True)
|
||||
|
||||
|
||||
def _from_ctypes_scalar(t):
|
||||
"""
|
||||
Return the dtype type with endianness included if it's the case
|
||||
"""
|
||||
if getattr(t, '__ctype_be__', None) is t:
|
||||
return np.dtype('>' + t._type_)
|
||||
elif getattr(t, '__ctype_le__', None) is t:
|
||||
return np.dtype('<' + t._type_)
|
||||
else:
|
||||
return np.dtype(t._type_)
|
||||
|
||||
|
||||
def _from_ctypes_union(t):
|
||||
import ctypes
|
||||
formats = []
|
||||
offsets = []
|
||||
names = []
|
||||
for fname, ftyp in t._fields_:
|
||||
names.append(fname)
|
||||
formats.append(dtype_from_ctypes_type(ftyp))
|
||||
offsets.append(0) # Union fields are offset to 0
|
||||
|
||||
return np.dtype(dict(
|
||||
formats=formats,
|
||||
offsets=offsets,
|
||||
names=names,
|
||||
itemsize=ctypes.sizeof(t)))
|
||||
|
||||
|
||||
def dtype_from_ctypes_type(t):
|
||||
"""
|
||||
Construct a dtype object from a ctypes type
|
||||
"""
|
||||
import _ctypes
|
||||
if issubclass(t, _ctypes.Array):
|
||||
return _from_ctypes_array(t)
|
||||
elif issubclass(t, _ctypes._Pointer):
|
||||
raise TypeError("ctypes pointers have no dtype equivalent")
|
||||
elif issubclass(t, _ctypes.Structure):
|
||||
return _from_ctypes_structure(t)
|
||||
elif issubclass(t, _ctypes.Union):
|
||||
return _from_ctypes_union(t)
|
||||
elif isinstance(getattr(t, '_type_', None), str):
|
||||
return _from_ctypes_scalar(t)
|
||||
else:
|
||||
raise NotImplementedError(
|
||||
"Unknown ctypes type {}".format(t.__name__))
|
172
teil20b/lib/python3.11/site-packages/numpy/core/_exceptions.py
Normal file
172
teil20b/lib/python3.11/site-packages/numpy/core/_exceptions.py
Normal file
@@ -0,0 +1,172 @@
|
||||
"""
|
||||
Various richly-typed exceptions, that also help us deal with string formatting
|
||||
in python where it's easier.
|
||||
|
||||
By putting the formatting in `__str__`, we also avoid paying the cost for
|
||||
users who silence the exceptions.
|
||||
"""
|
||||
from .._utils import set_module
|
||||
|
||||
def _unpack_tuple(tup):
|
||||
if len(tup) == 1:
|
||||
return tup[0]
|
||||
else:
|
||||
return tup
|
||||
|
||||
|
||||
def _display_as_base(cls):
|
||||
"""
|
||||
A decorator that makes an exception class look like its base.
|
||||
|
||||
We use this to hide subclasses that are implementation details - the user
|
||||
should catch the base type, which is what the traceback will show them.
|
||||
|
||||
Classes decorated with this decorator are subject to removal without a
|
||||
deprecation warning.
|
||||
"""
|
||||
assert issubclass(cls, Exception)
|
||||
cls.__name__ = cls.__base__.__name__
|
||||
return cls
|
||||
|
||||
|
||||
class UFuncTypeError(TypeError):
|
||||
""" Base class for all ufunc exceptions """
|
||||
def __init__(self, ufunc):
|
||||
self.ufunc = ufunc
|
||||
|
||||
|
||||
@_display_as_base
|
||||
class _UFuncNoLoopError(UFuncTypeError):
|
||||
""" Thrown when a ufunc loop cannot be found """
|
||||
def __init__(self, ufunc, dtypes):
|
||||
super().__init__(ufunc)
|
||||
self.dtypes = tuple(dtypes)
|
||||
|
||||
def __str__(self):
|
||||
return (
|
||||
"ufunc {!r} did not contain a loop with signature matching types "
|
||||
"{!r} -> {!r}"
|
||||
).format(
|
||||
self.ufunc.__name__,
|
||||
_unpack_tuple(self.dtypes[:self.ufunc.nin]),
|
||||
_unpack_tuple(self.dtypes[self.ufunc.nin:])
|
||||
)
|
||||
|
||||
|
||||
@_display_as_base
|
||||
class _UFuncBinaryResolutionError(_UFuncNoLoopError):
|
||||
""" Thrown when a binary resolution fails """
|
||||
def __init__(self, ufunc, dtypes):
|
||||
super().__init__(ufunc, dtypes)
|
||||
assert len(self.dtypes) == 2
|
||||
|
||||
def __str__(self):
|
||||
return (
|
||||
"ufunc {!r} cannot use operands with types {!r} and {!r}"
|
||||
).format(
|
||||
self.ufunc.__name__, *self.dtypes
|
||||
)
|
||||
|
||||
|
||||
@_display_as_base
|
||||
class _UFuncCastingError(UFuncTypeError):
|
||||
def __init__(self, ufunc, casting, from_, to):
|
||||
super().__init__(ufunc)
|
||||
self.casting = casting
|
||||
self.from_ = from_
|
||||
self.to = to
|
||||
|
||||
|
||||
@_display_as_base
|
||||
class _UFuncInputCastingError(_UFuncCastingError):
|
||||
""" Thrown when a ufunc input cannot be casted """
|
||||
def __init__(self, ufunc, casting, from_, to, i):
|
||||
super().__init__(ufunc, casting, from_, to)
|
||||
self.in_i = i
|
||||
|
||||
def __str__(self):
|
||||
# only show the number if more than one input exists
|
||||
i_str = "{} ".format(self.in_i) if self.ufunc.nin != 1 else ""
|
||||
return (
|
||||
"Cannot cast ufunc {!r} input {}from {!r} to {!r} with casting "
|
||||
"rule {!r}"
|
||||
).format(
|
||||
self.ufunc.__name__, i_str, self.from_, self.to, self.casting
|
||||
)
|
||||
|
||||
|
||||
@_display_as_base
|
||||
class _UFuncOutputCastingError(_UFuncCastingError):
|
||||
""" Thrown when a ufunc output cannot be casted """
|
||||
def __init__(self, ufunc, casting, from_, to, i):
|
||||
super().__init__(ufunc, casting, from_, to)
|
||||
self.out_i = i
|
||||
|
||||
def __str__(self):
|
||||
# only show the number if more than one output exists
|
||||
i_str = "{} ".format(self.out_i) if self.ufunc.nout != 1 else ""
|
||||
return (
|
||||
"Cannot cast ufunc {!r} output {}from {!r} to {!r} with casting "
|
||||
"rule {!r}"
|
||||
).format(
|
||||
self.ufunc.__name__, i_str, self.from_, self.to, self.casting
|
||||
)
|
||||
|
||||
|
||||
@_display_as_base
|
||||
class _ArrayMemoryError(MemoryError):
|
||||
""" Thrown when an array cannot be allocated"""
|
||||
def __init__(self, shape, dtype):
|
||||
self.shape = shape
|
||||
self.dtype = dtype
|
||||
|
||||
@property
|
||||
def _total_size(self):
|
||||
num_bytes = self.dtype.itemsize
|
||||
for dim in self.shape:
|
||||
num_bytes *= dim
|
||||
return num_bytes
|
||||
|
||||
@staticmethod
|
||||
def _size_to_string(num_bytes):
|
||||
""" Convert a number of bytes into a binary size string """
|
||||
|
||||
# https://en.wikipedia.org/wiki/Binary_prefix
|
||||
LOG2_STEP = 10
|
||||
STEP = 1024
|
||||
units = ['bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB']
|
||||
|
||||
unit_i = max(num_bytes.bit_length() - 1, 1) // LOG2_STEP
|
||||
unit_val = 1 << (unit_i * LOG2_STEP)
|
||||
n_units = num_bytes / unit_val
|
||||
del unit_val
|
||||
|
||||
# ensure we pick a unit that is correct after rounding
|
||||
if round(n_units) == STEP:
|
||||
unit_i += 1
|
||||
n_units /= STEP
|
||||
|
||||
# deal with sizes so large that we don't have units for them
|
||||
if unit_i >= len(units):
|
||||
new_unit_i = len(units) - 1
|
||||
n_units *= 1 << ((unit_i - new_unit_i) * LOG2_STEP)
|
||||
unit_i = new_unit_i
|
||||
|
||||
unit_name = units[unit_i]
|
||||
# format with a sensible number of digits
|
||||
if unit_i == 0:
|
||||
# no decimal point on bytes
|
||||
return '{:.0f} {}'.format(n_units, unit_name)
|
||||
elif round(n_units) < 1000:
|
||||
# 3 significant figures, if none are dropped to the left of the .
|
||||
return '{:#.3g} {}'.format(n_units, unit_name)
|
||||
else:
|
||||
# just give all the digits otherwise
|
||||
return '{:#.0f} {}'.format(n_units, unit_name)
|
||||
|
||||
def __str__(self):
|
||||
size_str = self._size_to_string(self._total_size)
|
||||
return (
|
||||
"Unable to allocate {} for an array with shape {} and data type {}"
|
||||
.format(size_str, self.shape, self.dtype)
|
||||
)
|
935
teil20b/lib/python3.11/site-packages/numpy/core/_internal.py
Normal file
935
teil20b/lib/python3.11/site-packages/numpy/core/_internal.py
Normal file
@@ -0,0 +1,935 @@
|
||||
"""
|
||||
A place for internal code
|
||||
|
||||
Some things are more easily handled Python.
|
||||
|
||||
"""
|
||||
import ast
|
||||
import re
|
||||
import sys
|
||||
import warnings
|
||||
|
||||
from ..exceptions import DTypePromotionError
|
||||
from .multiarray import dtype, array, ndarray, promote_types
|
||||
try:
|
||||
import ctypes
|
||||
except ImportError:
|
||||
ctypes = None
|
||||
|
||||
IS_PYPY = sys.implementation.name == 'pypy'
|
||||
|
||||
if sys.byteorder == 'little':
|
||||
_nbo = '<'
|
||||
else:
|
||||
_nbo = '>'
|
||||
|
||||
def _makenames_list(adict, align):
|
||||
allfields = []
|
||||
|
||||
for fname, obj in adict.items():
|
||||
n = len(obj)
|
||||
if not isinstance(obj, tuple) or n not in (2, 3):
|
||||
raise ValueError("entry not a 2- or 3- tuple")
|
||||
if n > 2 and obj[2] == fname:
|
||||
continue
|
||||
num = int(obj[1])
|
||||
if num < 0:
|
||||
raise ValueError("invalid offset.")
|
||||
format = dtype(obj[0], align=align)
|
||||
if n > 2:
|
||||
title = obj[2]
|
||||
else:
|
||||
title = None
|
||||
allfields.append((fname, format, num, title))
|
||||
# sort by offsets
|
||||
allfields.sort(key=lambda x: x[2])
|
||||
names = [x[0] for x in allfields]
|
||||
formats = [x[1] for x in allfields]
|
||||
offsets = [x[2] for x in allfields]
|
||||
titles = [x[3] for x in allfields]
|
||||
|
||||
return names, formats, offsets, titles
|
||||
|
||||
# Called in PyArray_DescrConverter function when
|
||||
# a dictionary without "names" and "formats"
|
||||
# fields is used as a data-type descriptor.
|
||||
def _usefields(adict, align):
|
||||
try:
|
||||
names = adict[-1]
|
||||
except KeyError:
|
||||
names = None
|
||||
if names is None:
|
||||
names, formats, offsets, titles = _makenames_list(adict, align)
|
||||
else:
|
||||
formats = []
|
||||
offsets = []
|
||||
titles = []
|
||||
for name in names:
|
||||
res = adict[name]
|
||||
formats.append(res[0])
|
||||
offsets.append(res[1])
|
||||
if len(res) > 2:
|
||||
titles.append(res[2])
|
||||
else:
|
||||
titles.append(None)
|
||||
|
||||
return dtype({"names": names,
|
||||
"formats": formats,
|
||||
"offsets": offsets,
|
||||
"titles": titles}, align)
|
||||
|
||||
|
||||
# construct an array_protocol descriptor list
|
||||
# from the fields attribute of a descriptor
|
||||
# This calls itself recursively but should eventually hit
|
||||
# a descriptor that has no fields and then return
|
||||
# a simple typestring
|
||||
|
||||
def _array_descr(descriptor):
|
||||
fields = descriptor.fields
|
||||
if fields is None:
|
||||
subdtype = descriptor.subdtype
|
||||
if subdtype is None:
|
||||
if descriptor.metadata is None:
|
||||
return descriptor.str
|
||||
else:
|
||||
new = descriptor.metadata.copy()
|
||||
if new:
|
||||
return (descriptor.str, new)
|
||||
else:
|
||||
return descriptor.str
|
||||
else:
|
||||
return (_array_descr(subdtype[0]), subdtype[1])
|
||||
|
||||
names = descriptor.names
|
||||
ordered_fields = [fields[x] + (x,) for x in names]
|
||||
result = []
|
||||
offset = 0
|
||||
for field in ordered_fields:
|
||||
if field[1] > offset:
|
||||
num = field[1] - offset
|
||||
result.append(('', f'|V{num}'))
|
||||
offset += num
|
||||
elif field[1] < offset:
|
||||
raise ValueError(
|
||||
"dtype.descr is not defined for types with overlapping or "
|
||||
"out-of-order fields")
|
||||
if len(field) > 3:
|
||||
name = (field[2], field[3])
|
||||
else:
|
||||
name = field[2]
|
||||
if field[0].subdtype:
|
||||
tup = (name, _array_descr(field[0].subdtype[0]),
|
||||
field[0].subdtype[1])
|
||||
else:
|
||||
tup = (name, _array_descr(field[0]))
|
||||
offset += field[0].itemsize
|
||||
result.append(tup)
|
||||
|
||||
if descriptor.itemsize > offset:
|
||||
num = descriptor.itemsize - offset
|
||||
result.append(('', f'|V{num}'))
|
||||
|
||||
return result
|
||||
|
||||
# Build a new array from the information in a pickle.
|
||||
# Note that the name numpy.core._internal._reconstruct is embedded in
|
||||
# pickles of ndarrays made with NumPy before release 1.0
|
||||
# so don't remove the name here, or you'll
|
||||
# break backward compatibility.
|
||||
def _reconstruct(subtype, shape, dtype):
|
||||
return ndarray.__new__(subtype, shape, dtype)
|
||||
|
||||
|
||||
# format_re was originally from numarray by J. Todd Miller
|
||||
|
||||
format_re = re.compile(r'(?P<order1>[<>|=]?)'
|
||||
r'(?P<repeats> *[(]?[ ,0-9]*[)]? *)'
|
||||
r'(?P<order2>[<>|=]?)'
|
||||
r'(?P<dtype>[A-Za-z0-9.?]*(?:\[[a-zA-Z0-9,.]+\])?)')
|
||||
sep_re = re.compile(r'\s*,\s*')
|
||||
space_re = re.compile(r'\s+$')
|
||||
|
||||
# astr is a string (perhaps comma separated)
|
||||
|
||||
_convorder = {'=': _nbo}
|
||||
|
||||
def _commastring(astr):
|
||||
startindex = 0
|
||||
result = []
|
||||
while startindex < len(astr):
|
||||
mo = format_re.match(astr, pos=startindex)
|
||||
try:
|
||||
(order1, repeats, order2, dtype) = mo.groups()
|
||||
except (TypeError, AttributeError):
|
||||
raise ValueError(
|
||||
f'format number {len(result)+1} of "{astr}" is not recognized'
|
||||
) from None
|
||||
startindex = mo.end()
|
||||
# Separator or ending padding
|
||||
if startindex < len(astr):
|
||||
if space_re.match(astr, pos=startindex):
|
||||
startindex = len(astr)
|
||||
else:
|
||||
mo = sep_re.match(astr, pos=startindex)
|
||||
if not mo:
|
||||
raise ValueError(
|
||||
'format number %d of "%s" is not recognized' %
|
||||
(len(result)+1, astr))
|
||||
startindex = mo.end()
|
||||
|
||||
if order2 == '':
|
||||
order = order1
|
||||
elif order1 == '':
|
||||
order = order2
|
||||
else:
|
||||
order1 = _convorder.get(order1, order1)
|
||||
order2 = _convorder.get(order2, order2)
|
||||
if (order1 != order2):
|
||||
raise ValueError(
|
||||
'inconsistent byte-order specification %s and %s' %
|
||||
(order1, order2))
|
||||
order = order1
|
||||
|
||||
if order in ('|', '=', _nbo):
|
||||
order = ''
|
||||
dtype = order + dtype
|
||||
if (repeats == ''):
|
||||
newitem = dtype
|
||||
else:
|
||||
newitem = (dtype, ast.literal_eval(repeats))
|
||||
result.append(newitem)
|
||||
|
||||
return result
|
||||
|
||||
class dummy_ctype:
|
||||
def __init__(self, cls):
|
||||
self._cls = cls
|
||||
def __mul__(self, other):
|
||||
return self
|
||||
def __call__(self, *other):
|
||||
return self._cls(other)
|
||||
def __eq__(self, other):
|
||||
return self._cls == other._cls
|
||||
def __ne__(self, other):
|
||||
return self._cls != other._cls
|
||||
|
||||
def _getintp_ctype():
|
||||
val = _getintp_ctype.cache
|
||||
if val is not None:
|
||||
return val
|
||||
if ctypes is None:
|
||||
import numpy as np
|
||||
val = dummy_ctype(np.intp)
|
||||
else:
|
||||
char = dtype('p').char
|
||||
if char == 'i':
|
||||
val = ctypes.c_int
|
||||
elif char == 'l':
|
||||
val = ctypes.c_long
|
||||
elif char == 'q':
|
||||
val = ctypes.c_longlong
|
||||
else:
|
||||
val = ctypes.c_long
|
||||
_getintp_ctype.cache = val
|
||||
return val
|
||||
_getintp_ctype.cache = None
|
||||
|
||||
# Used for .ctypes attribute of ndarray
|
||||
|
||||
class _missing_ctypes:
|
||||
def cast(self, num, obj):
|
||||
return num.value
|
||||
|
||||
class c_void_p:
|
||||
def __init__(self, ptr):
|
||||
self.value = ptr
|
||||
|
||||
|
||||
class _ctypes:
|
||||
def __init__(self, array, ptr=None):
|
||||
self._arr = array
|
||||
|
||||
if ctypes:
|
||||
self._ctypes = ctypes
|
||||
self._data = self._ctypes.c_void_p(ptr)
|
||||
else:
|
||||
# fake a pointer-like object that holds onto the reference
|
||||
self._ctypes = _missing_ctypes()
|
||||
self._data = self._ctypes.c_void_p(ptr)
|
||||
self._data._objects = array
|
||||
|
||||
if self._arr.ndim == 0:
|
||||
self._zerod = True
|
||||
else:
|
||||
self._zerod = False
|
||||
|
||||
def data_as(self, obj):
|
||||
"""
|
||||
Return the data pointer cast to a particular c-types object.
|
||||
For example, calling ``self._as_parameter_`` is equivalent to
|
||||
``self.data_as(ctypes.c_void_p)``. Perhaps you want to use the data as a
|
||||
pointer to a ctypes array of floating-point data:
|
||||
``self.data_as(ctypes.POINTER(ctypes.c_double))``.
|
||||
|
||||
The returned pointer will keep a reference to the array.
|
||||
"""
|
||||
# _ctypes.cast function causes a circular reference of self._data in
|
||||
# self._data._objects. Attributes of self._data cannot be released
|
||||
# until gc.collect is called. Make a copy of the pointer first then let
|
||||
# it hold the array reference. This is a workaround to circumvent the
|
||||
# CPython bug https://bugs.python.org/issue12836
|
||||
ptr = self._ctypes.cast(self._data, obj)
|
||||
ptr._arr = self._arr
|
||||
return ptr
|
||||
|
||||
def shape_as(self, obj):
|
||||
"""
|
||||
Return the shape tuple as an array of some other c-types
|
||||
type. For example: ``self.shape_as(ctypes.c_short)``.
|
||||
"""
|
||||
if self._zerod:
|
||||
return None
|
||||
return (obj*self._arr.ndim)(*self._arr.shape)
|
||||
|
||||
def strides_as(self, obj):
|
||||
"""
|
||||
Return the strides tuple as an array of some other
|
||||
c-types type. For example: ``self.strides_as(ctypes.c_longlong)``.
|
||||
"""
|
||||
if self._zerod:
|
||||
return None
|
||||
return (obj*self._arr.ndim)(*self._arr.strides)
|
||||
|
||||
@property
|
||||
def data(self):
|
||||
"""
|
||||
A pointer to the memory area of the array as a Python integer.
|
||||
This memory area may contain data that is not aligned, or not in correct
|
||||
byte-order. The memory area may not even be writeable. The array
|
||||
flags and data-type of this array should be respected when passing this
|
||||
attribute to arbitrary C-code to avoid trouble that can include Python
|
||||
crashing. User Beware! The value of this attribute is exactly the same
|
||||
as ``self._array_interface_['data'][0]``.
|
||||
|
||||
Note that unlike ``data_as``, a reference will not be kept to the array:
|
||||
code like ``ctypes.c_void_p((a + b).ctypes.data)`` will result in a
|
||||
pointer to a deallocated array, and should be spelt
|
||||
``(a + b).ctypes.data_as(ctypes.c_void_p)``
|
||||
"""
|
||||
return self._data.value
|
||||
|
||||
@property
|
||||
def shape(self):
|
||||
"""
|
||||
(c_intp*self.ndim): A ctypes array of length self.ndim where
|
||||
the basetype is the C-integer corresponding to ``dtype('p')`` on this
|
||||
platform (see `~numpy.ctypeslib.c_intp`). This base-type could be
|
||||
`ctypes.c_int`, `ctypes.c_long`, or `ctypes.c_longlong` depending on
|
||||
the platform. The ctypes array contains the shape of
|
||||
the underlying array.
|
||||
"""
|
||||
return self.shape_as(_getintp_ctype())
|
||||
|
||||
@property
|
||||
def strides(self):
|
||||
"""
|
||||
(c_intp*self.ndim): A ctypes array of length self.ndim where
|
||||
the basetype is the same as for the shape attribute. This ctypes array
|
||||
contains the strides information from the underlying array. This strides
|
||||
information is important for showing how many bytes must be jumped to
|
||||
get to the next element in the array.
|
||||
"""
|
||||
return self.strides_as(_getintp_ctype())
|
||||
|
||||
@property
|
||||
def _as_parameter_(self):
|
||||
"""
|
||||
Overrides the ctypes semi-magic method
|
||||
|
||||
Enables `c_func(some_array.ctypes)`
|
||||
"""
|
||||
return self.data_as(ctypes.c_void_p)
|
||||
|
||||
# Numpy 1.21.0, 2021-05-18
|
||||
|
||||
def get_data(self):
|
||||
"""Deprecated getter for the `_ctypes.data` property.
|
||||
|
||||
.. deprecated:: 1.21
|
||||
"""
|
||||
warnings.warn('"get_data" is deprecated. Use "data" instead',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
return self.data
|
||||
|
||||
def get_shape(self):
|
||||
"""Deprecated getter for the `_ctypes.shape` property.
|
||||
|
||||
.. deprecated:: 1.21
|
||||
"""
|
||||
warnings.warn('"get_shape" is deprecated. Use "shape" instead',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
return self.shape
|
||||
|
||||
def get_strides(self):
|
||||
"""Deprecated getter for the `_ctypes.strides` property.
|
||||
|
||||
.. deprecated:: 1.21
|
||||
"""
|
||||
warnings.warn('"get_strides" is deprecated. Use "strides" instead',
|
||||
DeprecationWarning, stacklevel=2)
|
||||
return self.strides
|
||||
|
||||
def get_as_parameter(self):
|
||||
"""Deprecated getter for the `_ctypes._as_parameter_` property.
|
||||
|
||||
.. deprecated:: 1.21
|
||||
"""
|
||||
warnings.warn(
|
||||
'"get_as_parameter" is deprecated. Use "_as_parameter_" instead',
|
||||
DeprecationWarning, stacklevel=2,
|
||||
)
|
||||
return self._as_parameter_
|
||||
|
||||
|
||||
def _newnames(datatype, order):
|
||||
"""
|
||||
Given a datatype and an order object, return a new names tuple, with the
|
||||
order indicated
|
||||
"""
|
||||
oldnames = datatype.names
|
||||
nameslist = list(oldnames)
|
||||
if isinstance(order, str):
|
||||
order = [order]
|
||||
seen = set()
|
||||
if isinstance(order, (list, tuple)):
|
||||
for name in order:
|
||||
try:
|
||||
nameslist.remove(name)
|
||||
except ValueError:
|
||||
if name in seen:
|
||||
raise ValueError(f"duplicate field name: {name}") from None
|
||||
else:
|
||||
raise ValueError(f"unknown field name: {name}") from None
|
||||
seen.add(name)
|
||||
return tuple(list(order) + nameslist)
|
||||
raise ValueError(f"unsupported order value: {order}")
|
||||
|
||||
def _copy_fields(ary):
|
||||
"""Return copy of structured array with padding between fields removed.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ary : ndarray
|
||||
Structured array from which to remove padding bytes
|
||||
|
||||
Returns
|
||||
-------
|
||||
ary_copy : ndarray
|
||||
Copy of ary with padding bytes removed
|
||||
"""
|
||||
dt = ary.dtype
|
||||
copy_dtype = {'names': dt.names,
|
||||
'formats': [dt.fields[name][0] for name in dt.names]}
|
||||
return array(ary, dtype=copy_dtype, copy=True)
|
||||
|
||||
def _promote_fields(dt1, dt2):
|
||||
""" Perform type promotion for two structured dtypes.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dt1 : structured dtype
|
||||
First dtype.
|
||||
dt2 : structured dtype
|
||||
Second dtype.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : dtype
|
||||
The promoted dtype
|
||||
|
||||
Notes
|
||||
-----
|
||||
If one of the inputs is aligned, the result will be. The titles of
|
||||
both descriptors must match (point to the same field).
|
||||
"""
|
||||
# Both must be structured and have the same names in the same order
|
||||
if (dt1.names is None or dt2.names is None) or dt1.names != dt2.names:
|
||||
raise DTypePromotionError(
|
||||
f"field names `{dt1.names}` and `{dt2.names}` mismatch.")
|
||||
|
||||
# if both are identical, we can (maybe!) just return the same dtype.
|
||||
identical = dt1 is dt2
|
||||
new_fields = []
|
||||
for name in dt1.names:
|
||||
field1 = dt1.fields[name]
|
||||
field2 = dt2.fields[name]
|
||||
new_descr = promote_types(field1[0], field2[0])
|
||||
identical = identical and new_descr is field1[0]
|
||||
|
||||
# Check that the titles match (if given):
|
||||
if field1[2:] != field2[2:]:
|
||||
raise DTypePromotionError(
|
||||
f"field titles of field '{name}' mismatch")
|
||||
if len(field1) == 2:
|
||||
new_fields.append((name, new_descr))
|
||||
else:
|
||||
new_fields.append(((field1[2], name), new_descr))
|
||||
|
||||
res = dtype(new_fields, align=dt1.isalignedstruct or dt2.isalignedstruct)
|
||||
|
||||
# Might as well preserve identity (and metadata) if the dtype is identical
|
||||
# and the itemsize, offsets are also unmodified. This could probably be
|
||||
# sped up, but also probably just be removed entirely.
|
||||
if identical and res.itemsize == dt1.itemsize:
|
||||
for name in dt1.names:
|
||||
if dt1.fields[name][1] != res.fields[name][1]:
|
||||
return res # the dtype changed.
|
||||
return dt1
|
||||
|
||||
return res
|
||||
|
||||
|
||||
def _getfield_is_safe(oldtype, newtype, offset):
|
||||
""" Checks safety of getfield for object arrays.
|
||||
|
||||
As in _view_is_safe, we need to check that memory containing objects is not
|
||||
reinterpreted as a non-object datatype and vice versa.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
oldtype : data-type
|
||||
Data type of the original ndarray.
|
||||
newtype : data-type
|
||||
Data type of the field being accessed by ndarray.getfield
|
||||
offset : int
|
||||
Offset of the field being accessed by ndarray.getfield
|
||||
|
||||
Raises
|
||||
------
|
||||
TypeError
|
||||
If the field access is invalid
|
||||
|
||||
"""
|
||||
if newtype.hasobject or oldtype.hasobject:
|
||||
if offset == 0 and newtype == oldtype:
|
||||
return
|
||||
if oldtype.names is not None:
|
||||
for name in oldtype.names:
|
||||
if (oldtype.fields[name][1] == offset and
|
||||
oldtype.fields[name][0] == newtype):
|
||||
return
|
||||
raise TypeError("Cannot get/set field of an object array")
|
||||
return
|
||||
|
||||
def _view_is_safe(oldtype, newtype):
|
||||
""" Checks safety of a view involving object arrays, for example when
|
||||
doing::
|
||||
|
||||
np.zeros(10, dtype=oldtype).view(newtype)
|
||||
|
||||
Parameters
|
||||
----------
|
||||
oldtype : data-type
|
||||
Data type of original ndarray
|
||||
newtype : data-type
|
||||
Data type of the view
|
||||
|
||||
Raises
|
||||
------
|
||||
TypeError
|
||||
If the new type is incompatible with the old type.
|
||||
|
||||
"""
|
||||
|
||||
# if the types are equivalent, there is no problem.
|
||||
# for example: dtype((np.record, 'i4,i4')) == dtype((np.void, 'i4,i4'))
|
||||
if oldtype == newtype:
|
||||
return
|
||||
|
||||
if newtype.hasobject or oldtype.hasobject:
|
||||
raise TypeError("Cannot change data-type for object array.")
|
||||
return
|
||||
|
||||
# Given a string containing a PEP 3118 format specifier,
|
||||
# construct a NumPy dtype
|
||||
|
||||
_pep3118_native_map = {
|
||||
'?': '?',
|
||||
'c': 'S1',
|
||||
'b': 'b',
|
||||
'B': 'B',
|
||||
'h': 'h',
|
||||
'H': 'H',
|
||||
'i': 'i',
|
||||
'I': 'I',
|
||||
'l': 'l',
|
||||
'L': 'L',
|
||||
'q': 'q',
|
||||
'Q': 'Q',
|
||||
'e': 'e',
|
||||
'f': 'f',
|
||||
'd': 'd',
|
||||
'g': 'g',
|
||||
'Zf': 'F',
|
||||
'Zd': 'D',
|
||||
'Zg': 'G',
|
||||
's': 'S',
|
||||
'w': 'U',
|
||||
'O': 'O',
|
||||
'x': 'V', # padding
|
||||
}
|
||||
_pep3118_native_typechars = ''.join(_pep3118_native_map.keys())
|
||||
|
||||
_pep3118_standard_map = {
|
||||
'?': '?',
|
||||
'c': 'S1',
|
||||
'b': 'b',
|
||||
'B': 'B',
|
||||
'h': 'i2',
|
||||
'H': 'u2',
|
||||
'i': 'i4',
|
||||
'I': 'u4',
|
||||
'l': 'i4',
|
||||
'L': 'u4',
|
||||
'q': 'i8',
|
||||
'Q': 'u8',
|
||||
'e': 'f2',
|
||||
'f': 'f',
|
||||
'd': 'd',
|
||||
'Zf': 'F',
|
||||
'Zd': 'D',
|
||||
's': 'S',
|
||||
'w': 'U',
|
||||
'O': 'O',
|
||||
'x': 'V', # padding
|
||||
}
|
||||
_pep3118_standard_typechars = ''.join(_pep3118_standard_map.keys())
|
||||
|
||||
_pep3118_unsupported_map = {
|
||||
'u': 'UCS-2 strings',
|
||||
'&': 'pointers',
|
||||
't': 'bitfields',
|
||||
'X': 'function pointers',
|
||||
}
|
||||
|
||||
class _Stream:
|
||||
def __init__(self, s):
|
||||
self.s = s
|
||||
self.byteorder = '@'
|
||||
|
||||
def advance(self, n):
|
||||
res = self.s[:n]
|
||||
self.s = self.s[n:]
|
||||
return res
|
||||
|
||||
def consume(self, c):
|
||||
if self.s[:len(c)] == c:
|
||||
self.advance(len(c))
|
||||
return True
|
||||
return False
|
||||
|
||||
def consume_until(self, c):
|
||||
if callable(c):
|
||||
i = 0
|
||||
while i < len(self.s) and not c(self.s[i]):
|
||||
i = i + 1
|
||||
return self.advance(i)
|
||||
else:
|
||||
i = self.s.index(c)
|
||||
res = self.advance(i)
|
||||
self.advance(len(c))
|
||||
return res
|
||||
|
||||
@property
|
||||
def next(self):
|
||||
return self.s[0]
|
||||
|
||||
def __bool__(self):
|
||||
return bool(self.s)
|
||||
|
||||
|
||||
def _dtype_from_pep3118(spec):
|
||||
stream = _Stream(spec)
|
||||
dtype, align = __dtype_from_pep3118(stream, is_subdtype=False)
|
||||
return dtype
|
||||
|
||||
def __dtype_from_pep3118(stream, is_subdtype):
|
||||
field_spec = dict(
|
||||
names=[],
|
||||
formats=[],
|
||||
offsets=[],
|
||||
itemsize=0
|
||||
)
|
||||
offset = 0
|
||||
common_alignment = 1
|
||||
is_padding = False
|
||||
|
||||
# Parse spec
|
||||
while stream:
|
||||
value = None
|
||||
|
||||
# End of structure, bail out to upper level
|
||||
if stream.consume('}'):
|
||||
break
|
||||
|
||||
# Sub-arrays (1)
|
||||
shape = None
|
||||
if stream.consume('('):
|
||||
shape = stream.consume_until(')')
|
||||
shape = tuple(map(int, shape.split(',')))
|
||||
|
||||
# Byte order
|
||||
if stream.next in ('@', '=', '<', '>', '^', '!'):
|
||||
byteorder = stream.advance(1)
|
||||
if byteorder == '!':
|
||||
byteorder = '>'
|
||||
stream.byteorder = byteorder
|
||||
|
||||
# Byte order characters also control native vs. standard type sizes
|
||||
if stream.byteorder in ('@', '^'):
|
||||
type_map = _pep3118_native_map
|
||||
type_map_chars = _pep3118_native_typechars
|
||||
else:
|
||||
type_map = _pep3118_standard_map
|
||||
type_map_chars = _pep3118_standard_typechars
|
||||
|
||||
# Item sizes
|
||||
itemsize_str = stream.consume_until(lambda c: not c.isdigit())
|
||||
if itemsize_str:
|
||||
itemsize = int(itemsize_str)
|
||||
else:
|
||||
itemsize = 1
|
||||
|
||||
# Data types
|
||||
is_padding = False
|
||||
|
||||
if stream.consume('T{'):
|
||||
value, align = __dtype_from_pep3118(
|
||||
stream, is_subdtype=True)
|
||||
elif stream.next in type_map_chars:
|
||||
if stream.next == 'Z':
|
||||
typechar = stream.advance(2)
|
||||
else:
|
||||
typechar = stream.advance(1)
|
||||
|
||||
is_padding = (typechar == 'x')
|
||||
dtypechar = type_map[typechar]
|
||||
if dtypechar in 'USV':
|
||||
dtypechar += '%d' % itemsize
|
||||
itemsize = 1
|
||||
numpy_byteorder = {'@': '=', '^': '='}.get(
|
||||
stream.byteorder, stream.byteorder)
|
||||
value = dtype(numpy_byteorder + dtypechar)
|
||||
align = value.alignment
|
||||
elif stream.next in _pep3118_unsupported_map:
|
||||
desc = _pep3118_unsupported_map[stream.next]
|
||||
raise NotImplementedError(
|
||||
"Unrepresentable PEP 3118 data type {!r} ({})"
|
||||
.format(stream.next, desc))
|
||||
else:
|
||||
raise ValueError("Unknown PEP 3118 data type specifier %r" % stream.s)
|
||||
|
||||
#
|
||||
# Native alignment may require padding
|
||||
#
|
||||
# Here we assume that the presence of a '@' character implicitly implies
|
||||
# that the start of the array is *already* aligned.
|
||||
#
|
||||
extra_offset = 0
|
||||
if stream.byteorder == '@':
|
||||
start_padding = (-offset) % align
|
||||
intra_padding = (-value.itemsize) % align
|
||||
|
||||
offset += start_padding
|
||||
|
||||
if intra_padding != 0:
|
||||
if itemsize > 1 or (shape is not None and _prod(shape) > 1):
|
||||
# Inject internal padding to the end of the sub-item
|
||||
value = _add_trailing_padding(value, intra_padding)
|
||||
else:
|
||||
# We can postpone the injection of internal padding,
|
||||
# as the item appears at most once
|
||||
extra_offset += intra_padding
|
||||
|
||||
# Update common alignment
|
||||
common_alignment = _lcm(align, common_alignment)
|
||||
|
||||
# Convert itemsize to sub-array
|
||||
if itemsize != 1:
|
||||
value = dtype((value, (itemsize,)))
|
||||
|
||||
# Sub-arrays (2)
|
||||
if shape is not None:
|
||||
value = dtype((value, shape))
|
||||
|
||||
# Field name
|
||||
if stream.consume(':'):
|
||||
name = stream.consume_until(':')
|
||||
else:
|
||||
name = None
|
||||
|
||||
if not (is_padding and name is None):
|
||||
if name is not None and name in field_spec['names']:
|
||||
raise RuntimeError(f"Duplicate field name '{name}' in PEP3118 format")
|
||||
field_spec['names'].append(name)
|
||||
field_spec['formats'].append(value)
|
||||
field_spec['offsets'].append(offset)
|
||||
|
||||
offset += value.itemsize
|
||||
offset += extra_offset
|
||||
|
||||
field_spec['itemsize'] = offset
|
||||
|
||||
# extra final padding for aligned types
|
||||
if stream.byteorder == '@':
|
||||
field_spec['itemsize'] += (-offset) % common_alignment
|
||||
|
||||
# Check if this was a simple 1-item type, and unwrap it
|
||||
if (field_spec['names'] == [None]
|
||||
and field_spec['offsets'][0] == 0
|
||||
and field_spec['itemsize'] == field_spec['formats'][0].itemsize
|
||||
and not is_subdtype):
|
||||
ret = field_spec['formats'][0]
|
||||
else:
|
||||
_fix_names(field_spec)
|
||||
ret = dtype(field_spec)
|
||||
|
||||
# Finished
|
||||
return ret, common_alignment
|
||||
|
||||
def _fix_names(field_spec):
|
||||
""" Replace names which are None with the next unused f%d name """
|
||||
names = field_spec['names']
|
||||
for i, name in enumerate(names):
|
||||
if name is not None:
|
||||
continue
|
||||
|
||||
j = 0
|
||||
while True:
|
||||
name = f'f{j}'
|
||||
if name not in names:
|
||||
break
|
||||
j = j + 1
|
||||
names[i] = name
|
||||
|
||||
def _add_trailing_padding(value, padding):
|
||||
"""Inject the specified number of padding bytes at the end of a dtype"""
|
||||
if value.fields is None:
|
||||
field_spec = dict(
|
||||
names=['f0'],
|
||||
formats=[value],
|
||||
offsets=[0],
|
||||
itemsize=value.itemsize
|
||||
)
|
||||
else:
|
||||
fields = value.fields
|
||||
names = value.names
|
||||
field_spec = dict(
|
||||
names=names,
|
||||
formats=[fields[name][0] for name in names],
|
||||
offsets=[fields[name][1] for name in names],
|
||||
itemsize=value.itemsize
|
||||
)
|
||||
|
||||
field_spec['itemsize'] += padding
|
||||
return dtype(field_spec)
|
||||
|
||||
def _prod(a):
|
||||
p = 1
|
||||
for x in a:
|
||||
p *= x
|
||||
return p
|
||||
|
||||
def _gcd(a, b):
|
||||
"""Calculate the greatest common divisor of a and b"""
|
||||
while b:
|
||||
a, b = b, a % b
|
||||
return a
|
||||
|
||||
def _lcm(a, b):
|
||||
return a // _gcd(a, b) * b
|
||||
|
||||
def array_ufunc_errmsg_formatter(dummy, ufunc, method, *inputs, **kwargs):
|
||||
""" Format the error message for when __array_ufunc__ gives up. """
|
||||
args_string = ', '.join(['{!r}'.format(arg) for arg in inputs] +
|
||||
['{}={!r}'.format(k, v)
|
||||
for k, v in kwargs.items()])
|
||||
args = inputs + kwargs.get('out', ())
|
||||
types_string = ', '.join(repr(type(arg).__name__) for arg in args)
|
||||
return ('operand type(s) all returned NotImplemented from '
|
||||
'__array_ufunc__({!r}, {!r}, {}): {}'
|
||||
.format(ufunc, method, args_string, types_string))
|
||||
|
||||
|
||||
def array_function_errmsg_formatter(public_api, types):
|
||||
""" Format the error message for when __array_ufunc__ gives up. """
|
||||
func_name = '{}.{}'.format(public_api.__module__, public_api.__name__)
|
||||
return ("no implementation found for '{}' on types that implement "
|
||||
'__array_function__: {}'.format(func_name, list(types)))
|
||||
|
||||
|
||||
def _ufunc_doc_signature_formatter(ufunc):
|
||||
"""
|
||||
Builds a signature string which resembles PEP 457
|
||||
|
||||
This is used to construct the first line of the docstring
|
||||
"""
|
||||
|
||||
# input arguments are simple
|
||||
if ufunc.nin == 1:
|
||||
in_args = 'x'
|
||||
else:
|
||||
in_args = ', '.join(f'x{i+1}' for i in range(ufunc.nin))
|
||||
|
||||
# output arguments are both keyword or positional
|
||||
if ufunc.nout == 0:
|
||||
out_args = ', /, out=()'
|
||||
elif ufunc.nout == 1:
|
||||
out_args = ', /, out=None'
|
||||
else:
|
||||
out_args = '[, {positional}], / [, out={default}]'.format(
|
||||
positional=', '.join(
|
||||
'out{}'.format(i+1) for i in range(ufunc.nout)),
|
||||
default=repr((None,)*ufunc.nout)
|
||||
)
|
||||
|
||||
# keyword only args depend on whether this is a gufunc
|
||||
kwargs = (
|
||||
", casting='same_kind'"
|
||||
", order='K'"
|
||||
", dtype=None"
|
||||
", subok=True"
|
||||
)
|
||||
|
||||
# NOTE: gufuncs may or may not support the `axis` parameter
|
||||
if ufunc.signature is None:
|
||||
kwargs = f", where=True{kwargs}[, signature, extobj]"
|
||||
else:
|
||||
kwargs += "[, signature, extobj, axes, axis]"
|
||||
|
||||
# join all the parts together
|
||||
return '{name}({in_args}{out_args}, *{kwargs})'.format(
|
||||
name=ufunc.__name__,
|
||||
in_args=in_args,
|
||||
out_args=out_args,
|
||||
kwargs=kwargs
|
||||
)
|
||||
|
||||
|
||||
def npy_ctypes_check(cls):
|
||||
# determine if a class comes from ctypes, in order to work around
|
||||
# a bug in the buffer protocol for those objects, bpo-10746
|
||||
try:
|
||||
# ctypes class are new-style, so have an __mro__. This probably fails
|
||||
# for ctypes classes with multiple inheritance.
|
||||
if IS_PYPY:
|
||||
# (..., _ctypes.basics._CData, Bufferable, object)
|
||||
ctype_base = cls.__mro__[-3]
|
||||
else:
|
||||
# # (..., _ctypes._CData, object)
|
||||
ctype_base = cls.__mro__[-2]
|
||||
# right now, they're part of the _ctypes module
|
||||
return '_ctypes' in ctype_base.__module__
|
||||
except Exception:
|
||||
return False
|
@@ -0,0 +1,30 @@
|
||||
from typing import Any, TypeVar, overload, Generic
|
||||
import ctypes as ct
|
||||
|
||||
from numpy import ndarray
|
||||
from numpy.ctypeslib import c_intp
|
||||
|
||||
_CastT = TypeVar("_CastT", bound=ct._CanCastTo) # Copied from `ctypes.cast`
|
||||
_CT = TypeVar("_CT", bound=ct._CData)
|
||||
_PT = TypeVar("_PT", bound=None | int)
|
||||
|
||||
# TODO: Let the likes of `shape_as` and `strides_as` return `None`
|
||||
# for 0D arrays once we've got shape-support
|
||||
|
||||
class _ctypes(Generic[_PT]):
|
||||
@overload
|
||||
def __new__(cls, array: ndarray[Any, Any], ptr: None = ...) -> _ctypes[None]: ...
|
||||
@overload
|
||||
def __new__(cls, array: ndarray[Any, Any], ptr: _PT) -> _ctypes[_PT]: ...
|
||||
@property
|
||||
def data(self) -> _PT: ...
|
||||
@property
|
||||
def shape(self) -> ct.Array[c_intp]: ...
|
||||
@property
|
||||
def strides(self) -> ct.Array[c_intp]: ...
|
||||
@property
|
||||
def _as_parameter_(self) -> ct.c_void_p: ...
|
||||
|
||||
def data_as(self, obj: type[_CastT]) -> _CastT: ...
|
||||
def shape_as(self, obj: type[_CT]) -> ct.Array[_CT]: ...
|
||||
def strides_as(self, obj: type[_CT]) -> ct.Array[_CT]: ...
|
356
teil20b/lib/python3.11/site-packages/numpy/core/_machar.py
Normal file
356
teil20b/lib/python3.11/site-packages/numpy/core/_machar.py
Normal file
@@ -0,0 +1,356 @@
|
||||
"""
|
||||
Machine arithmetic - determine the parameters of the
|
||||
floating-point arithmetic system
|
||||
|
||||
Author: Pearu Peterson, September 2003
|
||||
|
||||
"""
|
||||
__all__ = ['MachAr']
|
||||
|
||||
from .fromnumeric import any
|
||||
from ._ufunc_config import errstate
|
||||
from .._utils import set_module
|
||||
|
||||
# Need to speed this up...especially for longfloat
|
||||
|
||||
# Deprecated 2021-10-20, NumPy 1.22
|
||||
class MachAr:
|
||||
"""
|
||||
Diagnosing machine parameters.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
ibeta : int
|
||||
Radix in which numbers are represented.
|
||||
it : int
|
||||
Number of base-`ibeta` digits in the floating point mantissa M.
|
||||
machep : int
|
||||
Exponent of the smallest (most negative) power of `ibeta` that,
|
||||
added to 1.0, gives something different from 1.0
|
||||
eps : float
|
||||
Floating-point number ``beta**machep`` (floating point precision)
|
||||
negep : int
|
||||
Exponent of the smallest power of `ibeta` that, subtracted
|
||||
from 1.0, gives something different from 1.0.
|
||||
epsneg : float
|
||||
Floating-point number ``beta**negep``.
|
||||
iexp : int
|
||||
Number of bits in the exponent (including its sign and bias).
|
||||
minexp : int
|
||||
Smallest (most negative) power of `ibeta` consistent with there
|
||||
being no leading zeros in the mantissa.
|
||||
xmin : float
|
||||
Floating-point number ``beta**minexp`` (the smallest [in
|
||||
magnitude] positive floating point number with full precision).
|
||||
maxexp : int
|
||||
Smallest (positive) power of `ibeta` that causes overflow.
|
||||
xmax : float
|
||||
``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
|
||||
usable floating value).
|
||||
irnd : int
|
||||
In ``range(6)``, information on what kind of rounding is done
|
||||
in addition, and on how underflow is handled.
|
||||
ngrd : int
|
||||
Number of 'guard digits' used when truncating the product
|
||||
of two mantissas to fit the representation.
|
||||
epsilon : float
|
||||
Same as `eps`.
|
||||
tiny : float
|
||||
An alias for `smallest_normal`, kept for backwards compatibility.
|
||||
huge : float
|
||||
Same as `xmax`.
|
||||
precision : float
|
||||
``- int(-log10(eps))``
|
||||
resolution : float
|
||||
``- 10**(-precision)``
|
||||
smallest_normal : float
|
||||
The smallest positive floating point number with 1 as leading bit in
|
||||
the mantissa following IEEE-754. Same as `xmin`.
|
||||
smallest_subnormal : float
|
||||
The smallest positive floating point number with 0 as leading bit in
|
||||
the mantissa following IEEE-754.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
float_conv : function, optional
|
||||
Function that converts an integer or integer array to a float
|
||||
or float array. Default is `float`.
|
||||
int_conv : function, optional
|
||||
Function that converts a float or float array to an integer or
|
||||
integer array. Default is `int`.
|
||||
float_to_float : function, optional
|
||||
Function that converts a float array to float. Default is `float`.
|
||||
Note that this does not seem to do anything useful in the current
|
||||
implementation.
|
||||
float_to_str : function, optional
|
||||
Function that converts a single float to a string. Default is
|
||||
``lambda v:'%24.16e' %v``.
|
||||
title : str, optional
|
||||
Title that is printed in the string representation of `MachAr`.
|
||||
|
||||
See Also
|
||||
--------
|
||||
finfo : Machine limits for floating point types.
|
||||
iinfo : Machine limits for integer types.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] Press, Teukolsky, Vetterling and Flannery,
|
||||
"Numerical Recipes in C++," 2nd ed,
|
||||
Cambridge University Press, 2002, p. 31.
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, float_conv=float,int_conv=int,
|
||||
float_to_float=float,
|
||||
float_to_str=lambda v:'%24.16e' % v,
|
||||
title='Python floating point number'):
|
||||
"""
|
||||
|
||||
float_conv - convert integer to float (array)
|
||||
int_conv - convert float (array) to integer
|
||||
float_to_float - convert float array to float
|
||||
float_to_str - convert array float to str
|
||||
title - description of used floating point numbers
|
||||
|
||||
"""
|
||||
# We ignore all errors here because we are purposely triggering
|
||||
# underflow to detect the properties of the runninng arch.
|
||||
with errstate(under='ignore'):
|
||||
self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)
|
||||
|
||||
def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
|
||||
max_iterN = 10000
|
||||
msg = "Did not converge after %d tries with %s"
|
||||
one = float_conv(1)
|
||||
two = one + one
|
||||
zero = one - one
|
||||
|
||||
# Do we really need to do this? Aren't they 2 and 2.0?
|
||||
# Determine ibeta and beta
|
||||
a = one
|
||||
for _ in range(max_iterN):
|
||||
a = a + a
|
||||
temp = a + one
|
||||
temp1 = temp - a
|
||||
if any(temp1 - one != zero):
|
||||
break
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
b = one
|
||||
for _ in range(max_iterN):
|
||||
b = b + b
|
||||
temp = a + b
|
||||
itemp = int_conv(temp-a)
|
||||
if any(itemp != 0):
|
||||
break
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
ibeta = itemp
|
||||
beta = float_conv(ibeta)
|
||||
|
||||
# Determine it and irnd
|
||||
it = -1
|
||||
b = one
|
||||
for _ in range(max_iterN):
|
||||
it = it + 1
|
||||
b = b * beta
|
||||
temp = b + one
|
||||
temp1 = temp - b
|
||||
if any(temp1 - one != zero):
|
||||
break
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
|
||||
betah = beta / two
|
||||
a = one
|
||||
for _ in range(max_iterN):
|
||||
a = a + a
|
||||
temp = a + one
|
||||
temp1 = temp - a
|
||||
if any(temp1 - one != zero):
|
||||
break
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
temp = a + betah
|
||||
irnd = 0
|
||||
if any(temp-a != zero):
|
||||
irnd = 1
|
||||
tempa = a + beta
|
||||
temp = tempa + betah
|
||||
if irnd == 0 and any(temp-tempa != zero):
|
||||
irnd = 2
|
||||
|
||||
# Determine negep and epsneg
|
||||
negep = it + 3
|
||||
betain = one / beta
|
||||
a = one
|
||||
for i in range(negep):
|
||||
a = a * betain
|
||||
b = a
|
||||
for _ in range(max_iterN):
|
||||
temp = one - a
|
||||
if any(temp-one != zero):
|
||||
break
|
||||
a = a * beta
|
||||
negep = negep - 1
|
||||
# Prevent infinite loop on PPC with gcc 4.0:
|
||||
if negep < 0:
|
||||
raise RuntimeError("could not determine machine tolerance "
|
||||
"for 'negep', locals() -> %s" % (locals()))
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
negep = -negep
|
||||
epsneg = a
|
||||
|
||||
# Determine machep and eps
|
||||
machep = - it - 3
|
||||
a = b
|
||||
|
||||
for _ in range(max_iterN):
|
||||
temp = one + a
|
||||
if any(temp-one != zero):
|
||||
break
|
||||
a = a * beta
|
||||
machep = machep + 1
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
eps = a
|
||||
|
||||
# Determine ngrd
|
||||
ngrd = 0
|
||||
temp = one + eps
|
||||
if irnd == 0 and any(temp*one - one != zero):
|
||||
ngrd = 1
|
||||
|
||||
# Determine iexp
|
||||
i = 0
|
||||
k = 1
|
||||
z = betain
|
||||
t = one + eps
|
||||
nxres = 0
|
||||
for _ in range(max_iterN):
|
||||
y = z
|
||||
z = y*y
|
||||
a = z*one # Check here for underflow
|
||||
temp = z*t
|
||||
if any(a+a == zero) or any(abs(z) >= y):
|
||||
break
|
||||
temp1 = temp * betain
|
||||
if any(temp1*beta == z):
|
||||
break
|
||||
i = i + 1
|
||||
k = k + k
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
if ibeta != 10:
|
||||
iexp = i + 1
|
||||
mx = k + k
|
||||
else:
|
||||
iexp = 2
|
||||
iz = ibeta
|
||||
while k >= iz:
|
||||
iz = iz * ibeta
|
||||
iexp = iexp + 1
|
||||
mx = iz + iz - 1
|
||||
|
||||
# Determine minexp and xmin
|
||||
for _ in range(max_iterN):
|
||||
xmin = y
|
||||
y = y * betain
|
||||
a = y * one
|
||||
temp = y * t
|
||||
if any((a + a) != zero) and any(abs(y) < xmin):
|
||||
k = k + 1
|
||||
temp1 = temp * betain
|
||||
if any(temp1*beta == y) and any(temp != y):
|
||||
nxres = 3
|
||||
xmin = y
|
||||
break
|
||||
else:
|
||||
break
|
||||
else:
|
||||
raise RuntimeError(msg % (_, one.dtype))
|
||||
minexp = -k
|
||||
|
||||
# Determine maxexp, xmax
|
||||
if mx <= k + k - 3 and ibeta != 10:
|
||||
mx = mx + mx
|
||||
iexp = iexp + 1
|
||||
maxexp = mx + minexp
|
||||
irnd = irnd + nxres
|
||||
if irnd >= 2:
|
||||
maxexp = maxexp - 2
|
||||
i = maxexp + minexp
|
||||
if ibeta == 2 and not i:
|
||||
maxexp = maxexp - 1
|
||||
if i > 20:
|
||||
maxexp = maxexp - 1
|
||||
if any(a != y):
|
||||
maxexp = maxexp - 2
|
||||
xmax = one - epsneg
|
||||
if any(xmax*one != xmax):
|
||||
xmax = one - beta*epsneg
|
||||
xmax = xmax / (xmin*beta*beta*beta)
|
||||
i = maxexp + minexp + 3
|
||||
for j in range(i):
|
||||
if ibeta == 2:
|
||||
xmax = xmax + xmax
|
||||
else:
|
||||
xmax = xmax * beta
|
||||
|
||||
smallest_subnormal = abs(xmin / beta ** (it))
|
||||
|
||||
self.ibeta = ibeta
|
||||
self.it = it
|
||||
self.negep = negep
|
||||
self.epsneg = float_to_float(epsneg)
|
||||
self._str_epsneg = float_to_str(epsneg)
|
||||
self.machep = machep
|
||||
self.eps = float_to_float(eps)
|
||||
self._str_eps = float_to_str(eps)
|
||||
self.ngrd = ngrd
|
||||
self.iexp = iexp
|
||||
self.minexp = minexp
|
||||
self.xmin = float_to_float(xmin)
|
||||
self._str_xmin = float_to_str(xmin)
|
||||
self.maxexp = maxexp
|
||||
self.xmax = float_to_float(xmax)
|
||||
self._str_xmax = float_to_str(xmax)
|
||||
self.irnd = irnd
|
||||
|
||||
self.title = title
|
||||
# Commonly used parameters
|
||||
self.epsilon = self.eps
|
||||
self.tiny = self.xmin
|
||||
self.huge = self.xmax
|
||||
self.smallest_normal = self.xmin
|
||||
self._str_smallest_normal = float_to_str(self.xmin)
|
||||
self.smallest_subnormal = float_to_float(smallest_subnormal)
|
||||
self._str_smallest_subnormal = float_to_str(smallest_subnormal)
|
||||
|
||||
import math
|
||||
self.precision = int(-math.log10(float_to_float(self.eps)))
|
||||
ten = two + two + two + two + two
|
||||
resolution = ten ** (-self.precision)
|
||||
self.resolution = float_to_float(resolution)
|
||||
self._str_resolution = float_to_str(resolution)
|
||||
|
||||
def __str__(self):
|
||||
fmt = (
|
||||
'Machine parameters for %(title)s\n'
|
||||
'---------------------------------------------------------------------\n'
|
||||
'ibeta=%(ibeta)s it=%(it)s iexp=%(iexp)s ngrd=%(ngrd)s irnd=%(irnd)s\n'
|
||||
'machep=%(machep)s eps=%(_str_eps)s (beta**machep == epsilon)\n'
|
||||
'negep =%(negep)s epsneg=%(_str_epsneg)s (beta**epsneg)\n'
|
||||
'minexp=%(minexp)s xmin=%(_str_xmin)s (beta**minexp == tiny)\n'
|
||||
'maxexp=%(maxexp)s xmax=%(_str_xmax)s ((1-epsneg)*beta**maxexp == huge)\n'
|
||||
'smallest_normal=%(smallest_normal)s '
|
||||
'smallest_subnormal=%(smallest_subnormal)s\n'
|
||||
'---------------------------------------------------------------------\n'
|
||||
)
|
||||
return fmt % self.__dict__
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
print(MachAr())
|
234
teil20b/lib/python3.11/site-packages/numpy/core/_methods.py
Normal file
234
teil20b/lib/python3.11/site-packages/numpy/core/_methods.py
Normal file
@@ -0,0 +1,234 @@
|
||||
"""
|
||||
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)
|
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,100 @@
|
||||
"""
|
||||
String-handling utilities to avoid locale-dependence.
|
||||
|
||||
Used primarily to generate type name aliases.
|
||||
"""
|
||||
# "import string" is costly to import!
|
||||
# Construct the translation tables directly
|
||||
# "A" = chr(65), "a" = chr(97)
|
||||
_all_chars = tuple(map(chr, range(256)))
|
||||
_ascii_upper = _all_chars[65:65+26]
|
||||
_ascii_lower = _all_chars[97:97+26]
|
||||
LOWER_TABLE = "".join(_all_chars[:65] + _ascii_lower + _all_chars[65+26:])
|
||||
UPPER_TABLE = "".join(_all_chars[:97] + _ascii_upper + _all_chars[97+26:])
|
||||
|
||||
|
||||
def english_lower(s):
|
||||
""" Apply English case rules to convert ASCII strings to all lower case.
|
||||
|
||||
This is an internal utility function to replace calls to str.lower() such
|
||||
that we can avoid changing behavior with changing locales. In particular,
|
||||
Turkish has distinct dotted and dotless variants of the Latin letter "I" in
|
||||
both lowercase and uppercase. Thus, "I".lower() != "i" in a "tr" locale.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
s : str
|
||||
|
||||
Returns
|
||||
-------
|
||||
lowered : str
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from numpy.core.numerictypes import english_lower
|
||||
>>> english_lower('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
|
||||
'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789_'
|
||||
>>> english_lower('')
|
||||
''
|
||||
"""
|
||||
lowered = s.translate(LOWER_TABLE)
|
||||
return lowered
|
||||
|
||||
|
||||
def english_upper(s):
|
||||
""" Apply English case rules to convert ASCII strings to all upper case.
|
||||
|
||||
This is an internal utility function to replace calls to str.upper() such
|
||||
that we can avoid changing behavior with changing locales. In particular,
|
||||
Turkish has distinct dotted and dotless variants of the Latin letter "I" in
|
||||
both lowercase and uppercase. Thus, "i".upper() != "I" in a "tr" locale.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
s : str
|
||||
|
||||
Returns
|
||||
-------
|
||||
uppered : str
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from numpy.core.numerictypes import english_upper
|
||||
>>> english_upper('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
|
||||
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
|
||||
>>> english_upper('')
|
||||
''
|
||||
"""
|
||||
uppered = s.translate(UPPER_TABLE)
|
||||
return uppered
|
||||
|
||||
|
||||
def english_capitalize(s):
|
||||
""" Apply English case rules to convert the first character of an ASCII
|
||||
string to upper case.
|
||||
|
||||
This is an internal utility function to replace calls to str.capitalize()
|
||||
such that we can avoid changing behavior with changing locales.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
s : str
|
||||
|
||||
Returns
|
||||
-------
|
||||
capitalized : str
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from numpy.core.numerictypes import english_capitalize
|
||||
>>> english_capitalize('int8')
|
||||
'Int8'
|
||||
>>> english_capitalize('Int8')
|
||||
'Int8'
|
||||
>>> english_capitalize('')
|
||||
''
|
||||
"""
|
||||
if s:
|
||||
return english_upper(s[0]) + s[1:]
|
||||
else:
|
||||
return s
|
Binary file not shown.
245
teil20b/lib/python3.11/site-packages/numpy/core/_type_aliases.py
Normal file
245
teil20b/lib/python3.11/site-packages/numpy/core/_type_aliases.py
Normal file
@@ -0,0 +1,245 @@
|
||||
"""
|
||||
Due to compatibility, numpy has a very large number of different naming
|
||||
conventions for the scalar types (those subclassing from `numpy.generic`).
|
||||
This file produces a convoluted set of dictionaries mapping names to types,
|
||||
and sometimes other mappings too.
|
||||
|
||||
.. data:: allTypes
|
||||
A dictionary of names to types that will be exposed as attributes through
|
||||
``np.core.numerictypes.*``
|
||||
|
||||
.. data:: sctypeDict
|
||||
Similar to `allTypes`, but maps a broader set of aliases to their types.
|
||||
|
||||
.. data:: sctypes
|
||||
A dictionary keyed by a "type group" string, providing a list of types
|
||||
under that group.
|
||||
|
||||
"""
|
||||
|
||||
from numpy.compat import unicode
|
||||
from numpy.core._string_helpers import english_lower
|
||||
from numpy.core.multiarray import typeinfo, dtype
|
||||
from numpy.core._dtype import _kind_name
|
||||
|
||||
|
||||
sctypeDict = {} # Contains all leaf-node scalar types with aliases
|
||||
allTypes = {} # Collect the types we will add to the module
|
||||
|
||||
|
||||
# separate the actual type info from the abstract base classes
|
||||
_abstract_types = {}
|
||||
_concrete_typeinfo = {}
|
||||
for k, v in typeinfo.items():
|
||||
# make all the keys lowercase too
|
||||
k = english_lower(k)
|
||||
if isinstance(v, type):
|
||||
_abstract_types[k] = v
|
||||
else:
|
||||
_concrete_typeinfo[k] = v
|
||||
|
||||
_concrete_types = {v.type for k, v in _concrete_typeinfo.items()}
|
||||
|
||||
|
||||
def _bits_of(obj):
|
||||
try:
|
||||
info = next(v for v in _concrete_typeinfo.values() if v.type is obj)
|
||||
except StopIteration:
|
||||
if obj in _abstract_types.values():
|
||||
msg = "Cannot count the bits of an abstract type"
|
||||
raise ValueError(msg) from None
|
||||
|
||||
# some third-party type - make a best-guess
|
||||
return dtype(obj).itemsize * 8
|
||||
else:
|
||||
return info.bits
|
||||
|
||||
|
||||
def bitname(obj):
|
||||
"""Return a bit-width name for a given type object"""
|
||||
bits = _bits_of(obj)
|
||||
dt = dtype(obj)
|
||||
char = dt.kind
|
||||
base = _kind_name(dt)
|
||||
|
||||
if base == 'object':
|
||||
bits = 0
|
||||
|
||||
if bits != 0:
|
||||
char = "%s%d" % (char, bits // 8)
|
||||
|
||||
return base, bits, char
|
||||
|
||||
|
||||
def _add_types():
|
||||
for name, info in _concrete_typeinfo.items():
|
||||
# define C-name and insert typenum and typechar references also
|
||||
allTypes[name] = info.type
|
||||
sctypeDict[name] = info.type
|
||||
sctypeDict[info.char] = info.type
|
||||
sctypeDict[info.num] = info.type
|
||||
|
||||
for name, cls in _abstract_types.items():
|
||||
allTypes[name] = cls
|
||||
_add_types()
|
||||
|
||||
# This is the priority order used to assign the bit-sized NPY_INTxx names, which
|
||||
# must match the order in npy_common.h in order for NPY_INTxx and np.intxx to be
|
||||
# consistent.
|
||||
# If two C types have the same size, then the earliest one in this list is used
|
||||
# as the sized name.
|
||||
_int_ctypes = ['long', 'longlong', 'int', 'short', 'byte']
|
||||
_uint_ctypes = list('u' + t for t in _int_ctypes)
|
||||
|
||||
def _add_aliases():
|
||||
for name, info in _concrete_typeinfo.items():
|
||||
# these are handled by _add_integer_aliases
|
||||
if name in _int_ctypes or name in _uint_ctypes:
|
||||
continue
|
||||
|
||||
# insert bit-width version for this class (if relevant)
|
||||
base, bit, char = bitname(info.type)
|
||||
|
||||
myname = "%s%d" % (base, bit)
|
||||
|
||||
# ensure that (c)longdouble does not overwrite the aliases assigned to
|
||||
# (c)double
|
||||
if name in ('longdouble', 'clongdouble') and myname in allTypes:
|
||||
continue
|
||||
|
||||
# Add to the main namespace if desired:
|
||||
if bit != 0 and base != "bool":
|
||||
allTypes[myname] = info.type
|
||||
|
||||
# add forward, reverse, and string mapping to numarray
|
||||
sctypeDict[char] = info.type
|
||||
|
||||
# add mapping for both the bit name
|
||||
sctypeDict[myname] = info.type
|
||||
|
||||
|
||||
_add_aliases()
|
||||
|
||||
def _add_integer_aliases():
|
||||
seen_bits = set()
|
||||
for i_ctype, u_ctype in zip(_int_ctypes, _uint_ctypes):
|
||||
i_info = _concrete_typeinfo[i_ctype]
|
||||
u_info = _concrete_typeinfo[u_ctype]
|
||||
bits = i_info.bits # same for both
|
||||
|
||||
for info, charname, intname in [
|
||||
(i_info,'i%d' % (bits//8,), 'int%d' % bits),
|
||||
(u_info,'u%d' % (bits//8,), 'uint%d' % bits)]:
|
||||
if bits not in seen_bits:
|
||||
# sometimes two different types have the same number of bits
|
||||
# if so, the one iterated over first takes precedence
|
||||
allTypes[intname] = info.type
|
||||
sctypeDict[intname] = info.type
|
||||
sctypeDict[charname] = info.type
|
||||
|
||||
seen_bits.add(bits)
|
||||
|
||||
_add_integer_aliases()
|
||||
|
||||
# We use these later
|
||||
void = allTypes['void']
|
||||
|
||||
#
|
||||
# Rework the Python names (so that float and complex and int are consistent
|
||||
# with Python usage)
|
||||
#
|
||||
def _set_up_aliases():
|
||||
type_pairs = [('complex_', 'cdouble'),
|
||||
('single', 'float'),
|
||||
('csingle', 'cfloat'),
|
||||
('singlecomplex', 'cfloat'),
|
||||
('float_', 'double'),
|
||||
('intc', 'int'),
|
||||
('uintc', 'uint'),
|
||||
('int_', 'long'),
|
||||
('uint', 'ulong'),
|
||||
('cfloat', 'cdouble'),
|
||||
('longfloat', 'longdouble'),
|
||||
('clongfloat', 'clongdouble'),
|
||||
('longcomplex', 'clongdouble'),
|
||||
('bool_', 'bool'),
|
||||
('bytes_', 'string'),
|
||||
('string_', 'string'),
|
||||
('str_', 'unicode'),
|
||||
('unicode_', 'unicode'),
|
||||
('object_', 'object')]
|
||||
for alias, t in type_pairs:
|
||||
allTypes[alias] = allTypes[t]
|
||||
sctypeDict[alias] = sctypeDict[t]
|
||||
# Remove aliases overriding python types and modules
|
||||
to_remove = ['object', 'int', 'float',
|
||||
'complex', 'bool', 'string', 'datetime', 'timedelta',
|
||||
'bytes', 'str']
|
||||
|
||||
for t in to_remove:
|
||||
try:
|
||||
del allTypes[t]
|
||||
del sctypeDict[t]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
# Additional aliases in sctypeDict that should not be exposed as attributes
|
||||
attrs_to_remove = ['ulong']
|
||||
|
||||
for t in attrs_to_remove:
|
||||
try:
|
||||
del allTypes[t]
|
||||
except KeyError:
|
||||
pass
|
||||
_set_up_aliases()
|
||||
|
||||
|
||||
sctypes = {'int': [],
|
||||
'uint':[],
|
||||
'float':[],
|
||||
'complex':[],
|
||||
'others':[bool, object, bytes, unicode, void]}
|
||||
|
||||
def _add_array_type(typename, bits):
|
||||
try:
|
||||
t = allTypes['%s%d' % (typename, bits)]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
sctypes[typename].append(t)
|
||||
|
||||
def _set_array_types():
|
||||
ibytes = [1, 2, 4, 8, 16, 32, 64]
|
||||
fbytes = [2, 4, 8, 10, 12, 16, 32, 64]
|
||||
for bytes in ibytes:
|
||||
bits = 8*bytes
|
||||
_add_array_type('int', bits)
|
||||
_add_array_type('uint', bits)
|
||||
for bytes in fbytes:
|
||||
bits = 8*bytes
|
||||
_add_array_type('float', bits)
|
||||
_add_array_type('complex', 2*bits)
|
||||
_gi = dtype('p')
|
||||
if _gi.type not in sctypes['int']:
|
||||
indx = 0
|
||||
sz = _gi.itemsize
|
||||
_lst = sctypes['int']
|
||||
while (indx < len(_lst) and sz >= _lst[indx](0).itemsize):
|
||||
indx += 1
|
||||
sctypes['int'].insert(indx, _gi.type)
|
||||
sctypes['uint'].insert(indx, dtype('P').type)
|
||||
_set_array_types()
|
||||
|
||||
|
||||
# Add additional strings to the sctypeDict
|
||||
_toadd = ['int', 'float', 'complex', 'bool', 'object',
|
||||
'str', 'bytes', ('a', 'bytes_'),
|
||||
('int0', 'intp'), ('uint0', 'uintp')]
|
||||
|
||||
for name in _toadd:
|
||||
if isinstance(name, tuple):
|
||||
sctypeDict[name[0]] = allTypes[name[1]]
|
||||
else:
|
||||
sctypeDict[name] = allTypes['%s_' % name]
|
||||
|
||||
del _toadd, name
|
@@ -0,0 +1,13 @@
|
||||
from typing import Any, TypedDict
|
||||
|
||||
from numpy import generic, signedinteger, unsignedinteger, floating, complexfloating
|
||||
|
||||
class _SCTypes(TypedDict):
|
||||
int: list[type[signedinteger[Any]]]
|
||||
uint: list[type[unsignedinteger[Any]]]
|
||||
float: list[type[floating[Any]]]
|
||||
complex: list[type[complexfloating[Any, Any]]]
|
||||
others: list[type]
|
||||
|
||||
sctypeDict: dict[int | str, type[generic]]
|
||||
sctypes: _SCTypes
|
466
teil20b/lib/python3.11/site-packages/numpy/core/_ufunc_config.py
Normal file
466
teil20b/lib/python3.11/site-packages/numpy/core/_ufunc_config.py
Normal file
@@ -0,0 +1,466 @@
|
||||
"""
|
||||
Functions for changing global ufunc configuration
|
||||
|
||||
This provides helpers which wrap `umath.geterrobj` and `umath.seterrobj`
|
||||
"""
|
||||
import collections.abc
|
||||
import contextlib
|
||||
import contextvars
|
||||
|
||||
from .._utils import set_module
|
||||
from .umath import (
|
||||
UFUNC_BUFSIZE_DEFAULT,
|
||||
ERR_IGNORE, ERR_WARN, ERR_RAISE, ERR_CALL, ERR_PRINT, ERR_LOG, ERR_DEFAULT,
|
||||
SHIFT_DIVIDEBYZERO, SHIFT_OVERFLOW, SHIFT_UNDERFLOW, SHIFT_INVALID,
|
||||
)
|
||||
from . import umath
|
||||
|
||||
__all__ = [
|
||||
"seterr", "geterr", "setbufsize", "getbufsize", "seterrcall", "geterrcall",
|
||||
"errstate", '_no_nep50_warning'
|
||||
]
|
||||
|
||||
_errdict = {"ignore": ERR_IGNORE,
|
||||
"warn": ERR_WARN,
|
||||
"raise": ERR_RAISE,
|
||||
"call": ERR_CALL,
|
||||
"print": ERR_PRINT,
|
||||
"log": ERR_LOG}
|
||||
|
||||
_errdict_rev = {value: key for key, value in _errdict.items()}
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def seterr(all=None, divide=None, over=None, under=None, invalid=None):
|
||||
"""
|
||||
Set how floating-point errors are handled.
|
||||
|
||||
Note that operations on integer scalar types (such as `int16`) are
|
||||
handled like floating point, and are affected by these settings.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
||||
Set treatment for all types of floating-point errors at once:
|
||||
|
||||
- ignore: Take no action when the exception occurs.
|
||||
- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
|
||||
- raise: Raise a `FloatingPointError`.
|
||||
- call: Call a function specified using the `seterrcall` function.
|
||||
- print: Print a warning directly to ``stdout``.
|
||||
- log: Record error in a Log object specified by `seterrcall`.
|
||||
|
||||
The default is not to change the current behavior.
|
||||
divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
||||
Treatment for division by zero.
|
||||
over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
||||
Treatment for floating-point overflow.
|
||||
under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
||||
Treatment for floating-point underflow.
|
||||
invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
||||
Treatment for invalid floating-point operation.
|
||||
|
||||
Returns
|
||||
-------
|
||||
old_settings : dict
|
||||
Dictionary containing the old settings.
|
||||
|
||||
See also
|
||||
--------
|
||||
seterrcall : Set a callback function for the 'call' mode.
|
||||
geterr, geterrcall, errstate
|
||||
|
||||
Notes
|
||||
-----
|
||||
The floating-point exceptions are defined in the IEEE 754 standard [1]_:
|
||||
|
||||
- Division by zero: infinite result obtained from finite numbers.
|
||||
- Overflow: result too large to be expressed.
|
||||
- Underflow: result so close to zero that some precision
|
||||
was lost.
|
||||
- Invalid operation: result is not an expressible number, typically
|
||||
indicates that a NaN was produced.
|
||||
|
||||
.. [1] https://en.wikipedia.org/wiki/IEEE_754
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> old_settings = np.seterr(all='ignore') #seterr to known value
|
||||
>>> np.seterr(over='raise')
|
||||
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
|
||||
>>> np.seterr(**old_settings) # reset to default
|
||||
{'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}
|
||||
|
||||
>>> np.int16(32000) * np.int16(3)
|
||||
30464
|
||||
>>> old_settings = np.seterr(all='warn', over='raise')
|
||||
>>> np.int16(32000) * np.int16(3)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
FloatingPointError: overflow encountered in scalar multiply
|
||||
|
||||
>>> old_settings = np.seterr(all='print')
|
||||
>>> np.geterr()
|
||||
{'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
|
||||
>>> np.int16(32000) * np.int16(3)
|
||||
30464
|
||||
|
||||
"""
|
||||
|
||||
pyvals = umath.geterrobj()
|
||||
old = geterr()
|
||||
|
||||
if divide is None:
|
||||
divide = all or old['divide']
|
||||
if over is None:
|
||||
over = all or old['over']
|
||||
if under is None:
|
||||
under = all or old['under']
|
||||
if invalid is None:
|
||||
invalid = all or old['invalid']
|
||||
|
||||
maskvalue = ((_errdict[divide] << SHIFT_DIVIDEBYZERO) +
|
||||
(_errdict[over] << SHIFT_OVERFLOW) +
|
||||
(_errdict[under] << SHIFT_UNDERFLOW) +
|
||||
(_errdict[invalid] << SHIFT_INVALID))
|
||||
|
||||
pyvals[1] = maskvalue
|
||||
umath.seterrobj(pyvals)
|
||||
return old
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def geterr():
|
||||
"""
|
||||
Get the current way of handling floating-point errors.
|
||||
|
||||
Returns
|
||||
-------
|
||||
res : dict
|
||||
A dictionary with keys "divide", "over", "under", and "invalid",
|
||||
whose values are from the strings "ignore", "print", "log", "warn",
|
||||
"raise", and "call". The keys represent possible floating-point
|
||||
exceptions, and the values define how these exceptions are handled.
|
||||
|
||||
See Also
|
||||
--------
|
||||
geterrcall, seterr, seterrcall
|
||||
|
||||
Notes
|
||||
-----
|
||||
For complete documentation of the types of floating-point exceptions and
|
||||
treatment options, see `seterr`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.geterr()
|
||||
{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}
|
||||
>>> np.arange(3.) / np.arange(3.)
|
||||
array([nan, 1., 1.])
|
||||
|
||||
>>> oldsettings = np.seterr(all='warn', over='raise')
|
||||
>>> np.geterr()
|
||||
{'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'}
|
||||
>>> np.arange(3.) / np.arange(3.)
|
||||
array([nan, 1., 1.])
|
||||
|
||||
"""
|
||||
maskvalue = umath.geterrobj()[1]
|
||||
mask = 7
|
||||
res = {}
|
||||
val = (maskvalue >> SHIFT_DIVIDEBYZERO) & mask
|
||||
res['divide'] = _errdict_rev[val]
|
||||
val = (maskvalue >> SHIFT_OVERFLOW) & mask
|
||||
res['over'] = _errdict_rev[val]
|
||||
val = (maskvalue >> SHIFT_UNDERFLOW) & mask
|
||||
res['under'] = _errdict_rev[val]
|
||||
val = (maskvalue >> SHIFT_INVALID) & mask
|
||||
res['invalid'] = _errdict_rev[val]
|
||||
return res
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def setbufsize(size):
|
||||
"""
|
||||
Set the size of the buffer used in ufuncs.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
size : int
|
||||
Size of buffer.
|
||||
|
||||
"""
|
||||
if size > 10e6:
|
||||
raise ValueError("Buffer size, %s, is too big." % size)
|
||||
if size < 5:
|
||||
raise ValueError("Buffer size, %s, is too small." % size)
|
||||
if size % 16 != 0:
|
||||
raise ValueError("Buffer size, %s, is not a multiple of 16." % size)
|
||||
|
||||
pyvals = umath.geterrobj()
|
||||
old = getbufsize()
|
||||
pyvals[0] = size
|
||||
umath.seterrobj(pyvals)
|
||||
return old
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def getbufsize():
|
||||
"""
|
||||
Return the size of the buffer used in ufuncs.
|
||||
|
||||
Returns
|
||||
-------
|
||||
getbufsize : int
|
||||
Size of ufunc buffer in bytes.
|
||||
|
||||
"""
|
||||
return umath.geterrobj()[0]
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def seterrcall(func):
|
||||
"""
|
||||
Set the floating-point error callback function or log object.
|
||||
|
||||
There are two ways to capture floating-point error messages. The first
|
||||
is to set the error-handler to 'call', using `seterr`. Then, set
|
||||
the function to call using this function.
|
||||
|
||||
The second is to set the error-handler to 'log', using `seterr`.
|
||||
Floating-point errors then trigger a call to the 'write' method of
|
||||
the provided object.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
func : callable f(err, flag) or object with write method
|
||||
Function to call upon floating-point errors ('call'-mode) or
|
||||
object whose 'write' method is used to log such message ('log'-mode).
|
||||
|
||||
The call function takes two arguments. The first is a string describing
|
||||
the type of error (such as "divide by zero", "overflow", "underflow",
|
||||
or "invalid value"), and the second is the status flag. The flag is a
|
||||
byte, whose four least-significant bits indicate the type of error, one
|
||||
of "divide", "over", "under", "invalid"::
|
||||
|
||||
[0 0 0 0 divide over under invalid]
|
||||
|
||||
In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
|
||||
|
||||
If an object is provided, its write method should take one argument,
|
||||
a string.
|
||||
|
||||
Returns
|
||||
-------
|
||||
h : callable, log instance or None
|
||||
The old error handler.
|
||||
|
||||
See Also
|
||||
--------
|
||||
seterr, geterr, geterrcall
|
||||
|
||||
Examples
|
||||
--------
|
||||
Callback upon error:
|
||||
|
||||
>>> def err_handler(type, flag):
|
||||
... print("Floating point error (%s), with flag %s" % (type, flag))
|
||||
...
|
||||
|
||||
>>> saved_handler = np.seterrcall(err_handler)
|
||||
>>> save_err = np.seterr(all='call')
|
||||
|
||||
>>> np.array([1, 2, 3]) / 0.0
|
||||
Floating point error (divide by zero), with flag 1
|
||||
array([inf, inf, inf])
|
||||
|
||||
>>> np.seterrcall(saved_handler)
|
||||
<function err_handler at 0x...>
|
||||
>>> np.seterr(**save_err)
|
||||
{'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}
|
||||
|
||||
Log error message:
|
||||
|
||||
>>> class Log:
|
||||
... def write(self, msg):
|
||||
... print("LOG: %s" % msg)
|
||||
...
|
||||
|
||||
>>> log = Log()
|
||||
>>> saved_handler = np.seterrcall(log)
|
||||
>>> save_err = np.seterr(all='log')
|
||||
|
||||
>>> np.array([1, 2, 3]) / 0.0
|
||||
LOG: Warning: divide by zero encountered in divide
|
||||
array([inf, inf, inf])
|
||||
|
||||
>>> np.seterrcall(saved_handler)
|
||||
<numpy.core.numeric.Log object at 0x...>
|
||||
>>> np.seterr(**save_err)
|
||||
{'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}
|
||||
|
||||
"""
|
||||
if func is not None and not isinstance(func, collections.abc.Callable):
|
||||
if (not hasattr(func, 'write') or
|
||||
not isinstance(func.write, collections.abc.Callable)):
|
||||
raise ValueError("Only callable can be used as callback")
|
||||
pyvals = umath.geterrobj()
|
||||
old = geterrcall()
|
||||
pyvals[2] = func
|
||||
umath.seterrobj(pyvals)
|
||||
return old
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def geterrcall():
|
||||
"""
|
||||
Return the current callback function used on floating-point errors.
|
||||
|
||||
When the error handling for a floating-point error (one of "divide",
|
||||
"over", "under", or "invalid") is set to 'call' or 'log', the function
|
||||
that is called or the log instance that is written to is returned by
|
||||
`geterrcall`. This function or log instance has been set with
|
||||
`seterrcall`.
|
||||
|
||||
Returns
|
||||
-------
|
||||
errobj : callable, log instance or None
|
||||
The current error handler. If no handler was set through `seterrcall`,
|
||||
``None`` is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
seterrcall, seterr, geterr
|
||||
|
||||
Notes
|
||||
-----
|
||||
For complete documentation of the types of floating-point exceptions and
|
||||
treatment options, see `seterr`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.geterrcall() # we did not yet set a handler, returns None
|
||||
|
||||
>>> oldsettings = np.seterr(all='call')
|
||||
>>> def err_handler(type, flag):
|
||||
... print("Floating point error (%s), with flag %s" % (type, flag))
|
||||
>>> oldhandler = np.seterrcall(err_handler)
|
||||
>>> np.array([1, 2, 3]) / 0.0
|
||||
Floating point error (divide by zero), with flag 1
|
||||
array([inf, inf, inf])
|
||||
|
||||
>>> cur_handler = np.geterrcall()
|
||||
>>> cur_handler is err_handler
|
||||
True
|
||||
|
||||
"""
|
||||
return umath.geterrobj()[2]
|
||||
|
||||
|
||||
class _unspecified:
|
||||
pass
|
||||
|
||||
|
||||
_Unspecified = _unspecified()
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
class errstate(contextlib.ContextDecorator):
|
||||
"""
|
||||
errstate(**kwargs)
|
||||
|
||||
Context manager for floating-point error handling.
|
||||
|
||||
Using an instance of `errstate` as a context manager allows statements in
|
||||
that context to execute with a known error handling behavior. Upon entering
|
||||
the context the error handling is set with `seterr` and `seterrcall`, and
|
||||
upon exiting it is reset to what it was before.
|
||||
|
||||
.. versionchanged:: 1.17.0
|
||||
`errstate` is also usable as a function decorator, saving
|
||||
a level of indentation if an entire function is wrapped.
|
||||
See :py:class:`contextlib.ContextDecorator` for more information.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
kwargs : {divide, over, under, invalid}
|
||||
Keyword arguments. The valid keywords are the possible floating-point
|
||||
exceptions. Each keyword should have a string value that defines the
|
||||
treatment for the particular error. Possible values are
|
||||
{'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
|
||||
|
||||
See Also
|
||||
--------
|
||||
seterr, geterr, seterrcall, geterrcall
|
||||
|
||||
Notes
|
||||
-----
|
||||
For complete documentation of the types of floating-point exceptions and
|
||||
treatment options, see `seterr`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> olderr = np.seterr(all='ignore') # Set error handling to known state.
|
||||
|
||||
>>> np.arange(3) / 0.
|
||||
array([nan, inf, inf])
|
||||
>>> with np.errstate(divide='warn'):
|
||||
... np.arange(3) / 0.
|
||||
array([nan, inf, inf])
|
||||
|
||||
>>> np.sqrt(-1)
|
||||
nan
|
||||
>>> with np.errstate(invalid='raise'):
|
||||
... np.sqrt(-1)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 2, in <module>
|
||||
FloatingPointError: invalid value encountered in sqrt
|
||||
|
||||
Outside the context the error handling behavior has not changed:
|
||||
|
||||
>>> np.geterr()
|
||||
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, *, call=_Unspecified, **kwargs):
|
||||
self.call = call
|
||||
self.kwargs = kwargs
|
||||
|
||||
def __enter__(self):
|
||||
self.oldstate = seterr(**self.kwargs)
|
||||
if self.call is not _Unspecified:
|
||||
self.oldcall = seterrcall(self.call)
|
||||
|
||||
def __exit__(self, *exc_info):
|
||||
seterr(**self.oldstate)
|
||||
if self.call is not _Unspecified:
|
||||
seterrcall(self.oldcall)
|
||||
|
||||
|
||||
def _setdef():
|
||||
defval = [UFUNC_BUFSIZE_DEFAULT, ERR_DEFAULT, None]
|
||||
umath.seterrobj(defval)
|
||||
|
||||
|
||||
# set the default values
|
||||
_setdef()
|
||||
|
||||
|
||||
NO_NEP50_WARNING = contextvars.ContextVar("_no_nep50_warning", default=False)
|
||||
|
||||
@set_module('numpy')
|
||||
@contextlib.contextmanager
|
||||
def _no_nep50_warning():
|
||||
"""
|
||||
Context manager to disable NEP 50 warnings. This context manager is
|
||||
only relevant if the NEP 50 warnings are enabled globally (which is not
|
||||
thread/context safe).
|
||||
|
||||
This warning context manager itself is fully safe, however.
|
||||
"""
|
||||
token = NO_NEP50_WARNING.set(True)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
NO_NEP50_WARNING.reset(token)
|
@@ -0,0 +1,37 @@
|
||||
from collections.abc import Callable
|
||||
from typing import Any, Literal, TypedDict
|
||||
|
||||
from numpy import _SupportsWrite
|
||||
|
||||
_ErrKind = Literal["ignore", "warn", "raise", "call", "print", "log"]
|
||||
_ErrFunc = Callable[[str, int], Any]
|
||||
|
||||
class _ErrDict(TypedDict):
|
||||
divide: _ErrKind
|
||||
over: _ErrKind
|
||||
under: _ErrKind
|
||||
invalid: _ErrKind
|
||||
|
||||
class _ErrDictOptional(TypedDict, total=False):
|
||||
all: None | _ErrKind
|
||||
divide: None | _ErrKind
|
||||
over: None | _ErrKind
|
||||
under: None | _ErrKind
|
||||
invalid: None | _ErrKind
|
||||
|
||||
def seterr(
|
||||
all: None | _ErrKind = ...,
|
||||
divide: None | _ErrKind = ...,
|
||||
over: None | _ErrKind = ...,
|
||||
under: None | _ErrKind = ...,
|
||||
invalid: None | _ErrKind = ...,
|
||||
) -> _ErrDict: ...
|
||||
def geterr() -> _ErrDict: ...
|
||||
def setbufsize(size: int) -> int: ...
|
||||
def getbufsize() -> int: ...
|
||||
def seterrcall(
|
||||
func: None | _ErrFunc | _SupportsWrite[str]
|
||||
) -> None | _ErrFunc | _SupportsWrite[str]: ...
|
||||
def geterrcall() -> None | _ErrFunc | _SupportsWrite[str]: ...
|
||||
|
||||
# See `numpy/__init__.pyi` for the `errstate` class and `no_nep5_warnings`
|
Binary file not shown.
1725
teil20b/lib/python3.11/site-packages/numpy/core/arrayprint.py
Normal file
1725
teil20b/lib/python3.11/site-packages/numpy/core/arrayprint.py
Normal file
File diff suppressed because it is too large
Load Diff
142
teil20b/lib/python3.11/site-packages/numpy/core/arrayprint.pyi
Normal file
142
teil20b/lib/python3.11/site-packages/numpy/core/arrayprint.pyi
Normal file
@@ -0,0 +1,142 @@
|
||||
from types import TracebackType
|
||||
from collections.abc import Callable
|
||||
from typing import Any, Literal, TypedDict, SupportsIndex
|
||||
|
||||
# Using a private class is by no means ideal, but it is simply a consequence
|
||||
# of a `contextlib.context` returning an instance of aforementioned class
|
||||
from contextlib import _GeneratorContextManager
|
||||
|
||||
from numpy import (
|
||||
ndarray,
|
||||
generic,
|
||||
bool_,
|
||||
integer,
|
||||
timedelta64,
|
||||
datetime64,
|
||||
floating,
|
||||
complexfloating,
|
||||
void,
|
||||
str_,
|
||||
bytes_,
|
||||
longdouble,
|
||||
clongdouble,
|
||||
)
|
||||
from numpy._typing import ArrayLike, _CharLike_co, _FloatLike_co
|
||||
|
||||
_FloatMode = Literal["fixed", "unique", "maxprec", "maxprec_equal"]
|
||||
|
||||
class _FormatDict(TypedDict, total=False):
|
||||
bool: Callable[[bool_], str]
|
||||
int: Callable[[integer[Any]], str]
|
||||
timedelta: Callable[[timedelta64], str]
|
||||
datetime: Callable[[datetime64], str]
|
||||
float: Callable[[floating[Any]], str]
|
||||
longfloat: Callable[[longdouble], str]
|
||||
complexfloat: Callable[[complexfloating[Any, Any]], str]
|
||||
longcomplexfloat: Callable[[clongdouble], str]
|
||||
void: Callable[[void], str]
|
||||
numpystr: Callable[[_CharLike_co], str]
|
||||
object: Callable[[object], str]
|
||||
all: Callable[[object], str]
|
||||
int_kind: Callable[[integer[Any]], str]
|
||||
float_kind: Callable[[floating[Any]], str]
|
||||
complex_kind: Callable[[complexfloating[Any, Any]], str]
|
||||
str_kind: Callable[[_CharLike_co], str]
|
||||
|
||||
class _FormatOptions(TypedDict):
|
||||
precision: int
|
||||
threshold: int
|
||||
edgeitems: int
|
||||
linewidth: int
|
||||
suppress: bool
|
||||
nanstr: str
|
||||
infstr: str
|
||||
formatter: None | _FormatDict
|
||||
sign: Literal["-", "+", " "]
|
||||
floatmode: _FloatMode
|
||||
legacy: Literal[False, "1.13", "1.21"]
|
||||
|
||||
def set_printoptions(
|
||||
precision: None | SupportsIndex = ...,
|
||||
threshold: None | int = ...,
|
||||
edgeitems: None | int = ...,
|
||||
linewidth: None | int = ...,
|
||||
suppress: None | bool = ...,
|
||||
nanstr: None | str = ...,
|
||||
infstr: None | str = ...,
|
||||
formatter: None | _FormatDict = ...,
|
||||
sign: Literal[None, "-", "+", " "] = ...,
|
||||
floatmode: None | _FloatMode = ...,
|
||||
*,
|
||||
legacy: Literal[None, False, "1.13", "1.21"] = ...
|
||||
) -> None: ...
|
||||
def get_printoptions() -> _FormatOptions: ...
|
||||
def array2string(
|
||||
a: ndarray[Any, Any],
|
||||
max_line_width: None | int = ...,
|
||||
precision: None | SupportsIndex = ...,
|
||||
suppress_small: None | bool = ...,
|
||||
separator: str = ...,
|
||||
prefix: str = ...,
|
||||
# NOTE: With the `style` argument being deprecated,
|
||||
# all arguments between `formatter` and `suffix` are de facto
|
||||
# keyworld-only arguments
|
||||
*,
|
||||
formatter: None | _FormatDict = ...,
|
||||
threshold: None | int = ...,
|
||||
edgeitems: None | int = ...,
|
||||
sign: Literal[None, "-", "+", " "] = ...,
|
||||
floatmode: None | _FloatMode = ...,
|
||||
suffix: str = ...,
|
||||
legacy: Literal[None, False, "1.13", "1.21"] = ...,
|
||||
) -> str: ...
|
||||
def format_float_scientific(
|
||||
x: _FloatLike_co,
|
||||
precision: None | int = ...,
|
||||
unique: bool = ...,
|
||||
trim: Literal["k", ".", "0", "-"] = ...,
|
||||
sign: bool = ...,
|
||||
pad_left: None | int = ...,
|
||||
exp_digits: None | int = ...,
|
||||
min_digits: None | int = ...,
|
||||
) -> str: ...
|
||||
def format_float_positional(
|
||||
x: _FloatLike_co,
|
||||
precision: None | int = ...,
|
||||
unique: bool = ...,
|
||||
fractional: bool = ...,
|
||||
trim: Literal["k", ".", "0", "-"] = ...,
|
||||
sign: bool = ...,
|
||||
pad_left: None | int = ...,
|
||||
pad_right: None | int = ...,
|
||||
min_digits: None | int = ...,
|
||||
) -> str: ...
|
||||
def array_repr(
|
||||
arr: ndarray[Any, Any],
|
||||
max_line_width: None | int = ...,
|
||||
precision: None | SupportsIndex = ...,
|
||||
suppress_small: None | bool = ...,
|
||||
) -> str: ...
|
||||
def array_str(
|
||||
a: ndarray[Any, Any],
|
||||
max_line_width: None | int = ...,
|
||||
precision: None | SupportsIndex = ...,
|
||||
suppress_small: None | bool = ...,
|
||||
) -> str: ...
|
||||
def set_string_function(
|
||||
f: None | Callable[[ndarray[Any, Any]], str], repr: bool = ...
|
||||
) -> None: ...
|
||||
def printoptions(
|
||||
precision: None | SupportsIndex = ...,
|
||||
threshold: None | int = ...,
|
||||
edgeitems: None | int = ...,
|
||||
linewidth: None | int = ...,
|
||||
suppress: None | bool = ...,
|
||||
nanstr: None | str = ...,
|
||||
infstr: None | str = ...,
|
||||
formatter: None | _FormatDict = ...,
|
||||
sign: Literal[None, "-", "+", " "] = ...,
|
||||
floatmode: None | _FloatMode = ...,
|
||||
*,
|
||||
legacy: Literal[None, False, "1.13", "1.21"] = ...
|
||||
) -> _GeneratorContextManager[_FormatOptions]: ...
|
13
teil20b/lib/python3.11/site-packages/numpy/core/cversions.py
Normal file
13
teil20b/lib/python3.11/site-packages/numpy/core/cversions.py
Normal file
@@ -0,0 +1,13 @@
|
||||
"""Simple script to compute the api hash of the current API.
|
||||
|
||||
The API has is defined by numpy_api_order and ufunc_api_order.
|
||||
|
||||
"""
|
||||
from os.path import dirname
|
||||
|
||||
from code_generators.genapi import fullapi_hash
|
||||
from code_generators.numpy_api import full_api
|
||||
|
||||
if __name__ == '__main__':
|
||||
curdir = dirname(__file__)
|
||||
print(fullapi_hash(full_api))
|
2914
teil20b/lib/python3.11/site-packages/numpy/core/defchararray.py
Normal file
2914
teil20b/lib/python3.11/site-packages/numpy/core/defchararray.py
Normal file
File diff suppressed because it is too large
Load Diff
421
teil20b/lib/python3.11/site-packages/numpy/core/defchararray.pyi
Normal file
421
teil20b/lib/python3.11/site-packages/numpy/core/defchararray.pyi
Normal file
@@ -0,0 +1,421 @@
|
||||
from typing import (
|
||||
Literal as L,
|
||||
overload,
|
||||
TypeVar,
|
||||
Any,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
chararray as chararray,
|
||||
dtype,
|
||||
str_,
|
||||
bytes_,
|
||||
int_,
|
||||
bool_,
|
||||
object_,
|
||||
_OrderKACF,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
_ArrayLikeStr_co as U_co,
|
||||
_ArrayLikeBytes_co as S_co,
|
||||
_ArrayLikeInt_co as i_co,
|
||||
_ArrayLikeBool_co as b_co,
|
||||
)
|
||||
|
||||
from numpy.core.multiarray import compare_chararrays as compare_chararrays
|
||||
|
||||
_SCT = TypeVar("_SCT", str_, bytes_)
|
||||
_CharArray = chararray[Any, dtype[_SCT]]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# Comparison
|
||||
@overload
|
||||
def equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def not_equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def not_equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def greater_equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def greater_equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def less_equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def less_equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def greater(x1: U_co, x2: U_co) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def greater(x1: S_co, x2: S_co) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def less(x1: U_co, x2: U_co) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def less(x1: S_co, x2: S_co) -> NDArray[bool_]: ...
|
||||
|
||||
# String operations
|
||||
@overload
|
||||
def add(x1: U_co, x2: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def add(x1: S_co, x2: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def multiply(a: U_co, i: i_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def multiply(a: S_co, i: i_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def mod(a: U_co, value: Any) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def mod(a: S_co, value: Any) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def capitalize(a: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def capitalize(a: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def center(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def center(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[bytes_]: ...
|
||||
|
||||
def decode(
|
||||
a: S_co,
|
||||
encoding: None | str = ...,
|
||||
errors: None | str = ...,
|
||||
) -> NDArray[str_]: ...
|
||||
|
||||
def encode(
|
||||
a: U_co,
|
||||
encoding: None | str = ...,
|
||||
errors: None | str = ...,
|
||||
) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def expandtabs(a: U_co, tabsize: i_co = ...) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def expandtabs(a: S_co, tabsize: i_co = ...) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def join(sep: U_co, seq: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def join(sep: S_co, seq: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def ljust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def ljust(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def lower(a: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def lower(a: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def lstrip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def lstrip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def partition(a: U_co, sep: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def partition(a: S_co, sep: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def replace(
|
||||
a: U_co,
|
||||
old: U_co,
|
||||
new: U_co,
|
||||
count: None | i_co = ...,
|
||||
) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def replace(
|
||||
a: S_co,
|
||||
old: S_co,
|
||||
new: S_co,
|
||||
count: None | i_co = ...,
|
||||
) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def rjust(
|
||||
a: U_co,
|
||||
width: i_co,
|
||||
fillchar: U_co = ...,
|
||||
) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def rjust(
|
||||
a: S_co,
|
||||
width: i_co,
|
||||
fillchar: S_co = ...,
|
||||
) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def rpartition(a: U_co, sep: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def rpartition(a: S_co, sep: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def rsplit(
|
||||
a: U_co,
|
||||
sep: None | U_co = ...,
|
||||
maxsplit: None | i_co = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
@overload
|
||||
def rsplit(
|
||||
a: S_co,
|
||||
sep: None | S_co = ...,
|
||||
maxsplit: None | i_co = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def rstrip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def rstrip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def split(
|
||||
a: U_co,
|
||||
sep: None | U_co = ...,
|
||||
maxsplit: None | i_co = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
@overload
|
||||
def split(
|
||||
a: S_co,
|
||||
sep: None | S_co = ...,
|
||||
maxsplit: None | i_co = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def splitlines(a: U_co, keepends: None | b_co = ...) -> NDArray[object_]: ...
|
||||
@overload
|
||||
def splitlines(a: S_co, keepends: None | b_co = ...) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def strip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def strip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def swapcase(a: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def swapcase(a: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def title(a: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def title(a: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def translate(
|
||||
a: U_co,
|
||||
table: U_co,
|
||||
deletechars: None | U_co = ...,
|
||||
) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def translate(
|
||||
a: S_co,
|
||||
table: S_co,
|
||||
deletechars: None | S_co = ...,
|
||||
) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def upper(a: U_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def upper(a: S_co) -> NDArray[bytes_]: ...
|
||||
|
||||
@overload
|
||||
def zfill(a: U_co, width: i_co) -> NDArray[str_]: ...
|
||||
@overload
|
||||
def zfill(a: S_co, width: i_co) -> NDArray[bytes_]: ...
|
||||
|
||||
# String information
|
||||
@overload
|
||||
def count(
|
||||
a: U_co,
|
||||
sub: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
@overload
|
||||
def count(
|
||||
a: S_co,
|
||||
sub: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
|
||||
@overload
|
||||
def endswith(
|
||||
a: U_co,
|
||||
suffix: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def endswith(
|
||||
a: S_co,
|
||||
suffix: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def find(
|
||||
a: U_co,
|
||||
sub: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
@overload
|
||||
def find(
|
||||
a: S_co,
|
||||
sub: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
|
||||
@overload
|
||||
def index(
|
||||
a: U_co,
|
||||
sub: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
@overload
|
||||
def index(
|
||||
a: S_co,
|
||||
sub: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
|
||||
def isalpha(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def isalnum(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def isdecimal(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def isdigit(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def islower(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def isnumeric(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def isspace(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def istitle(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
def isupper(a: U_co | S_co) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def rfind(
|
||||
a: U_co,
|
||||
sub: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
@overload
|
||||
def rfind(
|
||||
a: S_co,
|
||||
sub: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
|
||||
@overload
|
||||
def rindex(
|
||||
a: U_co,
|
||||
sub: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
@overload
|
||||
def rindex(
|
||||
a: S_co,
|
||||
sub: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[int_]: ...
|
||||
|
||||
@overload
|
||||
def startswith(
|
||||
a: U_co,
|
||||
prefix: U_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def startswith(
|
||||
a: S_co,
|
||||
prefix: S_co,
|
||||
start: i_co = ...,
|
||||
end: None | i_co = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
|
||||
def str_len(A: U_co | S_co) -> NDArray[int_]: ...
|
||||
|
||||
# Overload 1 and 2: str- or bytes-based array-likes
|
||||
# overload 3: arbitrary object with unicode=False (-> bytes_)
|
||||
# overload 4: arbitrary object with unicode=True (-> str_)
|
||||
@overload
|
||||
def array(
|
||||
obj: U_co,
|
||||
itemsize: None | int = ...,
|
||||
copy: bool = ...,
|
||||
unicode: L[False] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[str_]: ...
|
||||
@overload
|
||||
def array(
|
||||
obj: S_co,
|
||||
itemsize: None | int = ...,
|
||||
copy: bool = ...,
|
||||
unicode: L[False] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[bytes_]: ...
|
||||
@overload
|
||||
def array(
|
||||
obj: object,
|
||||
itemsize: None | int = ...,
|
||||
copy: bool = ...,
|
||||
unicode: L[False] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[bytes_]: ...
|
||||
@overload
|
||||
def array(
|
||||
obj: object,
|
||||
itemsize: None | int = ...,
|
||||
copy: bool = ...,
|
||||
unicode: L[True] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[str_]: ...
|
||||
|
||||
@overload
|
||||
def asarray(
|
||||
obj: U_co,
|
||||
itemsize: None | int = ...,
|
||||
unicode: L[False] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[str_]: ...
|
||||
@overload
|
||||
def asarray(
|
||||
obj: S_co,
|
||||
itemsize: None | int = ...,
|
||||
unicode: L[False] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[bytes_]: ...
|
||||
@overload
|
||||
def asarray(
|
||||
obj: object,
|
||||
itemsize: None | int = ...,
|
||||
unicode: L[False] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[bytes_]: ...
|
||||
@overload
|
||||
def asarray(
|
||||
obj: object,
|
||||
itemsize: None | int = ...,
|
||||
unicode: L[True] = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> _CharArray[str_]: ...
|
1443
teil20b/lib/python3.11/site-packages/numpy/core/einsumfunc.py
Normal file
1443
teil20b/lib/python3.11/site-packages/numpy/core/einsumfunc.py
Normal file
File diff suppressed because it is too large
Load Diff
187
teil20b/lib/python3.11/site-packages/numpy/core/einsumfunc.pyi
Normal file
187
teil20b/lib/python3.11/site-packages/numpy/core/einsumfunc.pyi
Normal file
@@ -0,0 +1,187 @@
|
||||
from collections.abc import Sequence
|
||||
from typing import TypeVar, Any, overload, Union, Literal
|
||||
|
||||
from numpy import (
|
||||
ndarray,
|
||||
dtype,
|
||||
bool_,
|
||||
number,
|
||||
_OrderKACF,
|
||||
)
|
||||
from numpy._typing import (
|
||||
_ArrayLikeBool_co,
|
||||
_ArrayLikeUInt_co,
|
||||
_ArrayLikeInt_co,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
_ArrayLikeObject_co,
|
||||
_DTypeLikeBool,
|
||||
_DTypeLikeUInt,
|
||||
_DTypeLikeInt,
|
||||
_DTypeLikeFloat,
|
||||
_DTypeLikeComplex,
|
||||
_DTypeLikeComplex_co,
|
||||
_DTypeLikeObject,
|
||||
)
|
||||
|
||||
_ArrayType = TypeVar(
|
||||
"_ArrayType",
|
||||
bound=ndarray[Any, dtype[Union[bool_, number[Any]]]],
|
||||
)
|
||||
|
||||
_OptimizeKind = None | bool | Literal["greedy", "optimal"] | Sequence[Any]
|
||||
_CastingSafe = Literal["no", "equiv", "safe", "same_kind"]
|
||||
_CastingUnsafe = Literal["unsafe"]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# TODO: Properly handle the `casting`-based combinatorics
|
||||
# TODO: We need to evaluate the content `__subscripts` in order
|
||||
# to identify whether or an array or scalar is returned. At a cursory
|
||||
# glance this seems like something that can quite easily be done with
|
||||
# a mypy plugin.
|
||||
# Something like `is_scalar = bool(__subscripts.partition("->")[-1])`
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeBool_co,
|
||||
out: None = ...,
|
||||
dtype: None | _DTypeLikeBool = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeUInt_co,
|
||||
out: None = ...,
|
||||
dtype: None | _DTypeLikeUInt = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeInt_co,
|
||||
out: None = ...,
|
||||
dtype: None | _DTypeLikeInt = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeFloat_co,
|
||||
out: None = ...,
|
||||
dtype: None | _DTypeLikeFloat = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeComplex_co,
|
||||
out: None = ...,
|
||||
dtype: None | _DTypeLikeComplex = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: Any,
|
||||
casting: _CastingUnsafe,
|
||||
dtype: None | _DTypeLikeComplex_co = ...,
|
||||
out: None = ...,
|
||||
order: _OrderKACF = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeComplex_co,
|
||||
out: _ArrayType,
|
||||
dtype: None | _DTypeLikeComplex_co = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> _ArrayType: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: Any,
|
||||
out: _ArrayType,
|
||||
casting: _CastingUnsafe,
|
||||
dtype: None | _DTypeLikeComplex_co = ...,
|
||||
order: _OrderKACF = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> _ArrayType: ...
|
||||
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeObject_co,
|
||||
out: None = ...,
|
||||
dtype: None | _DTypeLikeObject = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: Any,
|
||||
casting: _CastingUnsafe,
|
||||
dtype: None | _DTypeLikeObject = ...,
|
||||
out: None = ...,
|
||||
order: _OrderKACF = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeObject_co,
|
||||
out: _ArrayType,
|
||||
dtype: None | _DTypeLikeObject = ...,
|
||||
order: _OrderKACF = ...,
|
||||
casting: _CastingSafe = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> _ArrayType: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: Any,
|
||||
out: _ArrayType,
|
||||
casting: _CastingUnsafe,
|
||||
dtype: None | _DTypeLikeObject = ...,
|
||||
order: _OrderKACF = ...,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> _ArrayType: ...
|
||||
|
||||
# NOTE: `einsum_call` is a hidden kwarg unavailable for public use.
|
||||
# It is therefore excluded from the signatures below.
|
||||
# NOTE: In practice the list consists of a `str` (first element)
|
||||
# and a variable number of integer tuples.
|
||||
def einsum_path(
|
||||
subscripts: str | _ArrayLikeInt_co,
|
||||
/,
|
||||
*operands: _ArrayLikeComplex_co | _DTypeLikeObject,
|
||||
optimize: _OptimizeKind = ...,
|
||||
) -> tuple[list[Any], str]: ...
|
3920
teil20b/lib/python3.11/site-packages/numpy/core/fromnumeric.py
Normal file
3920
teil20b/lib/python3.11/site-packages/numpy/core/fromnumeric.py
Normal file
File diff suppressed because it is too large
Load Diff
1053
teil20b/lib/python3.11/site-packages/numpy/core/fromnumeric.pyi
Normal file
1053
teil20b/lib/python3.11/site-packages/numpy/core/fromnumeric.pyi
Normal file
File diff suppressed because it is too large
Load Diff
551
teil20b/lib/python3.11/site-packages/numpy/core/function_base.py
Normal file
551
teil20b/lib/python3.11/site-packages/numpy/core/function_base.py
Normal file
@@ -0,0 +1,551 @@
|
||||
import functools
|
||||
import warnings
|
||||
import operator
|
||||
import types
|
||||
|
||||
import numpy as np
|
||||
from . import numeric as _nx
|
||||
from .numeric import result_type, NaN, asanyarray, ndim
|
||||
from numpy.core.multiarray import add_docstring
|
||||
from numpy.core import overrides
|
||||
|
||||
__all__ = ['logspace', 'linspace', 'geomspace']
|
||||
|
||||
|
||||
array_function_dispatch = functools.partial(
|
||||
overrides.array_function_dispatch, module='numpy')
|
||||
|
||||
|
||||
def _linspace_dispatcher(start, stop, num=None, endpoint=None, retstep=None,
|
||||
dtype=None, axis=None):
|
||||
return (start, stop)
|
||||
|
||||
|
||||
@array_function_dispatch(_linspace_dispatcher)
|
||||
def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,
|
||||
axis=0):
|
||||
"""
|
||||
Return evenly spaced numbers over a specified interval.
|
||||
|
||||
Returns `num` evenly spaced samples, calculated over the
|
||||
interval [`start`, `stop`].
|
||||
|
||||
The endpoint of the interval can optionally be excluded.
|
||||
|
||||
.. versionchanged:: 1.16.0
|
||||
Non-scalar `start` and `stop` are now supported.
|
||||
|
||||
.. versionchanged:: 1.20.0
|
||||
Values are rounded towards ``-inf`` instead of ``0`` when an
|
||||
integer ``dtype`` is specified. The old behavior can
|
||||
still be obtained with ``np.linspace(start, stop, num).astype(int)``
|
||||
|
||||
Parameters
|
||||
----------
|
||||
start : array_like
|
||||
The starting value of the sequence.
|
||||
stop : array_like
|
||||
The end value of the sequence, unless `endpoint` is set to False.
|
||||
In that case, the sequence consists of all but the last of ``num + 1``
|
||||
evenly spaced samples, so that `stop` is excluded. Note that the step
|
||||
size changes when `endpoint` is False.
|
||||
num : int, optional
|
||||
Number of samples to generate. Default is 50. Must be non-negative.
|
||||
endpoint : bool, optional
|
||||
If True, `stop` is the last sample. Otherwise, it is not included.
|
||||
Default is True.
|
||||
retstep : bool, optional
|
||||
If True, return (`samples`, `step`), where `step` is the spacing
|
||||
between samples.
|
||||
dtype : dtype, optional
|
||||
The type of the output array. If `dtype` is not given, the data type
|
||||
is inferred from `start` and `stop`. The inferred dtype will never be
|
||||
an integer; `float` is chosen even if the arguments would produce an
|
||||
array of integers.
|
||||
|
||||
.. versionadded:: 1.9.0
|
||||
|
||||
axis : int, optional
|
||||
The axis in the result to store the samples. Relevant only if start
|
||||
or stop are array-like. By default (0), the samples will be along a
|
||||
new axis inserted at the beginning. Use -1 to get an axis at the end.
|
||||
|
||||
.. versionadded:: 1.16.0
|
||||
|
||||
Returns
|
||||
-------
|
||||
samples : ndarray
|
||||
There are `num` equally spaced samples in the closed interval
|
||||
``[start, stop]`` or the half-open interval ``[start, stop)``
|
||||
(depending on whether `endpoint` is True or False).
|
||||
step : float, optional
|
||||
Only returned if `retstep` is True
|
||||
|
||||
Size of spacing between samples.
|
||||
|
||||
|
||||
See Also
|
||||
--------
|
||||
arange : Similar to `linspace`, but uses a step size (instead of the
|
||||
number of samples).
|
||||
geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
|
||||
scale (a geometric progression).
|
||||
logspace : Similar to `geomspace`, but with the end points specified as
|
||||
logarithms.
|
||||
:ref:`how-to-partition`
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.linspace(2.0, 3.0, num=5)
|
||||
array([2. , 2.25, 2.5 , 2.75, 3. ])
|
||||
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
|
||||
array([2. , 2.2, 2.4, 2.6, 2.8])
|
||||
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
|
||||
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)
|
||||
|
||||
Graphical illustration:
|
||||
|
||||
>>> import matplotlib.pyplot as plt
|
||||
>>> N = 8
|
||||
>>> y = np.zeros(N)
|
||||
>>> x1 = np.linspace(0, 10, N, endpoint=True)
|
||||
>>> x2 = np.linspace(0, 10, N, endpoint=False)
|
||||
>>> plt.plot(x1, y, 'o')
|
||||
[<matplotlib.lines.Line2D object at 0x...>]
|
||||
>>> plt.plot(x2, y + 0.5, 'o')
|
||||
[<matplotlib.lines.Line2D object at 0x...>]
|
||||
>>> plt.ylim([-0.5, 1])
|
||||
(-0.5, 1)
|
||||
>>> plt.show()
|
||||
|
||||
"""
|
||||
num = operator.index(num)
|
||||
if num < 0:
|
||||
raise ValueError("Number of samples, %s, must be non-negative." % num)
|
||||
div = (num - 1) if endpoint else num
|
||||
|
||||
# Convert float/complex array scalars to float, gh-3504
|
||||
# and make sure one can use variables that have an __array_interface__, gh-6634
|
||||
start = asanyarray(start) * 1.0
|
||||
stop = asanyarray(stop) * 1.0
|
||||
|
||||
dt = result_type(start, stop, float(num))
|
||||
if dtype is None:
|
||||
dtype = dt
|
||||
integer_dtype = False
|
||||
else:
|
||||
integer_dtype = _nx.issubdtype(dtype, _nx.integer)
|
||||
|
||||
delta = stop - start
|
||||
y = _nx.arange(0, num, dtype=dt).reshape((-1,) + (1,) * ndim(delta))
|
||||
# In-place multiplication y *= delta/div is faster, but prevents the multiplicant
|
||||
# from overriding what class is produced, and thus prevents, e.g. use of Quantities,
|
||||
# see gh-7142. Hence, we multiply in place only for standard scalar types.
|
||||
if div > 0:
|
||||
_mult_inplace = _nx.isscalar(delta)
|
||||
step = delta / div
|
||||
any_step_zero = (
|
||||
step == 0 if _mult_inplace else _nx.asanyarray(step == 0).any())
|
||||
if any_step_zero:
|
||||
# Special handling for denormal numbers, gh-5437
|
||||
y /= div
|
||||
if _mult_inplace:
|
||||
y *= delta
|
||||
else:
|
||||
y = y * delta
|
||||
else:
|
||||
if _mult_inplace:
|
||||
y *= step
|
||||
else:
|
||||
y = y * step
|
||||
else:
|
||||
# sequences with 0 items or 1 item with endpoint=True (i.e. div <= 0)
|
||||
# have an undefined step
|
||||
step = NaN
|
||||
# Multiply with delta to allow possible override of output class.
|
||||
y = y * delta
|
||||
|
||||
y += start
|
||||
|
||||
if endpoint and num > 1:
|
||||
y[-1, ...] = stop
|
||||
|
||||
if axis != 0:
|
||||
y = _nx.moveaxis(y, 0, axis)
|
||||
|
||||
if integer_dtype:
|
||||
_nx.floor(y, out=y)
|
||||
|
||||
if retstep:
|
||||
return y.astype(dtype, copy=False), step
|
||||
else:
|
||||
return y.astype(dtype, copy=False)
|
||||
|
||||
|
||||
def _logspace_dispatcher(start, stop, num=None, endpoint=None, base=None,
|
||||
dtype=None, axis=None):
|
||||
return (start, stop, base)
|
||||
|
||||
|
||||
@array_function_dispatch(_logspace_dispatcher)
|
||||
def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,
|
||||
axis=0):
|
||||
"""
|
||||
Return numbers spaced evenly on a log scale.
|
||||
|
||||
In linear space, the sequence starts at ``base ** start``
|
||||
(`base` to the power of `start`) and ends with ``base ** stop``
|
||||
(see `endpoint` below).
|
||||
|
||||
.. versionchanged:: 1.16.0
|
||||
Non-scalar `start` and `stop` are now supported.
|
||||
|
||||
.. versionchanged:: 1.25.0
|
||||
Non-scalar 'base` is now supported
|
||||
|
||||
Parameters
|
||||
----------
|
||||
start : array_like
|
||||
``base ** start`` is the starting value of the sequence.
|
||||
stop : array_like
|
||||
``base ** stop`` is the final value of the sequence, unless `endpoint`
|
||||
is False. In that case, ``num + 1`` values are spaced over the
|
||||
interval in log-space, of which all but the last (a sequence of
|
||||
length `num`) are returned.
|
||||
num : integer, optional
|
||||
Number of samples to generate. Default is 50.
|
||||
endpoint : boolean, optional
|
||||
If true, `stop` is the last sample. Otherwise, it is not included.
|
||||
Default is True.
|
||||
base : array_like, optional
|
||||
The base of the log space. The step size between the elements in
|
||||
``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
|
||||
Default is 10.0.
|
||||
dtype : dtype
|
||||
The type of the output array. If `dtype` is not given, the data type
|
||||
is inferred from `start` and `stop`. The inferred type will never be
|
||||
an integer; `float` is chosen even if the arguments would produce an
|
||||
array of integers.
|
||||
axis : int, optional
|
||||
The axis in the result to store the samples. Relevant only if start,
|
||||
stop, or base are array-like. By default (0), the samples will be
|
||||
along a new axis inserted at the beginning. Use -1 to get an axis at
|
||||
the end.
|
||||
|
||||
.. versionadded:: 1.16.0
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
samples : ndarray
|
||||
`num` samples, equally spaced on a log scale.
|
||||
|
||||
See Also
|
||||
--------
|
||||
arange : Similar to linspace, with the step size specified instead of the
|
||||
number of samples. Note that, when used with a float endpoint, the
|
||||
endpoint may or may not be included.
|
||||
linspace : Similar to logspace, but with the samples uniformly distributed
|
||||
in linear space, instead of log space.
|
||||
geomspace : Similar to logspace, but with endpoints specified directly.
|
||||
:ref:`how-to-partition`
|
||||
|
||||
Notes
|
||||
-----
|
||||
If base is a scalar, logspace is equivalent to the code
|
||||
|
||||
>>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
|
||||
... # doctest: +SKIP
|
||||
>>> power(base, y).astype(dtype)
|
||||
... # doctest: +SKIP
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.logspace(2.0, 3.0, num=4)
|
||||
array([ 100. , 215.443469 , 464.15888336, 1000. ])
|
||||
>>> np.logspace(2.0, 3.0, num=4, endpoint=False)
|
||||
array([100. , 177.827941 , 316.22776602, 562.34132519])
|
||||
>>> np.logspace(2.0, 3.0, num=4, base=2.0)
|
||||
array([4. , 5.0396842 , 6.34960421, 8. ])
|
||||
>>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1)
|
||||
array([[ 4. , 5.0396842 , 6.34960421, 8. ],
|
||||
[ 9. , 12.98024613, 18.72075441, 27. ]])
|
||||
|
||||
Graphical illustration:
|
||||
|
||||
>>> import matplotlib.pyplot as plt
|
||||
>>> N = 10
|
||||
>>> x1 = np.logspace(0.1, 1, N, endpoint=True)
|
||||
>>> x2 = np.logspace(0.1, 1, N, endpoint=False)
|
||||
>>> y = np.zeros(N)
|
||||
>>> plt.plot(x1, y, 'o')
|
||||
[<matplotlib.lines.Line2D object at 0x...>]
|
||||
>>> plt.plot(x2, y + 0.5, 'o')
|
||||
[<matplotlib.lines.Line2D object at 0x...>]
|
||||
>>> plt.ylim([-0.5, 1])
|
||||
(-0.5, 1)
|
||||
>>> plt.show()
|
||||
|
||||
"""
|
||||
ndmax = np.broadcast(start, stop, base).ndim
|
||||
start, stop, base = (
|
||||
np.array(a, copy=False, subok=True, ndmin=ndmax)
|
||||
for a in (start, stop, base)
|
||||
)
|
||||
y = linspace(start, stop, num=num, endpoint=endpoint, axis=axis)
|
||||
base = np.expand_dims(base, axis=axis)
|
||||
if dtype is None:
|
||||
return _nx.power(base, y)
|
||||
return _nx.power(base, y).astype(dtype, copy=False)
|
||||
|
||||
|
||||
def _geomspace_dispatcher(start, stop, num=None, endpoint=None, dtype=None,
|
||||
axis=None):
|
||||
return (start, stop)
|
||||
|
||||
|
||||
@array_function_dispatch(_geomspace_dispatcher)
|
||||
def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
|
||||
"""
|
||||
Return numbers spaced evenly on a log scale (a geometric progression).
|
||||
|
||||
This is similar to `logspace`, but with endpoints specified directly.
|
||||
Each output sample is a constant multiple of the previous.
|
||||
|
||||
.. versionchanged:: 1.16.0
|
||||
Non-scalar `start` and `stop` are now supported.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
start : array_like
|
||||
The starting value of the sequence.
|
||||
stop : array_like
|
||||
The final value of the sequence, unless `endpoint` is False.
|
||||
In that case, ``num + 1`` values are spaced over the
|
||||
interval in log-space, of which all but the last (a sequence of
|
||||
length `num`) are returned.
|
||||
num : integer, optional
|
||||
Number of samples to generate. Default is 50.
|
||||
endpoint : boolean, optional
|
||||
If true, `stop` is the last sample. Otherwise, it is not included.
|
||||
Default is True.
|
||||
dtype : dtype
|
||||
The type of the output array. If `dtype` is not given, the data type
|
||||
is inferred from `start` and `stop`. The inferred dtype will never be
|
||||
an integer; `float` is chosen even if the arguments would produce an
|
||||
array of integers.
|
||||
axis : int, optional
|
||||
The axis in the result to store the samples. Relevant only if start
|
||||
or stop are array-like. By default (0), the samples will be along a
|
||||
new axis inserted at the beginning. Use -1 to get an axis at the end.
|
||||
|
||||
.. versionadded:: 1.16.0
|
||||
|
||||
Returns
|
||||
-------
|
||||
samples : ndarray
|
||||
`num` samples, equally spaced on a log scale.
|
||||
|
||||
See Also
|
||||
--------
|
||||
logspace : Similar to geomspace, but with endpoints specified using log
|
||||
and base.
|
||||
linspace : Similar to geomspace, but with arithmetic instead of geometric
|
||||
progression.
|
||||
arange : Similar to linspace, with the step size specified instead of the
|
||||
number of samples.
|
||||
:ref:`how-to-partition`
|
||||
|
||||
Notes
|
||||
-----
|
||||
If the inputs or dtype are complex, the output will follow a logarithmic
|
||||
spiral in the complex plane. (There are an infinite number of spirals
|
||||
passing through two points; the output will follow the shortest such path.)
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.geomspace(1, 1000, num=4)
|
||||
array([ 1., 10., 100., 1000.])
|
||||
>>> np.geomspace(1, 1000, num=3, endpoint=False)
|
||||
array([ 1., 10., 100.])
|
||||
>>> np.geomspace(1, 1000, num=4, endpoint=False)
|
||||
array([ 1. , 5.62341325, 31.6227766 , 177.827941 ])
|
||||
>>> np.geomspace(1, 256, num=9)
|
||||
array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.])
|
||||
|
||||
Note that the above may not produce exact integers:
|
||||
|
||||
>>> np.geomspace(1, 256, num=9, dtype=int)
|
||||
array([ 1, 2, 4, 7, 16, 32, 63, 127, 256])
|
||||
>>> np.around(np.geomspace(1, 256, num=9)).astype(int)
|
||||
array([ 1, 2, 4, 8, 16, 32, 64, 128, 256])
|
||||
|
||||
Negative, decreasing, and complex inputs are allowed:
|
||||
|
||||
>>> np.geomspace(1000, 1, num=4)
|
||||
array([1000., 100., 10., 1.])
|
||||
>>> np.geomspace(-1000, -1, num=4)
|
||||
array([-1000., -100., -10., -1.])
|
||||
>>> np.geomspace(1j, 1000j, num=4) # Straight line
|
||||
array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j])
|
||||
>>> np.geomspace(-1+0j, 1+0j, num=5) # Circle
|
||||
array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
|
||||
6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j,
|
||||
1.00000000e+00+0.00000000e+00j])
|
||||
|
||||
Graphical illustration of `endpoint` parameter:
|
||||
|
||||
>>> import matplotlib.pyplot as plt
|
||||
>>> N = 10
|
||||
>>> y = np.zeros(N)
|
||||
>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
|
||||
[<matplotlib.lines.Line2D object at 0x...>]
|
||||
>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
|
||||
[<matplotlib.lines.Line2D object at 0x...>]
|
||||
>>> plt.axis([0.5, 2000, 0, 3])
|
||||
[0.5, 2000, 0, 3]
|
||||
>>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
|
||||
>>> plt.show()
|
||||
|
||||
"""
|
||||
start = asanyarray(start)
|
||||
stop = asanyarray(stop)
|
||||
if _nx.any(start == 0) or _nx.any(stop == 0):
|
||||
raise ValueError('Geometric sequence cannot include zero')
|
||||
|
||||
dt = result_type(start, stop, float(num), _nx.zeros((), dtype))
|
||||
if dtype is None:
|
||||
dtype = dt
|
||||
else:
|
||||
# complex to dtype('complex128'), for instance
|
||||
dtype = _nx.dtype(dtype)
|
||||
|
||||
# Promote both arguments to the same dtype in case, for instance, one is
|
||||
# complex and another is negative and log would produce NaN otherwise.
|
||||
# Copy since we may change things in-place further down.
|
||||
start = start.astype(dt, copy=True)
|
||||
stop = stop.astype(dt, copy=True)
|
||||
|
||||
out_sign = _nx.ones(_nx.broadcast(start, stop).shape, dt)
|
||||
# Avoid negligible real or imaginary parts in output by rotating to
|
||||
# positive real, calculating, then undoing rotation
|
||||
if _nx.issubdtype(dt, _nx.complexfloating):
|
||||
all_imag = (start.real == 0.) & (stop.real == 0.)
|
||||
if _nx.any(all_imag):
|
||||
start[all_imag] = start[all_imag].imag
|
||||
stop[all_imag] = stop[all_imag].imag
|
||||
out_sign[all_imag] = 1j
|
||||
|
||||
both_negative = (_nx.sign(start) == -1) & (_nx.sign(stop) == -1)
|
||||
if _nx.any(both_negative):
|
||||
_nx.negative(start, out=start, where=both_negative)
|
||||
_nx.negative(stop, out=stop, where=both_negative)
|
||||
_nx.negative(out_sign, out=out_sign, where=both_negative)
|
||||
|
||||
log_start = _nx.log10(start)
|
||||
log_stop = _nx.log10(stop)
|
||||
result = logspace(log_start, log_stop, num=num,
|
||||
endpoint=endpoint, base=10.0, dtype=dtype)
|
||||
|
||||
# Make sure the endpoints match the start and stop arguments. This is
|
||||
# necessary because np.exp(np.log(x)) is not necessarily equal to x.
|
||||
if num > 0:
|
||||
result[0] = start
|
||||
if num > 1 and endpoint:
|
||||
result[-1] = stop
|
||||
|
||||
result = out_sign * result
|
||||
|
||||
if axis != 0:
|
||||
result = _nx.moveaxis(result, 0, axis)
|
||||
|
||||
return result.astype(dtype, copy=False)
|
||||
|
||||
|
||||
def _needs_add_docstring(obj):
|
||||
"""
|
||||
Returns true if the only way to set the docstring of `obj` from python is
|
||||
via add_docstring.
|
||||
|
||||
This function errs on the side of being overly conservative.
|
||||
"""
|
||||
Py_TPFLAGS_HEAPTYPE = 1 << 9
|
||||
|
||||
if isinstance(obj, (types.FunctionType, types.MethodType, property)):
|
||||
return False
|
||||
|
||||
if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE:
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def _add_docstring(obj, doc, warn_on_python):
|
||||
if warn_on_python and not _needs_add_docstring(obj):
|
||||
warnings.warn(
|
||||
"add_newdoc was used on a pure-python object {}. "
|
||||
"Prefer to attach it directly to the source."
|
||||
.format(obj),
|
||||
UserWarning,
|
||||
stacklevel=3)
|
||||
try:
|
||||
add_docstring(obj, doc)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
def add_newdoc(place, obj, doc, warn_on_python=True):
|
||||
"""
|
||||
Add documentation to an existing object, typically one defined in C
|
||||
|
||||
The purpose is to allow easier editing of the docstrings without requiring
|
||||
a re-compile. This exists primarily for internal use within numpy itself.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
place : str
|
||||
The absolute name of the module to import from
|
||||
obj : str
|
||||
The name of the object to add documentation to, typically a class or
|
||||
function name
|
||||
doc : {str, Tuple[str, str], List[Tuple[str, str]]}
|
||||
If a string, the documentation to apply to `obj`
|
||||
|
||||
If a tuple, then the first element is interpreted as an attribute of
|
||||
`obj` and the second as the docstring to apply - ``(method, docstring)``
|
||||
|
||||
If a list, then each element of the list should be a tuple of length
|
||||
two - ``[(method1, docstring1), (method2, docstring2), ...]``
|
||||
warn_on_python : bool
|
||||
If True, the default, emit `UserWarning` if this is used to attach
|
||||
documentation to a pure-python object.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This routine never raises an error if the docstring can't be written, but
|
||||
will raise an error if the object being documented does not exist.
|
||||
|
||||
This routine cannot modify read-only docstrings, as appear
|
||||
in new-style classes or built-in functions. Because this
|
||||
routine never raises an error the caller must check manually
|
||||
that the docstrings were changed.
|
||||
|
||||
Since this function grabs the ``char *`` from a c-level str object and puts
|
||||
it into the ``tp_doc`` slot of the type of `obj`, it violates a number of
|
||||
C-API best-practices, by:
|
||||
|
||||
- modifying a `PyTypeObject` after calling `PyType_Ready`
|
||||
- calling `Py_INCREF` on the str and losing the reference, so the str
|
||||
will never be released
|
||||
|
||||
If possible it should be avoided.
|
||||
"""
|
||||
new = getattr(__import__(place, globals(), {}, [obj]), obj)
|
||||
if isinstance(doc, str):
|
||||
_add_docstring(new, doc.strip(), warn_on_python)
|
||||
elif isinstance(doc, tuple):
|
||||
attr, docstring = doc
|
||||
_add_docstring(getattr(new, attr), docstring.strip(), warn_on_python)
|
||||
elif isinstance(doc, list):
|
||||
for attr, docstring in doc:
|
||||
_add_docstring(getattr(new, attr), docstring.strip(), warn_on_python)
|
@@ -0,0 +1,187 @@
|
||||
from typing import (
|
||||
Literal as L,
|
||||
overload,
|
||||
Any,
|
||||
SupportsIndex,
|
||||
TypeVar,
|
||||
)
|
||||
|
||||
from numpy import floating, complexfloating, generic
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
DTypeLike,
|
||||
_DTypeLike,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
)
|
||||
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeFloat_co,
|
||||
stop: _ArrayLikeFloat_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[False] = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[False] = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[False] = ...,
|
||||
dtype: _DTypeLike[_SCT] = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[False] = ...,
|
||||
dtype: DTypeLike = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeFloat_co,
|
||||
stop: _ArrayLikeFloat_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[True] = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> tuple[NDArray[floating[Any]], floating[Any]]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[True] = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> tuple[NDArray[complexfloating[Any, Any]], complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[True] = ...,
|
||||
dtype: _DTypeLike[_SCT] = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> tuple[NDArray[_SCT], _SCT]: ...
|
||||
@overload
|
||||
def linspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
retstep: L[True] = ...,
|
||||
dtype: DTypeLike = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> tuple[NDArray[Any], Any]: ...
|
||||
|
||||
@overload
|
||||
def logspace(
|
||||
start: _ArrayLikeFloat_co,
|
||||
stop: _ArrayLikeFloat_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
base: _ArrayLikeFloat_co = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def logspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
base: _ArrayLikeComplex_co = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def logspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
base: _ArrayLikeComplex_co = ...,
|
||||
dtype: _DTypeLike[_SCT] = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def logspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
base: _ArrayLikeComplex_co = ...,
|
||||
dtype: DTypeLike = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def geomspace(
|
||||
start: _ArrayLikeFloat_co,
|
||||
stop: _ArrayLikeFloat_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def geomspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
dtype: None = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def geomspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
dtype: _DTypeLike[_SCT] = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def geomspace(
|
||||
start: _ArrayLikeComplex_co,
|
||||
stop: _ArrayLikeComplex_co,
|
||||
num: SupportsIndex = ...,
|
||||
endpoint: bool = ...,
|
||||
dtype: DTypeLike = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
# Re-exported to `np.lib.function_base`
|
||||
def add_newdoc(
|
||||
place: str,
|
||||
obj: str,
|
||||
doc: str | tuple[str, str] | list[tuple[str, str]],
|
||||
warn_on_python: bool = ...,
|
||||
) -> None: ...
|
@@ -0,0 +1,257 @@
|
||||
#!/usr/bin/env python3
|
||||
import os
|
||||
import argparse
|
||||
|
||||
import genapi
|
||||
from genapi import \
|
||||
TypeApi, GlobalVarApi, FunctionApi, BoolValuesApi
|
||||
|
||||
import numpy_api
|
||||
|
||||
# use annotated api when running under cpychecker
|
||||
h_template = r"""
|
||||
#if defined(_MULTIARRAYMODULE) || defined(WITH_CPYCHECKER_STEALS_REFERENCE_TO_ARG_ATTRIBUTE)
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_bool obval;
|
||||
} PyBoolScalarObject;
|
||||
|
||||
extern NPY_NO_EXPORT PyTypeObject PyArrayMapIter_Type;
|
||||
extern NPY_NO_EXPORT PyTypeObject PyArrayNeighborhoodIter_Type;
|
||||
extern NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2];
|
||||
|
||||
%s
|
||||
|
||||
#else
|
||||
|
||||
#if defined(PY_ARRAY_UNIQUE_SYMBOL)
|
||||
#define PyArray_API PY_ARRAY_UNIQUE_SYMBOL
|
||||
#endif
|
||||
|
||||
#if defined(NO_IMPORT) || defined(NO_IMPORT_ARRAY)
|
||||
extern void **PyArray_API;
|
||||
#else
|
||||
#if defined(PY_ARRAY_UNIQUE_SYMBOL)
|
||||
void **PyArray_API;
|
||||
#else
|
||||
static void **PyArray_API=NULL;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
%s
|
||||
|
||||
#if !defined(NO_IMPORT_ARRAY) && !defined(NO_IMPORT)
|
||||
static int
|
||||
_import_array(void)
|
||||
{
|
||||
int st;
|
||||
PyObject *numpy = PyImport_ImportModule("numpy.core._multiarray_umath");
|
||||
PyObject *c_api = NULL;
|
||||
|
||||
if (numpy == NULL) {
|
||||
return -1;
|
||||
}
|
||||
c_api = PyObject_GetAttrString(numpy, "_ARRAY_API");
|
||||
Py_DECREF(numpy);
|
||||
if (c_api == NULL) {
|
||||
PyErr_SetString(PyExc_AttributeError, "_ARRAY_API not found");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!PyCapsule_CheckExact(c_api)) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "_ARRAY_API is not PyCapsule object");
|
||||
Py_DECREF(c_api);
|
||||
return -1;
|
||||
}
|
||||
PyArray_API = (void **)PyCapsule_GetPointer(c_api, NULL);
|
||||
Py_DECREF(c_api);
|
||||
if (PyArray_API == NULL) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "_ARRAY_API is NULL pointer");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Perform runtime check of C API version */
|
||||
if (NPY_VERSION != PyArray_GetNDArrayCVersion()) {
|
||||
PyErr_Format(PyExc_RuntimeError, "module compiled against "\
|
||||
"ABI version 0x%%x but this version of numpy is 0x%%x", \
|
||||
(int) NPY_VERSION, (int) PyArray_GetNDArrayCVersion());
|
||||
return -1;
|
||||
}
|
||||
if (NPY_FEATURE_VERSION > PyArray_GetNDArrayCFeatureVersion()) {
|
||||
PyErr_Format(PyExc_RuntimeError, "module compiled against "\
|
||||
"API version 0x%%x but this version of numpy is 0x%%x . "\
|
||||
"Check the section C-API incompatibility at the "\
|
||||
"Troubleshooting ImportError section at "\
|
||||
"https://numpy.org/devdocs/user/troubleshooting-importerror.html"\
|
||||
"#c-api-incompatibility "\
|
||||
"for indications on how to solve this problem .", \
|
||||
(int) NPY_FEATURE_VERSION, (int) PyArray_GetNDArrayCFeatureVersion());
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform runtime check of endianness and check it matches the one set by
|
||||
* the headers (npy_endian.h) as a safeguard
|
||||
*/
|
||||
st = PyArray_GetEndianness();
|
||||
if (st == NPY_CPU_UNKNOWN_ENDIAN) {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"FATAL: module compiled as unknown endian");
|
||||
return -1;
|
||||
}
|
||||
#if NPY_BYTE_ORDER == NPY_BIG_ENDIAN
|
||||
if (st != NPY_CPU_BIG) {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"FATAL: module compiled as big endian, but "
|
||||
"detected different endianness at runtime");
|
||||
return -1;
|
||||
}
|
||||
#elif NPY_BYTE_ORDER == NPY_LITTLE_ENDIAN
|
||||
if (st != NPY_CPU_LITTLE) {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"FATAL: module compiled as little endian, but "
|
||||
"detected different endianness at runtime");
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define import_array() {if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); return NULL; } }
|
||||
|
||||
#define import_array1(ret) {if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); return ret; } }
|
||||
|
||||
#define import_array2(msg, ret) {if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, msg); return ret; } }
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
"""
|
||||
|
||||
|
||||
c_template = r"""
|
||||
/* These pointers will be stored in the C-object for use in other
|
||||
extension modules
|
||||
*/
|
||||
|
||||
void *PyArray_API[] = {
|
||||
%s
|
||||
};
|
||||
"""
|
||||
|
||||
def generate_api(output_dir, force=False):
|
||||
basename = 'multiarray_api'
|
||||
|
||||
h_file = os.path.join(output_dir, '__%s.h' % basename)
|
||||
c_file = os.path.join(output_dir, '__%s.c' % basename)
|
||||
targets = (h_file, c_file)
|
||||
|
||||
sources = numpy_api.multiarray_api
|
||||
|
||||
if (not force and not genapi.should_rebuild(targets, [numpy_api.__file__, __file__])):
|
||||
return targets
|
||||
else:
|
||||
do_generate_api(targets, sources)
|
||||
|
||||
return targets
|
||||
|
||||
def do_generate_api(targets, sources):
|
||||
header_file = targets[0]
|
||||
c_file = targets[1]
|
||||
|
||||
global_vars = sources[0]
|
||||
scalar_bool_values = sources[1]
|
||||
types_api = sources[2]
|
||||
multiarray_funcs = sources[3]
|
||||
|
||||
multiarray_api = sources[:]
|
||||
|
||||
module_list = []
|
||||
extension_list = []
|
||||
init_list = []
|
||||
|
||||
# Check multiarray api indexes
|
||||
multiarray_api_index = genapi.merge_api_dicts(multiarray_api)
|
||||
genapi.check_api_dict(multiarray_api_index)
|
||||
|
||||
numpyapi_list = genapi.get_api_functions('NUMPY_API',
|
||||
multiarray_funcs)
|
||||
|
||||
# Create dict name -> *Api instance
|
||||
api_name = 'PyArray_API'
|
||||
multiarray_api_dict = {}
|
||||
for f in numpyapi_list:
|
||||
name = f.name
|
||||
index = multiarray_funcs[name][0]
|
||||
annotations = multiarray_funcs[name][1:]
|
||||
multiarray_api_dict[f.name] = FunctionApi(f.name, index, annotations,
|
||||
f.return_type,
|
||||
f.args, api_name)
|
||||
|
||||
for name, val in global_vars.items():
|
||||
index, type = val
|
||||
multiarray_api_dict[name] = GlobalVarApi(name, index, type, api_name)
|
||||
|
||||
for name, val in scalar_bool_values.items():
|
||||
index = val[0]
|
||||
multiarray_api_dict[name] = BoolValuesApi(name, index, api_name)
|
||||
|
||||
for name, val in types_api.items():
|
||||
index = val[0]
|
||||
internal_type = None if len(val) == 1 else val[1]
|
||||
multiarray_api_dict[name] = TypeApi(
|
||||
name, index, 'PyTypeObject', api_name, internal_type)
|
||||
|
||||
if len(multiarray_api_dict) != len(multiarray_api_index):
|
||||
keys_dict = set(multiarray_api_dict.keys())
|
||||
keys_index = set(multiarray_api_index.keys())
|
||||
raise AssertionError(
|
||||
"Multiarray API size mismatch - "
|
||||
"index has extra keys {}, dict has extra keys {}"
|
||||
.format(keys_index - keys_dict, keys_dict - keys_index)
|
||||
)
|
||||
|
||||
extension_list = []
|
||||
for name, index in genapi.order_dict(multiarray_api_index):
|
||||
api_item = multiarray_api_dict[name]
|
||||
extension_list.append(api_item.define_from_array_api_string())
|
||||
init_list.append(api_item.array_api_define())
|
||||
module_list.append(api_item.internal_define())
|
||||
|
||||
# Write to header
|
||||
s = h_template % ('\n'.join(module_list), '\n'.join(extension_list))
|
||||
genapi.write_file(header_file, s)
|
||||
|
||||
# Write to c-code
|
||||
s = c_template % ',\n'.join(init_list)
|
||||
genapi.write_file(c_file, s)
|
||||
|
||||
return targets
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument(
|
||||
"-o",
|
||||
"--outdir",
|
||||
type=str,
|
||||
help="Path to the output directory"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-i",
|
||||
"--ignore",
|
||||
type=str,
|
||||
help="An ignored input - may be useful to add a "
|
||||
"dependency between custom targets"
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
outdir_abs = os.path.join(os.getcwd(), args.outdir)
|
||||
|
||||
generate_api(outdir_abs)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
735
teil20b/lib/python3.11/site-packages/numpy/core/getlimits.py
Normal file
735
teil20b/lib/python3.11/site-packages/numpy/core/getlimits.py
Normal file
@@ -0,0 +1,735 @@
|
||||
"""Machine limits for Float32 and Float64 and (long double) if available...
|
||||
|
||||
"""
|
||||
__all__ = ['finfo', 'iinfo']
|
||||
|
||||
import warnings
|
||||
|
||||
from .._utils import set_module
|
||||
from ._machar import MachAr
|
||||
from . import numeric
|
||||
from . import numerictypes as ntypes
|
||||
from .numeric import array, inf, NaN
|
||||
from .umath import log10, exp2, nextafter, isnan
|
||||
|
||||
|
||||
def _fr0(a):
|
||||
"""fix rank-0 --> rank-1"""
|
||||
if a.ndim == 0:
|
||||
a = a.copy()
|
||||
a.shape = (1,)
|
||||
return a
|
||||
|
||||
|
||||
def _fr1(a):
|
||||
"""fix rank > 0 --> rank-0"""
|
||||
if a.size == 1:
|
||||
a = a.copy()
|
||||
a.shape = ()
|
||||
return a
|
||||
|
||||
|
||||
class MachArLike:
|
||||
""" Object to simulate MachAr instance """
|
||||
def __init__(self, ftype, *, eps, epsneg, huge, tiny,
|
||||
ibeta, smallest_subnormal=None, **kwargs):
|
||||
self.params = _MACHAR_PARAMS[ftype]
|
||||
self.ftype = ftype
|
||||
self.title = self.params['title']
|
||||
# Parameter types same as for discovered MachAr object.
|
||||
if not smallest_subnormal:
|
||||
self._smallest_subnormal = nextafter(
|
||||
self.ftype(0), self.ftype(1), dtype=self.ftype)
|
||||
else:
|
||||
self._smallest_subnormal = smallest_subnormal
|
||||
self.epsilon = self.eps = self._float_to_float(eps)
|
||||
self.epsneg = self._float_to_float(epsneg)
|
||||
self.xmax = self.huge = self._float_to_float(huge)
|
||||
self.xmin = self._float_to_float(tiny)
|
||||
self.smallest_normal = self.tiny = self._float_to_float(tiny)
|
||||
self.ibeta = self.params['itype'](ibeta)
|
||||
self.__dict__.update(kwargs)
|
||||
self.precision = int(-log10(self.eps))
|
||||
self.resolution = self._float_to_float(
|
||||
self._float_conv(10) ** (-self.precision))
|
||||
self._str_eps = self._float_to_str(self.eps)
|
||||
self._str_epsneg = self._float_to_str(self.epsneg)
|
||||
self._str_xmin = self._float_to_str(self.xmin)
|
||||
self._str_xmax = self._float_to_str(self.xmax)
|
||||
self._str_resolution = self._float_to_str(self.resolution)
|
||||
self._str_smallest_normal = self._float_to_str(self.xmin)
|
||||
|
||||
@property
|
||||
def smallest_subnormal(self):
|
||||
"""Return the value for the smallest subnormal.
|
||||
|
||||
Returns
|
||||
-------
|
||||
smallest_subnormal : float
|
||||
value for the smallest subnormal.
|
||||
|
||||
Warns
|
||||
-----
|
||||
UserWarning
|
||||
If the calculated value for the smallest subnormal is zero.
|
||||
"""
|
||||
# Check that the calculated value is not zero, in case it raises a
|
||||
# warning.
|
||||
value = self._smallest_subnormal
|
||||
if self.ftype(0) == value:
|
||||
warnings.warn(
|
||||
'The value of the smallest subnormal for {} type '
|
||||
'is zero.'.format(self.ftype), UserWarning, stacklevel=2)
|
||||
|
||||
return self._float_to_float(value)
|
||||
|
||||
@property
|
||||
def _str_smallest_subnormal(self):
|
||||
"""Return the string representation of the smallest subnormal."""
|
||||
return self._float_to_str(self.smallest_subnormal)
|
||||
|
||||
def _float_to_float(self, value):
|
||||
"""Converts float to float.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
value : float
|
||||
value to be converted.
|
||||
"""
|
||||
return _fr1(self._float_conv(value))
|
||||
|
||||
def _float_conv(self, value):
|
||||
"""Converts float to conv.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
value : float
|
||||
value to be converted.
|
||||
"""
|
||||
return array([value], self.ftype)
|
||||
|
||||
def _float_to_str(self, value):
|
||||
"""Converts float to str.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
value : float
|
||||
value to be converted.
|
||||
"""
|
||||
return self.params['fmt'] % array(_fr0(value)[0], self.ftype)
|
||||
|
||||
|
||||
_convert_to_float = {
|
||||
ntypes.csingle: ntypes.single,
|
||||
ntypes.complex_: ntypes.float_,
|
||||
ntypes.clongfloat: ntypes.longfloat
|
||||
}
|
||||
|
||||
# Parameters for creating MachAr / MachAr-like objects
|
||||
_title_fmt = 'numpy {} precision floating point number'
|
||||
_MACHAR_PARAMS = {
|
||||
ntypes.double: dict(
|
||||
itype = ntypes.int64,
|
||||
fmt = '%24.16e',
|
||||
title = _title_fmt.format('double')),
|
||||
ntypes.single: dict(
|
||||
itype = ntypes.int32,
|
||||
fmt = '%15.7e',
|
||||
title = _title_fmt.format('single')),
|
||||
ntypes.longdouble: dict(
|
||||
itype = ntypes.longlong,
|
||||
fmt = '%s',
|
||||
title = _title_fmt.format('long double')),
|
||||
ntypes.half: dict(
|
||||
itype = ntypes.int16,
|
||||
fmt = '%12.5e',
|
||||
title = _title_fmt.format('half'))}
|
||||
|
||||
# Key to identify the floating point type. Key is result of
|
||||
# ftype('-0.1').newbyteorder('<').tobytes()
|
||||
#
|
||||
# 20230201 - use (ftype(-1.0) / ftype(10.0)).newbyteorder('<').tobytes()
|
||||
# instead because stold may have deficiencies on some platforms.
|
||||
# See:
|
||||
# https://perl5.git.perl.org/perl.git/blob/3118d7d684b56cbeb702af874f4326683c45f045:/Configure
|
||||
|
||||
_KNOWN_TYPES = {}
|
||||
def _register_type(machar, bytepat):
|
||||
_KNOWN_TYPES[bytepat] = machar
|
||||
_float_ma = {}
|
||||
|
||||
|
||||
def _register_known_types():
|
||||
# Known parameters for float16
|
||||
# See docstring of MachAr class for description of parameters.
|
||||
f16 = ntypes.float16
|
||||
float16_ma = MachArLike(f16,
|
||||
machep=-10,
|
||||
negep=-11,
|
||||
minexp=-14,
|
||||
maxexp=16,
|
||||
it=10,
|
||||
iexp=5,
|
||||
ibeta=2,
|
||||
irnd=5,
|
||||
ngrd=0,
|
||||
eps=exp2(f16(-10)),
|
||||
epsneg=exp2(f16(-11)),
|
||||
huge=f16(65504),
|
||||
tiny=f16(2 ** -14))
|
||||
_register_type(float16_ma, b'f\xae')
|
||||
_float_ma[16] = float16_ma
|
||||
|
||||
# Known parameters for float32
|
||||
f32 = ntypes.float32
|
||||
float32_ma = MachArLike(f32,
|
||||
machep=-23,
|
||||
negep=-24,
|
||||
minexp=-126,
|
||||
maxexp=128,
|
||||
it=23,
|
||||
iexp=8,
|
||||
ibeta=2,
|
||||
irnd=5,
|
||||
ngrd=0,
|
||||
eps=exp2(f32(-23)),
|
||||
epsneg=exp2(f32(-24)),
|
||||
huge=f32((1 - 2 ** -24) * 2**128),
|
||||
tiny=exp2(f32(-126)))
|
||||
_register_type(float32_ma, b'\xcd\xcc\xcc\xbd')
|
||||
_float_ma[32] = float32_ma
|
||||
|
||||
# Known parameters for float64
|
||||
f64 = ntypes.float64
|
||||
epsneg_f64 = 2.0 ** -53.0
|
||||
tiny_f64 = 2.0 ** -1022.0
|
||||
float64_ma = MachArLike(f64,
|
||||
machep=-52,
|
||||
negep=-53,
|
||||
minexp=-1022,
|
||||
maxexp=1024,
|
||||
it=52,
|
||||
iexp=11,
|
||||
ibeta=2,
|
||||
irnd=5,
|
||||
ngrd=0,
|
||||
eps=2.0 ** -52.0,
|
||||
epsneg=epsneg_f64,
|
||||
huge=(1.0 - epsneg_f64) / tiny_f64 * f64(4),
|
||||
tiny=tiny_f64)
|
||||
_register_type(float64_ma, b'\x9a\x99\x99\x99\x99\x99\xb9\xbf')
|
||||
_float_ma[64] = float64_ma
|
||||
|
||||
# Known parameters for IEEE 754 128-bit binary float
|
||||
ld = ntypes.longdouble
|
||||
epsneg_f128 = exp2(ld(-113))
|
||||
tiny_f128 = exp2(ld(-16382))
|
||||
# Ignore runtime error when this is not f128
|
||||
with numeric.errstate(all='ignore'):
|
||||
huge_f128 = (ld(1) - epsneg_f128) / tiny_f128 * ld(4)
|
||||
float128_ma = MachArLike(ld,
|
||||
machep=-112,
|
||||
negep=-113,
|
||||
minexp=-16382,
|
||||
maxexp=16384,
|
||||
it=112,
|
||||
iexp=15,
|
||||
ibeta=2,
|
||||
irnd=5,
|
||||
ngrd=0,
|
||||
eps=exp2(ld(-112)),
|
||||
epsneg=epsneg_f128,
|
||||
huge=huge_f128,
|
||||
tiny=tiny_f128)
|
||||
# IEEE 754 128-bit binary float
|
||||
_register_type(float128_ma,
|
||||
b'\x9a\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\xfb\xbf')
|
||||
_float_ma[128] = float128_ma
|
||||
|
||||
# Known parameters for float80 (Intel 80-bit extended precision)
|
||||
epsneg_f80 = exp2(ld(-64))
|
||||
tiny_f80 = exp2(ld(-16382))
|
||||
# Ignore runtime error when this is not f80
|
||||
with numeric.errstate(all='ignore'):
|
||||
huge_f80 = (ld(1) - epsneg_f80) / tiny_f80 * ld(4)
|
||||
float80_ma = MachArLike(ld,
|
||||
machep=-63,
|
||||
negep=-64,
|
||||
minexp=-16382,
|
||||
maxexp=16384,
|
||||
it=63,
|
||||
iexp=15,
|
||||
ibeta=2,
|
||||
irnd=5,
|
||||
ngrd=0,
|
||||
eps=exp2(ld(-63)),
|
||||
epsneg=epsneg_f80,
|
||||
huge=huge_f80,
|
||||
tiny=tiny_f80)
|
||||
# float80, first 10 bytes containing actual storage
|
||||
_register_type(float80_ma, b'\xcd\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xfb\xbf')
|
||||
_float_ma[80] = float80_ma
|
||||
|
||||
# Guessed / known parameters for double double; see:
|
||||
# https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#Double-double_arithmetic
|
||||
# These numbers have the same exponent range as float64, but extended number of
|
||||
# digits in the significand.
|
||||
huge_dd = nextafter(ld(inf), ld(0), dtype=ld)
|
||||
# As the smallest_normal in double double is so hard to calculate we set
|
||||
# it to NaN.
|
||||
smallest_normal_dd = NaN
|
||||
# Leave the same value for the smallest subnormal as double
|
||||
smallest_subnormal_dd = ld(nextafter(0., 1.))
|
||||
float_dd_ma = MachArLike(ld,
|
||||
machep=-105,
|
||||
negep=-106,
|
||||
minexp=-1022,
|
||||
maxexp=1024,
|
||||
it=105,
|
||||
iexp=11,
|
||||
ibeta=2,
|
||||
irnd=5,
|
||||
ngrd=0,
|
||||
eps=exp2(ld(-105)),
|
||||
epsneg=exp2(ld(-106)),
|
||||
huge=huge_dd,
|
||||
tiny=smallest_normal_dd,
|
||||
smallest_subnormal=smallest_subnormal_dd)
|
||||
# double double; low, high order (e.g. PPC 64)
|
||||
_register_type(float_dd_ma,
|
||||
b'\x9a\x99\x99\x99\x99\x99Y<\x9a\x99\x99\x99\x99\x99\xb9\xbf')
|
||||
# double double; high, low order (e.g. PPC 64 le)
|
||||
_register_type(float_dd_ma,
|
||||
b'\x9a\x99\x99\x99\x99\x99\xb9\xbf\x9a\x99\x99\x99\x99\x99Y<')
|
||||
_float_ma['dd'] = float_dd_ma
|
||||
|
||||
|
||||
def _get_machar(ftype):
|
||||
""" Get MachAr instance or MachAr-like instance
|
||||
|
||||
Get parameters for floating point type, by first trying signatures of
|
||||
various known floating point types, then, if none match, attempting to
|
||||
identify parameters by analysis.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ftype : class
|
||||
Numpy floating point type class (e.g. ``np.float64``)
|
||||
|
||||
Returns
|
||||
-------
|
||||
ma_like : instance of :class:`MachAr` or :class:`MachArLike`
|
||||
Object giving floating point parameters for `ftype`.
|
||||
|
||||
Warns
|
||||
-----
|
||||
UserWarning
|
||||
If the binary signature of the float type is not in the dictionary of
|
||||
known float types.
|
||||
"""
|
||||
params = _MACHAR_PARAMS.get(ftype)
|
||||
if params is None:
|
||||
raise ValueError(repr(ftype))
|
||||
# Detect known / suspected types
|
||||
# ftype(-1.0) / ftype(10.0) is better than ftype('-0.1') because stold
|
||||
# may be deficient
|
||||
key = (ftype(-1.0) / ftype(10.)).newbyteorder('<').tobytes()
|
||||
ma_like = None
|
||||
if ftype == ntypes.longdouble:
|
||||
# Could be 80 bit == 10 byte extended precision, where last bytes can
|
||||
# be random garbage.
|
||||
# Comparing first 10 bytes to pattern first to avoid branching on the
|
||||
# random garbage.
|
||||
ma_like = _KNOWN_TYPES.get(key[:10])
|
||||
if ma_like is None:
|
||||
# see if the full key is known.
|
||||
ma_like = _KNOWN_TYPES.get(key)
|
||||
if ma_like is None and len(key) == 16:
|
||||
# machine limits could be f80 masquerading as np.float128,
|
||||
# find all keys with length 16 and make new dict, but make the keys
|
||||
# only 10 bytes long, the last bytes can be random garbage
|
||||
_kt = {k[:10]: v for k, v in _KNOWN_TYPES.items() if len(k) == 16}
|
||||
ma_like = _kt.get(key[:10])
|
||||
if ma_like is not None:
|
||||
return ma_like
|
||||
# Fall back to parameter discovery
|
||||
warnings.warn(
|
||||
f'Signature {key} for {ftype} does not match any known type: '
|
||||
'falling back to type probe function.\n'
|
||||
'This warnings indicates broken support for the dtype!',
|
||||
UserWarning, stacklevel=2)
|
||||
return _discovered_machar(ftype)
|
||||
|
||||
|
||||
def _discovered_machar(ftype):
|
||||
""" Create MachAr instance with found information on float types
|
||||
|
||||
TODO: MachAr should be retired completely ideally. We currently only
|
||||
ever use it system with broken longdouble (valgrind, WSL).
|
||||
"""
|
||||
params = _MACHAR_PARAMS[ftype]
|
||||
return MachAr(lambda v: array([v], ftype),
|
||||
lambda v:_fr0(v.astype(params['itype']))[0],
|
||||
lambda v:array(_fr0(v)[0], ftype),
|
||||
lambda v: params['fmt'] % array(_fr0(v)[0], ftype),
|
||||
params['title'])
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
class finfo:
|
||||
"""
|
||||
finfo(dtype)
|
||||
|
||||
Machine limits for floating point types.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
bits : int
|
||||
The number of bits occupied by the type.
|
||||
dtype : dtype
|
||||
Returns the dtype for which `finfo` returns information. For complex
|
||||
input, the returned dtype is the associated ``float*`` dtype for its
|
||||
real and complex components.
|
||||
eps : float
|
||||
The difference between 1.0 and the next smallest representable float
|
||||
larger than 1.0. For example, for 64-bit binary floats in the IEEE-754
|
||||
standard, ``eps = 2**-52``, approximately 2.22e-16.
|
||||
epsneg : float
|
||||
The difference between 1.0 and the next smallest representable float
|
||||
less than 1.0. For example, for 64-bit binary floats in the IEEE-754
|
||||
standard, ``epsneg = 2**-53``, approximately 1.11e-16.
|
||||
iexp : int
|
||||
The number of bits in the exponent portion of the floating point
|
||||
representation.
|
||||
machep : int
|
||||
The exponent that yields `eps`.
|
||||
max : floating point number of the appropriate type
|
||||
The largest representable number.
|
||||
maxexp : int
|
||||
The smallest positive power of the base (2) that causes overflow.
|
||||
min : floating point number of the appropriate type
|
||||
The smallest representable number, typically ``-max``.
|
||||
minexp : int
|
||||
The most negative power of the base (2) consistent with there
|
||||
being no leading 0's in the mantissa.
|
||||
negep : int
|
||||
The exponent that yields `epsneg`.
|
||||
nexp : int
|
||||
The number of bits in the exponent including its sign and bias.
|
||||
nmant : int
|
||||
The number of bits in the mantissa.
|
||||
precision : int
|
||||
The approximate number of decimal digits to which this kind of
|
||||
float is precise.
|
||||
resolution : floating point number of the appropriate type
|
||||
The approximate decimal resolution of this type, i.e.,
|
||||
``10**-precision``.
|
||||
tiny : float
|
||||
An alias for `smallest_normal`, kept for backwards compatibility.
|
||||
smallest_normal : float
|
||||
The smallest positive floating point number with 1 as leading bit in
|
||||
the mantissa following IEEE-754 (see Notes).
|
||||
smallest_subnormal : float
|
||||
The smallest positive floating point number with 0 as leading bit in
|
||||
the mantissa following IEEE-754.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dtype : float, dtype, or instance
|
||||
Kind of floating point or complex floating point
|
||||
data-type about which to get information.
|
||||
|
||||
See Also
|
||||
--------
|
||||
iinfo : The equivalent for integer data types.
|
||||
spacing : The distance between a value and the nearest adjacent number
|
||||
nextafter : The next floating point value after x1 towards x2
|
||||
|
||||
Notes
|
||||
-----
|
||||
For developers of NumPy: do not instantiate this at the module level.
|
||||
The initial calculation of these parameters is expensive and negatively
|
||||
impacts import times. These objects are cached, so calling ``finfo()``
|
||||
repeatedly inside your functions is not a problem.
|
||||
|
||||
Note that ``smallest_normal`` is not actually the smallest positive
|
||||
representable value in a NumPy floating point type. As in the IEEE-754
|
||||
standard [1]_, NumPy floating point types make use of subnormal numbers to
|
||||
fill the gap between 0 and ``smallest_normal``. However, subnormal numbers
|
||||
may have significantly reduced precision [2]_.
|
||||
|
||||
This function can also be used for complex data types as well. If used,
|
||||
the output will be the same as the corresponding real float type
|
||||
(e.g. numpy.finfo(numpy.csingle) is the same as numpy.finfo(numpy.single)).
|
||||
However, the output is true for the real and imaginary components.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,
|
||||
pp.1-70, 2008, http://www.doi.org/10.1109/IEEESTD.2008.4610935
|
||||
.. [2] Wikipedia, "Denormal Numbers",
|
||||
https://en.wikipedia.org/wiki/Denormal_number
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.finfo(np.float64).dtype
|
||||
dtype('float64')
|
||||
>>> np.finfo(np.complex64).dtype
|
||||
dtype('float32')
|
||||
|
||||
"""
|
||||
|
||||
_finfo_cache = {}
|
||||
|
||||
def __new__(cls, dtype):
|
||||
try:
|
||||
obj = cls._finfo_cache.get(dtype) # most common path
|
||||
if obj is not None:
|
||||
return obj
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
if dtype is None:
|
||||
# Deprecated in NumPy 1.25, 2023-01-16
|
||||
warnings.warn(
|
||||
"finfo() dtype cannot be None. This behavior will "
|
||||
"raise an error in the future. (Deprecated in NumPy 1.25)",
|
||||
DeprecationWarning,
|
||||
stacklevel=2
|
||||
)
|
||||
|
||||
try:
|
||||
dtype = numeric.dtype(dtype)
|
||||
except TypeError:
|
||||
# In case a float instance was given
|
||||
dtype = numeric.dtype(type(dtype))
|
||||
|
||||
obj = cls._finfo_cache.get(dtype)
|
||||
if obj is not None:
|
||||
return obj
|
||||
dtypes = [dtype]
|
||||
newdtype = numeric.obj2sctype(dtype)
|
||||
if newdtype is not dtype:
|
||||
dtypes.append(newdtype)
|
||||
dtype = newdtype
|
||||
if not issubclass(dtype, numeric.inexact):
|
||||
raise ValueError("data type %r not inexact" % (dtype))
|
||||
obj = cls._finfo_cache.get(dtype)
|
||||
if obj is not None:
|
||||
return obj
|
||||
if not issubclass(dtype, numeric.floating):
|
||||
newdtype = _convert_to_float[dtype]
|
||||
if newdtype is not dtype:
|
||||
# dtype changed, for example from complex128 to float64
|
||||
dtypes.append(newdtype)
|
||||
dtype = newdtype
|
||||
|
||||
obj = cls._finfo_cache.get(dtype, None)
|
||||
if obj is not None:
|
||||
# the original dtype was not in the cache, but the new
|
||||
# dtype is in the cache. we add the original dtypes to
|
||||
# the cache and return the result
|
||||
for dt in dtypes:
|
||||
cls._finfo_cache[dt] = obj
|
||||
return obj
|
||||
obj = object.__new__(cls)._init(dtype)
|
||||
for dt in dtypes:
|
||||
cls._finfo_cache[dt] = obj
|
||||
return obj
|
||||
|
||||
def _init(self, dtype):
|
||||
self.dtype = numeric.dtype(dtype)
|
||||
machar = _get_machar(dtype)
|
||||
|
||||
for word in ['precision', 'iexp',
|
||||
'maxexp', 'minexp', 'negep',
|
||||
'machep']:
|
||||
setattr(self, word, getattr(machar, word))
|
||||
for word in ['resolution', 'epsneg', 'smallest_subnormal']:
|
||||
setattr(self, word, getattr(machar, word).flat[0])
|
||||
self.bits = self.dtype.itemsize * 8
|
||||
self.max = machar.huge.flat[0]
|
||||
self.min = -self.max
|
||||
self.eps = machar.eps.flat[0]
|
||||
self.nexp = machar.iexp
|
||||
self.nmant = machar.it
|
||||
self._machar = machar
|
||||
self._str_tiny = machar._str_xmin.strip()
|
||||
self._str_max = machar._str_xmax.strip()
|
||||
self._str_epsneg = machar._str_epsneg.strip()
|
||||
self._str_eps = machar._str_eps.strip()
|
||||
self._str_resolution = machar._str_resolution.strip()
|
||||
self._str_smallest_normal = machar._str_smallest_normal.strip()
|
||||
self._str_smallest_subnormal = machar._str_smallest_subnormal.strip()
|
||||
return self
|
||||
|
||||
def __str__(self):
|
||||
fmt = (
|
||||
'Machine parameters for %(dtype)s\n'
|
||||
'---------------------------------------------------------------\n'
|
||||
'precision = %(precision)3s resolution = %(_str_resolution)s\n'
|
||||
'machep = %(machep)6s eps = %(_str_eps)s\n'
|
||||
'negep = %(negep)6s epsneg = %(_str_epsneg)s\n'
|
||||
'minexp = %(minexp)6s tiny = %(_str_tiny)s\n'
|
||||
'maxexp = %(maxexp)6s max = %(_str_max)s\n'
|
||||
'nexp = %(nexp)6s min = -max\n'
|
||||
'smallest_normal = %(_str_smallest_normal)s '
|
||||
'smallest_subnormal = %(_str_smallest_subnormal)s\n'
|
||||
'---------------------------------------------------------------\n'
|
||||
)
|
||||
return fmt % self.__dict__
|
||||
|
||||
def __repr__(self):
|
||||
c = self.__class__.__name__
|
||||
d = self.__dict__.copy()
|
||||
d['klass'] = c
|
||||
return (("%(klass)s(resolution=%(resolution)s, min=-%(_str_max)s,"
|
||||
" max=%(_str_max)s, dtype=%(dtype)s)") % d)
|
||||
|
||||
@property
|
||||
def smallest_normal(self):
|
||||
"""Return the value for the smallest normal.
|
||||
|
||||
Returns
|
||||
-------
|
||||
smallest_normal : float
|
||||
Value for the smallest normal.
|
||||
|
||||
Warns
|
||||
-----
|
||||
UserWarning
|
||||
If the calculated value for the smallest normal is requested for
|
||||
double-double.
|
||||
"""
|
||||
# This check is necessary because the value for smallest_normal is
|
||||
# platform dependent for longdouble types.
|
||||
if isnan(self._machar.smallest_normal.flat[0]):
|
||||
warnings.warn(
|
||||
'The value of smallest normal is undefined for double double',
|
||||
UserWarning, stacklevel=2)
|
||||
return self._machar.smallest_normal.flat[0]
|
||||
|
||||
@property
|
||||
def tiny(self):
|
||||
"""Return the value for tiny, alias of smallest_normal.
|
||||
|
||||
Returns
|
||||
-------
|
||||
tiny : float
|
||||
Value for the smallest normal, alias of smallest_normal.
|
||||
|
||||
Warns
|
||||
-----
|
||||
UserWarning
|
||||
If the calculated value for the smallest normal is requested for
|
||||
double-double.
|
||||
"""
|
||||
return self.smallest_normal
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
class iinfo:
|
||||
"""
|
||||
iinfo(type)
|
||||
|
||||
Machine limits for integer types.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
bits : int
|
||||
The number of bits occupied by the type.
|
||||
dtype : dtype
|
||||
Returns the dtype for which `iinfo` returns information.
|
||||
min : int
|
||||
The smallest integer expressible by the type.
|
||||
max : int
|
||||
The largest integer expressible by the type.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
int_type : integer type, dtype, or instance
|
||||
The kind of integer data type to get information about.
|
||||
|
||||
See Also
|
||||
--------
|
||||
finfo : The equivalent for floating point data types.
|
||||
|
||||
Examples
|
||||
--------
|
||||
With types:
|
||||
|
||||
>>> ii16 = np.iinfo(np.int16)
|
||||
>>> ii16.min
|
||||
-32768
|
||||
>>> ii16.max
|
||||
32767
|
||||
>>> ii32 = np.iinfo(np.int32)
|
||||
>>> ii32.min
|
||||
-2147483648
|
||||
>>> ii32.max
|
||||
2147483647
|
||||
|
||||
With instances:
|
||||
|
||||
>>> ii32 = np.iinfo(np.int32(10))
|
||||
>>> ii32.min
|
||||
-2147483648
|
||||
>>> ii32.max
|
||||
2147483647
|
||||
|
||||
"""
|
||||
|
||||
_min_vals = {}
|
||||
_max_vals = {}
|
||||
|
||||
def __init__(self, int_type):
|
||||
try:
|
||||
self.dtype = numeric.dtype(int_type)
|
||||
except TypeError:
|
||||
self.dtype = numeric.dtype(type(int_type))
|
||||
self.kind = self.dtype.kind
|
||||
self.bits = self.dtype.itemsize * 8
|
||||
self.key = "%s%d" % (self.kind, self.bits)
|
||||
if self.kind not in 'iu':
|
||||
raise ValueError("Invalid integer data type %r." % (self.kind,))
|
||||
|
||||
@property
|
||||
def min(self):
|
||||
"""Minimum value of given dtype."""
|
||||
if self.kind == 'u':
|
||||
return 0
|
||||
else:
|
||||
try:
|
||||
val = iinfo._min_vals[self.key]
|
||||
except KeyError:
|
||||
val = int(-(1 << (self.bits-1)))
|
||||
iinfo._min_vals[self.key] = val
|
||||
return val
|
||||
|
||||
@property
|
||||
def max(self):
|
||||
"""Maximum value of given dtype."""
|
||||
try:
|
||||
val = iinfo._max_vals[self.key]
|
||||
except KeyError:
|
||||
if self.kind == 'u':
|
||||
val = int((1 << self.bits) - 1)
|
||||
else:
|
||||
val = int((1 << (self.bits-1)) - 1)
|
||||
iinfo._max_vals[self.key] = val
|
||||
return val
|
||||
|
||||
def __str__(self):
|
||||
"""String representation."""
|
||||
fmt = (
|
||||
'Machine parameters for %(dtype)s\n'
|
||||
'---------------------------------------------------------------\n'
|
||||
'min = %(min)s\n'
|
||||
'max = %(max)s\n'
|
||||
'---------------------------------------------------------------\n'
|
||||
)
|
||||
return fmt % {'dtype': self.dtype, 'min': self.min, 'max': self.max}
|
||||
|
||||
def __repr__(self):
|
||||
return "%s(min=%s, max=%s, dtype=%s)" % (self.__class__.__name__,
|
||||
self.min, self.max, self.dtype)
|
@@ -0,0 +1,6 @@
|
||||
from numpy import (
|
||||
finfo as finfo,
|
||||
iinfo as iinfo,
|
||||
)
|
||||
|
||||
__all__: list[str]
|
@@ -0,0 +1,2 @@
|
||||
INCLUDE_PATH += @CUR_DIR
|
||||
PREDEFINED += NPY_INTERNAL_BUILD
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,314 @@
|
||||
|
||||
#ifdef _UMATHMODULE
|
||||
|
||||
extern NPY_NO_EXPORT PyTypeObject PyUFunc_Type;
|
||||
|
||||
extern NPY_NO_EXPORT PyTypeObject PyUFunc_Type;
|
||||
|
||||
NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndData \
|
||||
(PyUFuncGenericFunction *, void **, char *, int, int, int, int, const char *, const char *, int);
|
||||
NPY_NO_EXPORT int PyUFunc_RegisterLoopForType \
|
||||
(PyUFuncObject *, int, PyUFuncGenericFunction, const int *, void *);
|
||||
NPY_NO_EXPORT int PyUFunc_GenericFunction \
|
||||
(PyUFuncObject *NPY_UNUSED(ufunc), PyObject *NPY_UNUSED(args), PyObject *NPY_UNUSED(kwds), PyArrayObject **NPY_UNUSED(op));
|
||||
NPY_NO_EXPORT void PyUFunc_f_f_As_d_d \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_d_d \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_f_f \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_g_g \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_F_F_As_D_D \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_F_F \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_D_D \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_G_G \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_O_O \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_ff_f_As_dd_d \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_ff_f \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_dd_d \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_gg_g \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_FF_F_As_DD_D \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_DD_D \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_FF_F \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_GG_G \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_OO_O \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_O_O_method \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_OO_O_method \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_On_Om \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT int PyUFunc_GetPyValues \
|
||||
(char *, int *, int *, PyObject **);
|
||||
NPY_NO_EXPORT int PyUFunc_checkfperr \
|
||||
(int, PyObject *, int *);
|
||||
NPY_NO_EXPORT void PyUFunc_clearfperr \
|
||||
(void);
|
||||
NPY_NO_EXPORT int PyUFunc_getfperr \
|
||||
(void);
|
||||
NPY_NO_EXPORT int PyUFunc_handlefperr \
|
||||
(int, PyObject *, int, int *);
|
||||
NPY_NO_EXPORT int PyUFunc_ReplaceLoopBySignature \
|
||||
(PyUFuncObject *, PyUFuncGenericFunction, const int *, PyUFuncGenericFunction *);
|
||||
NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndDataAndSignature \
|
||||
(PyUFuncGenericFunction *, void **, char *, int, int, int, int, const char *, const char *, int, const char *);
|
||||
NPY_NO_EXPORT int PyUFunc_SetUsesArraysAsData \
|
||||
(void **NPY_UNUSED(data), size_t NPY_UNUSED(i));
|
||||
NPY_NO_EXPORT void PyUFunc_e_e \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_e_e_As_f_f \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_e_e_As_d_d \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_ee_e \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_ee_e_As_ff_f \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT void PyUFunc_ee_e_As_dd_d \
|
||||
(char **, npy_intp const *, npy_intp const *, void *);
|
||||
NPY_NO_EXPORT int PyUFunc_DefaultTypeResolver \
|
||||
(PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyObject *, PyArray_Descr **);
|
||||
NPY_NO_EXPORT int PyUFunc_ValidateCasting \
|
||||
(PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyArray_Descr **);
|
||||
NPY_NO_EXPORT int PyUFunc_RegisterLoopForDescr \
|
||||
(PyUFuncObject *, PyArray_Descr *, PyUFuncGenericFunction, PyArray_Descr **, void *);
|
||||
NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndDataAndSignatureAndIdentity \
|
||||
(PyUFuncGenericFunction *, void **, char *, int, int, int, int, const char *, const char *, const int, const char *, PyObject *);
|
||||
|
||||
#else
|
||||
|
||||
#if defined(PY_UFUNC_UNIQUE_SYMBOL)
|
||||
#define PyUFunc_API PY_UFUNC_UNIQUE_SYMBOL
|
||||
#endif
|
||||
|
||||
#if defined(NO_IMPORT) || defined(NO_IMPORT_UFUNC)
|
||||
extern void **PyUFunc_API;
|
||||
#else
|
||||
#if defined(PY_UFUNC_UNIQUE_SYMBOL)
|
||||
void **PyUFunc_API;
|
||||
#else
|
||||
static void **PyUFunc_API=NULL;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define PyUFunc_Type (*(PyTypeObject *)PyUFunc_API[0])
|
||||
#define PyUFunc_FromFuncAndData \
|
||||
(*(PyObject * (*)(PyUFuncGenericFunction *, void **, char *, int, int, int, int, const char *, const char *, int)) \
|
||||
PyUFunc_API[1])
|
||||
#define PyUFunc_RegisterLoopForType \
|
||||
(*(int (*)(PyUFuncObject *, int, PyUFuncGenericFunction, const int *, void *)) \
|
||||
PyUFunc_API[2])
|
||||
#define PyUFunc_GenericFunction \
|
||||
(*(int (*)(PyUFuncObject *NPY_UNUSED(ufunc), PyObject *NPY_UNUSED(args), PyObject *NPY_UNUSED(kwds), PyArrayObject **NPY_UNUSED(op))) \
|
||||
PyUFunc_API[3])
|
||||
#define PyUFunc_f_f_As_d_d \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[4])
|
||||
#define PyUFunc_d_d \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[5])
|
||||
#define PyUFunc_f_f \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[6])
|
||||
#define PyUFunc_g_g \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[7])
|
||||
#define PyUFunc_F_F_As_D_D \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[8])
|
||||
#define PyUFunc_F_F \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[9])
|
||||
#define PyUFunc_D_D \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[10])
|
||||
#define PyUFunc_G_G \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[11])
|
||||
#define PyUFunc_O_O \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[12])
|
||||
#define PyUFunc_ff_f_As_dd_d \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[13])
|
||||
#define PyUFunc_ff_f \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[14])
|
||||
#define PyUFunc_dd_d \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[15])
|
||||
#define PyUFunc_gg_g \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[16])
|
||||
#define PyUFunc_FF_F_As_DD_D \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[17])
|
||||
#define PyUFunc_DD_D \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[18])
|
||||
#define PyUFunc_FF_F \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[19])
|
||||
#define PyUFunc_GG_G \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[20])
|
||||
#define PyUFunc_OO_O \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[21])
|
||||
#define PyUFunc_O_O_method \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[22])
|
||||
#define PyUFunc_OO_O_method \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[23])
|
||||
#define PyUFunc_On_Om \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[24])
|
||||
#define PyUFunc_GetPyValues \
|
||||
(*(int (*)(char *, int *, int *, PyObject **)) \
|
||||
PyUFunc_API[25])
|
||||
#define PyUFunc_checkfperr \
|
||||
(*(int (*)(int, PyObject *, int *)) \
|
||||
PyUFunc_API[26])
|
||||
#define PyUFunc_clearfperr \
|
||||
(*(void (*)(void)) \
|
||||
PyUFunc_API[27])
|
||||
#define PyUFunc_getfperr \
|
||||
(*(int (*)(void)) \
|
||||
PyUFunc_API[28])
|
||||
#define PyUFunc_handlefperr \
|
||||
(*(int (*)(int, PyObject *, int, int *)) \
|
||||
PyUFunc_API[29])
|
||||
#define PyUFunc_ReplaceLoopBySignature \
|
||||
(*(int (*)(PyUFuncObject *, PyUFuncGenericFunction, const int *, PyUFuncGenericFunction *)) \
|
||||
PyUFunc_API[30])
|
||||
#define PyUFunc_FromFuncAndDataAndSignature \
|
||||
(*(PyObject * (*)(PyUFuncGenericFunction *, void **, char *, int, int, int, int, const char *, const char *, int, const char *)) \
|
||||
PyUFunc_API[31])
|
||||
#define PyUFunc_SetUsesArraysAsData \
|
||||
(*(int (*)(void **NPY_UNUSED(data), size_t NPY_UNUSED(i))) \
|
||||
PyUFunc_API[32])
|
||||
#define PyUFunc_e_e \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[33])
|
||||
#define PyUFunc_e_e_As_f_f \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[34])
|
||||
#define PyUFunc_e_e_As_d_d \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[35])
|
||||
#define PyUFunc_ee_e \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[36])
|
||||
#define PyUFunc_ee_e_As_ff_f \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[37])
|
||||
#define PyUFunc_ee_e_As_dd_d \
|
||||
(*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \
|
||||
PyUFunc_API[38])
|
||||
#define PyUFunc_DefaultTypeResolver \
|
||||
(*(int (*)(PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyObject *, PyArray_Descr **)) \
|
||||
PyUFunc_API[39])
|
||||
#define PyUFunc_ValidateCasting \
|
||||
(*(int (*)(PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyArray_Descr **)) \
|
||||
PyUFunc_API[40])
|
||||
#define PyUFunc_RegisterLoopForDescr \
|
||||
(*(int (*)(PyUFuncObject *, PyArray_Descr *, PyUFuncGenericFunction, PyArray_Descr **, void *)) \
|
||||
PyUFunc_API[41])
|
||||
|
||||
#if NPY_FEATURE_VERSION >= NPY_1_16_API_VERSION
|
||||
#define PyUFunc_FromFuncAndDataAndSignatureAndIdentity \
|
||||
(*(PyObject * (*)(PyUFuncGenericFunction *, void **, char *, int, int, int, int, const char *, const char *, const int, const char *, PyObject *)) \
|
||||
PyUFunc_API[42])
|
||||
#endif
|
||||
|
||||
static inline int
|
||||
_import_umath(void)
|
||||
{
|
||||
PyObject *numpy = PyImport_ImportModule("numpy.core._multiarray_umath");
|
||||
PyObject *c_api = NULL;
|
||||
|
||||
if (numpy == NULL) {
|
||||
PyErr_SetString(PyExc_ImportError,
|
||||
"numpy.core._multiarray_umath failed to import");
|
||||
return -1;
|
||||
}
|
||||
c_api = PyObject_GetAttrString(numpy, "_UFUNC_API");
|
||||
Py_DECREF(numpy);
|
||||
if (c_api == NULL) {
|
||||
PyErr_SetString(PyExc_AttributeError, "_UFUNC_API not found");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!PyCapsule_CheckExact(c_api)) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "_UFUNC_API is not PyCapsule object");
|
||||
Py_DECREF(c_api);
|
||||
return -1;
|
||||
}
|
||||
PyUFunc_API = (void **)PyCapsule_GetPointer(c_api, NULL);
|
||||
Py_DECREF(c_api);
|
||||
if (PyUFunc_API == NULL) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "_UFUNC_API is NULL pointer");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define import_umath() \
|
||||
do {\
|
||||
UFUNC_NOFPE\
|
||||
if (_import_umath() < 0) {\
|
||||
PyErr_Print();\
|
||||
PyErr_SetString(PyExc_ImportError,\
|
||||
"numpy.core.umath failed to import");\
|
||||
return NULL;\
|
||||
}\
|
||||
} while(0)
|
||||
|
||||
#define import_umath1(ret) \
|
||||
do {\
|
||||
UFUNC_NOFPE\
|
||||
if (_import_umath() < 0) {\
|
||||
PyErr_Print();\
|
||||
PyErr_SetString(PyExc_ImportError,\
|
||||
"numpy.core.umath failed to import");\
|
||||
return ret;\
|
||||
}\
|
||||
} while(0)
|
||||
|
||||
#define import_umath2(ret, msg) \
|
||||
do {\
|
||||
UFUNC_NOFPE\
|
||||
if (_import_umath() < 0) {\
|
||||
PyErr_Print();\
|
||||
PyErr_SetString(PyExc_ImportError, msg);\
|
||||
return ret;\
|
||||
}\
|
||||
} while(0)
|
||||
|
||||
#define import_ufunc() \
|
||||
do {\
|
||||
UFUNC_NOFPE\
|
||||
if (_import_umath() < 0) {\
|
||||
PyErr_Print();\
|
||||
PyErr_SetString(PyExc_ImportError,\
|
||||
"numpy.core.umath failed to import");\
|
||||
}\
|
||||
} while(0)
|
||||
|
||||
#endif
|
@@ -0,0 +1,408 @@
|
||||
/*
|
||||
* DType related API shared by the (experimental) public API And internal API.
|
||||
*/
|
||||
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY___DTYPE_API_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY___DTYPE_API_H_
|
||||
|
||||
#define __EXPERIMENTAL_DTYPE_API_VERSION 11
|
||||
|
||||
struct PyArrayMethodObject_tag;
|
||||
|
||||
/*
|
||||
* Largely opaque struct for DType classes (i.e. metaclass instances).
|
||||
* The internal definition is currently in `ndarraytypes.h` (export is a bit
|
||||
* more complex because `PyArray_Descr` is a DTypeMeta internally but not
|
||||
* externally).
|
||||
*/
|
||||
#if !(defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD)
|
||||
|
||||
typedef struct PyArray_DTypeMeta_tag {
|
||||
PyHeapTypeObject super;
|
||||
|
||||
/*
|
||||
* Most DTypes will have a singleton default instance, for the
|
||||
* parametric legacy DTypes (bytes, string, void, datetime) this
|
||||
* may be a pointer to the *prototype* instance?
|
||||
*/
|
||||
PyArray_Descr *singleton;
|
||||
/* Copy of the legacy DTypes type number, usually invalid. */
|
||||
int type_num;
|
||||
|
||||
/* The type object of the scalar instances (may be NULL?) */
|
||||
PyTypeObject *scalar_type;
|
||||
/*
|
||||
* DType flags to signal legacy, parametric, or
|
||||
* abstract. But plenty of space for additional information/flags.
|
||||
*/
|
||||
npy_uint64 flags;
|
||||
|
||||
/*
|
||||
* Use indirection in order to allow a fixed size for this struct.
|
||||
* A stable ABI size makes creating a static DType less painful
|
||||
* while also ensuring flexibility for all opaque API (with one
|
||||
* indirection due the pointer lookup).
|
||||
*/
|
||||
void *dt_slots;
|
||||
/* Allow growing (at the moment also beyond this) */
|
||||
void *reserved[3];
|
||||
} PyArray_DTypeMeta;
|
||||
|
||||
#endif /* not internal build */
|
||||
|
||||
/*
|
||||
* ******************************************************
|
||||
* ArrayMethod API (Casting and UFuncs)
|
||||
* ******************************************************
|
||||
*/
|
||||
/*
|
||||
* NOTE: Expected changes:
|
||||
* * probably split runtime and general flags into two
|
||||
* * should possibly not use an enum for typedef for more stable ABI?
|
||||
*/
|
||||
typedef enum {
|
||||
/* Flag for whether the GIL is required */
|
||||
NPY_METH_REQUIRES_PYAPI = 1 << 0,
|
||||
/*
|
||||
* Some functions cannot set floating point error flags, this flag
|
||||
* gives us the option (not requirement) to skip floating point error
|
||||
* setup/check. No function should set error flags and ignore them
|
||||
* since it would interfere with chaining operations (e.g. casting).
|
||||
*/
|
||||
NPY_METH_NO_FLOATINGPOINT_ERRORS = 1 << 1,
|
||||
/* Whether the method supports unaligned access (not runtime) */
|
||||
NPY_METH_SUPPORTS_UNALIGNED = 1 << 2,
|
||||
/*
|
||||
* Used for reductions to allow reordering the operation. At this point
|
||||
* assume that if set, it also applies to normal operations though!
|
||||
*/
|
||||
NPY_METH_IS_REORDERABLE = 1 << 3,
|
||||
/*
|
||||
* Private flag for now for *logic* functions. The logical functions
|
||||
* `logical_or` and `logical_and` can always cast the inputs to booleans
|
||||
* "safely" (because that is how the cast to bool is defined).
|
||||
* @seberg: I am not sure this is the best way to handle this, so its
|
||||
* private for now (also it is very limited anyway).
|
||||
* There is one "exception". NA aware dtypes cannot cast to bool
|
||||
* (hopefully), so the `??->?` loop should error even with this flag.
|
||||
* But a second NA fallback loop will be necessary.
|
||||
*/
|
||||
_NPY_METH_FORCE_CAST_INPUTS = 1 << 17,
|
||||
|
||||
/* All flags which can change at runtime */
|
||||
NPY_METH_RUNTIME_FLAGS = (
|
||||
NPY_METH_REQUIRES_PYAPI |
|
||||
NPY_METH_NO_FLOATINGPOINT_ERRORS),
|
||||
} NPY_ARRAYMETHOD_FLAGS;
|
||||
|
||||
|
||||
typedef struct PyArrayMethod_Context_tag {
|
||||
/* The caller, which is typically the original ufunc. May be NULL */
|
||||
PyObject *caller;
|
||||
/* The method "self". Publically currentl an opaque object. */
|
||||
struct PyArrayMethodObject_tag *method;
|
||||
|
||||
/* Operand descriptors, filled in by resolve_descriptors */
|
||||
PyArray_Descr **descriptors;
|
||||
/* Structure may grow (this is harmless for DType authors) */
|
||||
} PyArrayMethod_Context;
|
||||
|
||||
|
||||
/*
|
||||
* The main object for creating a new ArrayMethod. We use the typical `slots`
|
||||
* mechanism used by the Python limited API (see below for the slot defs).
|
||||
*/
|
||||
typedef struct {
|
||||
const char *name;
|
||||
int nin, nout;
|
||||
NPY_CASTING casting;
|
||||
NPY_ARRAYMETHOD_FLAGS flags;
|
||||
PyArray_DTypeMeta **dtypes;
|
||||
PyType_Slot *slots;
|
||||
} PyArrayMethod_Spec;
|
||||
|
||||
|
||||
/*
|
||||
* ArrayMethod slots
|
||||
* -----------------
|
||||
*
|
||||
* SLOTS IDs For the ArrayMethod creation, once fully public, IDs are fixed
|
||||
* but can be deprecated and arbitrarily extended.
|
||||
*/
|
||||
#define NPY_METH_resolve_descriptors 1
|
||||
/* We may want to adapt the `get_loop` signature a bit: */
|
||||
#define _NPY_METH_get_loop 2
|
||||
#define NPY_METH_get_reduction_initial 3
|
||||
/* specific loops for constructions/default get_loop: */
|
||||
#define NPY_METH_strided_loop 4
|
||||
#define NPY_METH_contiguous_loop 5
|
||||
#define NPY_METH_unaligned_strided_loop 6
|
||||
#define NPY_METH_unaligned_contiguous_loop 7
|
||||
#define NPY_METH_contiguous_indexed_loop 8
|
||||
|
||||
/*
|
||||
* The resolve descriptors function, must be able to handle NULL values for
|
||||
* all output (but not input) `given_descrs` and fill `loop_descrs`.
|
||||
* Return -1 on error or 0 if the operation is not possible without an error
|
||||
* set. (This may still be in flux.)
|
||||
* Otherwise must return the "casting safety", for normal functions, this is
|
||||
* almost always "safe" (or even "equivalent"?).
|
||||
*
|
||||
* `resolve_descriptors` is optional if all output DTypes are non-parametric.
|
||||
*/
|
||||
typedef NPY_CASTING (resolve_descriptors_function)(
|
||||
/* "method" is currently opaque (necessary e.g. to wrap Python) */
|
||||
struct PyArrayMethodObject_tag *method,
|
||||
/* DTypes the method was created for */
|
||||
PyArray_DTypeMeta **dtypes,
|
||||
/* Input descriptors (instances). Outputs may be NULL. */
|
||||
PyArray_Descr **given_descrs,
|
||||
/* Exact loop descriptors to use, must not hold references on error */
|
||||
PyArray_Descr **loop_descrs,
|
||||
npy_intp *view_offset);
|
||||
|
||||
|
||||
typedef int (PyArrayMethod_StridedLoop)(PyArrayMethod_Context *context,
|
||||
char *const *data, const npy_intp *dimensions, const npy_intp *strides,
|
||||
NpyAuxData *transferdata);
|
||||
|
||||
|
||||
typedef int (get_loop_function)(
|
||||
PyArrayMethod_Context *context,
|
||||
int aligned, int move_references,
|
||||
const npy_intp *strides,
|
||||
PyArrayMethod_StridedLoop **out_loop,
|
||||
NpyAuxData **out_transferdata,
|
||||
NPY_ARRAYMETHOD_FLAGS *flags);
|
||||
|
||||
/**
|
||||
* Query an ArrayMethod for the initial value for use in reduction.
|
||||
*
|
||||
* @param context The arraymethod context, mainly to access the descriptors.
|
||||
* @param reduction_is_empty Whether the reduction is empty. When it is, the
|
||||
* value returned may differ. In this case it is a "default" value that
|
||||
* may differ from the "identity" value normally used. For example:
|
||||
* - `0.0` is the default for `sum([])`. But `-0.0` is the correct
|
||||
* identity otherwise as it preserves the sign for `sum([-0.0])`.
|
||||
* - We use no identity for object, but return the default of `0` and `1`
|
||||
* for the empty `sum([], dtype=object)` and `prod([], dtype=object)`.
|
||||
* This allows `np.sum(np.array(["a", "b"], dtype=object))` to work.
|
||||
* - `-inf` or `INT_MIN` for `max` is an identity, but at least `INT_MIN`
|
||||
* not a good *default* when there are no items.
|
||||
* @param initial Pointer to initial data to be filled (if possible)
|
||||
*
|
||||
* @returns -1, 0, or 1 indicating error, no initial value, and initial being
|
||||
* successfully filled. Errors must not be given where 0 is correct, NumPy
|
||||
* may call this even when not strictly necessary.
|
||||
*/
|
||||
typedef int (get_reduction_initial_function)(
|
||||
PyArrayMethod_Context *context, npy_bool reduction_is_empty,
|
||||
char *initial);
|
||||
|
||||
/*
|
||||
* The following functions are only used by the wrapping array method defined
|
||||
* in umath/wrapping_array_method.c
|
||||
*/
|
||||
|
||||
/*
|
||||
* The function to convert the given descriptors (passed in to
|
||||
* `resolve_descriptors`) and translates them for the wrapped loop.
|
||||
* The new descriptors MUST be viewable with the old ones, `NULL` must be
|
||||
* supported (for outputs) and should normally be forwarded.
|
||||
*
|
||||
* The function must clean up on error.
|
||||
*
|
||||
* NOTE: We currently assume that this translation gives "viewable" results.
|
||||
* I.e. there is no additional casting related to the wrapping process.
|
||||
* In principle that could be supported, but not sure it is useful.
|
||||
* This currently also means that e.g. alignment must apply identically
|
||||
* to the new dtypes.
|
||||
*
|
||||
* TODO: Due to the fact that `resolve_descriptors` is also used for `can_cast`
|
||||
* there is no way to "pass out" the result of this function. This means
|
||||
* it will be called twice for every ufunc call.
|
||||
* (I am considering including `auxdata` as an "optional" parameter to
|
||||
* `resolve_descriptors`, so that it can be filled there if not NULL.)
|
||||
*/
|
||||
typedef int translate_given_descrs_func(int nin, int nout,
|
||||
PyArray_DTypeMeta *wrapped_dtypes[],
|
||||
PyArray_Descr *given_descrs[], PyArray_Descr *new_descrs[]);
|
||||
|
||||
/**
|
||||
* The function to convert the actual loop descriptors (as returned by the
|
||||
* original `resolve_descriptors` function) to the ones the output array
|
||||
* should use.
|
||||
* This function must return "viewable" types, it must not mutate them in any
|
||||
* form that would break the inner-loop logic. Does not need to support NULL.
|
||||
*
|
||||
* The function must clean up on error.
|
||||
*
|
||||
* @param nargs Number of arguments
|
||||
* @param new_dtypes The DTypes of the output (usually probably not needed)
|
||||
* @param given_descrs Original given_descrs to the resolver, necessary to
|
||||
* fetch any information related to the new dtypes from the original.
|
||||
* @param original_descrs The `loop_descrs` returned by the wrapped loop.
|
||||
* @param loop_descrs The output descriptors, compatible to `original_descrs`.
|
||||
*
|
||||
* @returns 0 on success, -1 on failure.
|
||||
*/
|
||||
typedef int translate_loop_descrs_func(int nin, int nout,
|
||||
PyArray_DTypeMeta *new_dtypes[], PyArray_Descr *given_descrs[],
|
||||
PyArray_Descr *original_descrs[], PyArray_Descr *loop_descrs[]);
|
||||
|
||||
|
||||
/*
|
||||
* A traverse loop working on a single array. This is similar to the general
|
||||
* strided-loop function. This is designed for loops that need to visit every
|
||||
* element of a single array.
|
||||
*
|
||||
* Currently this is used for array clearing, via the NPY_DT_get_clear_loop
|
||||
* API hook, and zero-filling, via the NPY_DT_get_fill_zero_loop API hook.
|
||||
* These are most useful for handling arrays storing embedded references to
|
||||
* python objects or heap-allocated data.
|
||||
*
|
||||
* The `void *traverse_context` is passed in because we may need to pass in
|
||||
* Intepreter state or similar in the future, but we don't want to pass in
|
||||
* a full context (with pointers to dtypes, method, caller which all make
|
||||
* no sense for a traverse function).
|
||||
*
|
||||
* We assume for now that this context can be just passed through in the
|
||||
* the future (for structured dtypes).
|
||||
*
|
||||
*/
|
||||
typedef int (traverse_loop_function)(
|
||||
void *traverse_context, PyArray_Descr *descr, char *data,
|
||||
npy_intp size, npy_intp stride, NpyAuxData *auxdata);
|
||||
|
||||
|
||||
/*
|
||||
* Simplified get_loop function specific to dtype traversal
|
||||
*
|
||||
* It should set the flags needed for the traversal loop and set out_loop to the
|
||||
* loop function, which must be a valid traverse_loop_function
|
||||
* pointer. Currently this is used for zero-filling and clearing arrays storing
|
||||
* embedded references.
|
||||
*
|
||||
*/
|
||||
typedef int (get_traverse_loop_function)(
|
||||
void *traverse_context, PyArray_Descr *descr,
|
||||
int aligned, npy_intp fixed_stride,
|
||||
traverse_loop_function **out_loop, NpyAuxData **out_auxdata,
|
||||
NPY_ARRAYMETHOD_FLAGS *flags);
|
||||
|
||||
|
||||
/*
|
||||
* ****************************
|
||||
* DTYPE API
|
||||
* ****************************
|
||||
*/
|
||||
|
||||
#define NPY_DT_ABSTRACT 1 << 1
|
||||
#define NPY_DT_PARAMETRIC 1 << 2
|
||||
#define NPY_DT_NUMERIC 1 << 3
|
||||
|
||||
/*
|
||||
* These correspond to slots in the NPY_DType_Slots struct and must
|
||||
* be in the same order as the members of that struct. If new slots
|
||||
* get added or old slots get removed NPY_NUM_DTYPE_SLOTS must also
|
||||
* be updated
|
||||
*/
|
||||
|
||||
#define NPY_DT_discover_descr_from_pyobject 1
|
||||
// this slot is considered private because its API hasn't beed decided
|
||||
#define _NPY_DT_is_known_scalar_type 2
|
||||
#define NPY_DT_default_descr 3
|
||||
#define NPY_DT_common_dtype 4
|
||||
#define NPY_DT_common_instance 5
|
||||
#define NPY_DT_ensure_canonical 6
|
||||
#define NPY_DT_setitem 7
|
||||
#define NPY_DT_getitem 8
|
||||
#define NPY_DT_get_clear_loop 9
|
||||
#define NPY_DT_get_fill_zero_loop 10
|
||||
|
||||
// These PyArray_ArrFunc slots will be deprecated and replaced eventually
|
||||
// getitem and setitem can be defined as a performance optimization;
|
||||
// by default the user dtypes call `legacy_getitem_using_DType` and
|
||||
// `legacy_setitem_using_DType`, respectively. This functionality is
|
||||
// only supported for basic NumPy DTypes.
|
||||
|
||||
|
||||
// used to separate dtype slots from arrfuncs slots
|
||||
// intended only for internal use but defined here for clarity
|
||||
#define _NPY_DT_ARRFUNCS_OFFSET (1 << 10)
|
||||
|
||||
// Cast is disabled
|
||||
// #define NPY_DT_PyArray_ArrFuncs_cast 0 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
|
||||
#define NPY_DT_PyArray_ArrFuncs_getitem 1 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_setitem 2 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
|
||||
#define NPY_DT_PyArray_ArrFuncs_copyswapn 3 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_copyswap 4 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_compare 5 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_argmax 6 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_dotfunc 7 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_scanfunc 8 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_fromstr 9 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_nonzero 10 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_fill 11 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_fillwithscalar 12 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_sort 13 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_argsort 14 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
|
||||
// Casting related slots are disabled. See
|
||||
// https://github.com/numpy/numpy/pull/23173#discussion_r1101098163
|
||||
// #define NPY_DT_PyArray_ArrFuncs_castdict 15 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
// #define NPY_DT_PyArray_ArrFuncs_scalarkind 16 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
// #define NPY_DT_PyArray_ArrFuncs_cancastscalarkindto 17 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
// #define NPY_DT_PyArray_ArrFuncs_cancastto 18 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
|
||||
// These are deprecated in NumPy 1.19, so are disabled here.
|
||||
// #define NPY_DT_PyArray_ArrFuncs_fastclip 19 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
// #define NPY_DT_PyArray_ArrFuncs_fastputmask 20 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
// #define NPY_DT_PyArray_ArrFuncs_fasttake 21 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
#define NPY_DT_PyArray_ArrFuncs_argmin 22 + _NPY_DT_ARRFUNCS_OFFSET
|
||||
|
||||
// TODO: These slots probably still need some thought, and/or a way to "grow"?
|
||||
typedef struct {
|
||||
PyTypeObject *typeobj; /* type of python scalar or NULL */
|
||||
int flags; /* flags, including parametric and abstract */
|
||||
/* NULL terminated cast definitions. Use NULL for the newly created DType */
|
||||
PyArrayMethod_Spec **casts;
|
||||
PyType_Slot *slots;
|
||||
/* Baseclass or NULL (will always subclass `np.dtype`) */
|
||||
PyTypeObject *baseclass;
|
||||
} PyArrayDTypeMeta_Spec;
|
||||
|
||||
|
||||
typedef PyArray_Descr *(discover_descr_from_pyobject_function)(
|
||||
PyArray_DTypeMeta *cls, PyObject *obj);
|
||||
|
||||
/*
|
||||
* Before making this public, we should decide whether it should pass
|
||||
* the type, or allow looking at the object. A possible use-case:
|
||||
* `np.array(np.array([0]), dtype=np.ndarray)`
|
||||
* Could consider arrays that are not `dtype=ndarray` "scalars".
|
||||
*/
|
||||
typedef int (is_known_scalar_type_function)(
|
||||
PyArray_DTypeMeta *cls, PyTypeObject *obj);
|
||||
|
||||
typedef PyArray_Descr *(default_descr_function)(PyArray_DTypeMeta *cls);
|
||||
typedef PyArray_DTypeMeta *(common_dtype_function)(
|
||||
PyArray_DTypeMeta *dtype1, PyArray_DTypeMeta *dtype2);
|
||||
typedef PyArray_Descr *(common_instance_function)(
|
||||
PyArray_Descr *dtype1, PyArray_Descr *dtype2);
|
||||
typedef PyArray_Descr *(ensure_canonical_function)(PyArray_Descr *dtype);
|
||||
|
||||
/*
|
||||
* TODO: These two functions are currently only used for experimental DType
|
||||
* API support. Their relation should be "reversed": NumPy should
|
||||
* always use them internally.
|
||||
* There are open points about "casting safety" though, e.g. setting
|
||||
* elements is currently always unsafe.
|
||||
*/
|
||||
typedef int(setitemfunction)(PyArray_Descr *, PyObject *, char *);
|
||||
typedef PyObject *(getitemfunction)(PyArray_Descr *, char *);
|
||||
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY___DTYPE_API_H_ */
|
@@ -0,0 +1,90 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY__NEIGHBORHOOD_IMP_H_
|
||||
#error You should not include this header directly
|
||||
#endif
|
||||
/*
|
||||
* Private API (here for inline)
|
||||
*/
|
||||
static inline int
|
||||
_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter);
|
||||
|
||||
/*
|
||||
* Update to next item of the iterator
|
||||
*
|
||||
* Note: this simply increment the coordinates vector, last dimension
|
||||
* incremented first , i.e, for dimension 3
|
||||
* ...
|
||||
* -1, -1, -1
|
||||
* -1, -1, 0
|
||||
* -1, -1, 1
|
||||
* ....
|
||||
* -1, 0, -1
|
||||
* -1, 0, 0
|
||||
* ....
|
||||
* 0, -1, -1
|
||||
* 0, -1, 0
|
||||
* ....
|
||||
*/
|
||||
#define _UPDATE_COORD_ITER(c) \
|
||||
wb = iter->coordinates[c] < iter->bounds[c][1]; \
|
||||
if (wb) { \
|
||||
iter->coordinates[c] += 1; \
|
||||
return 0; \
|
||||
} \
|
||||
else { \
|
||||
iter->coordinates[c] = iter->bounds[c][0]; \
|
||||
}
|
||||
|
||||
static inline int
|
||||
_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter)
|
||||
{
|
||||
npy_intp i, wb;
|
||||
|
||||
for (i = iter->nd - 1; i >= 0; --i) {
|
||||
_UPDATE_COORD_ITER(i)
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Version optimized for 2d arrays, manual loop unrolling
|
||||
*/
|
||||
static inline int
|
||||
_PyArrayNeighborhoodIter_IncrCoord2D(PyArrayNeighborhoodIterObject* iter)
|
||||
{
|
||||
npy_intp wb;
|
||||
|
||||
_UPDATE_COORD_ITER(1)
|
||||
_UPDATE_COORD_ITER(0)
|
||||
|
||||
return 0;
|
||||
}
|
||||
#undef _UPDATE_COORD_ITER
|
||||
|
||||
/*
|
||||
* Advance to the next neighbour
|
||||
*/
|
||||
static inline int
|
||||
PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)
|
||||
{
|
||||
_PyArrayNeighborhoodIter_IncrCoord (iter);
|
||||
iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Reset functions
|
||||
*/
|
||||
static inline int
|
||||
PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter)
|
||||
{
|
||||
npy_intp i;
|
||||
|
||||
for (i = 0; i < iter->nd; ++i) {
|
||||
iter->coordinates[i] = iter->bounds[i][0];
|
||||
}
|
||||
iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates);
|
||||
|
||||
return 0;
|
||||
}
|
@@ -0,0 +1,27 @@
|
||||
#define NPY_HAVE_ENDIAN_H 1
|
||||
#define NPY_SIZEOF_SHORT SIZEOF_SHORT
|
||||
#define NPY_SIZEOF_INT SIZEOF_INT
|
||||
#define NPY_SIZEOF_LONG SIZEOF_LONG
|
||||
#define NPY_SIZEOF_FLOAT 4
|
||||
#define NPY_SIZEOF_COMPLEX_FLOAT 8
|
||||
#define NPY_SIZEOF_DOUBLE 8
|
||||
#define NPY_SIZEOF_COMPLEX_DOUBLE 16
|
||||
#define NPY_SIZEOF_LONGDOUBLE 8
|
||||
#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 16
|
||||
#define NPY_SIZEOF_PY_INTPTR_T 4
|
||||
#define NPY_SIZEOF_OFF_T 8
|
||||
#define NPY_SIZEOF_PY_LONG_LONG 8
|
||||
#define NPY_SIZEOF_LONGLONG 8
|
||||
#define NPY_NO_SMP 0
|
||||
#define NPY_USE_C99_COMPLEX 1
|
||||
#define NPY_HAVE_COMPLEX_DOUBLE 1
|
||||
#define NPY_HAVE_COMPLEX_FLOAT 1
|
||||
#define NPY_HAVE_COMPLEX_LONG_DOUBLE 1
|
||||
#define NPY_USE_C99_FORMATS 1
|
||||
#define NPY_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
|
||||
#define NPY_ABI_VERSION 0x01000009
|
||||
#define NPY_API_VERSION 0x00000011
|
||||
|
||||
#ifndef __STDC_FORMAT_MACROS
|
||||
#define __STDC_FORMAT_MACROS 1
|
||||
#endif
|
@@ -0,0 +1,32 @@
|
||||
#mesondefine NPY_HAVE_ENDIAN_H
|
||||
|
||||
#mesondefine NPY_SIZEOF_SHORT
|
||||
#mesondefine NPY_SIZEOF_INT
|
||||
#mesondefine NPY_SIZEOF_LONG
|
||||
#mesondefine NPY_SIZEOF_FLOAT
|
||||
#mesondefine NPY_SIZEOF_COMPLEX_FLOAT
|
||||
#mesondefine NPY_SIZEOF_DOUBLE
|
||||
#mesondefine NPY_SIZEOF_COMPLEX_DOUBLE
|
||||
#mesondefine NPY_SIZEOF_LONGDOUBLE
|
||||
#mesondefine NPY_SIZEOF_COMPLEX_LONGDOUBLE
|
||||
#mesondefine NPY_SIZEOF_PY_INTPTR_T
|
||||
#mesondefine NPY_SIZEOF_OFF_T
|
||||
#mesondefine NPY_SIZEOF_PY_LONG_LONG
|
||||
#mesondefine NPY_SIZEOF_LONGLONG
|
||||
|
||||
#mesondefine NPY_USE_C99_COMPLEX
|
||||
#mesondefine NPY_HAVE_COMPLEX_DOUBLE
|
||||
#mesondefine NPY_HAVE_COMPLEX_FLOAT
|
||||
#mesondefine NPY_HAVE_COMPLEX_LONG_DOUBLE
|
||||
#mesondefine NPY_USE_C99_FORMATS
|
||||
|
||||
#mesondefine NPY_NO_SIGNAL
|
||||
#mesondefine NPY_NO_SMP
|
||||
|
||||
#mesondefine NPY_VISIBILITY_HIDDEN
|
||||
#mesondefine NPY_ABI_VERSION
|
||||
#mesondefine NPY_API_VERSION
|
||||
|
||||
#ifndef __STDC_FORMAT_MACROS
|
||||
#define __STDC_FORMAT_MACROS 1
|
||||
#endif
|
@@ -0,0 +1,12 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_ARRAYOBJECT_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_ARRAYOBJECT_H_
|
||||
#define Py_ARRAYOBJECT_H
|
||||
|
||||
#include "ndarrayobject.h"
|
||||
#include "npy_interrupt.h"
|
||||
|
||||
#ifdef NPY_NO_PREFIX
|
||||
#include "noprefix.h"
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_ARRAYOBJECT_H_ */
|
@@ -0,0 +1,186 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_ARRAYSCALARS_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_ARRAYSCALARS_H_
|
||||
|
||||
#ifndef _MULTIARRAYMODULE
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_bool obval;
|
||||
} PyBoolScalarObject;
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
signed char obval;
|
||||
} PyByteScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
short obval;
|
||||
} PyShortScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
int obval;
|
||||
} PyIntScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
long obval;
|
||||
} PyLongScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_longlong obval;
|
||||
} PyLongLongScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
unsigned char obval;
|
||||
} PyUByteScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
unsigned short obval;
|
||||
} PyUShortScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
unsigned int obval;
|
||||
} PyUIntScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
unsigned long obval;
|
||||
} PyULongScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_ulonglong obval;
|
||||
} PyULongLongScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_half obval;
|
||||
} PyHalfScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
float obval;
|
||||
} PyFloatScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
double obval;
|
||||
} PyDoubleScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_longdouble obval;
|
||||
} PyLongDoubleScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_cfloat obval;
|
||||
} PyCFloatScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_cdouble obval;
|
||||
} PyCDoubleScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_clongdouble obval;
|
||||
} PyCLongDoubleScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
PyObject * obval;
|
||||
} PyObjectScalarObject;
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_datetime obval;
|
||||
PyArray_DatetimeMetaData obmeta;
|
||||
} PyDatetimeScalarObject;
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
npy_timedelta obval;
|
||||
PyArray_DatetimeMetaData obmeta;
|
||||
} PyTimedeltaScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
char obval;
|
||||
} PyScalarObject;
|
||||
|
||||
#define PyStringScalarObject PyBytesObject
|
||||
typedef struct {
|
||||
/* note that the PyObject_HEAD macro lives right here */
|
||||
PyUnicodeObject base;
|
||||
Py_UCS4 *obval;
|
||||
#if NPY_FEATURE_VERSION >= NPY_1_20_API_VERSION
|
||||
char *buffer_fmt;
|
||||
#endif
|
||||
} PyUnicodeScalarObject;
|
||||
|
||||
|
||||
typedef struct {
|
||||
PyObject_VAR_HEAD
|
||||
char *obval;
|
||||
PyArray_Descr *descr;
|
||||
int flags;
|
||||
PyObject *base;
|
||||
#if NPY_FEATURE_VERSION >= NPY_1_20_API_VERSION
|
||||
void *_buffer_info; /* private buffer info, tagged to allow warning */
|
||||
#endif
|
||||
} PyVoidScalarObject;
|
||||
|
||||
/* Macros
|
||||
Py<Cls><bitsize>ScalarObject
|
||||
Py<Cls><bitsize>ArrType_Type
|
||||
are defined in ndarrayobject.h
|
||||
*/
|
||||
|
||||
#define PyArrayScalar_False ((PyObject *)(&(_PyArrayScalar_BoolValues[0])))
|
||||
#define PyArrayScalar_True ((PyObject *)(&(_PyArrayScalar_BoolValues[1])))
|
||||
#define PyArrayScalar_FromLong(i) \
|
||||
((PyObject *)(&(_PyArrayScalar_BoolValues[((i)!=0)])))
|
||||
#define PyArrayScalar_RETURN_BOOL_FROM_LONG(i) \
|
||||
return Py_INCREF(PyArrayScalar_FromLong(i)), \
|
||||
PyArrayScalar_FromLong(i)
|
||||
#define PyArrayScalar_RETURN_FALSE \
|
||||
return Py_INCREF(PyArrayScalar_False), \
|
||||
PyArrayScalar_False
|
||||
#define PyArrayScalar_RETURN_TRUE \
|
||||
return Py_INCREF(PyArrayScalar_True), \
|
||||
PyArrayScalar_True
|
||||
|
||||
#define PyArrayScalar_New(cls) \
|
||||
Py##cls##ArrType_Type.tp_alloc(&Py##cls##ArrType_Type, 0)
|
||||
#define PyArrayScalar_VAL(obj, cls) \
|
||||
((Py##cls##ScalarObject *)obj)->obval
|
||||
#define PyArrayScalar_ASSIGN(obj, cls, val) \
|
||||
PyArrayScalar_VAL(obj, cls) = val
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_ARRAYSCALARS_H_ */
|
@@ -0,0 +1,365 @@
|
||||
/*
|
||||
* This header exports the new experimental DType API as proposed in
|
||||
* NEPs 41 to 43. For background, please check these NEPs. Otherwise,
|
||||
* this header also serves as documentation for the time being.
|
||||
*
|
||||
* The header includes `_dtype_api.h` which holds most definition while this
|
||||
* header mainly wraps functions for public consumption.
|
||||
*
|
||||
* Please do not hesitate to contact @seberg with questions. This is
|
||||
* developed together with https://github.com/seberg/experimental_user_dtypes
|
||||
* and those interested in experimenting are encouraged to contribute there.
|
||||
*
|
||||
* To use the functions defined in the header, call::
|
||||
*
|
||||
* if (import_experimental_dtype_api(version) < 0) {
|
||||
* return NULL;
|
||||
* }
|
||||
*
|
||||
* in your module init. (A version mismatch will be reported, just update
|
||||
* to the correct one, this will alert you of possible changes.)
|
||||
*
|
||||
* The following lists the main symbols currently exported. Please do not
|
||||
* hesitate to ask for help or clarification:
|
||||
*
|
||||
* - PyUFunc_AddLoopFromSpec:
|
||||
*
|
||||
* Register a new loop for a ufunc. This uses the `PyArrayMethod_Spec`
|
||||
* which must be filled in (see in-line comments).
|
||||
*
|
||||
* - PyUFunc_AddWrappingLoop:
|
||||
*
|
||||
* Register a new loop which reuses an existing one, but modifies the
|
||||
* result dtypes. Please search the internal NumPy docs for more info
|
||||
* at this point. (Used for physical units dtype.)
|
||||
*
|
||||
* - PyUFunc_AddPromoter:
|
||||
*
|
||||
* Register a new promoter for a ufunc. A promoter is a function stored
|
||||
* in a PyCapsule (see in-line comments). It is passed the operation and
|
||||
* requested DType signatures and can mutate it to attempt a new search
|
||||
* for a matching loop/promoter.
|
||||
* I.e. for Numba a promoter could even add the desired loop.
|
||||
*
|
||||
* - PyArrayInitDTypeMeta_FromSpec:
|
||||
*
|
||||
* Initialize a new DType. It must currently be a static Python C type
|
||||
* that is declared as `PyArray_DTypeMeta` and not `PyTypeObject`.
|
||||
* Further, it must subclass `np.dtype` and set its type to
|
||||
* `PyArrayDTypeMeta_Type` (before calling `PyType_Read()`).
|
||||
*
|
||||
* - PyArray_CommonDType:
|
||||
*
|
||||
* Find the common-dtype ("promotion") for two DType classes. Similar
|
||||
* to `np.result_type`, but works on the classes and not instances.
|
||||
*
|
||||
* - PyArray_PromoteDTypeSequence:
|
||||
*
|
||||
* Same as CommonDType, but works with an arbitrary number of DTypes.
|
||||
* This function is smarter and can often return successful and unambiguous
|
||||
* results when `common_dtype(common_dtype(dt1, dt2), dt3)` would
|
||||
* depend on the operation order or fail. Nevertheless, DTypes should
|
||||
* aim to ensure that their common-dtype implementation is associative
|
||||
* and commutative! (Mainly, unsigned and signed integers are not.)
|
||||
*
|
||||
* For guaranteed consistent results DTypes must implement common-Dtype
|
||||
* "transitively". If A promotes B and B promotes C, than A must generally
|
||||
* also promote C; where "promotes" means implements the promotion.
|
||||
* (There are some exceptions for abstract DTypes)
|
||||
*
|
||||
* - PyArray_GetDefaultDescr:
|
||||
*
|
||||
* Given a DType class, returns the default instance (descriptor).
|
||||
* This is an inline function checking for `singleton` first and only
|
||||
* calls the `default_descr` function if necessary.
|
||||
*
|
||||
* - PyArray_DoubleDType, etc.:
|
||||
*
|
||||
* Aliases to the DType classes for the builtin NumPy DTypes.
|
||||
*
|
||||
* WARNING
|
||||
* =======
|
||||
*
|
||||
* By using this header, you understand that this is a fully experimental
|
||||
* exposure. Details are expected to change, and some options may have no
|
||||
* effect. (Please contact @seberg if you have questions!)
|
||||
* If the exposure stops working, please file a bug report with NumPy.
|
||||
* Further, a DType created using this API/header should still be expected
|
||||
* to be incompatible with some functionality inside and outside of NumPy.
|
||||
* In this case crashes must be expected. Please report any such problems
|
||||
* so that they can be fixed before final exposure.
|
||||
* Furthermore, expect missing checks for programming errors which the final
|
||||
* API is expected to have.
|
||||
*
|
||||
* Symbols with a leading underscore are likely to not be included in the
|
||||
* first public version, if these are central to your use-case, please let
|
||||
* us know, so that we can reconsider.
|
||||
*
|
||||
* "Array-like" consumer API not yet under considerations
|
||||
* ======================================================
|
||||
*
|
||||
* The new DType API is designed in a way to make it potentially useful for
|
||||
* alternative "array-like" implementations. This will require careful
|
||||
* exposure of details and functions and is not part of this experimental API.
|
||||
*
|
||||
* Brief (incompatibility) changelog
|
||||
* =================================
|
||||
*
|
||||
* 2. None (only additions).
|
||||
* 3. New `npy_intp *view_offset` argument for `resolve_descriptors`.
|
||||
* This replaces the `NPY_CAST_IS_VIEW` flag. It can be set to 0 if the
|
||||
* operation is a view, and is pre-initialized to `NPY_MIN_INTP` indicating
|
||||
* that the operation is not a view.
|
||||
*/
|
||||
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_EXPERIMENTAL_DTYPE_API_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_EXPERIMENTAL_DTYPE_API_H_
|
||||
|
||||
#include <Python.h>
|
||||
#include "ndarraytypes.h"
|
||||
#include "_dtype_api.h"
|
||||
|
||||
/*
|
||||
* The contents of PyArrayMethodObject are currently opaque (is there a way
|
||||
* good way to make them be `PyObject *`?)
|
||||
*/
|
||||
typedef struct PyArrayMethodObject_tag PyArrayMethodObject;
|
||||
|
||||
/*
|
||||
* There must be a better way?! -- Oh well, this is experimental
|
||||
* (my issue with it, is that I cannot undef those helpers).
|
||||
*/
|
||||
#if defined(PY_ARRAY_UNIQUE_SYMBOL)
|
||||
#define NPY_EXP_DTYPE_API_CONCAT_HELPER2(x, y) x ## y
|
||||
#define NPY_EXP_DTYPE_API_CONCAT_HELPER(arg) NPY_EXP_DTYPE_API_CONCAT_HELPER2(arg, __experimental_dtype_api_table)
|
||||
#define __experimental_dtype_api_table NPY_EXP_DTYPE_API_CONCAT_HELPER(PY_ARRAY_UNIQUE_SYMBOL)
|
||||
#else
|
||||
#define __experimental_dtype_api_table __experimental_dtype_api_table
|
||||
#endif
|
||||
|
||||
/* Support for correct multi-file projects: */
|
||||
#if defined(NO_IMPORT) || defined(NO_IMPORT_ARRAY)
|
||||
extern void **__experimental_dtype_api_table;
|
||||
#else
|
||||
/*
|
||||
* Just a hack so I don't forget importing as much myself, I spend way too
|
||||
* much time noticing it the first time around :).
|
||||
*/
|
||||
static void
|
||||
__not_imported(void)
|
||||
{
|
||||
printf("*****\nCritical error, dtype API not imported\n*****\n");
|
||||
}
|
||||
|
||||
static void *__uninitialized_table[] = {
|
||||
&__not_imported, &__not_imported, &__not_imported, &__not_imported,
|
||||
&__not_imported, &__not_imported, &__not_imported, &__not_imported};
|
||||
|
||||
#if defined(PY_ARRAY_UNIQUE_SYMBOL)
|
||||
void **__experimental_dtype_api_table = __uninitialized_table;
|
||||
#else
|
||||
static void **__experimental_dtype_api_table = __uninitialized_table;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
typedef int _ufunc_addloop_fromspec_func(
|
||||
PyObject *ufunc, PyArrayMethod_Spec *spec);
|
||||
/*
|
||||
* The main ufunc registration function. This adds a new implementation/loop
|
||||
* to a ufunc. It replaces `PyUFunc_RegisterLoopForType`.
|
||||
*/
|
||||
#define PyUFunc_AddLoopFromSpec \
|
||||
(*(_ufunc_addloop_fromspec_func *)(__experimental_dtype_api_table[0]))
|
||||
|
||||
|
||||
/* Please see the NumPy definitions in `array_method.h` for details on these */
|
||||
typedef int translate_given_descrs_func(int nin, int nout,
|
||||
PyArray_DTypeMeta *wrapped_dtypes[],
|
||||
PyArray_Descr *given_descrs[], PyArray_Descr *new_descrs[]);
|
||||
typedef int translate_loop_descrs_func(int nin, int nout,
|
||||
PyArray_DTypeMeta *new_dtypes[], PyArray_Descr *given_descrs[],
|
||||
PyArray_Descr *original_descrs[], PyArray_Descr *loop_descrs[]);
|
||||
|
||||
typedef int _ufunc_wrapping_loop_func(PyObject *ufunc_obj,
|
||||
PyArray_DTypeMeta *new_dtypes[], PyArray_DTypeMeta *wrapped_dtypes[],
|
||||
translate_given_descrs_func *translate_given_descrs,
|
||||
translate_loop_descrs_func *translate_loop_descrs);
|
||||
#define PyUFunc_AddWrappingLoop \
|
||||
(*(_ufunc_wrapping_loop_func *)(__experimental_dtype_api_table[7]))
|
||||
|
||||
/*
|
||||
* Type of the C promoter function, which must be wrapped into a
|
||||
* PyCapsule with name "numpy._ufunc_promoter".
|
||||
*
|
||||
* Note that currently the output dtypes are always NULL unless they are
|
||||
* also part of the signature. This is an implementation detail and could
|
||||
* change in the future. However, in general promoters should not have a
|
||||
* need for output dtypes.
|
||||
* (There are potential use-cases, these are currently unsupported.)
|
||||
*/
|
||||
typedef int promoter_function(PyObject *ufunc,
|
||||
PyArray_DTypeMeta *op_dtypes[], PyArray_DTypeMeta *signature[],
|
||||
PyArray_DTypeMeta *new_op_dtypes[]);
|
||||
|
||||
/*
|
||||
* Function to register a promoter.
|
||||
*
|
||||
* @param ufunc The ufunc object to register the promoter with.
|
||||
* @param DType_tuple A Python tuple containing DTypes or None matching the
|
||||
* number of inputs and outputs of the ufunc.
|
||||
* @param promoter A PyCapsule with name "numpy._ufunc_promoter" containing
|
||||
* a pointer to a `promoter_function`.
|
||||
*/
|
||||
typedef int _ufunc_addpromoter_func(
|
||||
PyObject *ufunc, PyObject *DType_tuple, PyObject *promoter);
|
||||
#define PyUFunc_AddPromoter \
|
||||
(*(_ufunc_addpromoter_func *)(__experimental_dtype_api_table[1]))
|
||||
|
||||
#define PyArrayDTypeMeta_Type \
|
||||
(*(PyTypeObject *)__experimental_dtype_api_table[2])
|
||||
typedef int __dtypemeta_fromspec(
|
||||
PyArray_DTypeMeta *DType, PyArrayDTypeMeta_Spec *dtype_spec);
|
||||
/*
|
||||
* Finalize creation of a DTypeMeta. You must ensure that the DTypeMeta is
|
||||
* a proper subclass. The DTypeMeta object has additional fields compared to
|
||||
* a normal PyTypeObject!
|
||||
* The only (easy) creation of a new DType is to create a static Type which
|
||||
* inherits `PyArray_DescrType`, sets its type to `PyArrayDTypeMeta_Type` and
|
||||
* uses `PyArray_DTypeMeta` defined above as the C-structure.
|
||||
*/
|
||||
#define PyArrayInitDTypeMeta_FromSpec \
|
||||
((__dtypemeta_fromspec *)(__experimental_dtype_api_table[3]))
|
||||
|
||||
|
||||
/*
|
||||
* *************************************
|
||||
* WORKING WITH DTYPES
|
||||
* *************************************
|
||||
*/
|
||||
|
||||
typedef PyArray_DTypeMeta *__common_dtype(
|
||||
PyArray_DTypeMeta *DType1, PyArray_DTypeMeta *DType2);
|
||||
#define PyArray_CommonDType \
|
||||
((__common_dtype *)(__experimental_dtype_api_table[4]))
|
||||
|
||||
|
||||
typedef PyArray_DTypeMeta *__promote_dtype_sequence(
|
||||
npy_intp num, PyArray_DTypeMeta *DTypes[]);
|
||||
#define PyArray_PromoteDTypeSequence \
|
||||
((__promote_dtype_sequence *)(__experimental_dtype_api_table[5]))
|
||||
|
||||
|
||||
typedef PyArray_Descr *__get_default_descr(
|
||||
PyArray_DTypeMeta *DType);
|
||||
#define _PyArray_GetDefaultDescr \
|
||||
((__get_default_descr *)(__experimental_dtype_api_table[6]))
|
||||
|
||||
static inline PyArray_Descr *
|
||||
PyArray_GetDefaultDescr(PyArray_DTypeMeta *DType)
|
||||
{
|
||||
if (DType->singleton != NULL) {
|
||||
Py_INCREF(DType->singleton);
|
||||
return DType->singleton;
|
||||
}
|
||||
return _PyArray_GetDefaultDescr(DType);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* NumPy's builtin DTypes:
|
||||
*/
|
||||
#define PyArray_BoolDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[10])
|
||||
/* Integers */
|
||||
#define PyArray_ByteDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[11])
|
||||
#define PyArray_UByteDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[12])
|
||||
#define PyArray_ShortDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[13])
|
||||
#define PyArray_UShortDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[14])
|
||||
#define PyArray_IntDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[15])
|
||||
#define PyArray_UIntDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[16])
|
||||
#define PyArray_LongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[17])
|
||||
#define PyArray_ULongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[18])
|
||||
#define PyArray_LongLongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[19])
|
||||
#define PyArray_ULongLongDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[20])
|
||||
/* Integer aliases */
|
||||
#define PyArray_Int8Type (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[21])
|
||||
#define PyArray_UInt8DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[22])
|
||||
#define PyArray_Int16DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[23])
|
||||
#define PyArray_UInt16DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[24])
|
||||
#define PyArray_Int32DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[25])
|
||||
#define PyArray_UInt32DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[26])
|
||||
#define PyArray_Int64DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[27])
|
||||
#define PyArray_UInt64DType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[28])
|
||||
#define PyArray_IntpDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[29])
|
||||
#define PyArray_UIntpDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[30])
|
||||
/* Floats */
|
||||
#define PyArray_HalfType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[31])
|
||||
#define PyArray_FloatDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[32])
|
||||
#define PyArray_DoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[33])
|
||||
#define PyArray_LongDoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[34])
|
||||
/* Complex */
|
||||
#define PyArray_CFloatDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[35])
|
||||
#define PyArray_CDoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[36])
|
||||
#define PyArray_CLongDoubleDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[37])
|
||||
/* String/Bytes */
|
||||
#define PyArray_StringDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[38])
|
||||
#define PyArray_UnicodeDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[39])
|
||||
/* Datetime/Timedelta */
|
||||
#define PyArray_DatetimeDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[40])
|
||||
#define PyArray_TimedeltaDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[41])
|
||||
/* Object/Void */
|
||||
#define PyArray_ObjectDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[42])
|
||||
#define PyArray_VoidDType (*(PyArray_DTypeMeta *)__experimental_dtype_api_table[43])
|
||||
|
||||
/*
|
||||
* ********************************
|
||||
* Initialization
|
||||
* ********************************
|
||||
*
|
||||
* Import the experimental API, the version must match the one defined in
|
||||
* the header to ensure changes are taken into account. NumPy will further
|
||||
* runtime-check this.
|
||||
* You must call this function to use the symbols defined in this file.
|
||||
*/
|
||||
#if !defined(NO_IMPORT) && !defined(NO_IMPORT_ARRAY)
|
||||
|
||||
static int
|
||||
import_experimental_dtype_api(int version)
|
||||
{
|
||||
if (version != __EXPERIMENTAL_DTYPE_API_VERSION) {
|
||||
PyErr_Format(PyExc_RuntimeError,
|
||||
"DType API version %d did not match header version %d. Please "
|
||||
"update the import statement and check for API changes.",
|
||||
version, __EXPERIMENTAL_DTYPE_API_VERSION);
|
||||
return -1;
|
||||
}
|
||||
if (__experimental_dtype_api_table != __uninitialized_table) {
|
||||
/* already imported. */
|
||||
return 0;
|
||||
}
|
||||
|
||||
PyObject *multiarray = PyImport_ImportModule("numpy.core._multiarray_umath");
|
||||
if (multiarray == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
PyObject *api = PyObject_CallMethod(multiarray,
|
||||
"_get_experimental_dtype_api", "i", version);
|
||||
Py_DECREF(multiarray);
|
||||
if (api == NULL) {
|
||||
return -1;
|
||||
}
|
||||
__experimental_dtype_api_table = (void **)PyCapsule_GetPointer(api,
|
||||
"experimental_dtype_api_table");
|
||||
Py_DECREF(api);
|
||||
|
||||
if (__experimental_dtype_api_table == NULL) {
|
||||
__experimental_dtype_api_table = __uninitialized_table;
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* !defined(NO_IMPORT) && !defined(NO_IMPORT_ARRAY) */
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_EXPERIMENTAL_DTYPE_API_H_ */
|
@@ -0,0 +1,70 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_HALFFLOAT_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_HALFFLOAT_H_
|
||||
|
||||
#include <Python.h>
|
||||
#include <numpy/npy_math.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Half-precision routines
|
||||
*/
|
||||
|
||||
/* Conversions */
|
||||
float npy_half_to_float(npy_half h);
|
||||
double npy_half_to_double(npy_half h);
|
||||
npy_half npy_float_to_half(float f);
|
||||
npy_half npy_double_to_half(double d);
|
||||
/* Comparisons */
|
||||
int npy_half_eq(npy_half h1, npy_half h2);
|
||||
int npy_half_ne(npy_half h1, npy_half h2);
|
||||
int npy_half_le(npy_half h1, npy_half h2);
|
||||
int npy_half_lt(npy_half h1, npy_half h2);
|
||||
int npy_half_ge(npy_half h1, npy_half h2);
|
||||
int npy_half_gt(npy_half h1, npy_half h2);
|
||||
/* faster *_nonan variants for when you know h1 and h2 are not NaN */
|
||||
int npy_half_eq_nonan(npy_half h1, npy_half h2);
|
||||
int npy_half_lt_nonan(npy_half h1, npy_half h2);
|
||||
int npy_half_le_nonan(npy_half h1, npy_half h2);
|
||||
/* Miscellaneous functions */
|
||||
int npy_half_iszero(npy_half h);
|
||||
int npy_half_isnan(npy_half h);
|
||||
int npy_half_isinf(npy_half h);
|
||||
int npy_half_isfinite(npy_half h);
|
||||
int npy_half_signbit(npy_half h);
|
||||
npy_half npy_half_copysign(npy_half x, npy_half y);
|
||||
npy_half npy_half_spacing(npy_half h);
|
||||
npy_half npy_half_nextafter(npy_half x, npy_half y);
|
||||
npy_half npy_half_divmod(npy_half x, npy_half y, npy_half *modulus);
|
||||
|
||||
/*
|
||||
* Half-precision constants
|
||||
*/
|
||||
|
||||
#define NPY_HALF_ZERO (0x0000u)
|
||||
#define NPY_HALF_PZERO (0x0000u)
|
||||
#define NPY_HALF_NZERO (0x8000u)
|
||||
#define NPY_HALF_ONE (0x3c00u)
|
||||
#define NPY_HALF_NEGONE (0xbc00u)
|
||||
#define NPY_HALF_PINF (0x7c00u)
|
||||
#define NPY_HALF_NINF (0xfc00u)
|
||||
#define NPY_HALF_NAN (0x7e00u)
|
||||
|
||||
#define NPY_MAX_HALF (0x7bffu)
|
||||
|
||||
/*
|
||||
* Bit-level conversions
|
||||
*/
|
||||
|
||||
npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f);
|
||||
npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d);
|
||||
npy_uint32 npy_halfbits_to_floatbits(npy_uint16 h);
|
||||
npy_uint64 npy_halfbits_to_doublebits(npy_uint16 h);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_HALFFLOAT_H_ */
|
@@ -0,0 +1,21 @@
|
||||
zlib License
|
||||
------------
|
||||
|
||||
Copyright (C) 2010 - 2019 ridiculous_fish, <libdivide@ridiculousfish.com>
|
||||
Copyright (C) 2016 - 2019 Kim Walisch, <kim.walisch@gmail.com>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,251 @@
|
||||
/*
|
||||
* DON'T INCLUDE THIS DIRECTLY.
|
||||
*/
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NDARRAYOBJECT_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NDARRAYOBJECT_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <Python.h>
|
||||
#include "ndarraytypes.h"
|
||||
|
||||
/* Includes the "function" C-API -- these are all stored in a
|
||||
list of pointers --- one for each file
|
||||
The two lists are concatenated into one in multiarray.
|
||||
|
||||
They are available as import_array()
|
||||
*/
|
||||
|
||||
#include "__multiarray_api.h"
|
||||
|
||||
|
||||
/* C-API that requires previous API to be defined */
|
||||
|
||||
#define PyArray_DescrCheck(op) PyObject_TypeCheck(op, &PyArrayDescr_Type)
|
||||
|
||||
#define PyArray_Check(op) PyObject_TypeCheck(op, &PyArray_Type)
|
||||
#define PyArray_CheckExact(op) (((PyObject*)(op))->ob_type == &PyArray_Type)
|
||||
|
||||
#define PyArray_HasArrayInterfaceType(op, type, context, out) \
|
||||
((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) || \
|
||||
(((out)=PyArray_FromInterface(op)) != Py_NotImplemented) || \
|
||||
(((out)=PyArray_FromArrayAttr(op, type, context)) != \
|
||||
Py_NotImplemented))
|
||||
|
||||
#define PyArray_HasArrayInterface(op, out) \
|
||||
PyArray_HasArrayInterfaceType(op, NULL, NULL, out)
|
||||
|
||||
#define PyArray_IsZeroDim(op) (PyArray_Check(op) && \
|
||||
(PyArray_NDIM((PyArrayObject *)op) == 0))
|
||||
|
||||
#define PyArray_IsScalar(obj, cls) \
|
||||
(PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
|
||||
|
||||
#define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) || \
|
||||
PyArray_IsZeroDim(m))
|
||||
#define PyArray_IsPythonNumber(obj) \
|
||||
(PyFloat_Check(obj) || PyComplex_Check(obj) || \
|
||||
PyLong_Check(obj) || PyBool_Check(obj))
|
||||
#define PyArray_IsIntegerScalar(obj) (PyLong_Check(obj) \
|
||||
|| PyArray_IsScalar((obj), Integer))
|
||||
#define PyArray_IsPythonScalar(obj) \
|
||||
(PyArray_IsPythonNumber(obj) || PyBytes_Check(obj) || \
|
||||
PyUnicode_Check(obj))
|
||||
|
||||
#define PyArray_IsAnyScalar(obj) \
|
||||
(PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj))
|
||||
|
||||
#define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) || \
|
||||
PyArray_CheckScalar(obj))
|
||||
|
||||
|
||||
#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? \
|
||||
Py_INCREF(m), (m) : \
|
||||
(PyArrayObject *)(PyArray_Copy(m)))
|
||||
|
||||
#define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) && \
|
||||
PyArray_CompareLists(PyArray_DIMS(a1), \
|
||||
PyArray_DIMS(a2), \
|
||||
PyArray_NDIM(a1)))
|
||||
|
||||
#define PyArray_SIZE(m) PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m))
|
||||
#define PyArray_NBYTES(m) (PyArray_ITEMSIZE(m) * PyArray_SIZE(m))
|
||||
#define PyArray_FROM_O(m) PyArray_FromAny(m, NULL, 0, 0, 0, NULL)
|
||||
|
||||
#define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags, \
|
||||
NULL)
|
||||
|
||||
#define PyArray_FROM_OT(m,type) PyArray_FromAny(m, \
|
||||
PyArray_DescrFromType(type), 0, 0, 0, NULL)
|
||||
|
||||
#define PyArray_FROM_OTF(m, type, flags) \
|
||||
PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0, \
|
||||
(((flags) & NPY_ARRAY_ENSURECOPY) ? \
|
||||
((flags) | NPY_ARRAY_DEFAULT) : (flags)), NULL)
|
||||
|
||||
#define PyArray_FROMANY(m, type, min, max, flags) \
|
||||
PyArray_FromAny(m, PyArray_DescrFromType(type), min, max, \
|
||||
(((flags) & NPY_ARRAY_ENSURECOPY) ? \
|
||||
(flags) | NPY_ARRAY_DEFAULT : (flags)), NULL)
|
||||
|
||||
#define PyArray_ZEROS(m, dims, type, is_f_order) \
|
||||
PyArray_Zeros(m, dims, PyArray_DescrFromType(type), is_f_order)
|
||||
|
||||
#define PyArray_EMPTY(m, dims, type, is_f_order) \
|
||||
PyArray_Empty(m, dims, PyArray_DescrFromType(type), is_f_order)
|
||||
|
||||
#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, \
|
||||
PyArray_NBYTES(obj))
|
||||
#ifndef PYPY_VERSION
|
||||
#define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
|
||||
#define NPY_REFCOUNT PyArray_REFCOUNT
|
||||
#endif
|
||||
#define NPY_MAX_ELSIZE (2 * NPY_SIZEOF_LONGDOUBLE)
|
||||
|
||||
#define PyArray_ContiguousFromAny(op, type, min_depth, max_depth) \
|
||||
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
|
||||
max_depth, NPY_ARRAY_DEFAULT, NULL)
|
||||
|
||||
#define PyArray_EquivArrTypes(a1, a2) \
|
||||
PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2))
|
||||
|
||||
#define PyArray_EquivByteorders(b1, b2) \
|
||||
(((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2)))
|
||||
|
||||
#define PyArray_SimpleNew(nd, dims, typenum) \
|
||||
PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL)
|
||||
|
||||
#define PyArray_SimpleNewFromData(nd, dims, typenum, data) \
|
||||
PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, \
|
||||
data, 0, NPY_ARRAY_CARRAY, NULL)
|
||||
|
||||
#define PyArray_SimpleNewFromDescr(nd, dims, descr) \
|
||||
PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, \
|
||||
NULL, NULL, 0, NULL)
|
||||
|
||||
#define PyArray_ToScalar(data, arr) \
|
||||
PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr)
|
||||
|
||||
|
||||
/* These might be faster without the dereferencing of obj
|
||||
going on inside -- of course an optimizing compiler should
|
||||
inline the constants inside a for loop making it a moot point
|
||||
*/
|
||||
|
||||
#define PyArray_GETPTR1(obj, i) ((void *)(PyArray_BYTES(obj) + \
|
||||
(i)*PyArray_STRIDES(obj)[0]))
|
||||
|
||||
#define PyArray_GETPTR2(obj, i, j) ((void *)(PyArray_BYTES(obj) + \
|
||||
(i)*PyArray_STRIDES(obj)[0] + \
|
||||
(j)*PyArray_STRIDES(obj)[1]))
|
||||
|
||||
#define PyArray_GETPTR3(obj, i, j, k) ((void *)(PyArray_BYTES(obj) + \
|
||||
(i)*PyArray_STRIDES(obj)[0] + \
|
||||
(j)*PyArray_STRIDES(obj)[1] + \
|
||||
(k)*PyArray_STRIDES(obj)[2]))
|
||||
|
||||
#define PyArray_GETPTR4(obj, i, j, k, l) ((void *)(PyArray_BYTES(obj) + \
|
||||
(i)*PyArray_STRIDES(obj)[0] + \
|
||||
(j)*PyArray_STRIDES(obj)[1] + \
|
||||
(k)*PyArray_STRIDES(obj)[2] + \
|
||||
(l)*PyArray_STRIDES(obj)[3]))
|
||||
|
||||
static inline void
|
||||
PyArray_DiscardWritebackIfCopy(PyArrayObject *arr)
|
||||
{
|
||||
PyArrayObject_fields *fa = (PyArrayObject_fields *)arr;
|
||||
if (fa && fa->base) {
|
||||
if (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY) {
|
||||
PyArray_ENABLEFLAGS((PyArrayObject*)fa->base, NPY_ARRAY_WRITEABLE);
|
||||
Py_DECREF(fa->base);
|
||||
fa->base = NULL;
|
||||
PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEBACKIFCOPY);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define PyArray_DESCR_REPLACE(descr) do { \
|
||||
PyArray_Descr *_new_; \
|
||||
_new_ = PyArray_DescrNew(descr); \
|
||||
Py_XDECREF(descr); \
|
||||
descr = _new_; \
|
||||
} while(0)
|
||||
|
||||
/* Copy should always return contiguous array */
|
||||
#define PyArray_Copy(obj) PyArray_NewCopy(obj, NPY_CORDER)
|
||||
|
||||
#define PyArray_FromObject(op, type, min_depth, max_depth) \
|
||||
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
|
||||
max_depth, NPY_ARRAY_BEHAVED | \
|
||||
NPY_ARRAY_ENSUREARRAY, NULL)
|
||||
|
||||
#define PyArray_ContiguousFromObject(op, type, min_depth, max_depth) \
|
||||
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
|
||||
max_depth, NPY_ARRAY_DEFAULT | \
|
||||
NPY_ARRAY_ENSUREARRAY, NULL)
|
||||
|
||||
#define PyArray_CopyFromObject(op, type, min_depth, max_depth) \
|
||||
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
|
||||
max_depth, NPY_ARRAY_ENSURECOPY | \
|
||||
NPY_ARRAY_DEFAULT | \
|
||||
NPY_ARRAY_ENSUREARRAY, NULL)
|
||||
|
||||
#define PyArray_Cast(mp, type_num) \
|
||||
PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0)
|
||||
|
||||
#define PyArray_Take(ap, items, axis) \
|
||||
PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE)
|
||||
|
||||
#define PyArray_Put(ap, items, values) \
|
||||
PyArray_PutTo(ap, items, values, NPY_RAISE)
|
||||
|
||||
/* Compatibility with old Numeric stuff -- don't use in new code */
|
||||
|
||||
#define PyArray_FromDimsAndData(nd, d, type, data) \
|
||||
PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type), \
|
||||
data)
|
||||
|
||||
|
||||
/*
|
||||
Check to see if this key in the dictionary is the "title"
|
||||
entry of the tuple (i.e. a duplicate dictionary entry in the fields
|
||||
dict).
|
||||
*/
|
||||
|
||||
static inline int
|
||||
NPY_TITLE_KEY_check(PyObject *key, PyObject *value)
|
||||
{
|
||||
PyObject *title;
|
||||
if (PyTuple_Size(value) != 3) {
|
||||
return 0;
|
||||
}
|
||||
title = PyTuple_GetItem(value, 2);
|
||||
if (key == title) {
|
||||
return 1;
|
||||
}
|
||||
#ifdef PYPY_VERSION
|
||||
/*
|
||||
* On PyPy, dictionary keys do not always preserve object identity.
|
||||
* Fall back to comparison by value.
|
||||
*/
|
||||
if (PyUnicode_Check(title) && PyUnicode_Check(key)) {
|
||||
return PyUnicode_Compare(title, key) == 0 ? 1 : 0;
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Macro, for backward compat with "if NPY_TITLE_KEY(key, value) { ..." */
|
||||
#define NPY_TITLE_KEY(key, value) (NPY_TITLE_KEY_check((key), (value)))
|
||||
|
||||
#define DEPRECATE(msg) PyErr_WarnEx(PyExc_DeprecationWarning,msg,1)
|
||||
#define DEPRECATE_FUTUREWARNING(msg) PyErr_WarnEx(PyExc_FutureWarning,msg,1)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NDARRAYOBJECT_H_ */
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,211 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NOPREFIX_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NOPREFIX_H_
|
||||
|
||||
/*
|
||||
* You can directly include noprefix.h as a backward
|
||||
* compatibility measure
|
||||
*/
|
||||
#ifndef NPY_NO_PREFIX
|
||||
#include "ndarrayobject.h"
|
||||
#include "npy_interrupt.h"
|
||||
#endif
|
||||
|
||||
#define SIGSETJMP NPY_SIGSETJMP
|
||||
#define SIGLONGJMP NPY_SIGLONGJMP
|
||||
#define SIGJMP_BUF NPY_SIGJMP_BUF
|
||||
|
||||
#define MAX_DIMS NPY_MAXDIMS
|
||||
|
||||
#define longlong npy_longlong
|
||||
#define ulonglong npy_ulonglong
|
||||
#define Bool npy_bool
|
||||
#define longdouble npy_longdouble
|
||||
#define byte npy_byte
|
||||
|
||||
#ifndef _BSD_SOURCE
|
||||
#define ushort npy_ushort
|
||||
#define uint npy_uint
|
||||
#define ulong npy_ulong
|
||||
#endif
|
||||
|
||||
#define ubyte npy_ubyte
|
||||
#define ushort npy_ushort
|
||||
#define uint npy_uint
|
||||
#define ulong npy_ulong
|
||||
#define cfloat npy_cfloat
|
||||
#define cdouble npy_cdouble
|
||||
#define clongdouble npy_clongdouble
|
||||
#define Int8 npy_int8
|
||||
#define UInt8 npy_uint8
|
||||
#define Int16 npy_int16
|
||||
#define UInt16 npy_uint16
|
||||
#define Int32 npy_int32
|
||||
#define UInt32 npy_uint32
|
||||
#define Int64 npy_int64
|
||||
#define UInt64 npy_uint64
|
||||
#define Int128 npy_int128
|
||||
#define UInt128 npy_uint128
|
||||
#define Int256 npy_int256
|
||||
#define UInt256 npy_uint256
|
||||
#define Float16 npy_float16
|
||||
#define Complex32 npy_complex32
|
||||
#define Float32 npy_float32
|
||||
#define Complex64 npy_complex64
|
||||
#define Float64 npy_float64
|
||||
#define Complex128 npy_complex128
|
||||
#define Float80 npy_float80
|
||||
#define Complex160 npy_complex160
|
||||
#define Float96 npy_float96
|
||||
#define Complex192 npy_complex192
|
||||
#define Float128 npy_float128
|
||||
#define Complex256 npy_complex256
|
||||
#define intp npy_intp
|
||||
#define uintp npy_uintp
|
||||
#define datetime npy_datetime
|
||||
#define timedelta npy_timedelta
|
||||
|
||||
#define SIZEOF_LONGLONG NPY_SIZEOF_LONGLONG
|
||||
#define SIZEOF_INTP NPY_SIZEOF_INTP
|
||||
#define SIZEOF_UINTP NPY_SIZEOF_UINTP
|
||||
#define SIZEOF_HALF NPY_SIZEOF_HALF
|
||||
#define SIZEOF_LONGDOUBLE NPY_SIZEOF_LONGDOUBLE
|
||||
#define SIZEOF_DATETIME NPY_SIZEOF_DATETIME
|
||||
#define SIZEOF_TIMEDELTA NPY_SIZEOF_TIMEDELTA
|
||||
|
||||
#define LONGLONG_FMT NPY_LONGLONG_FMT
|
||||
#define ULONGLONG_FMT NPY_ULONGLONG_FMT
|
||||
#define LONGLONG_SUFFIX NPY_LONGLONG_SUFFIX
|
||||
#define ULONGLONG_SUFFIX NPY_ULONGLONG_SUFFIX
|
||||
|
||||
#define MAX_INT8 127
|
||||
#define MIN_INT8 -128
|
||||
#define MAX_UINT8 255
|
||||
#define MAX_INT16 32767
|
||||
#define MIN_INT16 -32768
|
||||
#define MAX_UINT16 65535
|
||||
#define MAX_INT32 2147483647
|
||||
#define MIN_INT32 (-MAX_INT32 - 1)
|
||||
#define MAX_UINT32 4294967295U
|
||||
#define MAX_INT64 LONGLONG_SUFFIX(9223372036854775807)
|
||||
#define MIN_INT64 (-MAX_INT64 - LONGLONG_SUFFIX(1))
|
||||
#define MAX_UINT64 ULONGLONG_SUFFIX(18446744073709551615)
|
||||
#define MAX_INT128 LONGLONG_SUFFIX(85070591730234615865843651857942052864)
|
||||
#define MIN_INT128 (-MAX_INT128 - LONGLONG_SUFFIX(1))
|
||||
#define MAX_UINT128 ULONGLONG_SUFFIX(170141183460469231731687303715884105728)
|
||||
#define MAX_INT256 LONGLONG_SUFFIX(57896044618658097711785492504343953926634992332820282019728792003956564819967)
|
||||
#define MIN_INT256 (-MAX_INT256 - LONGLONG_SUFFIX(1))
|
||||
#define MAX_UINT256 ULONGLONG_SUFFIX(115792089237316195423570985008687907853269984665640564039457584007913129639935)
|
||||
|
||||
#define MAX_BYTE NPY_MAX_BYTE
|
||||
#define MIN_BYTE NPY_MIN_BYTE
|
||||
#define MAX_UBYTE NPY_MAX_UBYTE
|
||||
#define MAX_SHORT NPY_MAX_SHORT
|
||||
#define MIN_SHORT NPY_MIN_SHORT
|
||||
#define MAX_USHORT NPY_MAX_USHORT
|
||||
#define MAX_INT NPY_MAX_INT
|
||||
#define MIN_INT NPY_MIN_INT
|
||||
#define MAX_UINT NPY_MAX_UINT
|
||||
#define MAX_LONG NPY_MAX_LONG
|
||||
#define MIN_LONG NPY_MIN_LONG
|
||||
#define MAX_ULONG NPY_MAX_ULONG
|
||||
#define MAX_LONGLONG NPY_MAX_LONGLONG
|
||||
#define MIN_LONGLONG NPY_MIN_LONGLONG
|
||||
#define MAX_ULONGLONG NPY_MAX_ULONGLONG
|
||||
#define MIN_DATETIME NPY_MIN_DATETIME
|
||||
#define MAX_DATETIME NPY_MAX_DATETIME
|
||||
#define MIN_TIMEDELTA NPY_MIN_TIMEDELTA
|
||||
#define MAX_TIMEDELTA NPY_MAX_TIMEDELTA
|
||||
|
||||
#define BITSOF_BOOL NPY_BITSOF_BOOL
|
||||
#define BITSOF_CHAR NPY_BITSOF_CHAR
|
||||
#define BITSOF_SHORT NPY_BITSOF_SHORT
|
||||
#define BITSOF_INT NPY_BITSOF_INT
|
||||
#define BITSOF_LONG NPY_BITSOF_LONG
|
||||
#define BITSOF_LONGLONG NPY_BITSOF_LONGLONG
|
||||
#define BITSOF_HALF NPY_BITSOF_HALF
|
||||
#define BITSOF_FLOAT NPY_BITSOF_FLOAT
|
||||
#define BITSOF_DOUBLE NPY_BITSOF_DOUBLE
|
||||
#define BITSOF_LONGDOUBLE NPY_BITSOF_LONGDOUBLE
|
||||
#define BITSOF_DATETIME NPY_BITSOF_DATETIME
|
||||
#define BITSOF_TIMEDELTA NPY_BITSOF_TIMEDELTA
|
||||
|
||||
#define _pya_malloc PyArray_malloc
|
||||
#define _pya_free PyArray_free
|
||||
#define _pya_realloc PyArray_realloc
|
||||
|
||||
#define BEGIN_THREADS_DEF NPY_BEGIN_THREADS_DEF
|
||||
#define BEGIN_THREADS NPY_BEGIN_THREADS
|
||||
#define END_THREADS NPY_END_THREADS
|
||||
#define ALLOW_C_API_DEF NPY_ALLOW_C_API_DEF
|
||||
#define ALLOW_C_API NPY_ALLOW_C_API
|
||||
#define DISABLE_C_API NPY_DISABLE_C_API
|
||||
|
||||
#define PY_FAIL NPY_FAIL
|
||||
#define PY_SUCCEED NPY_SUCCEED
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE NPY_TRUE
|
||||
#endif
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE NPY_FALSE
|
||||
#endif
|
||||
|
||||
#define LONGDOUBLE_FMT NPY_LONGDOUBLE_FMT
|
||||
|
||||
#define CONTIGUOUS NPY_CONTIGUOUS
|
||||
#define C_CONTIGUOUS NPY_C_CONTIGUOUS
|
||||
#define FORTRAN NPY_FORTRAN
|
||||
#define F_CONTIGUOUS NPY_F_CONTIGUOUS
|
||||
#define OWNDATA NPY_OWNDATA
|
||||
#define FORCECAST NPY_FORCECAST
|
||||
#define ENSURECOPY NPY_ENSURECOPY
|
||||
#define ENSUREARRAY NPY_ENSUREARRAY
|
||||
#define ELEMENTSTRIDES NPY_ELEMENTSTRIDES
|
||||
#define ALIGNED NPY_ALIGNED
|
||||
#define NOTSWAPPED NPY_NOTSWAPPED
|
||||
#define WRITEABLE NPY_WRITEABLE
|
||||
#define WRITEBACKIFCOPY NPY_ARRAY_WRITEBACKIFCOPY
|
||||
#define ARR_HAS_DESCR NPY_ARR_HAS_DESCR
|
||||
#define BEHAVED NPY_BEHAVED
|
||||
#define BEHAVED_NS NPY_BEHAVED_NS
|
||||
#define CARRAY NPY_CARRAY
|
||||
#define CARRAY_RO NPY_CARRAY_RO
|
||||
#define FARRAY NPY_FARRAY
|
||||
#define FARRAY_RO NPY_FARRAY_RO
|
||||
#define DEFAULT NPY_DEFAULT
|
||||
#define IN_ARRAY NPY_IN_ARRAY
|
||||
#define OUT_ARRAY NPY_OUT_ARRAY
|
||||
#define INOUT_ARRAY NPY_INOUT_ARRAY
|
||||
#define IN_FARRAY NPY_IN_FARRAY
|
||||
#define OUT_FARRAY NPY_OUT_FARRAY
|
||||
#define INOUT_FARRAY NPY_INOUT_FARRAY
|
||||
#define UPDATE_ALL NPY_UPDATE_ALL
|
||||
|
||||
#define OWN_DATA NPY_OWNDATA
|
||||
#define BEHAVED_FLAGS NPY_BEHAVED
|
||||
#define BEHAVED_FLAGS_NS NPY_BEHAVED_NS
|
||||
#define CARRAY_FLAGS_RO NPY_CARRAY_RO
|
||||
#define CARRAY_FLAGS NPY_CARRAY
|
||||
#define FARRAY_FLAGS NPY_FARRAY
|
||||
#define FARRAY_FLAGS_RO NPY_FARRAY_RO
|
||||
#define DEFAULT_FLAGS NPY_DEFAULT
|
||||
#define UPDATE_ALL_FLAGS NPY_UPDATE_ALL_FLAGS
|
||||
|
||||
#ifndef MIN
|
||||
#define MIN PyArray_MIN
|
||||
#endif
|
||||
#ifndef MAX
|
||||
#define MAX PyArray_MAX
|
||||
#endif
|
||||
#define MAX_INTP NPY_MAX_INTP
|
||||
#define MIN_INTP NPY_MIN_INTP
|
||||
#define MAX_UINTP NPY_MAX_UINTP
|
||||
#define INTP_FMT NPY_INTP_FMT
|
||||
|
||||
#ifndef PYPY_VERSION
|
||||
#define REFCOUNT PyArray_REFCOUNT
|
||||
#define MAX_ELSIZE NPY_MAX_ELSIZE
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NOPREFIX_H_ */
|
@@ -0,0 +1,124 @@
|
||||
#ifndef NPY_DEPRECATED_INCLUDES
|
||||
#error "Should never include npy_*_*_deprecated_api directly."
|
||||
#endif
|
||||
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_
|
||||
|
||||
/* Emit a warning if the user did not specifically request the old API */
|
||||
#ifndef NPY_NO_DEPRECATED_API
|
||||
#if defined(_WIN32)
|
||||
#define _WARN___STR2__(x) #x
|
||||
#define _WARN___STR1__(x) _WARN___STR2__(x)
|
||||
#define _WARN___LOC__ __FILE__ "(" _WARN___STR1__(__LINE__) ") : Warning Msg: "
|
||||
#pragma message(_WARN___LOC__"Using deprecated NumPy API, disable it with " \
|
||||
"#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION")
|
||||
#else
|
||||
#warning "Using deprecated NumPy API, disable it with " \
|
||||
"#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This header exists to collect all dangerous/deprecated NumPy API
|
||||
* as of NumPy 1.7.
|
||||
*
|
||||
* This is an attempt to remove bad API, the proliferation of macros,
|
||||
* and namespace pollution currently produced by the NumPy headers.
|
||||
*/
|
||||
|
||||
/* These array flags are deprecated as of NumPy 1.7 */
|
||||
#define NPY_CONTIGUOUS NPY_ARRAY_C_CONTIGUOUS
|
||||
#define NPY_FORTRAN NPY_ARRAY_F_CONTIGUOUS
|
||||
|
||||
/*
|
||||
* The consistent NPY_ARRAY_* names which don't pollute the NPY_*
|
||||
* namespace were added in NumPy 1.7.
|
||||
*
|
||||
* These versions of the carray flags are deprecated, but
|
||||
* probably should only be removed after two releases instead of one.
|
||||
*/
|
||||
#define NPY_C_CONTIGUOUS NPY_ARRAY_C_CONTIGUOUS
|
||||
#define NPY_F_CONTIGUOUS NPY_ARRAY_F_CONTIGUOUS
|
||||
#define NPY_OWNDATA NPY_ARRAY_OWNDATA
|
||||
#define NPY_FORCECAST NPY_ARRAY_FORCECAST
|
||||
#define NPY_ENSURECOPY NPY_ARRAY_ENSURECOPY
|
||||
#define NPY_ENSUREARRAY NPY_ARRAY_ENSUREARRAY
|
||||
#define NPY_ELEMENTSTRIDES NPY_ARRAY_ELEMENTSTRIDES
|
||||
#define NPY_ALIGNED NPY_ARRAY_ALIGNED
|
||||
#define NPY_NOTSWAPPED NPY_ARRAY_NOTSWAPPED
|
||||
#define NPY_WRITEABLE NPY_ARRAY_WRITEABLE
|
||||
#define NPY_BEHAVED NPY_ARRAY_BEHAVED
|
||||
#define NPY_BEHAVED_NS NPY_ARRAY_BEHAVED_NS
|
||||
#define NPY_CARRAY NPY_ARRAY_CARRAY
|
||||
#define NPY_CARRAY_RO NPY_ARRAY_CARRAY_RO
|
||||
#define NPY_FARRAY NPY_ARRAY_FARRAY
|
||||
#define NPY_FARRAY_RO NPY_ARRAY_FARRAY_RO
|
||||
#define NPY_DEFAULT NPY_ARRAY_DEFAULT
|
||||
#define NPY_IN_ARRAY NPY_ARRAY_IN_ARRAY
|
||||
#define NPY_OUT_ARRAY NPY_ARRAY_OUT_ARRAY
|
||||
#define NPY_INOUT_ARRAY NPY_ARRAY_INOUT_ARRAY
|
||||
#define NPY_IN_FARRAY NPY_ARRAY_IN_FARRAY
|
||||
#define NPY_OUT_FARRAY NPY_ARRAY_OUT_FARRAY
|
||||
#define NPY_INOUT_FARRAY NPY_ARRAY_INOUT_FARRAY
|
||||
#define NPY_UPDATE_ALL NPY_ARRAY_UPDATE_ALL
|
||||
|
||||
/* This way of accessing the default type is deprecated as of NumPy 1.7 */
|
||||
#define PyArray_DEFAULT NPY_DEFAULT_TYPE
|
||||
|
||||
/* These DATETIME bits aren't used internally */
|
||||
#define PyDataType_GetDatetimeMetaData(descr) \
|
||||
((descr->metadata == NULL) ? NULL : \
|
||||
((PyArray_DatetimeMetaData *)(PyCapsule_GetPointer( \
|
||||
PyDict_GetItemString( \
|
||||
descr->metadata, NPY_METADATA_DTSTR), NULL))))
|
||||
|
||||
/*
|
||||
* Deprecated as of NumPy 1.7, this kind of shortcut doesn't
|
||||
* belong in the public API.
|
||||
*/
|
||||
#define NPY_AO PyArrayObject
|
||||
|
||||
/*
|
||||
* Deprecated as of NumPy 1.7, an all-lowercase macro doesn't
|
||||
* belong in the public API.
|
||||
*/
|
||||
#define fortran fortran_
|
||||
|
||||
/*
|
||||
* Deprecated as of NumPy 1.7, as it is a namespace-polluting
|
||||
* macro.
|
||||
*/
|
||||
#define FORTRAN_IF PyArray_FORTRAN_IF
|
||||
|
||||
/* Deprecated as of NumPy 1.7, datetime64 uses c_metadata instead */
|
||||
#define NPY_METADATA_DTSTR "__timeunit__"
|
||||
|
||||
/*
|
||||
* Deprecated as of NumPy 1.7.
|
||||
* The reasoning:
|
||||
* - These are for datetime, but there's no datetime "namespace".
|
||||
* - They just turn NPY_STR_<x> into "<x>", which is just
|
||||
* making something simple be indirected.
|
||||
*/
|
||||
#define NPY_STR_Y "Y"
|
||||
#define NPY_STR_M "M"
|
||||
#define NPY_STR_W "W"
|
||||
#define NPY_STR_D "D"
|
||||
#define NPY_STR_h "h"
|
||||
#define NPY_STR_m "m"
|
||||
#define NPY_STR_s "s"
|
||||
#define NPY_STR_ms "ms"
|
||||
#define NPY_STR_us "us"
|
||||
#define NPY_STR_ns "ns"
|
||||
#define NPY_STR_ps "ps"
|
||||
#define NPY_STR_fs "fs"
|
||||
#define NPY_STR_as "as"
|
||||
|
||||
/*
|
||||
* The macros in old_defines.h are Deprecated as of NumPy 1.7 and will be
|
||||
* removed in the next major release.
|
||||
*/
|
||||
#include "old_defines.h"
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_ */
|
@@ -0,0 +1,595 @@
|
||||
/*
|
||||
* This is a convenience header file providing compatibility utilities
|
||||
* for supporting different minor versions of Python 3.
|
||||
* It was originally used to support the transition from Python 2,
|
||||
* hence the "3k" naming.
|
||||
*
|
||||
* If you want to use this for your own projects, it's recommended to make a
|
||||
* copy of it. Although the stuff below is unlikely to change, we don't provide
|
||||
* strong backwards compatibility guarantees at the moment.
|
||||
*/
|
||||
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_
|
||||
|
||||
#include <Python.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef NPY_PY3K
|
||||
#define NPY_PY3K 1
|
||||
#endif
|
||||
|
||||
#include "numpy/npy_common.h"
|
||||
#include "numpy/ndarrayobject.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* PyInt -> PyLong
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* This is a renamed copy of the Python non-limited API function _PyLong_AsInt. It is
|
||||
* included here because it is missing from the PyPy API. It completes the PyLong_As*
|
||||
* group of functions and can be useful in replacing PyInt_Check.
|
||||
*/
|
||||
static inline int
|
||||
Npy__PyLong_AsInt(PyObject *obj)
|
||||
{
|
||||
int overflow;
|
||||
long result = PyLong_AsLongAndOverflow(obj, &overflow);
|
||||
|
||||
/* INT_MAX and INT_MIN are defined in Python.h */
|
||||
if (overflow || result > INT_MAX || result < INT_MIN) {
|
||||
/* XXX: could be cute and give a different
|
||||
message for overflow == -1 */
|
||||
PyErr_SetString(PyExc_OverflowError,
|
||||
"Python int too large to convert to C int");
|
||||
return -1;
|
||||
}
|
||||
return (int)result;
|
||||
}
|
||||
|
||||
|
||||
#if defined(NPY_PY3K)
|
||||
/* Return True only if the long fits in a C long */
|
||||
static inline int PyInt_Check(PyObject *op) {
|
||||
int overflow = 0;
|
||||
if (!PyLong_Check(op)) {
|
||||
return 0;
|
||||
}
|
||||
PyLong_AsLongAndOverflow(op, &overflow);
|
||||
return (overflow == 0);
|
||||
}
|
||||
|
||||
|
||||
#define PyInt_FromLong PyLong_FromLong
|
||||
#define PyInt_AsLong PyLong_AsLong
|
||||
#define PyInt_AS_LONG PyLong_AsLong
|
||||
#define PyInt_AsSsize_t PyLong_AsSsize_t
|
||||
#define PyNumber_Int PyNumber_Long
|
||||
|
||||
/* NOTE:
|
||||
*
|
||||
* Since the PyLong type is very different from the fixed-range PyInt,
|
||||
* we don't define PyInt_Type -> PyLong_Type.
|
||||
*/
|
||||
#endif /* NPY_PY3K */
|
||||
|
||||
/* Py3 changes PySlice_GetIndicesEx' first argument's type to PyObject* */
|
||||
#ifdef NPY_PY3K
|
||||
# define NpySlice_GetIndicesEx PySlice_GetIndicesEx
|
||||
#else
|
||||
# define NpySlice_GetIndicesEx(op, nop, start, end, step, slicelength) \
|
||||
PySlice_GetIndicesEx((PySliceObject *)op, nop, start, end, step, slicelength)
|
||||
#endif
|
||||
|
||||
#if PY_VERSION_HEX < 0x030900a4
|
||||
/* Introduced in https://github.com/python/cpython/commit/d2ec81a8c99796b51fb8c49b77a7fe369863226f */
|
||||
#define Py_SET_TYPE(obj, type) ((Py_TYPE(obj) = (type)), (void)0)
|
||||
/* Introduced in https://github.com/python/cpython/commit/b10dc3e7a11fcdb97e285882eba6da92594f90f9 */
|
||||
#define Py_SET_SIZE(obj, size) ((Py_SIZE(obj) = (size)), (void)0)
|
||||
/* Introduced in https://github.com/python/cpython/commit/c86a11221df7e37da389f9c6ce6e47ea22dc44ff */
|
||||
#define Py_SET_REFCNT(obj, refcnt) ((Py_REFCNT(obj) = (refcnt)), (void)0)
|
||||
#endif
|
||||
|
||||
|
||||
#define Npy_EnterRecursiveCall(x) Py_EnterRecursiveCall(x)
|
||||
|
||||
/*
|
||||
* PyString -> PyBytes
|
||||
*/
|
||||
|
||||
#if defined(NPY_PY3K)
|
||||
|
||||
#define PyString_Type PyBytes_Type
|
||||
#define PyString_Check PyBytes_Check
|
||||
#define PyStringObject PyBytesObject
|
||||
#define PyString_FromString PyBytes_FromString
|
||||
#define PyString_FromStringAndSize PyBytes_FromStringAndSize
|
||||
#define PyString_AS_STRING PyBytes_AS_STRING
|
||||
#define PyString_AsStringAndSize PyBytes_AsStringAndSize
|
||||
#define PyString_FromFormat PyBytes_FromFormat
|
||||
#define PyString_Concat PyBytes_Concat
|
||||
#define PyString_ConcatAndDel PyBytes_ConcatAndDel
|
||||
#define PyString_AsString PyBytes_AsString
|
||||
#define PyString_GET_SIZE PyBytes_GET_SIZE
|
||||
#define PyString_Size PyBytes_Size
|
||||
|
||||
#define PyUString_Type PyUnicode_Type
|
||||
#define PyUString_Check PyUnicode_Check
|
||||
#define PyUStringObject PyUnicodeObject
|
||||
#define PyUString_FromString PyUnicode_FromString
|
||||
#define PyUString_FromStringAndSize PyUnicode_FromStringAndSize
|
||||
#define PyUString_FromFormat PyUnicode_FromFormat
|
||||
#define PyUString_Concat PyUnicode_Concat2
|
||||
#define PyUString_ConcatAndDel PyUnicode_ConcatAndDel
|
||||
#define PyUString_GET_SIZE PyUnicode_GET_SIZE
|
||||
#define PyUString_Size PyUnicode_Size
|
||||
#define PyUString_InternFromString PyUnicode_InternFromString
|
||||
#define PyUString_Format PyUnicode_Format
|
||||
|
||||
#define PyBaseString_Check(obj) (PyUnicode_Check(obj))
|
||||
|
||||
#else
|
||||
|
||||
#define PyBytes_Type PyString_Type
|
||||
#define PyBytes_Check PyString_Check
|
||||
#define PyBytesObject PyStringObject
|
||||
#define PyBytes_FromString PyString_FromString
|
||||
#define PyBytes_FromStringAndSize PyString_FromStringAndSize
|
||||
#define PyBytes_AS_STRING PyString_AS_STRING
|
||||
#define PyBytes_AsStringAndSize PyString_AsStringAndSize
|
||||
#define PyBytes_FromFormat PyString_FromFormat
|
||||
#define PyBytes_Concat PyString_Concat
|
||||
#define PyBytes_ConcatAndDel PyString_ConcatAndDel
|
||||
#define PyBytes_AsString PyString_AsString
|
||||
#define PyBytes_GET_SIZE PyString_GET_SIZE
|
||||
#define PyBytes_Size PyString_Size
|
||||
|
||||
#define PyUString_Type PyString_Type
|
||||
#define PyUString_Check PyString_Check
|
||||
#define PyUStringObject PyStringObject
|
||||
#define PyUString_FromString PyString_FromString
|
||||
#define PyUString_FromStringAndSize PyString_FromStringAndSize
|
||||
#define PyUString_FromFormat PyString_FromFormat
|
||||
#define PyUString_Concat PyString_Concat
|
||||
#define PyUString_ConcatAndDel PyString_ConcatAndDel
|
||||
#define PyUString_GET_SIZE PyString_GET_SIZE
|
||||
#define PyUString_Size PyString_Size
|
||||
#define PyUString_InternFromString PyString_InternFromString
|
||||
#define PyUString_Format PyString_Format
|
||||
|
||||
#define PyBaseString_Check(obj) (PyBytes_Check(obj) || PyUnicode_Check(obj))
|
||||
|
||||
#endif /* NPY_PY3K */
|
||||
|
||||
/*
|
||||
* Macros to protect CRT calls against instant termination when passed an
|
||||
* invalid parameter (https://bugs.python.org/issue23524).
|
||||
*/
|
||||
#if defined _MSC_VER && _MSC_VER >= 1900
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler;
|
||||
#define NPY_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \
|
||||
_set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler);
|
||||
#define NPY_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); }
|
||||
|
||||
#else
|
||||
|
||||
#define NPY_BEGIN_SUPPRESS_IPH
|
||||
#define NPY_END_SUPPRESS_IPH
|
||||
|
||||
#endif /* _MSC_VER >= 1900 */
|
||||
|
||||
|
||||
static inline void
|
||||
PyUnicode_ConcatAndDel(PyObject **left, PyObject *right)
|
||||
{
|
||||
Py_SETREF(*left, PyUnicode_Concat(*left, right));
|
||||
Py_DECREF(right);
|
||||
}
|
||||
|
||||
static inline void
|
||||
PyUnicode_Concat2(PyObject **left, PyObject *right)
|
||||
{
|
||||
Py_SETREF(*left, PyUnicode_Concat(*left, right));
|
||||
}
|
||||
|
||||
/*
|
||||
* PyFile_* compatibility
|
||||
*/
|
||||
|
||||
/*
|
||||
* Get a FILE* handle to the file represented by the Python object
|
||||
*/
|
||||
static inline FILE*
|
||||
npy_PyFile_Dup2(PyObject *file, char *mode, npy_off_t *orig_pos)
|
||||
{
|
||||
int fd, fd2, unbuf;
|
||||
Py_ssize_t fd2_tmp;
|
||||
PyObject *ret, *os, *io, *io_raw;
|
||||
npy_off_t pos;
|
||||
FILE *handle;
|
||||
|
||||
/* For Python 2 PyFileObject, use PyFile_AsFile */
|
||||
#if !defined(NPY_PY3K)
|
||||
if (PyFile_Check(file)) {
|
||||
return PyFile_AsFile(file);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Flush first to ensure things end up in the file in the correct order */
|
||||
ret = PyObject_CallMethod(file, "flush", "");
|
||||
if (ret == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
Py_DECREF(ret);
|
||||
fd = PyObject_AsFileDescriptor(file);
|
||||
if (fd == -1) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* The handle needs to be dup'd because we have to call fclose
|
||||
* at the end
|
||||
*/
|
||||
os = PyImport_ImportModule("os");
|
||||
if (os == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
ret = PyObject_CallMethod(os, "dup", "i", fd);
|
||||
Py_DECREF(os);
|
||||
if (ret == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
fd2_tmp = PyNumber_AsSsize_t(ret, PyExc_IOError);
|
||||
Py_DECREF(ret);
|
||||
if (fd2_tmp == -1 && PyErr_Occurred()) {
|
||||
return NULL;
|
||||
}
|
||||
if (fd2_tmp < INT_MIN || fd2_tmp > INT_MAX) {
|
||||
PyErr_SetString(PyExc_IOError,
|
||||
"Getting an 'int' from os.dup() failed");
|
||||
return NULL;
|
||||
}
|
||||
fd2 = (int)fd2_tmp;
|
||||
|
||||
/* Convert to FILE* handle */
|
||||
#ifdef _WIN32
|
||||
NPY_BEGIN_SUPPRESS_IPH
|
||||
handle = _fdopen(fd2, mode);
|
||||
NPY_END_SUPPRESS_IPH
|
||||
#else
|
||||
handle = fdopen(fd2, mode);
|
||||
#endif
|
||||
if (handle == NULL) {
|
||||
PyErr_SetString(PyExc_IOError,
|
||||
"Getting a FILE* from a Python file object via "
|
||||
"_fdopen failed. If you built NumPy, you probably "
|
||||
"linked with the wrong debug/release runtime");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Record the original raw file handle position */
|
||||
*orig_pos = npy_ftell(handle);
|
||||
if (*orig_pos == -1) {
|
||||
/* The io module is needed to determine if buffering is used */
|
||||
io = PyImport_ImportModule("io");
|
||||
if (io == NULL) {
|
||||
fclose(handle);
|
||||
return NULL;
|
||||
}
|
||||
/* File object instances of RawIOBase are unbuffered */
|
||||
io_raw = PyObject_GetAttrString(io, "RawIOBase");
|
||||
Py_DECREF(io);
|
||||
if (io_raw == NULL) {
|
||||
fclose(handle);
|
||||
return NULL;
|
||||
}
|
||||
unbuf = PyObject_IsInstance(file, io_raw);
|
||||
Py_DECREF(io_raw);
|
||||
if (unbuf == 1) {
|
||||
/* Succeed if the IO is unbuffered */
|
||||
return handle;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_IOError, "obtaining file position failed");
|
||||
fclose(handle);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Seek raw handle to the Python-side position */
|
||||
ret = PyObject_CallMethod(file, "tell", "");
|
||||
if (ret == NULL) {
|
||||
fclose(handle);
|
||||
return NULL;
|
||||
}
|
||||
pos = PyLong_AsLongLong(ret);
|
||||
Py_DECREF(ret);
|
||||
if (PyErr_Occurred()) {
|
||||
fclose(handle);
|
||||
return NULL;
|
||||
}
|
||||
if (npy_fseek(handle, pos, SEEK_SET) == -1) {
|
||||
PyErr_SetString(PyExc_IOError, "seeking file failed");
|
||||
fclose(handle);
|
||||
return NULL;
|
||||
}
|
||||
return handle;
|
||||
}
|
||||
|
||||
/*
|
||||
* Close the dup-ed file handle, and seek the Python one to the current position
|
||||
*/
|
||||
static inline int
|
||||
npy_PyFile_DupClose2(PyObject *file, FILE* handle, npy_off_t orig_pos)
|
||||
{
|
||||
int fd, unbuf;
|
||||
PyObject *ret, *io, *io_raw;
|
||||
npy_off_t position;
|
||||
|
||||
/* For Python 2 PyFileObject, do nothing */
|
||||
#if !defined(NPY_PY3K)
|
||||
if (PyFile_Check(file)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
position = npy_ftell(handle);
|
||||
|
||||
/* Close the FILE* handle */
|
||||
fclose(handle);
|
||||
|
||||
/*
|
||||
* Restore original file handle position, in order to not confuse
|
||||
* Python-side data structures
|
||||
*/
|
||||
fd = PyObject_AsFileDescriptor(file);
|
||||
if (fd == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (npy_lseek(fd, orig_pos, SEEK_SET) == -1) {
|
||||
|
||||
/* The io module is needed to determine if buffering is used */
|
||||
io = PyImport_ImportModule("io");
|
||||
if (io == NULL) {
|
||||
return -1;
|
||||
}
|
||||
/* File object instances of RawIOBase are unbuffered */
|
||||
io_raw = PyObject_GetAttrString(io, "RawIOBase");
|
||||
Py_DECREF(io);
|
||||
if (io_raw == NULL) {
|
||||
return -1;
|
||||
}
|
||||
unbuf = PyObject_IsInstance(file, io_raw);
|
||||
Py_DECREF(io_raw);
|
||||
if (unbuf == 1) {
|
||||
/* Succeed if the IO is unbuffered */
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_IOError, "seeking file failed");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (position == -1) {
|
||||
PyErr_SetString(PyExc_IOError, "obtaining file position failed");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Seek Python-side handle to the FILE* handle position */
|
||||
ret = PyObject_CallMethod(file, "seek", NPY_OFF_T_PYFMT "i", position, 0);
|
||||
if (ret == NULL) {
|
||||
return -1;
|
||||
}
|
||||
Py_DECREF(ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int
|
||||
npy_PyFile_Check(PyObject *file)
|
||||
{
|
||||
int fd;
|
||||
/* For Python 2, check if it is a PyFileObject */
|
||||
#if !defined(NPY_PY3K)
|
||||
if (PyFile_Check(file)) {
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
fd = PyObject_AsFileDescriptor(file);
|
||||
if (fd == -1) {
|
||||
PyErr_Clear();
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline PyObject*
|
||||
npy_PyFile_OpenFile(PyObject *filename, const char *mode)
|
||||
{
|
||||
PyObject *open;
|
||||
open = PyDict_GetItemString(PyEval_GetBuiltins(), "open");
|
||||
if (open == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
return PyObject_CallFunction(open, "Os", filename, mode);
|
||||
}
|
||||
|
||||
static inline int
|
||||
npy_PyFile_CloseFile(PyObject *file)
|
||||
{
|
||||
PyObject *ret;
|
||||
|
||||
ret = PyObject_CallMethod(file, "close", NULL);
|
||||
if (ret == NULL) {
|
||||
return -1;
|
||||
}
|
||||
Py_DECREF(ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* This is a copy of _PyErr_ChainExceptions
|
||||
*/
|
||||
static inline void
|
||||
npy_PyErr_ChainExceptions(PyObject *exc, PyObject *val, PyObject *tb)
|
||||
{
|
||||
if (exc == NULL)
|
||||
return;
|
||||
|
||||
if (PyErr_Occurred()) {
|
||||
/* only py3 supports this anyway */
|
||||
#ifdef NPY_PY3K
|
||||
PyObject *exc2, *val2, *tb2;
|
||||
PyErr_Fetch(&exc2, &val2, &tb2);
|
||||
PyErr_NormalizeException(&exc, &val, &tb);
|
||||
if (tb != NULL) {
|
||||
PyException_SetTraceback(val, tb);
|
||||
Py_DECREF(tb);
|
||||
}
|
||||
Py_DECREF(exc);
|
||||
PyErr_NormalizeException(&exc2, &val2, &tb2);
|
||||
PyException_SetContext(val2, val);
|
||||
PyErr_Restore(exc2, val2, tb2);
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
PyErr_Restore(exc, val, tb);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* This is a copy of _PyErr_ChainExceptions, with:
|
||||
* - a minimal implementation for python 2
|
||||
* - __cause__ used instead of __context__
|
||||
*/
|
||||
static inline void
|
||||
npy_PyErr_ChainExceptionsCause(PyObject *exc, PyObject *val, PyObject *tb)
|
||||
{
|
||||
if (exc == NULL)
|
||||
return;
|
||||
|
||||
if (PyErr_Occurred()) {
|
||||
/* only py3 supports this anyway */
|
||||
#ifdef NPY_PY3K
|
||||
PyObject *exc2, *val2, *tb2;
|
||||
PyErr_Fetch(&exc2, &val2, &tb2);
|
||||
PyErr_NormalizeException(&exc, &val, &tb);
|
||||
if (tb != NULL) {
|
||||
PyException_SetTraceback(val, tb);
|
||||
Py_DECREF(tb);
|
||||
}
|
||||
Py_DECREF(exc);
|
||||
PyErr_NormalizeException(&exc2, &val2, &tb2);
|
||||
PyException_SetCause(val2, val);
|
||||
PyErr_Restore(exc2, val2, tb2);
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
PyErr_Restore(exc, val, tb);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* PyObject_Cmp
|
||||
*/
|
||||
#if defined(NPY_PY3K)
|
||||
static inline int
|
||||
PyObject_Cmp(PyObject *i1, PyObject *i2, int *cmp)
|
||||
{
|
||||
int v;
|
||||
v = PyObject_RichCompareBool(i1, i2, Py_LT);
|
||||
if (v == 1) {
|
||||
*cmp = -1;
|
||||
return 1;
|
||||
}
|
||||
else if (v == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
v = PyObject_RichCompareBool(i1, i2, Py_GT);
|
||||
if (v == 1) {
|
||||
*cmp = 1;
|
||||
return 1;
|
||||
}
|
||||
else if (v == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
v = PyObject_RichCompareBool(i1, i2, Py_EQ);
|
||||
if (v == 1) {
|
||||
*cmp = 0;
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
*cmp = 0;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* PyCObject functions adapted to PyCapsules.
|
||||
*
|
||||
* The main job here is to get rid of the improved error handling
|
||||
* of PyCapsules. It's a shame...
|
||||
*/
|
||||
static inline PyObject *
|
||||
NpyCapsule_FromVoidPtr(void *ptr, void (*dtor)(PyObject *))
|
||||
{
|
||||
PyObject *ret = PyCapsule_New(ptr, NULL, dtor);
|
||||
if (ret == NULL) {
|
||||
PyErr_Clear();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline PyObject *
|
||||
NpyCapsule_FromVoidPtrAndDesc(void *ptr, void* context, void (*dtor)(PyObject *))
|
||||
{
|
||||
PyObject *ret = NpyCapsule_FromVoidPtr(ptr, dtor);
|
||||
if (ret != NULL && PyCapsule_SetContext(ret, context) != 0) {
|
||||
PyErr_Clear();
|
||||
Py_DECREF(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void *
|
||||
NpyCapsule_AsVoidPtr(PyObject *obj)
|
||||
{
|
||||
void *ret = PyCapsule_GetPointer(obj, NULL);
|
||||
if (ret == NULL) {
|
||||
PyErr_Clear();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void *
|
||||
NpyCapsule_GetDesc(PyObject *obj)
|
||||
{
|
||||
return PyCapsule_GetContext(obj);
|
||||
}
|
||||
|
||||
static inline int
|
||||
NpyCapsule_Check(PyObject *ptr)
|
||||
{
|
||||
return PyCapsule_CheckExact(ptr);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_ */
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,129 @@
|
||||
/*
|
||||
* This set (target) cpu specific macros:
|
||||
* - Possible values:
|
||||
* NPY_CPU_X86
|
||||
* NPY_CPU_AMD64
|
||||
* NPY_CPU_PPC
|
||||
* NPY_CPU_PPC64
|
||||
* NPY_CPU_PPC64LE
|
||||
* NPY_CPU_SPARC
|
||||
* NPY_CPU_S390
|
||||
* NPY_CPU_IA64
|
||||
* NPY_CPU_HPPA
|
||||
* NPY_CPU_ALPHA
|
||||
* NPY_CPU_ARMEL
|
||||
* NPY_CPU_ARMEB
|
||||
* NPY_CPU_SH_LE
|
||||
* NPY_CPU_SH_BE
|
||||
* NPY_CPU_ARCEL
|
||||
* NPY_CPU_ARCEB
|
||||
* NPY_CPU_RISCV64
|
||||
* NPY_CPU_LOONGARCH
|
||||
* NPY_CPU_WASM
|
||||
*/
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_CPU_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_CPU_H_
|
||||
|
||||
#include "numpyconfig.h"
|
||||
|
||||
#if defined( __i386__ ) || defined(i386) || defined(_M_IX86)
|
||||
/*
|
||||
* __i386__ is defined by gcc and Intel compiler on Linux,
|
||||
* _M_IX86 by VS compiler,
|
||||
* i386 by Sun compilers on opensolaris at least
|
||||
*/
|
||||
#define NPY_CPU_X86
|
||||
#elif defined(__x86_64__) || defined(__amd64__) || defined(__x86_64) || defined(_M_AMD64)
|
||||
/*
|
||||
* both __x86_64__ and __amd64__ are defined by gcc
|
||||
* __x86_64 defined by sun compiler on opensolaris at least
|
||||
* _M_AMD64 defined by MS compiler
|
||||
*/
|
||||
#define NPY_CPU_AMD64
|
||||
#elif defined(__powerpc64__) && defined(__LITTLE_ENDIAN__)
|
||||
#define NPY_CPU_PPC64LE
|
||||
#elif defined(__powerpc64__) && defined(__BIG_ENDIAN__)
|
||||
#define NPY_CPU_PPC64
|
||||
#elif defined(__ppc__) || defined(__powerpc__) || defined(_ARCH_PPC)
|
||||
/*
|
||||
* __ppc__ is defined by gcc, I remember having seen __powerpc__ once,
|
||||
* but can't find it ATM
|
||||
* _ARCH_PPC is used by at least gcc on AIX
|
||||
* As __powerpc__ and _ARCH_PPC are also defined by PPC64 check
|
||||
* for those specifically first before defaulting to ppc
|
||||
*/
|
||||
#define NPY_CPU_PPC
|
||||
#elif defined(__sparc__) || defined(__sparc)
|
||||
/* __sparc__ is defined by gcc and Forte (e.g. Sun) compilers */
|
||||
#define NPY_CPU_SPARC
|
||||
#elif defined(__s390__)
|
||||
#define NPY_CPU_S390
|
||||
#elif defined(__ia64)
|
||||
#define NPY_CPU_IA64
|
||||
#elif defined(__hppa)
|
||||
#define NPY_CPU_HPPA
|
||||
#elif defined(__alpha__)
|
||||
#define NPY_CPU_ALPHA
|
||||
#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64)
|
||||
/* _M_ARM64 is defined in MSVC for ARM64 compilation on Windows */
|
||||
#if defined(__ARMEB__) || defined(__AARCH64EB__)
|
||||
#if defined(__ARM_32BIT_STATE)
|
||||
#define NPY_CPU_ARMEB_AARCH32
|
||||
#elif defined(__ARM_64BIT_STATE)
|
||||
#define NPY_CPU_ARMEB_AARCH64
|
||||
#else
|
||||
#define NPY_CPU_ARMEB
|
||||
#endif
|
||||
#elif defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64)
|
||||
#if defined(__ARM_32BIT_STATE)
|
||||
#define NPY_CPU_ARMEL_AARCH32
|
||||
#elif defined(__ARM_64BIT_STATE) || defined(_M_ARM64) || defined(__AARCH64EL__)
|
||||
#define NPY_CPU_ARMEL_AARCH64
|
||||
#else
|
||||
#define NPY_CPU_ARMEL
|
||||
#endif
|
||||
#else
|
||||
# error Unknown ARM CPU, please report this to numpy maintainers with \
|
||||
information about your platform (OS, CPU and compiler)
|
||||
#endif
|
||||
#elif defined(__sh__) && defined(__LITTLE_ENDIAN__)
|
||||
#define NPY_CPU_SH_LE
|
||||
#elif defined(__sh__) && defined(__BIG_ENDIAN__)
|
||||
#define NPY_CPU_SH_BE
|
||||
#elif defined(__MIPSEL__)
|
||||
#define NPY_CPU_MIPSEL
|
||||
#elif defined(__MIPSEB__)
|
||||
#define NPY_CPU_MIPSEB
|
||||
#elif defined(__or1k__)
|
||||
#define NPY_CPU_OR1K
|
||||
#elif defined(__mc68000__)
|
||||
#define NPY_CPU_M68K
|
||||
#elif defined(__arc__) && defined(__LITTLE_ENDIAN__)
|
||||
#define NPY_CPU_ARCEL
|
||||
#elif defined(__arc__) && defined(__BIG_ENDIAN__)
|
||||
#define NPY_CPU_ARCEB
|
||||
#elif defined(__riscv) && defined(__riscv_xlen) && __riscv_xlen == 64
|
||||
#define NPY_CPU_RISCV64
|
||||
#elif defined(__loongarch__)
|
||||
#define NPY_CPU_LOONGARCH
|
||||
#elif defined(__EMSCRIPTEN__)
|
||||
/* __EMSCRIPTEN__ is defined by emscripten: an LLVM-to-Web compiler */
|
||||
#define NPY_CPU_WASM
|
||||
#else
|
||||
#error Unknown CPU, please report this to numpy maintainers with \
|
||||
information about your platform (OS, CPU and compiler)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Except for the following architectures, memory access is limited to the natural
|
||||
* alignment of data types otherwise it may lead to bus error or performance regression.
|
||||
* For more details about unaligned access, see https://www.kernel.org/doc/Documentation/unaligned-memory-access.txt.
|
||||
*/
|
||||
#if defined(NPY_CPU_X86) || defined(NPY_CPU_AMD64) || defined(__aarch64__) || defined(__powerpc64__)
|
||||
#define NPY_ALIGNMENT_REQUIRED 0
|
||||
#endif
|
||||
#ifndef NPY_ALIGNMENT_REQUIRED
|
||||
#define NPY_ALIGNMENT_REQUIRED 1
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_CPU_H_ */
|
@@ -0,0 +1,77 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_ENDIAN_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_ENDIAN_H_
|
||||
|
||||
/*
|
||||
* NPY_BYTE_ORDER is set to the same value as BYTE_ORDER set by glibc in
|
||||
* endian.h
|
||||
*/
|
||||
|
||||
#if defined(NPY_HAVE_ENDIAN_H) || defined(NPY_HAVE_SYS_ENDIAN_H)
|
||||
/* Use endian.h if available */
|
||||
|
||||
#if defined(NPY_HAVE_ENDIAN_H)
|
||||
#include <endian.h>
|
||||
#elif defined(NPY_HAVE_SYS_ENDIAN_H)
|
||||
#include <sys/endian.h>
|
||||
#endif
|
||||
|
||||
#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && defined(LITTLE_ENDIAN)
|
||||
#define NPY_BYTE_ORDER BYTE_ORDER
|
||||
#define NPY_LITTLE_ENDIAN LITTLE_ENDIAN
|
||||
#define NPY_BIG_ENDIAN BIG_ENDIAN
|
||||
#elif defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && defined(_LITTLE_ENDIAN)
|
||||
#define NPY_BYTE_ORDER _BYTE_ORDER
|
||||
#define NPY_LITTLE_ENDIAN _LITTLE_ENDIAN
|
||||
#define NPY_BIG_ENDIAN _BIG_ENDIAN
|
||||
#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN)
|
||||
#define NPY_BYTE_ORDER __BYTE_ORDER
|
||||
#define NPY_LITTLE_ENDIAN __LITTLE_ENDIAN
|
||||
#define NPY_BIG_ENDIAN __BIG_ENDIAN
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef NPY_BYTE_ORDER
|
||||
/* Set endianness info using target CPU */
|
||||
#include "npy_cpu.h"
|
||||
|
||||
#define NPY_LITTLE_ENDIAN 1234
|
||||
#define NPY_BIG_ENDIAN 4321
|
||||
|
||||
#if defined(NPY_CPU_X86) \
|
||||
|| defined(NPY_CPU_AMD64) \
|
||||
|| defined(NPY_CPU_IA64) \
|
||||
|| defined(NPY_CPU_ALPHA) \
|
||||
|| defined(NPY_CPU_ARMEL) \
|
||||
|| defined(NPY_CPU_ARMEL_AARCH32) \
|
||||
|| defined(NPY_CPU_ARMEL_AARCH64) \
|
||||
|| defined(NPY_CPU_SH_LE) \
|
||||
|| defined(NPY_CPU_MIPSEL) \
|
||||
|| defined(NPY_CPU_PPC64LE) \
|
||||
|| defined(NPY_CPU_ARCEL) \
|
||||
|| defined(NPY_CPU_RISCV64) \
|
||||
|| defined(NPY_CPU_LOONGARCH) \
|
||||
|| defined(NPY_CPU_WASM)
|
||||
#define NPY_BYTE_ORDER NPY_LITTLE_ENDIAN
|
||||
|
||||
#elif defined(NPY_CPU_PPC) \
|
||||
|| defined(NPY_CPU_SPARC) \
|
||||
|| defined(NPY_CPU_S390) \
|
||||
|| defined(NPY_CPU_HPPA) \
|
||||
|| defined(NPY_CPU_PPC64) \
|
||||
|| defined(NPY_CPU_ARMEB) \
|
||||
|| defined(NPY_CPU_ARMEB_AARCH32) \
|
||||
|| defined(NPY_CPU_ARMEB_AARCH64) \
|
||||
|| defined(NPY_CPU_SH_BE) \
|
||||
|| defined(NPY_CPU_MIPSEB) \
|
||||
|| defined(NPY_CPU_OR1K) \
|
||||
|| defined(NPY_CPU_M68K) \
|
||||
|| defined(NPY_CPU_ARCEB)
|
||||
#define NPY_BYTE_ORDER NPY_BIG_ENDIAN
|
||||
|
||||
#else
|
||||
#error Unknown CPU: can not set endianness
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_ENDIAN_H_ */
|
@@ -0,0 +1,56 @@
|
||||
/*
|
||||
* This API is only provided because it is part of publicly exported
|
||||
* headers. Its use is considered DEPRECATED, and it will be removed
|
||||
* eventually.
|
||||
* (This includes the _PyArray_SigintHandler and _PyArray_GetSigintBuf
|
||||
* functions which are however, public API, and not headers.)
|
||||
*
|
||||
* Instead of using these non-threadsafe macros consider periodically
|
||||
* querying `PyErr_CheckSignals()` or `PyOS_InterruptOccurred()` will work.
|
||||
* Both of these require holding the GIL, although cpython could add a
|
||||
* version of `PyOS_InterruptOccurred()` which does not. Such a version
|
||||
* actually exists as private API in Python 3.10, and backported to 3.9 and 3.8,
|
||||
* see also https://bugs.python.org/issue41037 and
|
||||
* https://github.com/python/cpython/pull/20599).
|
||||
*/
|
||||
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_INTERRUPT_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_INTERRUPT_H_
|
||||
|
||||
#ifndef NPY_NO_SIGNAL
|
||||
|
||||
#include <setjmp.h>
|
||||
#include <signal.h>
|
||||
|
||||
#ifndef sigsetjmp
|
||||
|
||||
#define NPY_SIGSETJMP(arg1, arg2) setjmp(arg1)
|
||||
#define NPY_SIGLONGJMP(arg1, arg2) longjmp(arg1, arg2)
|
||||
#define NPY_SIGJMP_BUF jmp_buf
|
||||
|
||||
#else
|
||||
|
||||
#define NPY_SIGSETJMP(arg1, arg2) sigsetjmp(arg1, arg2)
|
||||
#define NPY_SIGLONGJMP(arg1, arg2) siglongjmp(arg1, arg2)
|
||||
#define NPY_SIGJMP_BUF sigjmp_buf
|
||||
|
||||
#endif
|
||||
|
||||
# define NPY_SIGINT_ON { \
|
||||
PyOS_sighandler_t _npy_sig_save; \
|
||||
_npy_sig_save = PyOS_setsig(SIGINT, _PyArray_SigintHandler); \
|
||||
if (NPY_SIGSETJMP(*((NPY_SIGJMP_BUF *)_PyArray_GetSigintBuf()), \
|
||||
1) == 0) { \
|
||||
|
||||
# define NPY_SIGINT_OFF } \
|
||||
PyOS_setsig(SIGINT, _npy_sig_save); \
|
||||
}
|
||||
|
||||
#else /* NPY_NO_SIGNAL */
|
||||
|
||||
#define NPY_SIGINT_ON
|
||||
#define NPY_SIGINT_OFF
|
||||
|
||||
#endif /* HAVE_SIGSETJMP */
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_INTERRUPT_H_ */
|
@@ -0,0 +1,563 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_
|
||||
|
||||
#include <numpy/npy_common.h>
|
||||
|
||||
#include <math.h>
|
||||
|
||||
/* By adding static inline specifiers to npy_math function definitions when
|
||||
appropriate, compiler is given the opportunity to optimize */
|
||||
#if NPY_INLINE_MATH
|
||||
#define NPY_INPLACE static inline
|
||||
#else
|
||||
#define NPY_INPLACE
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* NAN and INFINITY like macros (same behavior as glibc for NAN, same as C99
|
||||
* for INFINITY)
|
||||
*
|
||||
* XXX: I should test whether INFINITY and NAN are available on the platform
|
||||
*/
|
||||
static inline float __npy_inff(void)
|
||||
{
|
||||
const union { npy_uint32 __i; float __f;} __bint = {0x7f800000UL};
|
||||
return __bint.__f;
|
||||
}
|
||||
|
||||
static inline float __npy_nanf(void)
|
||||
{
|
||||
const union { npy_uint32 __i; float __f;} __bint = {0x7fc00000UL};
|
||||
return __bint.__f;
|
||||
}
|
||||
|
||||
static inline float __npy_pzerof(void)
|
||||
{
|
||||
const union { npy_uint32 __i; float __f;} __bint = {0x00000000UL};
|
||||
return __bint.__f;
|
||||
}
|
||||
|
||||
static inline float __npy_nzerof(void)
|
||||
{
|
||||
const union { npy_uint32 __i; float __f;} __bint = {0x80000000UL};
|
||||
return __bint.__f;
|
||||
}
|
||||
|
||||
#define NPY_INFINITYF __npy_inff()
|
||||
#define NPY_NANF __npy_nanf()
|
||||
#define NPY_PZEROF __npy_pzerof()
|
||||
#define NPY_NZEROF __npy_nzerof()
|
||||
|
||||
#define NPY_INFINITY ((npy_double)NPY_INFINITYF)
|
||||
#define NPY_NAN ((npy_double)NPY_NANF)
|
||||
#define NPY_PZERO ((npy_double)NPY_PZEROF)
|
||||
#define NPY_NZERO ((npy_double)NPY_NZEROF)
|
||||
|
||||
#define NPY_INFINITYL ((npy_longdouble)NPY_INFINITYF)
|
||||
#define NPY_NANL ((npy_longdouble)NPY_NANF)
|
||||
#define NPY_PZEROL ((npy_longdouble)NPY_PZEROF)
|
||||
#define NPY_NZEROL ((npy_longdouble)NPY_NZEROF)
|
||||
|
||||
/*
|
||||
* Useful constants
|
||||
*/
|
||||
#define NPY_E 2.718281828459045235360287471352662498 /* e */
|
||||
#define NPY_LOG2E 1.442695040888963407359924681001892137 /* log_2 e */
|
||||
#define NPY_LOG10E 0.434294481903251827651128918916605082 /* log_10 e */
|
||||
#define NPY_LOGE2 0.693147180559945309417232121458176568 /* log_e 2 */
|
||||
#define NPY_LOGE10 2.302585092994045684017991454684364208 /* log_e 10 */
|
||||
#define NPY_PI 3.141592653589793238462643383279502884 /* pi */
|
||||
#define NPY_PI_2 1.570796326794896619231321691639751442 /* pi/2 */
|
||||
#define NPY_PI_4 0.785398163397448309615660845819875721 /* pi/4 */
|
||||
#define NPY_1_PI 0.318309886183790671537767526745028724 /* 1/pi */
|
||||
#define NPY_2_PI 0.636619772367581343075535053490057448 /* 2/pi */
|
||||
#define NPY_EULER 0.577215664901532860606512090082402431 /* Euler constant */
|
||||
#define NPY_SQRT2 1.414213562373095048801688724209698079 /* sqrt(2) */
|
||||
#define NPY_SQRT1_2 0.707106781186547524400844362104849039 /* 1/sqrt(2) */
|
||||
|
||||
#define NPY_Ef 2.718281828459045235360287471352662498F /* e */
|
||||
#define NPY_LOG2Ef 1.442695040888963407359924681001892137F /* log_2 e */
|
||||
#define NPY_LOG10Ef 0.434294481903251827651128918916605082F /* log_10 e */
|
||||
#define NPY_LOGE2f 0.693147180559945309417232121458176568F /* log_e 2 */
|
||||
#define NPY_LOGE10f 2.302585092994045684017991454684364208F /* log_e 10 */
|
||||
#define NPY_PIf 3.141592653589793238462643383279502884F /* pi */
|
||||
#define NPY_PI_2f 1.570796326794896619231321691639751442F /* pi/2 */
|
||||
#define NPY_PI_4f 0.785398163397448309615660845819875721F /* pi/4 */
|
||||
#define NPY_1_PIf 0.318309886183790671537767526745028724F /* 1/pi */
|
||||
#define NPY_2_PIf 0.636619772367581343075535053490057448F /* 2/pi */
|
||||
#define NPY_EULERf 0.577215664901532860606512090082402431F /* Euler constant */
|
||||
#define NPY_SQRT2f 1.414213562373095048801688724209698079F /* sqrt(2) */
|
||||
#define NPY_SQRT1_2f 0.707106781186547524400844362104849039F /* 1/sqrt(2) */
|
||||
|
||||
#define NPY_El 2.718281828459045235360287471352662498L /* e */
|
||||
#define NPY_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
|
||||
#define NPY_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
|
||||
#define NPY_LOGE2l 0.693147180559945309417232121458176568L /* log_e 2 */
|
||||
#define NPY_LOGE10l 2.302585092994045684017991454684364208L /* log_e 10 */
|
||||
#define NPY_PIl 3.141592653589793238462643383279502884L /* pi */
|
||||
#define NPY_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
|
||||
#define NPY_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
|
||||
#define NPY_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
|
||||
#define NPY_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
|
||||
#define NPY_EULERl 0.577215664901532860606512090082402431L /* Euler constant */
|
||||
#define NPY_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
|
||||
#define NPY_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
|
||||
|
||||
/*
|
||||
* Integer functions.
|
||||
*/
|
||||
NPY_INPLACE npy_uint npy_gcdu(npy_uint a, npy_uint b);
|
||||
NPY_INPLACE npy_uint npy_lcmu(npy_uint a, npy_uint b);
|
||||
NPY_INPLACE npy_ulong npy_gcdul(npy_ulong a, npy_ulong b);
|
||||
NPY_INPLACE npy_ulong npy_lcmul(npy_ulong a, npy_ulong b);
|
||||
NPY_INPLACE npy_ulonglong npy_gcdull(npy_ulonglong a, npy_ulonglong b);
|
||||
NPY_INPLACE npy_ulonglong npy_lcmull(npy_ulonglong a, npy_ulonglong b);
|
||||
|
||||
NPY_INPLACE npy_int npy_gcd(npy_int a, npy_int b);
|
||||
NPY_INPLACE npy_int npy_lcm(npy_int a, npy_int b);
|
||||
NPY_INPLACE npy_long npy_gcdl(npy_long a, npy_long b);
|
||||
NPY_INPLACE npy_long npy_lcml(npy_long a, npy_long b);
|
||||
NPY_INPLACE npy_longlong npy_gcdll(npy_longlong a, npy_longlong b);
|
||||
NPY_INPLACE npy_longlong npy_lcmll(npy_longlong a, npy_longlong b);
|
||||
|
||||
NPY_INPLACE npy_ubyte npy_rshiftuhh(npy_ubyte a, npy_ubyte b);
|
||||
NPY_INPLACE npy_ubyte npy_lshiftuhh(npy_ubyte a, npy_ubyte b);
|
||||
NPY_INPLACE npy_ushort npy_rshiftuh(npy_ushort a, npy_ushort b);
|
||||
NPY_INPLACE npy_ushort npy_lshiftuh(npy_ushort a, npy_ushort b);
|
||||
NPY_INPLACE npy_uint npy_rshiftu(npy_uint a, npy_uint b);
|
||||
NPY_INPLACE npy_uint npy_lshiftu(npy_uint a, npy_uint b);
|
||||
NPY_INPLACE npy_ulong npy_rshiftul(npy_ulong a, npy_ulong b);
|
||||
NPY_INPLACE npy_ulong npy_lshiftul(npy_ulong a, npy_ulong b);
|
||||
NPY_INPLACE npy_ulonglong npy_rshiftull(npy_ulonglong a, npy_ulonglong b);
|
||||
NPY_INPLACE npy_ulonglong npy_lshiftull(npy_ulonglong a, npy_ulonglong b);
|
||||
|
||||
NPY_INPLACE npy_byte npy_rshifthh(npy_byte a, npy_byte b);
|
||||
NPY_INPLACE npy_byte npy_lshifthh(npy_byte a, npy_byte b);
|
||||
NPY_INPLACE npy_short npy_rshifth(npy_short a, npy_short b);
|
||||
NPY_INPLACE npy_short npy_lshifth(npy_short a, npy_short b);
|
||||
NPY_INPLACE npy_int npy_rshift(npy_int a, npy_int b);
|
||||
NPY_INPLACE npy_int npy_lshift(npy_int a, npy_int b);
|
||||
NPY_INPLACE npy_long npy_rshiftl(npy_long a, npy_long b);
|
||||
NPY_INPLACE npy_long npy_lshiftl(npy_long a, npy_long b);
|
||||
NPY_INPLACE npy_longlong npy_rshiftll(npy_longlong a, npy_longlong b);
|
||||
NPY_INPLACE npy_longlong npy_lshiftll(npy_longlong a, npy_longlong b);
|
||||
|
||||
NPY_INPLACE uint8_t npy_popcountuhh(npy_ubyte a);
|
||||
NPY_INPLACE uint8_t npy_popcountuh(npy_ushort a);
|
||||
NPY_INPLACE uint8_t npy_popcountu(npy_uint a);
|
||||
NPY_INPLACE uint8_t npy_popcountul(npy_ulong a);
|
||||
NPY_INPLACE uint8_t npy_popcountull(npy_ulonglong a);
|
||||
NPY_INPLACE uint8_t npy_popcounthh(npy_byte a);
|
||||
NPY_INPLACE uint8_t npy_popcounth(npy_short a);
|
||||
NPY_INPLACE uint8_t npy_popcount(npy_int a);
|
||||
NPY_INPLACE uint8_t npy_popcountl(npy_long a);
|
||||
NPY_INPLACE uint8_t npy_popcountll(npy_longlong a);
|
||||
|
||||
/*
|
||||
* C99 double math funcs that need fixups or are blocklist-able
|
||||
*/
|
||||
NPY_INPLACE double npy_sin(double x);
|
||||
NPY_INPLACE double npy_cos(double x);
|
||||
NPY_INPLACE double npy_tan(double x);
|
||||
NPY_INPLACE double npy_hypot(double x, double y);
|
||||
NPY_INPLACE double npy_log2(double x);
|
||||
NPY_INPLACE double npy_atan2(double x, double y);
|
||||
|
||||
/* Mandatory C99 double math funcs, no blocklisting or fixups */
|
||||
/* defined for legacy reasons, should be deprecated at some point */
|
||||
#define npy_sinh sinh
|
||||
#define npy_cosh cosh
|
||||
#define npy_tanh tanh
|
||||
#define npy_asin asin
|
||||
#define npy_acos acos
|
||||
#define npy_atan atan
|
||||
#define npy_log log
|
||||
#define npy_log10 log10
|
||||
#define npy_cbrt cbrt
|
||||
#define npy_fabs fabs
|
||||
#define npy_ceil ceil
|
||||
#define npy_fmod fmod
|
||||
#define npy_floor floor
|
||||
#define npy_expm1 expm1
|
||||
#define npy_log1p log1p
|
||||
#define npy_acosh acosh
|
||||
#define npy_asinh asinh
|
||||
#define npy_atanh atanh
|
||||
#define npy_rint rint
|
||||
#define npy_trunc trunc
|
||||
#define npy_exp2 exp2
|
||||
#define npy_frexp frexp
|
||||
#define npy_ldexp ldexp
|
||||
#define npy_copysign copysign
|
||||
#define npy_exp exp
|
||||
#define npy_sqrt sqrt
|
||||
#define npy_pow pow
|
||||
#define npy_modf modf
|
||||
#define npy_nextafter nextafter
|
||||
|
||||
double npy_spacing(double x);
|
||||
|
||||
/*
|
||||
* IEEE 754 fpu handling
|
||||
*/
|
||||
|
||||
/* use builtins to avoid function calls in tight loops
|
||||
* only available if npy_config.h is available (= numpys own build) */
|
||||
#ifdef HAVE___BUILTIN_ISNAN
|
||||
#define npy_isnan(x) __builtin_isnan(x)
|
||||
#else
|
||||
#define npy_isnan(x) isnan(x)
|
||||
#endif
|
||||
|
||||
|
||||
/* only available if npy_config.h is available (= numpys own build) */
|
||||
#ifdef HAVE___BUILTIN_ISFINITE
|
||||
#define npy_isfinite(x) __builtin_isfinite(x)
|
||||
#else
|
||||
#define npy_isfinite(x) isfinite((x))
|
||||
#endif
|
||||
|
||||
/* only available if npy_config.h is available (= numpys own build) */
|
||||
#ifdef HAVE___BUILTIN_ISINF
|
||||
#define npy_isinf(x) __builtin_isinf(x)
|
||||
#else
|
||||
#define npy_isinf(x) isinf((x))
|
||||
#endif
|
||||
|
||||
#define npy_signbit(x) signbit((x))
|
||||
|
||||
/*
|
||||
* float C99 math funcs that need fixups or are blocklist-able
|
||||
*/
|
||||
NPY_INPLACE float npy_sinf(float x);
|
||||
NPY_INPLACE float npy_cosf(float x);
|
||||
NPY_INPLACE float npy_tanf(float x);
|
||||
NPY_INPLACE float npy_expf(float x);
|
||||
NPY_INPLACE float npy_sqrtf(float x);
|
||||
NPY_INPLACE float npy_hypotf(float x, float y);
|
||||
NPY_INPLACE float npy_log2f(float x);
|
||||
NPY_INPLACE float npy_atan2f(float x, float y);
|
||||
NPY_INPLACE float npy_powf(float x, float y);
|
||||
NPY_INPLACE float npy_modff(float x, float* y);
|
||||
|
||||
/* Mandatory C99 float math funcs, no blocklisting or fixups */
|
||||
/* defined for legacy reasons, should be deprecated at some point */
|
||||
|
||||
#define npy_sinhf sinhf
|
||||
#define npy_coshf coshf
|
||||
#define npy_tanhf tanhf
|
||||
#define npy_asinf asinf
|
||||
#define npy_acosf acosf
|
||||
#define npy_atanf atanf
|
||||
#define npy_logf logf
|
||||
#define npy_log10f log10f
|
||||
#define npy_cbrtf cbrtf
|
||||
#define npy_fabsf fabsf
|
||||
#define npy_ceilf ceilf
|
||||
#define npy_fmodf fmodf
|
||||
#define npy_floorf floorf
|
||||
#define npy_expm1f expm1f
|
||||
#define npy_log1pf log1pf
|
||||
#define npy_asinhf asinhf
|
||||
#define npy_acoshf acoshf
|
||||
#define npy_atanhf atanhf
|
||||
#define npy_rintf rintf
|
||||
#define npy_truncf truncf
|
||||
#define npy_exp2f exp2f
|
||||
#define npy_frexpf frexpf
|
||||
#define npy_ldexpf ldexpf
|
||||
#define npy_copysignf copysignf
|
||||
#define npy_nextafterf nextafterf
|
||||
|
||||
float npy_spacingf(float x);
|
||||
|
||||
/*
|
||||
* long double C99 double math funcs that need fixups or are blocklist-able
|
||||
*/
|
||||
NPY_INPLACE npy_longdouble npy_sinl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_cosl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_tanl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_expl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_sqrtl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_hypotl(npy_longdouble x, npy_longdouble y);
|
||||
NPY_INPLACE npy_longdouble npy_log2l(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_atan2l(npy_longdouble x, npy_longdouble y);
|
||||
NPY_INPLACE npy_longdouble npy_powl(npy_longdouble x, npy_longdouble y);
|
||||
NPY_INPLACE npy_longdouble npy_modfl(npy_longdouble x, npy_longdouble* y);
|
||||
|
||||
/* Mandatory C99 double math funcs, no blocklisting or fixups */
|
||||
/* defined for legacy reasons, should be deprecated at some point */
|
||||
#define npy_sinhl sinhl
|
||||
#define npy_coshl coshl
|
||||
#define npy_tanhl tanhl
|
||||
#define npy_fabsl fabsl
|
||||
#define npy_floorl floorl
|
||||
#define npy_ceill ceill
|
||||
#define npy_rintl rintl
|
||||
#define npy_truncl truncl
|
||||
#define npy_cbrtl cbrtl
|
||||
#define npy_log10l log10l
|
||||
#define npy_logl logl
|
||||
#define npy_expm1l expm1l
|
||||
#define npy_asinl asinl
|
||||
#define npy_acosl acosl
|
||||
#define npy_atanl atanl
|
||||
#define npy_asinhl asinhl
|
||||
#define npy_acoshl acoshl
|
||||
#define npy_atanhl atanhl
|
||||
#define npy_log1pl log1pl
|
||||
#define npy_exp2l exp2l
|
||||
#define npy_fmodl fmodl
|
||||
#define npy_frexpl frexpl
|
||||
#define npy_ldexpl ldexpl
|
||||
#define npy_copysignl copysignl
|
||||
#define npy_nextafterl nextafterl
|
||||
|
||||
npy_longdouble npy_spacingl(npy_longdouble x);
|
||||
|
||||
/*
|
||||
* Non standard functions
|
||||
*/
|
||||
NPY_INPLACE double npy_deg2rad(double x);
|
||||
NPY_INPLACE double npy_rad2deg(double x);
|
||||
NPY_INPLACE double npy_logaddexp(double x, double y);
|
||||
NPY_INPLACE double npy_logaddexp2(double x, double y);
|
||||
NPY_INPLACE double npy_divmod(double x, double y, double *modulus);
|
||||
NPY_INPLACE double npy_heaviside(double x, double h0);
|
||||
|
||||
NPY_INPLACE float npy_deg2radf(float x);
|
||||
NPY_INPLACE float npy_rad2degf(float x);
|
||||
NPY_INPLACE float npy_logaddexpf(float x, float y);
|
||||
NPY_INPLACE float npy_logaddexp2f(float x, float y);
|
||||
NPY_INPLACE float npy_divmodf(float x, float y, float *modulus);
|
||||
NPY_INPLACE float npy_heavisidef(float x, float h0);
|
||||
|
||||
NPY_INPLACE npy_longdouble npy_deg2radl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_rad2degl(npy_longdouble x);
|
||||
NPY_INPLACE npy_longdouble npy_logaddexpl(npy_longdouble x, npy_longdouble y);
|
||||
NPY_INPLACE npy_longdouble npy_logaddexp2l(npy_longdouble x, npy_longdouble y);
|
||||
NPY_INPLACE npy_longdouble npy_divmodl(npy_longdouble x, npy_longdouble y,
|
||||
npy_longdouble *modulus);
|
||||
NPY_INPLACE npy_longdouble npy_heavisidel(npy_longdouble x, npy_longdouble h0);
|
||||
|
||||
#define npy_degrees npy_rad2deg
|
||||
#define npy_degreesf npy_rad2degf
|
||||
#define npy_degreesl npy_rad2degl
|
||||
|
||||
#define npy_radians npy_deg2rad
|
||||
#define npy_radiansf npy_deg2radf
|
||||
#define npy_radiansl npy_deg2radl
|
||||
|
||||
/*
|
||||
* Complex declarations
|
||||
*/
|
||||
|
||||
/*
|
||||
* C99 specifies that complex numbers have the same representation as
|
||||
* an array of two elements, where the first element is the real part
|
||||
* and the second element is the imaginary part.
|
||||
*/
|
||||
#define __NPY_CPACK_IMP(x, y, type, ctype) \
|
||||
union { \
|
||||
ctype z; \
|
||||
type a[2]; \
|
||||
} z1; \
|
||||
\
|
||||
z1.a[0] = (x); \
|
||||
z1.a[1] = (y); \
|
||||
\
|
||||
return z1.z;
|
||||
|
||||
static inline npy_cdouble npy_cpack(double x, double y)
|
||||
{
|
||||
__NPY_CPACK_IMP(x, y, double, npy_cdouble);
|
||||
}
|
||||
|
||||
static inline npy_cfloat npy_cpackf(float x, float y)
|
||||
{
|
||||
__NPY_CPACK_IMP(x, y, float, npy_cfloat);
|
||||
}
|
||||
|
||||
static inline npy_clongdouble npy_cpackl(npy_longdouble x, npy_longdouble y)
|
||||
{
|
||||
__NPY_CPACK_IMP(x, y, npy_longdouble, npy_clongdouble);
|
||||
}
|
||||
#undef __NPY_CPACK_IMP
|
||||
|
||||
/*
|
||||
* Same remark as above, but in the other direction: extract first/second
|
||||
* member of complex number, assuming a C99-compatible representation
|
||||
*
|
||||
* Those are defineds as static inline, and such as a reasonable compiler would
|
||||
* most likely compile this to one or two instructions (on CISC at least)
|
||||
*/
|
||||
#define __NPY_CEXTRACT_IMP(z, index, type, ctype) \
|
||||
union { \
|
||||
ctype z; \
|
||||
type a[2]; \
|
||||
} __z_repr; \
|
||||
__z_repr.z = z; \
|
||||
\
|
||||
return __z_repr.a[index];
|
||||
|
||||
static inline double npy_creal(npy_cdouble z)
|
||||
{
|
||||
__NPY_CEXTRACT_IMP(z, 0, double, npy_cdouble);
|
||||
}
|
||||
|
||||
static inline double npy_cimag(npy_cdouble z)
|
||||
{
|
||||
__NPY_CEXTRACT_IMP(z, 1, double, npy_cdouble);
|
||||
}
|
||||
|
||||
static inline float npy_crealf(npy_cfloat z)
|
||||
{
|
||||
__NPY_CEXTRACT_IMP(z, 0, float, npy_cfloat);
|
||||
}
|
||||
|
||||
static inline float npy_cimagf(npy_cfloat z)
|
||||
{
|
||||
__NPY_CEXTRACT_IMP(z, 1, float, npy_cfloat);
|
||||
}
|
||||
|
||||
static inline npy_longdouble npy_creall(npy_clongdouble z)
|
||||
{
|
||||
__NPY_CEXTRACT_IMP(z, 0, npy_longdouble, npy_clongdouble);
|
||||
}
|
||||
|
||||
static inline npy_longdouble npy_cimagl(npy_clongdouble z)
|
||||
{
|
||||
__NPY_CEXTRACT_IMP(z, 1, npy_longdouble, npy_clongdouble);
|
||||
}
|
||||
#undef __NPY_CEXTRACT_IMP
|
||||
|
||||
/*
|
||||
* Double precision complex functions
|
||||
*/
|
||||
double npy_cabs(npy_cdouble z);
|
||||
double npy_carg(npy_cdouble z);
|
||||
|
||||
npy_cdouble npy_cexp(npy_cdouble z);
|
||||
npy_cdouble npy_clog(npy_cdouble z);
|
||||
npy_cdouble npy_cpow(npy_cdouble x, npy_cdouble y);
|
||||
|
||||
npy_cdouble npy_csqrt(npy_cdouble z);
|
||||
|
||||
npy_cdouble npy_ccos(npy_cdouble z);
|
||||
npy_cdouble npy_csin(npy_cdouble z);
|
||||
npy_cdouble npy_ctan(npy_cdouble z);
|
||||
|
||||
npy_cdouble npy_ccosh(npy_cdouble z);
|
||||
npy_cdouble npy_csinh(npy_cdouble z);
|
||||
npy_cdouble npy_ctanh(npy_cdouble z);
|
||||
|
||||
npy_cdouble npy_cacos(npy_cdouble z);
|
||||
npy_cdouble npy_casin(npy_cdouble z);
|
||||
npy_cdouble npy_catan(npy_cdouble z);
|
||||
|
||||
npy_cdouble npy_cacosh(npy_cdouble z);
|
||||
npy_cdouble npy_casinh(npy_cdouble z);
|
||||
npy_cdouble npy_catanh(npy_cdouble z);
|
||||
|
||||
/*
|
||||
* Single precision complex functions
|
||||
*/
|
||||
float npy_cabsf(npy_cfloat z);
|
||||
float npy_cargf(npy_cfloat z);
|
||||
|
||||
npy_cfloat npy_cexpf(npy_cfloat z);
|
||||
npy_cfloat npy_clogf(npy_cfloat z);
|
||||
npy_cfloat npy_cpowf(npy_cfloat x, npy_cfloat y);
|
||||
|
||||
npy_cfloat npy_csqrtf(npy_cfloat z);
|
||||
|
||||
npy_cfloat npy_ccosf(npy_cfloat z);
|
||||
npy_cfloat npy_csinf(npy_cfloat z);
|
||||
npy_cfloat npy_ctanf(npy_cfloat z);
|
||||
|
||||
npy_cfloat npy_ccoshf(npy_cfloat z);
|
||||
npy_cfloat npy_csinhf(npy_cfloat z);
|
||||
npy_cfloat npy_ctanhf(npy_cfloat z);
|
||||
|
||||
npy_cfloat npy_cacosf(npy_cfloat z);
|
||||
npy_cfloat npy_casinf(npy_cfloat z);
|
||||
npy_cfloat npy_catanf(npy_cfloat z);
|
||||
|
||||
npy_cfloat npy_cacoshf(npy_cfloat z);
|
||||
npy_cfloat npy_casinhf(npy_cfloat z);
|
||||
npy_cfloat npy_catanhf(npy_cfloat z);
|
||||
|
||||
|
||||
/*
|
||||
* Extended precision complex functions
|
||||
*/
|
||||
npy_longdouble npy_cabsl(npy_clongdouble z);
|
||||
npy_longdouble npy_cargl(npy_clongdouble z);
|
||||
|
||||
npy_clongdouble npy_cexpl(npy_clongdouble z);
|
||||
npy_clongdouble npy_clogl(npy_clongdouble z);
|
||||
npy_clongdouble npy_cpowl(npy_clongdouble x, npy_clongdouble y);
|
||||
|
||||
npy_clongdouble npy_csqrtl(npy_clongdouble z);
|
||||
|
||||
npy_clongdouble npy_ccosl(npy_clongdouble z);
|
||||
npy_clongdouble npy_csinl(npy_clongdouble z);
|
||||
npy_clongdouble npy_ctanl(npy_clongdouble z);
|
||||
|
||||
npy_clongdouble npy_ccoshl(npy_clongdouble z);
|
||||
npy_clongdouble npy_csinhl(npy_clongdouble z);
|
||||
npy_clongdouble npy_ctanhl(npy_clongdouble z);
|
||||
|
||||
npy_clongdouble npy_cacosl(npy_clongdouble z);
|
||||
npy_clongdouble npy_casinl(npy_clongdouble z);
|
||||
npy_clongdouble npy_catanl(npy_clongdouble z);
|
||||
|
||||
npy_clongdouble npy_cacoshl(npy_clongdouble z);
|
||||
npy_clongdouble npy_casinhl(npy_clongdouble z);
|
||||
npy_clongdouble npy_catanhl(npy_clongdouble z);
|
||||
|
||||
|
||||
/*
|
||||
* Functions that set the floating point error
|
||||
* status word.
|
||||
*/
|
||||
|
||||
/*
|
||||
* platform-dependent code translates floating point
|
||||
* status to an integer sum of these values
|
||||
*/
|
||||
#define NPY_FPE_DIVIDEBYZERO 1
|
||||
#define NPY_FPE_OVERFLOW 2
|
||||
#define NPY_FPE_UNDERFLOW 4
|
||||
#define NPY_FPE_INVALID 8
|
||||
|
||||
int npy_clear_floatstatus_barrier(char*);
|
||||
int npy_get_floatstatus_barrier(char*);
|
||||
/*
|
||||
* use caution with these - clang and gcc8.1 are known to reorder calls
|
||||
* to this form of the function which can defeat the check. The _barrier
|
||||
* form of the call is preferable, where the argument is
|
||||
* (char*)&local_variable
|
||||
*/
|
||||
int npy_clear_floatstatus(void);
|
||||
int npy_get_floatstatus(void);
|
||||
|
||||
void npy_set_floatstatus_divbyzero(void);
|
||||
void npy_set_floatstatus_overflow(void);
|
||||
void npy_set_floatstatus_underflow(void);
|
||||
void npy_set_floatstatus_invalid(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#if NPY_INLINE_MATH
|
||||
#include "npy_math_internal.h"
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_ */
|
@@ -0,0 +1,20 @@
|
||||
/*
|
||||
* This include file is provided for inclusion in Cython *.pyd files where
|
||||
* one would like to define the NPY_NO_DEPRECATED_API macro. It can be
|
||||
* included by
|
||||
*
|
||||
* cdef extern from "npy_no_deprecated_api.h": pass
|
||||
*
|
||||
*/
|
||||
#ifndef NPY_NO_DEPRECATED_API
|
||||
|
||||
/* put this check here since there may be multiple includes in C extensions. */
|
||||
#if defined(NUMPY_CORE_INCLUDE_NUMPY_NDARRAYTYPES_H_) || \
|
||||
defined(NUMPY_CORE_INCLUDE_NUMPY_NPY_DEPRECATED_API_H) || \
|
||||
defined(NUMPY_CORE_INCLUDE_NUMPY_OLD_DEFINES_H_)
|
||||
#error "npy_no_deprecated_api.h" must be first among numpy includes.
|
||||
#else
|
||||
#define NPY_NO_DEPRECATED_API NPY_API_VERSION
|
||||
#endif
|
||||
|
||||
#endif /* NPY_NO_DEPRECATED_API */
|
@@ -0,0 +1,36 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_OS_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_OS_H_
|
||||
|
||||
#if defined(linux) || defined(__linux) || defined(__linux__)
|
||||
#define NPY_OS_LINUX
|
||||
#elif defined(__FreeBSD__) || defined(__NetBSD__) || \
|
||||
defined(__OpenBSD__) || defined(__DragonFly__)
|
||||
#define NPY_OS_BSD
|
||||
#ifdef __FreeBSD__
|
||||
#define NPY_OS_FREEBSD
|
||||
#elif defined(__NetBSD__)
|
||||
#define NPY_OS_NETBSD
|
||||
#elif defined(__OpenBSD__)
|
||||
#define NPY_OS_OPENBSD
|
||||
#elif defined(__DragonFly__)
|
||||
#define NPY_OS_DRAGONFLY
|
||||
#endif
|
||||
#elif defined(sun) || defined(__sun)
|
||||
#define NPY_OS_SOLARIS
|
||||
#elif defined(__CYGWIN__)
|
||||
#define NPY_OS_CYGWIN
|
||||
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
|
||||
#define NPY_OS_WIN32
|
||||
#elif defined(_WIN64) || defined(__WIN64__) || defined(WIN64)
|
||||
#define NPY_OS_WIN64
|
||||
#elif defined(__MINGW32__) || defined(__MINGW64__)
|
||||
#define NPY_OS_MINGW
|
||||
#elif defined(__APPLE__)
|
||||
#define NPY_OS_DARWIN
|
||||
#elif defined(__HAIKU__)
|
||||
#define NPY_OS_HAIKU
|
||||
#else
|
||||
#define NPY_OS_UNKNOWN
|
||||
#endif
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_OS_H_ */
|
@@ -0,0 +1,138 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_
|
||||
|
||||
#include "_numpyconfig.h"
|
||||
|
||||
/*
|
||||
* On Mac OS X, because there is only one configuration stage for all the archs
|
||||
* in universal builds, any macro which depends on the arch needs to be
|
||||
* hardcoded.
|
||||
*
|
||||
* Note that distutils/pip will attempt a universal2 build when Python itself
|
||||
* is built as universal2, hence this hardcoding is needed even if we do not
|
||||
* support universal2 wheels anymore (see gh-22796).
|
||||
* This code block can be removed after we have dropped the setup.py based
|
||||
* build completely.
|
||||
*/
|
||||
#ifdef __APPLE__
|
||||
#undef NPY_SIZEOF_LONG
|
||||
#undef NPY_SIZEOF_PY_INTPTR_T
|
||||
|
||||
#ifdef __LP64__
|
||||
#define NPY_SIZEOF_LONG 8
|
||||
#define NPY_SIZEOF_PY_INTPTR_T 8
|
||||
#else
|
||||
#define NPY_SIZEOF_LONG 4
|
||||
#define NPY_SIZEOF_PY_INTPTR_T 4
|
||||
#endif
|
||||
|
||||
#undef NPY_SIZEOF_LONGDOUBLE
|
||||
#undef NPY_SIZEOF_COMPLEX_LONGDOUBLE
|
||||
#ifdef HAVE_LDOUBLE_IEEE_DOUBLE_LE
|
||||
#undef HAVE_LDOUBLE_IEEE_DOUBLE_LE
|
||||
#endif
|
||||
#ifdef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE
|
||||
#undef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE
|
||||
#endif
|
||||
|
||||
#if defined(__arm64__)
|
||||
#define NPY_SIZEOF_LONGDOUBLE 8
|
||||
#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 16
|
||||
#define HAVE_LDOUBLE_IEEE_DOUBLE_LE 1
|
||||
#elif defined(__x86_64)
|
||||
#define NPY_SIZEOF_LONGDOUBLE 16
|
||||
#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32
|
||||
#define HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE 1
|
||||
#elif defined (__i386)
|
||||
#define NPY_SIZEOF_LONGDOUBLE 12
|
||||
#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 24
|
||||
#elif defined(__ppc__) || defined (__ppc64__)
|
||||
#define NPY_SIZEOF_LONGDOUBLE 16
|
||||
#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32
|
||||
#else
|
||||
#error "unknown architecture"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* To help with both NPY_TARGET_VERSION and the NPY_NO_DEPRECATED_API macro,
|
||||
* we include API version numbers for specific versions of NumPy.
|
||||
* To exclude all API that was deprecated as of 1.7, add the following before
|
||||
* #including any NumPy headers:
|
||||
* #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
|
||||
* The same is true for NPY_TARGET_VERSION, although NumPy will default to
|
||||
* a backwards compatible build anyway.
|
||||
*/
|
||||
#define NPY_1_7_API_VERSION 0x00000007
|
||||
#define NPY_1_8_API_VERSION 0x00000008
|
||||
#define NPY_1_9_API_VERSION 0x00000009
|
||||
#define NPY_1_10_API_VERSION 0x0000000a
|
||||
#define NPY_1_11_API_VERSION 0x0000000a
|
||||
#define NPY_1_12_API_VERSION 0x0000000a
|
||||
#define NPY_1_13_API_VERSION 0x0000000b
|
||||
#define NPY_1_14_API_VERSION 0x0000000c
|
||||
#define NPY_1_15_API_VERSION 0x0000000c
|
||||
#define NPY_1_16_API_VERSION 0x0000000d
|
||||
#define NPY_1_17_API_VERSION 0x0000000d
|
||||
#define NPY_1_18_API_VERSION 0x0000000d
|
||||
#define NPY_1_19_API_VERSION 0x0000000d
|
||||
#define NPY_1_20_API_VERSION 0x0000000e
|
||||
#define NPY_1_21_API_VERSION 0x0000000e
|
||||
#define NPY_1_22_API_VERSION 0x0000000f
|
||||
#define NPY_1_23_API_VERSION 0x00000010
|
||||
#define NPY_1_24_API_VERSION 0x00000010
|
||||
#define NPY_1_25_API_VERSION 0x00000011
|
||||
|
||||
|
||||
/*
|
||||
* Binary compatibility version number. This number is increased
|
||||
* whenever the C-API is changed such that binary compatibility is
|
||||
* broken, i.e. whenever a recompile of extension modules is needed.
|
||||
*/
|
||||
#define NPY_VERSION NPY_ABI_VERSION
|
||||
|
||||
/*
|
||||
* Minor API version we are compiling to be compatible with. The version
|
||||
* Number is always increased when the API changes via: `NPY_API_VERSION`
|
||||
* (and should maybe just track the NumPy version).
|
||||
*
|
||||
* If we have an internal build, we always target the current version of
|
||||
* course.
|
||||
*
|
||||
* For downstream users, we default to an older version to provide them with
|
||||
* maximum compatibility by default. Downstream can choose to extend that
|
||||
* default, or narrow it down if they wish to use newer API. If you adjust
|
||||
* this, consider the Python version support (example for 1.25.x):
|
||||
*
|
||||
* NumPy 1.25.x supports Python: 3.9 3.10 3.11 (3.12)
|
||||
* NumPy 1.19.x supports Python: 3.6 3.7 3.8 3.9
|
||||
* NumPy 1.17.x supports Python: 3.5 3.6 3.7 3.8
|
||||
* NumPy 1.15.x supports Python: ... 3.6 3.7
|
||||
*
|
||||
* Users of the stable ABI may wish to target the last Python that is not
|
||||
* end of life. This would be 3.8 at NumPy 1.25 release time.
|
||||
* 1.17 as default was the choice of oldest-support-numpy at the time and
|
||||
* has in practice no limit (comapared to 1.19). Even earlier becomes legacy.
|
||||
*/
|
||||
#if defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD
|
||||
/* NumPy internal build, always use current version. */
|
||||
#define NPY_FEATURE_VERSION NPY_API_VERSION
|
||||
#elif defined(NPY_TARGET_VERSION) && NPY_TARGET_VERSION
|
||||
/* user provided a target version, use it */
|
||||
#define NPY_FEATURE_VERSION NPY_TARGET_VERSION
|
||||
#else
|
||||
/* Use the default (increase when dropping Python 3.9 support) */
|
||||
#define NPY_FEATURE_VERSION NPY_1_19_API_VERSION
|
||||
#endif
|
||||
|
||||
/* Sanity check the (requested) feature version */
|
||||
#if NPY_FEATURE_VERSION > NPY_API_VERSION
|
||||
#error "NPY_TARGET_VERSION higher than NumPy headers!"
|
||||
#elif NPY_FEATURE_VERSION < NPY_1_15_API_VERSION
|
||||
/* No support for irrelevant old targets, no need for error, but warn. */
|
||||
#warning "Requested NumPy target lower than supported NumPy 1.15."
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_ */
|
@@ -0,0 +1,187 @@
|
||||
/* This header is deprecated as of NumPy 1.7 */
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_OLD_DEFINES_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_OLD_DEFINES_H_
|
||||
|
||||
#if defined(NPY_NO_DEPRECATED_API) && NPY_NO_DEPRECATED_API >= NPY_1_7_API_VERSION
|
||||
#error The header "old_defines.h" is deprecated as of NumPy 1.7.
|
||||
#endif
|
||||
|
||||
#define NDARRAY_VERSION NPY_VERSION
|
||||
|
||||
#define PyArray_MIN_BUFSIZE NPY_MIN_BUFSIZE
|
||||
#define PyArray_MAX_BUFSIZE NPY_MAX_BUFSIZE
|
||||
#define PyArray_BUFSIZE NPY_BUFSIZE
|
||||
|
||||
#define PyArray_PRIORITY NPY_PRIORITY
|
||||
#define PyArray_SUBTYPE_PRIORITY NPY_PRIORITY
|
||||
#define PyArray_NUM_FLOATTYPE NPY_NUM_FLOATTYPE
|
||||
|
||||
#define NPY_MAX PyArray_MAX
|
||||
#define NPY_MIN PyArray_MIN
|
||||
|
||||
#define PyArray_TYPES NPY_TYPES
|
||||
#define PyArray_BOOL NPY_BOOL
|
||||
#define PyArray_BYTE NPY_BYTE
|
||||
#define PyArray_UBYTE NPY_UBYTE
|
||||
#define PyArray_SHORT NPY_SHORT
|
||||
#define PyArray_USHORT NPY_USHORT
|
||||
#define PyArray_INT NPY_INT
|
||||
#define PyArray_UINT NPY_UINT
|
||||
#define PyArray_LONG NPY_LONG
|
||||
#define PyArray_ULONG NPY_ULONG
|
||||
#define PyArray_LONGLONG NPY_LONGLONG
|
||||
#define PyArray_ULONGLONG NPY_ULONGLONG
|
||||
#define PyArray_HALF NPY_HALF
|
||||
#define PyArray_FLOAT NPY_FLOAT
|
||||
#define PyArray_DOUBLE NPY_DOUBLE
|
||||
#define PyArray_LONGDOUBLE NPY_LONGDOUBLE
|
||||
#define PyArray_CFLOAT NPY_CFLOAT
|
||||
#define PyArray_CDOUBLE NPY_CDOUBLE
|
||||
#define PyArray_CLONGDOUBLE NPY_CLONGDOUBLE
|
||||
#define PyArray_OBJECT NPY_OBJECT
|
||||
#define PyArray_STRING NPY_STRING
|
||||
#define PyArray_UNICODE NPY_UNICODE
|
||||
#define PyArray_VOID NPY_VOID
|
||||
#define PyArray_DATETIME NPY_DATETIME
|
||||
#define PyArray_TIMEDELTA NPY_TIMEDELTA
|
||||
#define PyArray_NTYPES NPY_NTYPES
|
||||
#define PyArray_NOTYPE NPY_NOTYPE
|
||||
#define PyArray_CHAR NPY_CHAR
|
||||
#define PyArray_USERDEF NPY_USERDEF
|
||||
#define PyArray_NUMUSERTYPES NPY_NUMUSERTYPES
|
||||
|
||||
#define PyArray_INTP NPY_INTP
|
||||
#define PyArray_UINTP NPY_UINTP
|
||||
|
||||
#define PyArray_INT8 NPY_INT8
|
||||
#define PyArray_UINT8 NPY_UINT8
|
||||
#define PyArray_INT16 NPY_INT16
|
||||
#define PyArray_UINT16 NPY_UINT16
|
||||
#define PyArray_INT32 NPY_INT32
|
||||
#define PyArray_UINT32 NPY_UINT32
|
||||
|
||||
#ifdef NPY_INT64
|
||||
#define PyArray_INT64 NPY_INT64
|
||||
#define PyArray_UINT64 NPY_UINT64
|
||||
#endif
|
||||
|
||||
#ifdef NPY_INT128
|
||||
#define PyArray_INT128 NPY_INT128
|
||||
#define PyArray_UINT128 NPY_UINT128
|
||||
#endif
|
||||
|
||||
#ifdef NPY_FLOAT16
|
||||
#define PyArray_FLOAT16 NPY_FLOAT16
|
||||
#define PyArray_COMPLEX32 NPY_COMPLEX32
|
||||
#endif
|
||||
|
||||
#ifdef NPY_FLOAT80
|
||||
#define PyArray_FLOAT80 NPY_FLOAT80
|
||||
#define PyArray_COMPLEX160 NPY_COMPLEX160
|
||||
#endif
|
||||
|
||||
#ifdef NPY_FLOAT96
|
||||
#define PyArray_FLOAT96 NPY_FLOAT96
|
||||
#define PyArray_COMPLEX192 NPY_COMPLEX192
|
||||
#endif
|
||||
|
||||
#ifdef NPY_FLOAT128
|
||||
#define PyArray_FLOAT128 NPY_FLOAT128
|
||||
#define PyArray_COMPLEX256 NPY_COMPLEX256
|
||||
#endif
|
||||
|
||||
#define PyArray_FLOAT32 NPY_FLOAT32
|
||||
#define PyArray_COMPLEX64 NPY_COMPLEX64
|
||||
#define PyArray_FLOAT64 NPY_FLOAT64
|
||||
#define PyArray_COMPLEX128 NPY_COMPLEX128
|
||||
|
||||
|
||||
#define PyArray_TYPECHAR NPY_TYPECHAR
|
||||
#define PyArray_BOOLLTR NPY_BOOLLTR
|
||||
#define PyArray_BYTELTR NPY_BYTELTR
|
||||
#define PyArray_UBYTELTR NPY_UBYTELTR
|
||||
#define PyArray_SHORTLTR NPY_SHORTLTR
|
||||
#define PyArray_USHORTLTR NPY_USHORTLTR
|
||||
#define PyArray_INTLTR NPY_INTLTR
|
||||
#define PyArray_UINTLTR NPY_UINTLTR
|
||||
#define PyArray_LONGLTR NPY_LONGLTR
|
||||
#define PyArray_ULONGLTR NPY_ULONGLTR
|
||||
#define PyArray_LONGLONGLTR NPY_LONGLONGLTR
|
||||
#define PyArray_ULONGLONGLTR NPY_ULONGLONGLTR
|
||||
#define PyArray_HALFLTR NPY_HALFLTR
|
||||
#define PyArray_FLOATLTR NPY_FLOATLTR
|
||||
#define PyArray_DOUBLELTR NPY_DOUBLELTR
|
||||
#define PyArray_LONGDOUBLELTR NPY_LONGDOUBLELTR
|
||||
#define PyArray_CFLOATLTR NPY_CFLOATLTR
|
||||
#define PyArray_CDOUBLELTR NPY_CDOUBLELTR
|
||||
#define PyArray_CLONGDOUBLELTR NPY_CLONGDOUBLELTR
|
||||
#define PyArray_OBJECTLTR NPY_OBJECTLTR
|
||||
#define PyArray_STRINGLTR NPY_STRINGLTR
|
||||
#define PyArray_STRINGLTR2 NPY_STRINGLTR2
|
||||
#define PyArray_UNICODELTR NPY_UNICODELTR
|
||||
#define PyArray_VOIDLTR NPY_VOIDLTR
|
||||
#define PyArray_DATETIMELTR NPY_DATETIMELTR
|
||||
#define PyArray_TIMEDELTALTR NPY_TIMEDELTALTR
|
||||
#define PyArray_CHARLTR NPY_CHARLTR
|
||||
#define PyArray_INTPLTR NPY_INTPLTR
|
||||
#define PyArray_UINTPLTR NPY_UINTPLTR
|
||||
#define PyArray_GENBOOLLTR NPY_GENBOOLLTR
|
||||
#define PyArray_SIGNEDLTR NPY_SIGNEDLTR
|
||||
#define PyArray_UNSIGNEDLTR NPY_UNSIGNEDLTR
|
||||
#define PyArray_FLOATINGLTR NPY_FLOATINGLTR
|
||||
#define PyArray_COMPLEXLTR NPY_COMPLEXLTR
|
||||
|
||||
#define PyArray_QUICKSORT NPY_QUICKSORT
|
||||
#define PyArray_HEAPSORT NPY_HEAPSORT
|
||||
#define PyArray_MERGESORT NPY_MERGESORT
|
||||
#define PyArray_SORTKIND NPY_SORTKIND
|
||||
#define PyArray_NSORTS NPY_NSORTS
|
||||
|
||||
#define PyArray_NOSCALAR NPY_NOSCALAR
|
||||
#define PyArray_BOOL_SCALAR NPY_BOOL_SCALAR
|
||||
#define PyArray_INTPOS_SCALAR NPY_INTPOS_SCALAR
|
||||
#define PyArray_INTNEG_SCALAR NPY_INTNEG_SCALAR
|
||||
#define PyArray_FLOAT_SCALAR NPY_FLOAT_SCALAR
|
||||
#define PyArray_COMPLEX_SCALAR NPY_COMPLEX_SCALAR
|
||||
#define PyArray_OBJECT_SCALAR NPY_OBJECT_SCALAR
|
||||
#define PyArray_SCALARKIND NPY_SCALARKIND
|
||||
#define PyArray_NSCALARKINDS NPY_NSCALARKINDS
|
||||
|
||||
#define PyArray_ANYORDER NPY_ANYORDER
|
||||
#define PyArray_CORDER NPY_CORDER
|
||||
#define PyArray_FORTRANORDER NPY_FORTRANORDER
|
||||
#define PyArray_ORDER NPY_ORDER
|
||||
|
||||
#define PyDescr_ISBOOL PyDataType_ISBOOL
|
||||
#define PyDescr_ISUNSIGNED PyDataType_ISUNSIGNED
|
||||
#define PyDescr_ISSIGNED PyDataType_ISSIGNED
|
||||
#define PyDescr_ISINTEGER PyDataType_ISINTEGER
|
||||
#define PyDescr_ISFLOAT PyDataType_ISFLOAT
|
||||
#define PyDescr_ISNUMBER PyDataType_ISNUMBER
|
||||
#define PyDescr_ISSTRING PyDataType_ISSTRING
|
||||
#define PyDescr_ISCOMPLEX PyDataType_ISCOMPLEX
|
||||
#define PyDescr_ISPYTHON PyDataType_ISPYTHON
|
||||
#define PyDescr_ISFLEXIBLE PyDataType_ISFLEXIBLE
|
||||
#define PyDescr_ISUSERDEF PyDataType_ISUSERDEF
|
||||
#define PyDescr_ISEXTENDED PyDataType_ISEXTENDED
|
||||
#define PyDescr_ISOBJECT PyDataType_ISOBJECT
|
||||
#define PyDescr_HASFIELDS PyDataType_HASFIELDS
|
||||
|
||||
#define PyArray_LITTLE NPY_LITTLE
|
||||
#define PyArray_BIG NPY_BIG
|
||||
#define PyArray_NATIVE NPY_NATIVE
|
||||
#define PyArray_SWAP NPY_SWAP
|
||||
#define PyArray_IGNORE NPY_IGNORE
|
||||
|
||||
#define PyArray_NATBYTE NPY_NATBYTE
|
||||
#define PyArray_OPPBYTE NPY_OPPBYTE
|
||||
|
||||
#define PyArray_MAX_ELSIZE NPY_MAX_ELSIZE
|
||||
|
||||
#define PyArray_USE_PYMEM NPY_USE_PYMEM
|
||||
|
||||
#define PyArray_RemoveLargest PyArray_RemoveSmallest
|
||||
|
||||
#define PyArray_UCS4 npy_ucs4
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_OLD_DEFINES_H_ */
|
@@ -0,0 +1,32 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_OLDNUMERIC_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_OLDNUMERIC_H_
|
||||
|
||||
/* FIXME -- this file can be deleted? */
|
||||
|
||||
#include "arrayobject.h"
|
||||
|
||||
#ifndef PYPY_VERSION
|
||||
#ifndef REFCOUNT
|
||||
# define REFCOUNT NPY_REFCOUNT
|
||||
# define MAX_ELSIZE 16
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define PyArray_UNSIGNED_TYPES
|
||||
#define PyArray_SBYTE NPY_BYTE
|
||||
#define PyArray_CopyArray PyArray_CopyInto
|
||||
#define _PyArray_multiply_list PyArray_MultiplyIntList
|
||||
#define PyArray_ISSPACESAVER(m) NPY_FALSE
|
||||
#define PyScalarArray_Check PyArray_CheckScalar
|
||||
|
||||
#define CONTIGUOUS NPY_CONTIGUOUS
|
||||
#define OWN_DIMENSIONS 0
|
||||
#define OWN_STRIDES 0
|
||||
#define OWN_DATA NPY_OWNDATA
|
||||
#define SAVESPACE 0
|
||||
#define SAVESPACEBIT 0
|
||||
|
||||
#undef import_array
|
||||
#define import_array() { if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); } }
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_OLDNUMERIC_H_ */
|
@@ -0,0 +1,20 @@
|
||||
#ifndef NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_
|
||||
#define NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_
|
||||
|
||||
#pragma once
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Must match the declaration in numpy/random/<any>.pxd */
|
||||
|
||||
typedef struct bitgen {
|
||||
void *state;
|
||||
uint64_t (*next_uint64)(void *st);
|
||||
uint32_t (*next_uint32)(void *st);
|
||||
double (*next_double)(void *st);
|
||||
uint64_t (*next_raw)(void *st);
|
||||
} bitgen_t;
|
||||
|
||||
|
||||
#endif /* NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_ */
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user