Restore 0.1.5 version from stash
This commit is contained in:
liaibo
@@ -0,0 +1,92 @@
|
||||
"""
|
||||
**Note:** almost all functions in the ``numpy.lib`` namespace
|
||||
are also present in the main ``numpy`` namespace. Please use the
|
||||
functions as ``np.<funcname>`` where possible.
|
||||
|
||||
``numpy.lib`` is mostly a space for implementing functions that don't
|
||||
belong in core or in another NumPy submodule with a clear purpose
|
||||
(e.g. ``random``, ``fft``, ``linalg``, ``ma``).
|
||||
|
||||
Most contains basic functions that are used by several submodules and are
|
||||
useful to have in the main name-space.
|
||||
|
||||
"""
|
||||
|
||||
# Public submodules
|
||||
# Note: recfunctions and (maybe) format are public too, but not imported
|
||||
from . import mixins
|
||||
from . import scimath as emath
|
||||
|
||||
# Private submodules
|
||||
# load module names. See https://github.com/networkx/networkx/issues/5838
|
||||
from . import type_check
|
||||
from . import index_tricks
|
||||
from . import function_base
|
||||
from . import nanfunctions
|
||||
from . import shape_base
|
||||
from . import stride_tricks
|
||||
from . import twodim_base
|
||||
from . import ufunclike
|
||||
from . import histograms
|
||||
from . import polynomial
|
||||
from . import utils
|
||||
from . import arraysetops
|
||||
from . import npyio
|
||||
from . import arrayterator
|
||||
from . import arraypad
|
||||
from . import _version
|
||||
|
||||
from .type_check import *
|
||||
from .index_tricks import *
|
||||
from .function_base import *
|
||||
from .nanfunctions import *
|
||||
from .shape_base import *
|
||||
from .stride_tricks import *
|
||||
from .twodim_base import *
|
||||
from .ufunclike import *
|
||||
from .histograms import *
|
||||
|
||||
from .polynomial import *
|
||||
from .utils import *
|
||||
from .arraysetops import *
|
||||
from .npyio import *
|
||||
from .arrayterator import Arrayterator
|
||||
from .arraypad import *
|
||||
from ._version import *
|
||||
from numpy.core._multiarray_umath import tracemalloc_domain
|
||||
|
||||
__all__ = ['emath', 'tracemalloc_domain', 'Arrayterator']
|
||||
__all__ += type_check.__all__
|
||||
__all__ += index_tricks.__all__
|
||||
__all__ += function_base.__all__
|
||||
__all__ += shape_base.__all__
|
||||
__all__ += stride_tricks.__all__
|
||||
__all__ += twodim_base.__all__
|
||||
__all__ += ufunclike.__all__
|
||||
__all__ += arraypad.__all__
|
||||
__all__ += polynomial.__all__
|
||||
__all__ += utils.__all__
|
||||
__all__ += arraysetops.__all__
|
||||
__all__ += npyio.__all__
|
||||
__all__ += nanfunctions.__all__
|
||||
__all__ += histograms.__all__
|
||||
|
||||
from numpy._pytesttester import PytestTester
|
||||
test = PytestTester(__name__)
|
||||
del PytestTester
|
||||
|
||||
def __getattr__(attr):
|
||||
# Warn for reprecated attributes
|
||||
import math
|
||||
import warnings
|
||||
|
||||
if attr == 'math':
|
||||
warnings.warn(
|
||||
"`np.lib.math` is a deprecated alias for the standard library "
|
||||
"`math` module (Deprecated Numpy 1.25). Replace usages of "
|
||||
"`numpy.lib.math` with `math`", DeprecationWarning, stacklevel=2)
|
||||
return math
|
||||
else:
|
||||
raise AttributeError("module {!r} has no attribute "
|
||||
"{!r}".format(__name__, attr))
|
||||
|
||||
@@ -0,0 +1,245 @@
|
||||
import math as math
|
||||
from typing import Any
|
||||
|
||||
from numpy._pytesttester import PytestTester
|
||||
|
||||
from numpy import (
|
||||
ndenumerate as ndenumerate,
|
||||
ndindex as ndindex,
|
||||
)
|
||||
|
||||
from numpy.version import version
|
||||
|
||||
from numpy.lib import (
|
||||
format as format,
|
||||
mixins as mixins,
|
||||
scimath as scimath,
|
||||
stride_tricks as stride_tricks,
|
||||
)
|
||||
|
||||
from numpy.lib._version import (
|
||||
NumpyVersion as NumpyVersion,
|
||||
)
|
||||
|
||||
from numpy.lib.arraypad import (
|
||||
pad as pad,
|
||||
)
|
||||
|
||||
from numpy.lib.arraysetops import (
|
||||
ediff1d as ediff1d,
|
||||
intersect1d as intersect1d,
|
||||
setxor1d as setxor1d,
|
||||
union1d as union1d,
|
||||
setdiff1d as setdiff1d,
|
||||
unique as unique,
|
||||
in1d as in1d,
|
||||
isin as isin,
|
||||
)
|
||||
|
||||
from numpy.lib.arrayterator import (
|
||||
Arrayterator as Arrayterator,
|
||||
)
|
||||
|
||||
from numpy.lib.function_base import (
|
||||
select as select,
|
||||
piecewise as piecewise,
|
||||
trim_zeros as trim_zeros,
|
||||
copy as copy,
|
||||
iterable as iterable,
|
||||
percentile as percentile,
|
||||
diff as diff,
|
||||
gradient as gradient,
|
||||
angle as angle,
|
||||
unwrap as unwrap,
|
||||
sort_complex as sort_complex,
|
||||
disp as disp,
|
||||
flip as flip,
|
||||
rot90 as rot90,
|
||||
extract as extract,
|
||||
place as place,
|
||||
vectorize as vectorize,
|
||||
asarray_chkfinite as asarray_chkfinite,
|
||||
average as average,
|
||||
bincount as bincount,
|
||||
digitize as digitize,
|
||||
cov as cov,
|
||||
corrcoef as corrcoef,
|
||||
median as median,
|
||||
sinc as sinc,
|
||||
hamming as hamming,
|
||||
hanning as hanning,
|
||||
bartlett as bartlett,
|
||||
blackman as blackman,
|
||||
kaiser as kaiser,
|
||||
trapz as trapz,
|
||||
i0 as i0,
|
||||
add_newdoc as add_newdoc,
|
||||
add_docstring as add_docstring,
|
||||
meshgrid as meshgrid,
|
||||
delete as delete,
|
||||
insert as insert,
|
||||
append as append,
|
||||
interp as interp,
|
||||
add_newdoc_ufunc as add_newdoc_ufunc,
|
||||
quantile as quantile,
|
||||
)
|
||||
|
||||
from numpy.lib.histograms import (
|
||||
histogram_bin_edges as histogram_bin_edges,
|
||||
histogram as histogram,
|
||||
histogramdd as histogramdd,
|
||||
)
|
||||
|
||||
from numpy.lib.index_tricks import (
|
||||
ravel_multi_index as ravel_multi_index,
|
||||
unravel_index as unravel_index,
|
||||
mgrid as mgrid,
|
||||
ogrid as ogrid,
|
||||
r_ as r_,
|
||||
c_ as c_,
|
||||
s_ as s_,
|
||||
index_exp as index_exp,
|
||||
ix_ as ix_,
|
||||
fill_diagonal as fill_diagonal,
|
||||
diag_indices as diag_indices,
|
||||
diag_indices_from as diag_indices_from,
|
||||
)
|
||||
|
||||
from numpy.lib.nanfunctions import (
|
||||
nansum as nansum,
|
||||
nanmax as nanmax,
|
||||
nanmin as nanmin,
|
||||
nanargmax as nanargmax,
|
||||
nanargmin as nanargmin,
|
||||
nanmean as nanmean,
|
||||
nanmedian as nanmedian,
|
||||
nanpercentile as nanpercentile,
|
||||
nanvar as nanvar,
|
||||
nanstd as nanstd,
|
||||
nanprod as nanprod,
|
||||
nancumsum as nancumsum,
|
||||
nancumprod as nancumprod,
|
||||
nanquantile as nanquantile,
|
||||
)
|
||||
|
||||
from numpy.lib.npyio import (
|
||||
savetxt as savetxt,
|
||||
loadtxt as loadtxt,
|
||||
genfromtxt as genfromtxt,
|
||||
recfromtxt as recfromtxt,
|
||||
recfromcsv as recfromcsv,
|
||||
load as load,
|
||||
save as save,
|
||||
savez as savez,
|
||||
savez_compressed as savez_compressed,
|
||||
packbits as packbits,
|
||||
unpackbits as unpackbits,
|
||||
fromregex as fromregex,
|
||||
DataSource as DataSource,
|
||||
)
|
||||
|
||||
from numpy.lib.polynomial import (
|
||||
poly as poly,
|
||||
roots as roots,
|
||||
polyint as polyint,
|
||||
polyder as polyder,
|
||||
polyadd as polyadd,
|
||||
polysub as polysub,
|
||||
polymul as polymul,
|
||||
polydiv as polydiv,
|
||||
polyval as polyval,
|
||||
polyfit as polyfit,
|
||||
RankWarning as RankWarning,
|
||||
poly1d as poly1d,
|
||||
)
|
||||
|
||||
from numpy.lib.shape_base import (
|
||||
column_stack as column_stack,
|
||||
row_stack as row_stack,
|
||||
dstack as dstack,
|
||||
array_split as array_split,
|
||||
split as split,
|
||||
hsplit as hsplit,
|
||||
vsplit as vsplit,
|
||||
dsplit as dsplit,
|
||||
apply_over_axes as apply_over_axes,
|
||||
expand_dims as expand_dims,
|
||||
apply_along_axis as apply_along_axis,
|
||||
kron as kron,
|
||||
tile as tile,
|
||||
get_array_wrap as get_array_wrap,
|
||||
take_along_axis as take_along_axis,
|
||||
put_along_axis as put_along_axis,
|
||||
)
|
||||
|
||||
from numpy.lib.stride_tricks import (
|
||||
broadcast_to as broadcast_to,
|
||||
broadcast_arrays as broadcast_arrays,
|
||||
broadcast_shapes as broadcast_shapes,
|
||||
)
|
||||
|
||||
from numpy.lib.twodim_base import (
|
||||
diag as diag,
|
||||
diagflat as diagflat,
|
||||
eye as eye,
|
||||
fliplr as fliplr,
|
||||
flipud as flipud,
|
||||
tri as tri,
|
||||
triu as triu,
|
||||
tril as tril,
|
||||
vander as vander,
|
||||
histogram2d as histogram2d,
|
||||
mask_indices as mask_indices,
|
||||
tril_indices as tril_indices,
|
||||
tril_indices_from as tril_indices_from,
|
||||
triu_indices as triu_indices,
|
||||
triu_indices_from as triu_indices_from,
|
||||
)
|
||||
|
||||
from numpy.lib.type_check import (
|
||||
mintypecode as mintypecode,
|
||||
asfarray as asfarray,
|
||||
real as real,
|
||||
imag as imag,
|
||||
iscomplex as iscomplex,
|
||||
isreal as isreal,
|
||||
iscomplexobj as iscomplexobj,
|
||||
isrealobj as isrealobj,
|
||||
nan_to_num as nan_to_num,
|
||||
real_if_close as real_if_close,
|
||||
typename as typename,
|
||||
common_type as common_type,
|
||||
)
|
||||
|
||||
from numpy.lib.ufunclike import (
|
||||
fix as fix,
|
||||
isposinf as isposinf,
|
||||
isneginf as isneginf,
|
||||
)
|
||||
|
||||
from numpy.lib.utils import (
|
||||
issubclass_ as issubclass_,
|
||||
issubsctype as issubsctype,
|
||||
issubdtype as issubdtype,
|
||||
deprecate as deprecate,
|
||||
deprecate_with_doc as deprecate_with_doc,
|
||||
get_include as get_include,
|
||||
info as info,
|
||||
source as source,
|
||||
who as who,
|
||||
lookfor as lookfor,
|
||||
byte_bounds as byte_bounds,
|
||||
safe_eval as safe_eval,
|
||||
show_runtime as show_runtime,
|
||||
)
|
||||
|
||||
from numpy.core.multiarray import (
|
||||
tracemalloc_domain as tracemalloc_domain,
|
||||
)
|
||||
|
||||
__all__: list[str]
|
||||
__path__: list[str]
|
||||
test: PytestTester
|
||||
|
||||
__version__ = version
|
||||
emath = scimath
|
||||
@@ -0,0 +1,704 @@
|
||||
"""A file interface for handling local and remote data files.
|
||||
|
||||
The goal of datasource is to abstract some of the file system operations
|
||||
when dealing with data files so the researcher doesn't have to know all the
|
||||
low-level details. Through datasource, a researcher can obtain and use a
|
||||
file with one function call, regardless of location of the file.
|
||||
|
||||
DataSource is meant to augment standard python libraries, not replace them.
|
||||
It should work seamlessly with standard file IO operations and the os
|
||||
module.
|
||||
|
||||
DataSource files can originate locally or remotely:
|
||||
|
||||
- local files : '/home/guido/src/local/data.txt'
|
||||
- URLs (http, ftp, ...) : 'http://www.scipy.org/not/real/data.txt'
|
||||
|
||||
DataSource files can also be compressed or uncompressed. Currently only
|
||||
gzip, bz2 and xz are supported.
|
||||
|
||||
Example::
|
||||
|
||||
>>> # Create a DataSource, use os.curdir (default) for local storage.
|
||||
>>> from numpy import DataSource
|
||||
>>> ds = DataSource()
|
||||
>>>
|
||||
>>> # Open a remote file.
|
||||
>>> # DataSource downloads the file, stores it locally in:
|
||||
>>> # './www.google.com/index.html'
|
||||
>>> # opens the file and returns a file object.
|
||||
>>> fp = ds.open('http://www.google.com/') # doctest: +SKIP
|
||||
>>>
|
||||
>>> # Use the file as you normally would
|
||||
>>> fp.read() # doctest: +SKIP
|
||||
>>> fp.close() # doctest: +SKIP
|
||||
|
||||
"""
|
||||
import os
|
||||
import io
|
||||
|
||||
from .._utils import set_module
|
||||
|
||||
|
||||
_open = open
|
||||
|
||||
|
||||
def _check_mode(mode, encoding, newline):
|
||||
"""Check mode and that encoding and newline are compatible.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
mode : str
|
||||
File open mode.
|
||||
encoding : str
|
||||
File encoding.
|
||||
newline : str
|
||||
Newline for text files.
|
||||
|
||||
"""
|
||||
if "t" in mode:
|
||||
if "b" in mode:
|
||||
raise ValueError("Invalid mode: %r" % (mode,))
|
||||
else:
|
||||
if encoding is not None:
|
||||
raise ValueError("Argument 'encoding' not supported in binary mode")
|
||||
if newline is not None:
|
||||
raise ValueError("Argument 'newline' not supported in binary mode")
|
||||
|
||||
|
||||
# Using a class instead of a module-level dictionary
|
||||
# to reduce the initial 'import numpy' overhead by
|
||||
# deferring the import of lzma, bz2 and gzip until needed
|
||||
|
||||
# TODO: .zip support, .tar support?
|
||||
class _FileOpeners:
|
||||
"""
|
||||
Container for different methods to open (un-)compressed files.
|
||||
|
||||
`_FileOpeners` contains a dictionary that holds one method for each
|
||||
supported file format. Attribute lookup is implemented in such a way
|
||||
that an instance of `_FileOpeners` itself can be indexed with the keys
|
||||
of that dictionary. Currently uncompressed files as well as files
|
||||
compressed with ``gzip``, ``bz2`` or ``xz`` compression are supported.
|
||||
|
||||
Notes
|
||||
-----
|
||||
`_file_openers`, an instance of `_FileOpeners`, is made available for
|
||||
use in the `_datasource` module.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> import gzip
|
||||
>>> np.lib._datasource._file_openers.keys()
|
||||
[None, '.bz2', '.gz', '.xz', '.lzma']
|
||||
>>> np.lib._datasource._file_openers['.gz'] is gzip.open
|
||||
True
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self._loaded = False
|
||||
self._file_openers = {None: io.open}
|
||||
|
||||
def _load(self):
|
||||
if self._loaded:
|
||||
return
|
||||
|
||||
try:
|
||||
import bz2
|
||||
self._file_openers[".bz2"] = bz2.open
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
try:
|
||||
import gzip
|
||||
self._file_openers[".gz"] = gzip.open
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
try:
|
||||
import lzma
|
||||
self._file_openers[".xz"] = lzma.open
|
||||
self._file_openers[".lzma"] = lzma.open
|
||||
except (ImportError, AttributeError):
|
||||
# There are incompatible backports of lzma that do not have the
|
||||
# lzma.open attribute, so catch that as well as ImportError.
|
||||
pass
|
||||
|
||||
self._loaded = True
|
||||
|
||||
def keys(self):
|
||||
"""
|
||||
Return the keys of currently supported file openers.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
None
|
||||
|
||||
Returns
|
||||
-------
|
||||
keys : list
|
||||
The keys are None for uncompressed files and the file extension
|
||||
strings (i.e. ``'.gz'``, ``'.xz'``) for supported compression
|
||||
methods.
|
||||
|
||||
"""
|
||||
self._load()
|
||||
return list(self._file_openers.keys())
|
||||
|
||||
def __getitem__(self, key):
|
||||
self._load()
|
||||
return self._file_openers[key]
|
||||
|
||||
_file_openers = _FileOpeners()
|
||||
|
||||
def open(path, mode='r', destpath=os.curdir, encoding=None, newline=None):
|
||||
"""
|
||||
Open `path` with `mode` and return the file object.
|
||||
|
||||
If ``path`` is an URL, it will be downloaded, stored in the
|
||||
`DataSource` `destpath` directory and opened from there.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Local file path or URL to open.
|
||||
mode : str, optional
|
||||
Mode to open `path`. Mode 'r' for reading, 'w' for writing, 'a' to
|
||||
append. Available modes depend on the type of object specified by
|
||||
path. Default is 'r'.
|
||||
destpath : str, optional
|
||||
Path to the directory where the source file gets downloaded to for
|
||||
use. If `destpath` is None, a temporary directory will be created.
|
||||
The default path is the current directory.
|
||||
encoding : {None, str}, optional
|
||||
Open text file with given encoding. The default encoding will be
|
||||
what `io.open` uses.
|
||||
newline : {None, str}, optional
|
||||
Newline to use when reading text file.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : file object
|
||||
The opened file.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This is a convenience function that instantiates a `DataSource` and
|
||||
returns the file object from ``DataSource.open(path)``.
|
||||
|
||||
"""
|
||||
|
||||
ds = DataSource(destpath)
|
||||
return ds.open(path, mode, encoding=encoding, newline=newline)
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
class DataSource:
|
||||
"""
|
||||
DataSource(destpath='.')
|
||||
|
||||
A generic data source file (file, http, ftp, ...).
|
||||
|
||||
DataSources can be local files or remote files/URLs. The files may
|
||||
also be compressed or uncompressed. DataSource hides some of the
|
||||
low-level details of downloading the file, allowing you to simply pass
|
||||
in a valid file path (or URL) and obtain a file object.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
destpath : str or None, optional
|
||||
Path to the directory where the source file gets downloaded to for
|
||||
use. If `destpath` is None, a temporary directory will be created.
|
||||
The default path is the current directory.
|
||||
|
||||
Notes
|
||||
-----
|
||||
URLs require a scheme string (``http://``) to be used, without it they
|
||||
will fail::
|
||||
|
||||
>>> repos = np.DataSource()
|
||||
>>> repos.exists('www.google.com/index.html')
|
||||
False
|
||||
>>> repos.exists('http://www.google.com/index.html')
|
||||
True
|
||||
|
||||
Temporary directories are deleted when the DataSource is deleted.
|
||||
|
||||
Examples
|
||||
--------
|
||||
::
|
||||
|
||||
>>> ds = np.DataSource('/home/guido')
|
||||
>>> urlname = 'http://www.google.com/'
|
||||
>>> gfile = ds.open('http://www.google.com/')
|
||||
>>> ds.abspath(urlname)
|
||||
'/home/guido/www.google.com/index.html'
|
||||
|
||||
>>> ds = np.DataSource(None) # use with temporary file
|
||||
>>> ds.open('/home/guido/foobar.txt')
|
||||
<open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
|
||||
>>> ds.abspath('/home/guido/foobar.txt')
|
||||
'/tmp/.../home/guido/foobar.txt'
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, destpath=os.curdir):
|
||||
"""Create a DataSource with a local path at destpath."""
|
||||
if destpath:
|
||||
self._destpath = os.path.abspath(destpath)
|
||||
self._istmpdest = False
|
||||
else:
|
||||
import tempfile # deferring import to improve startup time
|
||||
self._destpath = tempfile.mkdtemp()
|
||||
self._istmpdest = True
|
||||
|
||||
def __del__(self):
|
||||
# Remove temp directories
|
||||
if hasattr(self, '_istmpdest') and self._istmpdest:
|
||||
import shutil
|
||||
|
||||
shutil.rmtree(self._destpath)
|
||||
|
||||
def _iszip(self, filename):
|
||||
"""Test if the filename is a zip file by looking at the file extension.
|
||||
|
||||
"""
|
||||
fname, ext = os.path.splitext(filename)
|
||||
return ext in _file_openers.keys()
|
||||
|
||||
def _iswritemode(self, mode):
|
||||
"""Test if the given mode will open a file for writing."""
|
||||
|
||||
# Currently only used to test the bz2 files.
|
||||
_writemodes = ("w", "+")
|
||||
for c in mode:
|
||||
if c in _writemodes:
|
||||
return True
|
||||
return False
|
||||
|
||||
def _splitzipext(self, filename):
|
||||
"""Split zip extension from filename and return filename.
|
||||
|
||||
Returns
|
||||
-------
|
||||
base, zip_ext : {tuple}
|
||||
|
||||
"""
|
||||
|
||||
if self._iszip(filename):
|
||||
return os.path.splitext(filename)
|
||||
else:
|
||||
return filename, None
|
||||
|
||||
def _possible_names(self, filename):
|
||||
"""Return a tuple containing compressed filename variations."""
|
||||
names = [filename]
|
||||
if not self._iszip(filename):
|
||||
for zipext in _file_openers.keys():
|
||||
if zipext:
|
||||
names.append(filename+zipext)
|
||||
return names
|
||||
|
||||
def _isurl(self, path):
|
||||
"""Test if path is a net location. Tests the scheme and netloc."""
|
||||
|
||||
# We do this here to reduce the 'import numpy' initial import time.
|
||||
from urllib.parse import urlparse
|
||||
|
||||
# BUG : URLs require a scheme string ('http://') to be used.
|
||||
# www.google.com will fail.
|
||||
# Should we prepend the scheme for those that don't have it and
|
||||
# test that also? Similar to the way we append .gz and test for
|
||||
# for compressed versions of files.
|
||||
|
||||
scheme, netloc, upath, uparams, uquery, ufrag = urlparse(path)
|
||||
return bool(scheme and netloc)
|
||||
|
||||
def _cache(self, path):
|
||||
"""Cache the file specified by path.
|
||||
|
||||
Creates a copy of the file in the datasource cache.
|
||||
|
||||
"""
|
||||
# We import these here because importing them is slow and
|
||||
# a significant fraction of numpy's total import time.
|
||||
import shutil
|
||||
from urllib.request import urlopen
|
||||
|
||||
upath = self.abspath(path)
|
||||
|
||||
# ensure directory exists
|
||||
if not os.path.exists(os.path.dirname(upath)):
|
||||
os.makedirs(os.path.dirname(upath))
|
||||
|
||||
# TODO: Doesn't handle compressed files!
|
||||
if self._isurl(path):
|
||||
with urlopen(path) as openedurl:
|
||||
with _open(upath, 'wb') as f:
|
||||
shutil.copyfileobj(openedurl, f)
|
||||
else:
|
||||
shutil.copyfile(path, upath)
|
||||
return upath
|
||||
|
||||
def _findfile(self, path):
|
||||
"""Searches for ``path`` and returns full path if found.
|
||||
|
||||
If path is an URL, _findfile will cache a local copy and return the
|
||||
path to the cached file. If path is a local file, _findfile will
|
||||
return a path to that local file.
|
||||
|
||||
The search will include possible compressed versions of the file
|
||||
and return the first occurrence found.
|
||||
|
||||
"""
|
||||
|
||||
# Build list of possible local file paths
|
||||
if not self._isurl(path):
|
||||
# Valid local paths
|
||||
filelist = self._possible_names(path)
|
||||
# Paths in self._destpath
|
||||
filelist += self._possible_names(self.abspath(path))
|
||||
else:
|
||||
# Cached URLs in self._destpath
|
||||
filelist = self._possible_names(self.abspath(path))
|
||||
# Remote URLs
|
||||
filelist = filelist + self._possible_names(path)
|
||||
|
||||
for name in filelist:
|
||||
if self.exists(name):
|
||||
if self._isurl(name):
|
||||
name = self._cache(name)
|
||||
return name
|
||||
return None
|
||||
|
||||
def abspath(self, path):
|
||||
"""
|
||||
Return absolute path of file in the DataSource directory.
|
||||
|
||||
If `path` is an URL, then `abspath` will return either the location
|
||||
the file exists locally or the location it would exist when opened
|
||||
using the `open` method.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Can be a local file or a remote URL.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : str
|
||||
Complete path, including the `DataSource` destination directory.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The functionality is based on `os.path.abspath`.
|
||||
|
||||
"""
|
||||
# We do this here to reduce the 'import numpy' initial import time.
|
||||
from urllib.parse import urlparse
|
||||
|
||||
# TODO: This should be more robust. Handles case where path includes
|
||||
# the destpath, but not other sub-paths. Failing case:
|
||||
# path = /home/guido/datafile.txt
|
||||
# destpath = /home/alex/
|
||||
# upath = self.abspath(path)
|
||||
# upath == '/home/alex/home/guido/datafile.txt'
|
||||
|
||||
# handle case where path includes self._destpath
|
||||
splitpath = path.split(self._destpath, 2)
|
||||
if len(splitpath) > 1:
|
||||
path = splitpath[1]
|
||||
scheme, netloc, upath, uparams, uquery, ufrag = urlparse(path)
|
||||
netloc = self._sanitize_relative_path(netloc)
|
||||
upath = self._sanitize_relative_path(upath)
|
||||
return os.path.join(self._destpath, netloc, upath)
|
||||
|
||||
def _sanitize_relative_path(self, path):
|
||||
"""Return a sanitised relative path for which
|
||||
os.path.abspath(os.path.join(base, path)).startswith(base)
|
||||
"""
|
||||
last = None
|
||||
path = os.path.normpath(path)
|
||||
while path != last:
|
||||
last = path
|
||||
# Note: os.path.join treats '/' as os.sep on Windows
|
||||
path = path.lstrip(os.sep).lstrip('/')
|
||||
path = path.lstrip(os.pardir).lstrip('..')
|
||||
drive, path = os.path.splitdrive(path) # for Windows
|
||||
return path
|
||||
|
||||
def exists(self, path):
|
||||
"""
|
||||
Test if path exists.
|
||||
|
||||
Test if `path` exists as (and in this order):
|
||||
|
||||
- a local file.
|
||||
- a remote URL that has been downloaded and stored locally in the
|
||||
`DataSource` directory.
|
||||
- a remote URL that has not been downloaded, but is valid and
|
||||
accessible.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Can be a local file or a remote URL.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : bool
|
||||
True if `path` exists.
|
||||
|
||||
Notes
|
||||
-----
|
||||
When `path` is an URL, `exists` will return True if it's either
|
||||
stored locally in the `DataSource` directory, or is a valid remote
|
||||
URL. `DataSource` does not discriminate between the two, the file
|
||||
is accessible if it exists in either location.
|
||||
|
||||
"""
|
||||
|
||||
# First test for local path
|
||||
if os.path.exists(path):
|
||||
return True
|
||||
|
||||
# We import this here because importing urllib is slow and
|
||||
# a significant fraction of numpy's total import time.
|
||||
from urllib.request import urlopen
|
||||
from urllib.error import URLError
|
||||
|
||||
# Test cached url
|
||||
upath = self.abspath(path)
|
||||
if os.path.exists(upath):
|
||||
return True
|
||||
|
||||
# Test remote url
|
||||
if self._isurl(path):
|
||||
try:
|
||||
netfile = urlopen(path)
|
||||
netfile.close()
|
||||
del(netfile)
|
||||
return True
|
||||
except URLError:
|
||||
return False
|
||||
return False
|
||||
|
||||
def open(self, path, mode='r', encoding=None, newline=None):
|
||||
"""
|
||||
Open and return file-like object.
|
||||
|
||||
If `path` is an URL, it will be downloaded, stored in the
|
||||
`DataSource` directory and opened from there.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Local file path or URL to open.
|
||||
mode : {'r', 'w', 'a'}, optional
|
||||
Mode to open `path`. Mode 'r' for reading, 'w' for writing,
|
||||
'a' to append. Available modes depend on the type of object
|
||||
specified by `path`. Default is 'r'.
|
||||
encoding : {None, str}, optional
|
||||
Open text file with given encoding. The default encoding will be
|
||||
what `io.open` uses.
|
||||
newline : {None, str}, optional
|
||||
Newline to use when reading text file.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : file object
|
||||
File object.
|
||||
|
||||
"""
|
||||
|
||||
# TODO: There is no support for opening a file for writing which
|
||||
# doesn't exist yet (creating a file). Should there be?
|
||||
|
||||
# TODO: Add a ``subdir`` parameter for specifying the subdirectory
|
||||
# used to store URLs in self._destpath.
|
||||
|
||||
if self._isurl(path) and self._iswritemode(mode):
|
||||
raise ValueError("URLs are not writeable")
|
||||
|
||||
# NOTE: _findfile will fail on a new file opened for writing.
|
||||
found = self._findfile(path)
|
||||
if found:
|
||||
_fname, ext = self._splitzipext(found)
|
||||
if ext == 'bz2':
|
||||
mode.replace("+", "")
|
||||
return _file_openers[ext](found, mode=mode,
|
||||
encoding=encoding, newline=newline)
|
||||
else:
|
||||
raise FileNotFoundError(f"{path} not found.")
|
||||
|
||||
|
||||
class Repository (DataSource):
|
||||
"""
|
||||
Repository(baseurl, destpath='.')
|
||||
|
||||
A data repository where multiple DataSource's share a base
|
||||
URL/directory.
|
||||
|
||||
`Repository` extends `DataSource` by prepending a base URL (or
|
||||
directory) to all the files it handles. Use `Repository` when you will
|
||||
be working with multiple files from one base URL. Initialize
|
||||
`Repository` with the base URL, then refer to each file by its filename
|
||||
only.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
baseurl : str
|
||||
Path to the local directory or remote location that contains the
|
||||
data files.
|
||||
destpath : str or None, optional
|
||||
Path to the directory where the source file gets downloaded to for
|
||||
use. If `destpath` is None, a temporary directory will be created.
|
||||
The default path is the current directory.
|
||||
|
||||
Examples
|
||||
--------
|
||||
To analyze all files in the repository, do something like this
|
||||
(note: this is not self-contained code)::
|
||||
|
||||
>>> repos = np.lib._datasource.Repository('/home/user/data/dir/')
|
||||
>>> for filename in filelist:
|
||||
... fp = repos.open(filename)
|
||||
... fp.analyze()
|
||||
... fp.close()
|
||||
|
||||
Similarly you could use a URL for a repository::
|
||||
|
||||
>>> repos = np.lib._datasource.Repository('http://www.xyz.edu/data')
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, baseurl, destpath=os.curdir):
|
||||
"""Create a Repository with a shared url or directory of baseurl."""
|
||||
DataSource.__init__(self, destpath=destpath)
|
||||
self._baseurl = baseurl
|
||||
|
||||
def __del__(self):
|
||||
DataSource.__del__(self)
|
||||
|
||||
def _fullpath(self, path):
|
||||
"""Return complete path for path. Prepends baseurl if necessary."""
|
||||
splitpath = path.split(self._baseurl, 2)
|
||||
if len(splitpath) == 1:
|
||||
result = os.path.join(self._baseurl, path)
|
||||
else:
|
||||
result = path # path contains baseurl already
|
||||
return result
|
||||
|
||||
def _findfile(self, path):
|
||||
"""Extend DataSource method to prepend baseurl to ``path``."""
|
||||
return DataSource._findfile(self, self._fullpath(path))
|
||||
|
||||
def abspath(self, path):
|
||||
"""
|
||||
Return absolute path of file in the Repository directory.
|
||||
|
||||
If `path` is an URL, then `abspath` will return either the location
|
||||
the file exists locally or the location it would exist when opened
|
||||
using the `open` method.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Can be a local file or a remote URL. This may, but does not
|
||||
have to, include the `baseurl` with which the `Repository` was
|
||||
initialized.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : str
|
||||
Complete path, including the `DataSource` destination directory.
|
||||
|
||||
"""
|
||||
return DataSource.abspath(self, self._fullpath(path))
|
||||
|
||||
def exists(self, path):
|
||||
"""
|
||||
Test if path exists prepending Repository base URL to path.
|
||||
|
||||
Test if `path` exists as (and in this order):
|
||||
|
||||
- a local file.
|
||||
- a remote URL that has been downloaded and stored locally in the
|
||||
`DataSource` directory.
|
||||
- a remote URL that has not been downloaded, but is valid and
|
||||
accessible.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Can be a local file or a remote URL. This may, but does not
|
||||
have to, include the `baseurl` with which the `Repository` was
|
||||
initialized.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : bool
|
||||
True if `path` exists.
|
||||
|
||||
Notes
|
||||
-----
|
||||
When `path` is an URL, `exists` will return True if it's either
|
||||
stored locally in the `DataSource` directory, or is a valid remote
|
||||
URL. `DataSource` does not discriminate between the two, the file
|
||||
is accessible if it exists in either location.
|
||||
|
||||
"""
|
||||
return DataSource.exists(self, self._fullpath(path))
|
||||
|
||||
def open(self, path, mode='r', encoding=None, newline=None):
|
||||
"""
|
||||
Open and return file-like object prepending Repository base URL.
|
||||
|
||||
If `path` is an URL, it will be downloaded, stored in the
|
||||
DataSource directory and opened from there.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
path : str
|
||||
Local file path or URL to open. This may, but does not have to,
|
||||
include the `baseurl` with which the `Repository` was
|
||||
initialized.
|
||||
mode : {'r', 'w', 'a'}, optional
|
||||
Mode to open `path`. Mode 'r' for reading, 'w' for writing,
|
||||
'a' to append. Available modes depend on the type of object
|
||||
specified by `path`. Default is 'r'.
|
||||
encoding : {None, str}, optional
|
||||
Open text file with given encoding. The default encoding will be
|
||||
what `io.open` uses.
|
||||
newline : {None, str}, optional
|
||||
Newline to use when reading text file.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : file object
|
||||
File object.
|
||||
|
||||
"""
|
||||
return DataSource.open(self, self._fullpath(path), mode,
|
||||
encoding=encoding, newline=newline)
|
||||
|
||||
def listdir(self):
|
||||
"""
|
||||
List files in the source Repository.
|
||||
|
||||
Returns
|
||||
-------
|
||||
files : list of str
|
||||
List of file names (not containing a directory part).
|
||||
|
||||
Notes
|
||||
-----
|
||||
Does not currently work for remote repositories.
|
||||
|
||||
"""
|
||||
if self._isurl(self._baseurl):
|
||||
raise NotImplementedError(
|
||||
"Directory listing of URLs, not supported yet.")
|
||||
else:
|
||||
return os.listdir(self._baseurl)
|
||||
@@ -0,0 +1,897 @@
|
||||
"""A collection of functions designed to help I/O with ascii files.
|
||||
|
||||
"""
|
||||
__docformat__ = "restructuredtext en"
|
||||
|
||||
import numpy as np
|
||||
import numpy.core.numeric as nx
|
||||
from numpy.compat import asbytes, asunicode
|
||||
|
||||
|
||||
def _decode_line(line, encoding=None):
|
||||
"""Decode bytes from binary input streams.
|
||||
|
||||
Defaults to decoding from 'latin1'. That differs from the behavior of
|
||||
np.compat.asunicode that decodes from 'ascii'.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
line : str or bytes
|
||||
Line to be decoded.
|
||||
encoding : str
|
||||
Encoding used to decode `line`.
|
||||
|
||||
Returns
|
||||
-------
|
||||
decoded_line : str
|
||||
|
||||
"""
|
||||
if type(line) is bytes:
|
||||
if encoding is None:
|
||||
encoding = "latin1"
|
||||
line = line.decode(encoding)
|
||||
|
||||
return line
|
||||
|
||||
|
||||
def _is_string_like(obj):
|
||||
"""
|
||||
Check whether obj behaves like a string.
|
||||
"""
|
||||
try:
|
||||
obj + ''
|
||||
except (TypeError, ValueError):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _is_bytes_like(obj):
|
||||
"""
|
||||
Check whether obj behaves like a bytes object.
|
||||
"""
|
||||
try:
|
||||
obj + b''
|
||||
except (TypeError, ValueError):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def has_nested_fields(ndtype):
|
||||
"""
|
||||
Returns whether one or several fields of a dtype are nested.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ndtype : dtype
|
||||
Data-type of a structured array.
|
||||
|
||||
Raises
|
||||
------
|
||||
AttributeError
|
||||
If `ndtype` does not have a `names` attribute.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> dt = np.dtype([('name', 'S4'), ('x', float), ('y', float)])
|
||||
>>> np.lib._iotools.has_nested_fields(dt)
|
||||
False
|
||||
|
||||
"""
|
||||
for name in ndtype.names or ():
|
||||
if ndtype[name].names is not None:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def flatten_dtype(ndtype, flatten_base=False):
|
||||
"""
|
||||
Unpack a structured data-type by collapsing nested fields and/or fields
|
||||
with a shape.
|
||||
|
||||
Note that the field names are lost.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ndtype : dtype
|
||||
The datatype to collapse
|
||||
flatten_base : bool, optional
|
||||
If True, transform a field with a shape into several fields. Default is
|
||||
False.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> dt = np.dtype([('name', 'S4'), ('x', float), ('y', float),
|
||||
... ('block', int, (2, 3))])
|
||||
>>> np.lib._iotools.flatten_dtype(dt)
|
||||
[dtype('S4'), dtype('float64'), dtype('float64'), dtype('int64')]
|
||||
>>> np.lib._iotools.flatten_dtype(dt, flatten_base=True)
|
||||
[dtype('S4'),
|
||||
dtype('float64'),
|
||||
dtype('float64'),
|
||||
dtype('int64'),
|
||||
dtype('int64'),
|
||||
dtype('int64'),
|
||||
dtype('int64'),
|
||||
dtype('int64'),
|
||||
dtype('int64')]
|
||||
|
||||
"""
|
||||
names = ndtype.names
|
||||
if names is None:
|
||||
if flatten_base:
|
||||
return [ndtype.base] * int(np.prod(ndtype.shape))
|
||||
return [ndtype.base]
|
||||
else:
|
||||
types = []
|
||||
for field in names:
|
||||
info = ndtype.fields[field]
|
||||
flat_dt = flatten_dtype(info[0], flatten_base)
|
||||
types.extend(flat_dt)
|
||||
return types
|
||||
|
||||
|
||||
class LineSplitter:
|
||||
"""
|
||||
Object to split a string at a given delimiter or at given places.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
delimiter : str, int, or sequence of ints, optional
|
||||
If a string, character used to delimit consecutive fields.
|
||||
If an integer or a sequence of integers, width(s) of each field.
|
||||
comments : str, optional
|
||||
Character used to mark the beginning of a comment. Default is '#'.
|
||||
autostrip : bool, optional
|
||||
Whether to strip each individual field. Default is True.
|
||||
|
||||
"""
|
||||
|
||||
def autostrip(self, method):
|
||||
"""
|
||||
Wrapper to strip each member of the output of `method`.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
method : function
|
||||
Function that takes a single argument and returns a sequence of
|
||||
strings.
|
||||
|
||||
Returns
|
||||
-------
|
||||
wrapped : function
|
||||
The result of wrapping `method`. `wrapped` takes a single input
|
||||
argument and returns a list of strings that are stripped of
|
||||
white-space.
|
||||
|
||||
"""
|
||||
return lambda input: [_.strip() for _ in method(input)]
|
||||
|
||||
def __init__(self, delimiter=None, comments='#', autostrip=True,
|
||||
encoding=None):
|
||||
delimiter = _decode_line(delimiter)
|
||||
comments = _decode_line(comments)
|
||||
|
||||
self.comments = comments
|
||||
|
||||
# Delimiter is a character
|
||||
if (delimiter is None) or isinstance(delimiter, str):
|
||||
delimiter = delimiter or None
|
||||
_handyman = self._delimited_splitter
|
||||
# Delimiter is a list of field widths
|
||||
elif hasattr(delimiter, '__iter__'):
|
||||
_handyman = self._variablewidth_splitter
|
||||
idx = np.cumsum([0] + list(delimiter))
|
||||
delimiter = [slice(i, j) for (i, j) in zip(idx[:-1], idx[1:])]
|
||||
# Delimiter is a single integer
|
||||
elif int(delimiter):
|
||||
(_handyman, delimiter) = (
|
||||
self._fixedwidth_splitter, int(delimiter))
|
||||
else:
|
||||
(_handyman, delimiter) = (self._delimited_splitter, None)
|
||||
self.delimiter = delimiter
|
||||
if autostrip:
|
||||
self._handyman = self.autostrip(_handyman)
|
||||
else:
|
||||
self._handyman = _handyman
|
||||
self.encoding = encoding
|
||||
|
||||
def _delimited_splitter(self, line):
|
||||
"""Chop off comments, strip, and split at delimiter. """
|
||||
if self.comments is not None:
|
||||
line = line.split(self.comments)[0]
|
||||
line = line.strip(" \r\n")
|
||||
if not line:
|
||||
return []
|
||||
return line.split(self.delimiter)
|
||||
|
||||
def _fixedwidth_splitter(self, line):
|
||||
if self.comments is not None:
|
||||
line = line.split(self.comments)[0]
|
||||
line = line.strip("\r\n")
|
||||
if not line:
|
||||
return []
|
||||
fixed = self.delimiter
|
||||
slices = [slice(i, i + fixed) for i in range(0, len(line), fixed)]
|
||||
return [line[s] for s in slices]
|
||||
|
||||
def _variablewidth_splitter(self, line):
|
||||
if self.comments is not None:
|
||||
line = line.split(self.comments)[0]
|
||||
if not line:
|
||||
return []
|
||||
slices = self.delimiter
|
||||
return [line[s] for s in slices]
|
||||
|
||||
def __call__(self, line):
|
||||
return self._handyman(_decode_line(line, self.encoding))
|
||||
|
||||
|
||||
class NameValidator:
|
||||
"""
|
||||
Object to validate a list of strings to use as field names.
|
||||
|
||||
The strings are stripped of any non alphanumeric character, and spaces
|
||||
are replaced by '_'. During instantiation, the user can define a list
|
||||
of names to exclude, as well as a list of invalid characters. Names in
|
||||
the exclusion list are appended a '_' character.
|
||||
|
||||
Once an instance has been created, it can be called with a list of
|
||||
names, and a list of valid names will be created. The `__call__`
|
||||
method accepts an optional keyword "default" that sets the default name
|
||||
in case of ambiguity. By default this is 'f', so that names will
|
||||
default to `f0`, `f1`, etc.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
excludelist : sequence, optional
|
||||
A list of names to exclude. This list is appended to the default
|
||||
list ['return', 'file', 'print']. Excluded names are appended an
|
||||
underscore: for example, `file` becomes `file_` if supplied.
|
||||
deletechars : str, optional
|
||||
A string combining invalid characters that must be deleted from the
|
||||
names.
|
||||
case_sensitive : {True, False, 'upper', 'lower'}, optional
|
||||
* If True, field names are case-sensitive.
|
||||
* If False or 'upper', field names are converted to upper case.
|
||||
* If 'lower', field names are converted to lower case.
|
||||
|
||||
The default value is True.
|
||||
replace_space : '_', optional
|
||||
Character(s) used in replacement of white spaces.
|
||||
|
||||
Notes
|
||||
-----
|
||||
Calling an instance of `NameValidator` is the same as calling its
|
||||
method `validate`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> validator = np.lib._iotools.NameValidator()
|
||||
>>> validator(['file', 'field2', 'with space', 'CaSe'])
|
||||
('file_', 'field2', 'with_space', 'CaSe')
|
||||
|
||||
>>> validator = np.lib._iotools.NameValidator(excludelist=['excl'],
|
||||
... deletechars='q',
|
||||
... case_sensitive=False)
|
||||
>>> validator(['excl', 'field2', 'no_q', 'with space', 'CaSe'])
|
||||
('EXCL', 'FIELD2', 'NO_Q', 'WITH_SPACE', 'CASE')
|
||||
|
||||
"""
|
||||
|
||||
defaultexcludelist = ['return', 'file', 'print']
|
||||
defaultdeletechars = set(r"""~!@#$%^&*()-=+~\|]}[{';: /?.>,<""")
|
||||
|
||||
def __init__(self, excludelist=None, deletechars=None,
|
||||
case_sensitive=None, replace_space='_'):
|
||||
# Process the exclusion list ..
|
||||
if excludelist is None:
|
||||
excludelist = []
|
||||
excludelist.extend(self.defaultexcludelist)
|
||||
self.excludelist = excludelist
|
||||
# Process the list of characters to delete
|
||||
if deletechars is None:
|
||||
delete = self.defaultdeletechars
|
||||
else:
|
||||
delete = set(deletechars)
|
||||
delete.add('"')
|
||||
self.deletechars = delete
|
||||
# Process the case option .....
|
||||
if (case_sensitive is None) or (case_sensitive is True):
|
||||
self.case_converter = lambda x: x
|
||||
elif (case_sensitive is False) or case_sensitive.startswith('u'):
|
||||
self.case_converter = lambda x: x.upper()
|
||||
elif case_sensitive.startswith('l'):
|
||||
self.case_converter = lambda x: x.lower()
|
||||
else:
|
||||
msg = 'unrecognized case_sensitive value %s.' % case_sensitive
|
||||
raise ValueError(msg)
|
||||
|
||||
self.replace_space = replace_space
|
||||
|
||||
def validate(self, names, defaultfmt="f%i", nbfields=None):
|
||||
"""
|
||||
Validate a list of strings as field names for a structured array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
names : sequence of str
|
||||
Strings to be validated.
|
||||
defaultfmt : str, optional
|
||||
Default format string, used if validating a given string
|
||||
reduces its length to zero.
|
||||
nbfields : integer, optional
|
||||
Final number of validated names, used to expand or shrink the
|
||||
initial list of names.
|
||||
|
||||
Returns
|
||||
-------
|
||||
validatednames : list of str
|
||||
The list of validated field names.
|
||||
|
||||
Notes
|
||||
-----
|
||||
A `NameValidator` instance can be called directly, which is the
|
||||
same as calling `validate`. For examples, see `NameValidator`.
|
||||
|
||||
"""
|
||||
# Initial checks ..............
|
||||
if (names is None):
|
||||
if (nbfields is None):
|
||||
return None
|
||||
names = []
|
||||
if isinstance(names, str):
|
||||
names = [names, ]
|
||||
if nbfields is not None:
|
||||
nbnames = len(names)
|
||||
if (nbnames < nbfields):
|
||||
names = list(names) + [''] * (nbfields - nbnames)
|
||||
elif (nbnames > nbfields):
|
||||
names = names[:nbfields]
|
||||
# Set some shortcuts ...........
|
||||
deletechars = self.deletechars
|
||||
excludelist = self.excludelist
|
||||
case_converter = self.case_converter
|
||||
replace_space = self.replace_space
|
||||
# Initializes some variables ...
|
||||
validatednames = []
|
||||
seen = dict()
|
||||
nbempty = 0
|
||||
|
||||
for item in names:
|
||||
item = case_converter(item).strip()
|
||||
if replace_space:
|
||||
item = item.replace(' ', replace_space)
|
||||
item = ''.join([c for c in item if c not in deletechars])
|
||||
if item == '':
|
||||
item = defaultfmt % nbempty
|
||||
while item in names:
|
||||
nbempty += 1
|
||||
item = defaultfmt % nbempty
|
||||
nbempty += 1
|
||||
elif item in excludelist:
|
||||
item += '_'
|
||||
cnt = seen.get(item, 0)
|
||||
if cnt > 0:
|
||||
validatednames.append(item + '_%d' % cnt)
|
||||
else:
|
||||
validatednames.append(item)
|
||||
seen[item] = cnt + 1
|
||||
return tuple(validatednames)
|
||||
|
||||
def __call__(self, names, defaultfmt="f%i", nbfields=None):
|
||||
return self.validate(names, defaultfmt=defaultfmt, nbfields=nbfields)
|
||||
|
||||
|
||||
def str2bool(value):
|
||||
"""
|
||||
Tries to transform a string supposed to represent a boolean to a boolean.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
value : str
|
||||
The string that is transformed to a boolean.
|
||||
|
||||
Returns
|
||||
-------
|
||||
boolval : bool
|
||||
The boolean representation of `value`.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the string is not 'True' or 'False' (case independent)
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.lib._iotools.str2bool('TRUE')
|
||||
True
|
||||
>>> np.lib._iotools.str2bool('false')
|
||||
False
|
||||
|
||||
"""
|
||||
value = value.upper()
|
||||
if value == 'TRUE':
|
||||
return True
|
||||
elif value == 'FALSE':
|
||||
return False
|
||||
else:
|
||||
raise ValueError("Invalid boolean")
|
||||
|
||||
|
||||
class ConverterError(Exception):
|
||||
"""
|
||||
Exception raised when an error occurs in a converter for string values.
|
||||
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class ConverterLockError(ConverterError):
|
||||
"""
|
||||
Exception raised when an attempt is made to upgrade a locked converter.
|
||||
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class ConversionWarning(UserWarning):
|
||||
"""
|
||||
Warning issued when a string converter has a problem.
|
||||
|
||||
Notes
|
||||
-----
|
||||
In `genfromtxt` a `ConversionWarning` is issued if raising exceptions
|
||||
is explicitly suppressed with the "invalid_raise" keyword.
|
||||
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class StringConverter:
|
||||
"""
|
||||
Factory class for function transforming a string into another object
|
||||
(int, float).
|
||||
|
||||
After initialization, an instance can be called to transform a string
|
||||
into another object. If the string is recognized as representing a
|
||||
missing value, a default value is returned.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
func : function
|
||||
Function used for the conversion.
|
||||
default : any
|
||||
Default value to return when the input corresponds to a missing
|
||||
value.
|
||||
type : type
|
||||
Type of the output.
|
||||
_status : int
|
||||
Integer representing the order of the conversion.
|
||||
_mapper : sequence of tuples
|
||||
Sequence of tuples (dtype, function, default value) to evaluate in
|
||||
order.
|
||||
_locked : bool
|
||||
Holds `locked` parameter.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dtype_or_func : {None, dtype, function}, optional
|
||||
If a `dtype`, specifies the input data type, used to define a basic
|
||||
function and a default value for missing data. For example, when
|
||||
`dtype` is float, the `func` attribute is set to `float` and the
|
||||
default value to `np.nan`. If a function, this function is used to
|
||||
convert a string to another object. In this case, it is recommended
|
||||
to give an associated default value as input.
|
||||
default : any, optional
|
||||
Value to return by default, that is, when the string to be
|
||||
converted is flagged as missing. If not given, `StringConverter`
|
||||
tries to supply a reasonable default value.
|
||||
missing_values : {None, sequence of str}, optional
|
||||
``None`` or sequence of strings indicating a missing value. If ``None``
|
||||
then missing values are indicated by empty entries. The default is
|
||||
``None``.
|
||||
locked : bool, optional
|
||||
Whether the StringConverter should be locked to prevent automatic
|
||||
upgrade or not. Default is False.
|
||||
|
||||
"""
|
||||
_mapper = [(nx.bool_, str2bool, False),
|
||||
(nx.int_, int, -1),]
|
||||
|
||||
# On 32-bit systems, we need to make sure that we explicitly include
|
||||
# nx.int64 since ns.int_ is nx.int32.
|
||||
if nx.dtype(nx.int_).itemsize < nx.dtype(nx.int64).itemsize:
|
||||
_mapper.append((nx.int64, int, -1))
|
||||
|
||||
_mapper.extend([(nx.float64, float, nx.nan),
|
||||
(nx.complex128, complex, nx.nan + 0j),
|
||||
(nx.longdouble, nx.longdouble, nx.nan),
|
||||
# If a non-default dtype is passed, fall back to generic
|
||||
# ones (should only be used for the converter)
|
||||
(nx.integer, int, -1),
|
||||
(nx.floating, float, nx.nan),
|
||||
(nx.complexfloating, complex, nx.nan + 0j),
|
||||
# Last, try with the string types (must be last, because
|
||||
# `_mapper[-1]` is used as default in some cases)
|
||||
(nx.str_, asunicode, '???'),
|
||||
(nx.bytes_, asbytes, '???'),
|
||||
])
|
||||
|
||||
@classmethod
|
||||
def _getdtype(cls, val):
|
||||
"""Returns the dtype of the input variable."""
|
||||
return np.array(val).dtype
|
||||
|
||||
@classmethod
|
||||
def _getsubdtype(cls, val):
|
||||
"""Returns the type of the dtype of the input variable."""
|
||||
return np.array(val).dtype.type
|
||||
|
||||
@classmethod
|
||||
def _dtypeortype(cls, dtype):
|
||||
"""Returns dtype for datetime64 and type of dtype otherwise."""
|
||||
|
||||
# This is a bit annoying. We want to return the "general" type in most
|
||||
# cases (ie. "string" rather than "S10"), but we want to return the
|
||||
# specific type for datetime64 (ie. "datetime64[us]" rather than
|
||||
# "datetime64").
|
||||
if dtype.type == np.datetime64:
|
||||
return dtype
|
||||
return dtype.type
|
||||
|
||||
@classmethod
|
||||
def upgrade_mapper(cls, func, default=None):
|
||||
"""
|
||||
Upgrade the mapper of a StringConverter by adding a new function and
|
||||
its corresponding default.
|
||||
|
||||
The input function (or sequence of functions) and its associated
|
||||
default value (if any) is inserted in penultimate position of the
|
||||
mapper. The corresponding type is estimated from the dtype of the
|
||||
default value.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
func : var
|
||||
Function, or sequence of functions
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> import dateutil.parser
|
||||
>>> import datetime
|
||||
>>> dateparser = dateutil.parser.parse
|
||||
>>> defaultdate = datetime.date(2000, 1, 1)
|
||||
>>> StringConverter.upgrade_mapper(dateparser, default=defaultdate)
|
||||
"""
|
||||
# Func is a single functions
|
||||
if hasattr(func, '__call__'):
|
||||
cls._mapper.insert(-1, (cls._getsubdtype(default), func, default))
|
||||
return
|
||||
elif hasattr(func, '__iter__'):
|
||||
if isinstance(func[0], (tuple, list)):
|
||||
for _ in func:
|
||||
cls._mapper.insert(-1, _)
|
||||
return
|
||||
if default is None:
|
||||
default = [None] * len(func)
|
||||
else:
|
||||
default = list(default)
|
||||
default.append([None] * (len(func) - len(default)))
|
||||
for fct, dft in zip(func, default):
|
||||
cls._mapper.insert(-1, (cls._getsubdtype(dft), fct, dft))
|
||||
|
||||
@classmethod
|
||||
def _find_map_entry(cls, dtype):
|
||||
# if a converter for the specific dtype is available use that
|
||||
for i, (deftype, func, default_def) in enumerate(cls._mapper):
|
||||
if dtype.type == deftype:
|
||||
return i, (deftype, func, default_def)
|
||||
|
||||
# otherwise find an inexact match
|
||||
for i, (deftype, func, default_def) in enumerate(cls._mapper):
|
||||
if np.issubdtype(dtype.type, deftype):
|
||||
return i, (deftype, func, default_def)
|
||||
|
||||
raise LookupError
|
||||
|
||||
def __init__(self, dtype_or_func=None, default=None, missing_values=None,
|
||||
locked=False):
|
||||
# Defines a lock for upgrade
|
||||
self._locked = bool(locked)
|
||||
# No input dtype: minimal initialization
|
||||
if dtype_or_func is None:
|
||||
self.func = str2bool
|
||||
self._status = 0
|
||||
self.default = default or False
|
||||
dtype = np.dtype('bool')
|
||||
else:
|
||||
# Is the input a np.dtype ?
|
||||
try:
|
||||
self.func = None
|
||||
dtype = np.dtype(dtype_or_func)
|
||||
except TypeError:
|
||||
# dtype_or_func must be a function, then
|
||||
if not hasattr(dtype_or_func, '__call__'):
|
||||
errmsg = ("The input argument `dtype` is neither a"
|
||||
" function nor a dtype (got '%s' instead)")
|
||||
raise TypeError(errmsg % type(dtype_or_func))
|
||||
# Set the function
|
||||
self.func = dtype_or_func
|
||||
# If we don't have a default, try to guess it or set it to
|
||||
# None
|
||||
if default is None:
|
||||
try:
|
||||
default = self.func('0')
|
||||
except ValueError:
|
||||
default = None
|
||||
dtype = self._getdtype(default)
|
||||
|
||||
# find the best match in our mapper
|
||||
try:
|
||||
self._status, (_, func, default_def) = self._find_map_entry(dtype)
|
||||
except LookupError:
|
||||
# no match
|
||||
self.default = default
|
||||
_, func, _ = self._mapper[-1]
|
||||
self._status = 0
|
||||
else:
|
||||
# use the found default only if we did not already have one
|
||||
if default is None:
|
||||
self.default = default_def
|
||||
else:
|
||||
self.default = default
|
||||
|
||||
# If the input was a dtype, set the function to the last we saw
|
||||
if self.func is None:
|
||||
self.func = func
|
||||
|
||||
# If the status is 1 (int), change the function to
|
||||
# something more robust.
|
||||
if self.func == self._mapper[1][1]:
|
||||
if issubclass(dtype.type, np.uint64):
|
||||
self.func = np.uint64
|
||||
elif issubclass(dtype.type, np.int64):
|
||||
self.func = np.int64
|
||||
else:
|
||||
self.func = lambda x: int(float(x))
|
||||
# Store the list of strings corresponding to missing values.
|
||||
if missing_values is None:
|
||||
self.missing_values = {''}
|
||||
else:
|
||||
if isinstance(missing_values, str):
|
||||
missing_values = missing_values.split(",")
|
||||
self.missing_values = set(list(missing_values) + [''])
|
||||
|
||||
self._callingfunction = self._strict_call
|
||||
self.type = self._dtypeortype(dtype)
|
||||
self._checked = False
|
||||
self._initial_default = default
|
||||
|
||||
def _loose_call(self, value):
|
||||
try:
|
||||
return self.func(value)
|
||||
except ValueError:
|
||||
return self.default
|
||||
|
||||
def _strict_call(self, value):
|
||||
try:
|
||||
|
||||
# We check if we can convert the value using the current function
|
||||
new_value = self.func(value)
|
||||
|
||||
# In addition to having to check whether func can convert the
|
||||
# value, we also have to make sure that we don't get overflow
|
||||
# errors for integers.
|
||||
if self.func is int:
|
||||
try:
|
||||
np.array(value, dtype=self.type)
|
||||
except OverflowError:
|
||||
raise ValueError
|
||||
|
||||
# We're still here so we can now return the new value
|
||||
return new_value
|
||||
|
||||
except ValueError:
|
||||
if value.strip() in self.missing_values:
|
||||
if not self._status:
|
||||
self._checked = False
|
||||
return self.default
|
||||
raise ValueError("Cannot convert string '%s'" % value)
|
||||
|
||||
def __call__(self, value):
|
||||
return self._callingfunction(value)
|
||||
|
||||
def _do_upgrade(self):
|
||||
# Raise an exception if we locked the converter...
|
||||
if self._locked:
|
||||
errmsg = "Converter is locked and cannot be upgraded"
|
||||
raise ConverterLockError(errmsg)
|
||||
_statusmax = len(self._mapper)
|
||||
# Complains if we try to upgrade by the maximum
|
||||
_status = self._status
|
||||
if _status == _statusmax:
|
||||
errmsg = "Could not find a valid conversion function"
|
||||
raise ConverterError(errmsg)
|
||||
elif _status < _statusmax - 1:
|
||||
_status += 1
|
||||
self.type, self.func, default = self._mapper[_status]
|
||||
self._status = _status
|
||||
if self._initial_default is not None:
|
||||
self.default = self._initial_default
|
||||
else:
|
||||
self.default = default
|
||||
|
||||
def upgrade(self, value):
|
||||
"""
|
||||
Find the best converter for a given string, and return the result.
|
||||
|
||||
The supplied string `value` is converted by testing different
|
||||
converters in order. First the `func` method of the
|
||||
`StringConverter` instance is tried, if this fails other available
|
||||
converters are tried. The order in which these other converters
|
||||
are tried is determined by the `_status` attribute of the instance.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
value : str
|
||||
The string to convert.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : any
|
||||
The result of converting `value` with the appropriate converter.
|
||||
|
||||
"""
|
||||
self._checked = True
|
||||
try:
|
||||
return self._strict_call(value)
|
||||
except ValueError:
|
||||
self._do_upgrade()
|
||||
return self.upgrade(value)
|
||||
|
||||
def iterupgrade(self, value):
|
||||
self._checked = True
|
||||
if not hasattr(value, '__iter__'):
|
||||
value = (value,)
|
||||
_strict_call = self._strict_call
|
||||
try:
|
||||
for _m in value:
|
||||
_strict_call(_m)
|
||||
except ValueError:
|
||||
self._do_upgrade()
|
||||
self.iterupgrade(value)
|
||||
|
||||
def update(self, func, default=None, testing_value=None,
|
||||
missing_values='', locked=False):
|
||||
"""
|
||||
Set StringConverter attributes directly.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
func : function
|
||||
Conversion function.
|
||||
default : any, optional
|
||||
Value to return by default, that is, when the string to be
|
||||
converted is flagged as missing. If not given,
|
||||
`StringConverter` tries to supply a reasonable default value.
|
||||
testing_value : str, optional
|
||||
A string representing a standard input value of the converter.
|
||||
This string is used to help defining a reasonable default
|
||||
value.
|
||||
missing_values : {sequence of str, None}, optional
|
||||
Sequence of strings indicating a missing value. If ``None``, then
|
||||
the existing `missing_values` are cleared. The default is `''`.
|
||||
locked : bool, optional
|
||||
Whether the StringConverter should be locked to prevent
|
||||
automatic upgrade or not. Default is False.
|
||||
|
||||
Notes
|
||||
-----
|
||||
`update` takes the same parameters as the constructor of
|
||||
`StringConverter`, except that `func` does not accept a `dtype`
|
||||
whereas `dtype_or_func` in the constructor does.
|
||||
|
||||
"""
|
||||
self.func = func
|
||||
self._locked = locked
|
||||
|
||||
# Don't reset the default to None if we can avoid it
|
||||
if default is not None:
|
||||
self.default = default
|
||||
self.type = self._dtypeortype(self._getdtype(default))
|
||||
else:
|
||||
try:
|
||||
tester = func(testing_value or '1')
|
||||
except (TypeError, ValueError):
|
||||
tester = None
|
||||
self.type = self._dtypeortype(self._getdtype(tester))
|
||||
|
||||
# Add the missing values to the existing set or clear it.
|
||||
if missing_values is None:
|
||||
# Clear all missing values even though the ctor initializes it to
|
||||
# set(['']) when the argument is None.
|
||||
self.missing_values = set()
|
||||
else:
|
||||
if not np.iterable(missing_values):
|
||||
missing_values = [missing_values]
|
||||
if not all(isinstance(v, str) for v in missing_values):
|
||||
raise TypeError("missing_values must be strings or unicode")
|
||||
self.missing_values.update(missing_values)
|
||||
|
||||
|
||||
def easy_dtype(ndtype, names=None, defaultfmt="f%i", **validationargs):
|
||||
"""
|
||||
Convenience function to create a `np.dtype` object.
|
||||
|
||||
The function processes the input `dtype` and matches it with the given
|
||||
names.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ndtype : var
|
||||
Definition of the dtype. Can be any string or dictionary recognized
|
||||
by the `np.dtype` function, or a sequence of types.
|
||||
names : str or sequence, optional
|
||||
Sequence of strings to use as field names for a structured dtype.
|
||||
For convenience, `names` can be a string of a comma-separated list
|
||||
of names.
|
||||
defaultfmt : str, optional
|
||||
Format string used to define missing names, such as ``"f%i"``
|
||||
(default) or ``"fields_%02i"``.
|
||||
validationargs : optional
|
||||
A series of optional arguments used to initialize a
|
||||
`NameValidator`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.lib._iotools.easy_dtype(float)
|
||||
dtype('float64')
|
||||
>>> np.lib._iotools.easy_dtype("i4, f8")
|
||||
dtype([('f0', '<i4'), ('f1', '<f8')])
|
||||
>>> np.lib._iotools.easy_dtype("i4, f8", defaultfmt="field_%03i")
|
||||
dtype([('field_000', '<i4'), ('field_001', '<f8')])
|
||||
|
||||
>>> np.lib._iotools.easy_dtype((int, float, float), names="a,b,c")
|
||||
dtype([('a', '<i8'), ('b', '<f8'), ('c', '<f8')])
|
||||
>>> np.lib._iotools.easy_dtype(float, names="a,b,c")
|
||||
dtype([('a', '<f8'), ('b', '<f8'), ('c', '<f8')])
|
||||
|
||||
"""
|
||||
try:
|
||||
ndtype = np.dtype(ndtype)
|
||||
except TypeError:
|
||||
validate = NameValidator(**validationargs)
|
||||
nbfields = len(ndtype)
|
||||
if names is None:
|
||||
names = [''] * len(ndtype)
|
||||
elif isinstance(names, str):
|
||||
names = names.split(",")
|
||||
names = validate(names, nbfields=nbfields, defaultfmt=defaultfmt)
|
||||
ndtype = np.dtype(dict(formats=ndtype, names=names))
|
||||
else:
|
||||
# Explicit names
|
||||
if names is not None:
|
||||
validate = NameValidator(**validationargs)
|
||||
if isinstance(names, str):
|
||||
names = names.split(",")
|
||||
# Simple dtype: repeat to match the nb of names
|
||||
if ndtype.names is None:
|
||||
formats = tuple([ndtype.type] * len(names))
|
||||
names = validate(names, defaultfmt=defaultfmt)
|
||||
ndtype = np.dtype(list(zip(names, formats)))
|
||||
# Structured dtype: just validate the names as needed
|
||||
else:
|
||||
ndtype.names = validate(names, nbfields=len(ndtype.names),
|
||||
defaultfmt=defaultfmt)
|
||||
# No implicit names
|
||||
elif ndtype.names is not None:
|
||||
validate = NameValidator(**validationargs)
|
||||
# Default initial names : should we change the format ?
|
||||
numbered_names = tuple("f%i" % i for i in range(len(ndtype.names)))
|
||||
if ((ndtype.names == numbered_names) and (defaultfmt != "f%i")):
|
||||
ndtype.names = validate([''] * len(ndtype.names),
|
||||
defaultfmt=defaultfmt)
|
||||
# Explicit initial names : just validate
|
||||
else:
|
||||
ndtype.names = validate(ndtype.names, defaultfmt=defaultfmt)
|
||||
return ndtype
|
||||
@@ -0,0 +1,155 @@
|
||||
"""Utility to compare (NumPy) version strings.
|
||||
|
||||
The NumpyVersion class allows properly comparing numpy version strings.
|
||||
The LooseVersion and StrictVersion classes that distutils provides don't
|
||||
work; they don't recognize anything like alpha/beta/rc/dev versions.
|
||||
|
||||
"""
|
||||
import re
|
||||
|
||||
|
||||
__all__ = ['NumpyVersion']
|
||||
|
||||
|
||||
class NumpyVersion():
|
||||
"""Parse and compare numpy version strings.
|
||||
|
||||
NumPy has the following versioning scheme (numbers given are examples; they
|
||||
can be > 9 in principle):
|
||||
|
||||
- Released version: '1.8.0', '1.8.1', etc.
|
||||
- Alpha: '1.8.0a1', '1.8.0a2', etc.
|
||||
- Beta: '1.8.0b1', '1.8.0b2', etc.
|
||||
- Release candidates: '1.8.0rc1', '1.8.0rc2', etc.
|
||||
- Development versions: '1.8.0.dev-f1234afa' (git commit hash appended)
|
||||
- Development versions after a1: '1.8.0a1.dev-f1234afa',
|
||||
'1.8.0b2.dev-f1234afa',
|
||||
'1.8.1rc1.dev-f1234afa', etc.
|
||||
- Development versions (no git hash available): '1.8.0.dev-Unknown'
|
||||
|
||||
Comparing needs to be done against a valid version string or other
|
||||
`NumpyVersion` instance. Note that all development versions of the same
|
||||
(pre-)release compare equal.
|
||||
|
||||
.. versionadded:: 1.9.0
|
||||
|
||||
Parameters
|
||||
----------
|
||||
vstring : str
|
||||
NumPy version string (``np.__version__``).
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from numpy.lib import NumpyVersion
|
||||
>>> if NumpyVersion(np.__version__) < '1.7.0':
|
||||
... print('skip')
|
||||
>>> # skip
|
||||
|
||||
>>> NumpyVersion('1.7') # raises ValueError, add ".0"
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: Not a valid numpy version string
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, vstring):
|
||||
self.vstring = vstring
|
||||
ver_main = re.match(r'\d+\.\d+\.\d+', vstring)
|
||||
if not ver_main:
|
||||
raise ValueError("Not a valid numpy version string")
|
||||
|
||||
self.version = ver_main.group()
|
||||
self.major, self.minor, self.bugfix = [int(x) for x in
|
||||
self.version.split('.')]
|
||||
if len(vstring) == ver_main.end():
|
||||
self.pre_release = 'final'
|
||||
else:
|
||||
alpha = re.match(r'a\d', vstring[ver_main.end():])
|
||||
beta = re.match(r'b\d', vstring[ver_main.end():])
|
||||
rc = re.match(r'rc\d', vstring[ver_main.end():])
|
||||
pre_rel = [m for m in [alpha, beta, rc] if m is not None]
|
||||
if pre_rel:
|
||||
self.pre_release = pre_rel[0].group()
|
||||
else:
|
||||
self.pre_release = ''
|
||||
|
||||
self.is_devversion = bool(re.search(r'.dev', vstring))
|
||||
|
||||
def _compare_version(self, other):
|
||||
"""Compare major.minor.bugfix"""
|
||||
if self.major == other.major:
|
||||
if self.minor == other.minor:
|
||||
if self.bugfix == other.bugfix:
|
||||
vercmp = 0
|
||||
elif self.bugfix > other.bugfix:
|
||||
vercmp = 1
|
||||
else:
|
||||
vercmp = -1
|
||||
elif self.minor > other.minor:
|
||||
vercmp = 1
|
||||
else:
|
||||
vercmp = -1
|
||||
elif self.major > other.major:
|
||||
vercmp = 1
|
||||
else:
|
||||
vercmp = -1
|
||||
|
||||
return vercmp
|
||||
|
||||
def _compare_pre_release(self, other):
|
||||
"""Compare alpha/beta/rc/final."""
|
||||
if self.pre_release == other.pre_release:
|
||||
vercmp = 0
|
||||
elif self.pre_release == 'final':
|
||||
vercmp = 1
|
||||
elif other.pre_release == 'final':
|
||||
vercmp = -1
|
||||
elif self.pre_release > other.pre_release:
|
||||
vercmp = 1
|
||||
else:
|
||||
vercmp = -1
|
||||
|
||||
return vercmp
|
||||
|
||||
def _compare(self, other):
|
||||
if not isinstance(other, (str, NumpyVersion)):
|
||||
raise ValueError("Invalid object to compare with NumpyVersion.")
|
||||
|
||||
if isinstance(other, str):
|
||||
other = NumpyVersion(other)
|
||||
|
||||
vercmp = self._compare_version(other)
|
||||
if vercmp == 0:
|
||||
# Same x.y.z version, check for alpha/beta/rc
|
||||
vercmp = self._compare_pre_release(other)
|
||||
if vercmp == 0:
|
||||
# Same version and same pre-release, check if dev version
|
||||
if self.is_devversion is other.is_devversion:
|
||||
vercmp = 0
|
||||
elif self.is_devversion:
|
||||
vercmp = -1
|
||||
else:
|
||||
vercmp = 1
|
||||
|
||||
return vercmp
|
||||
|
||||
def __lt__(self, other):
|
||||
return self._compare(other) < 0
|
||||
|
||||
def __le__(self, other):
|
||||
return self._compare(other) <= 0
|
||||
|
||||
def __eq__(self, other):
|
||||
return self._compare(other) == 0
|
||||
|
||||
def __ne__(self, other):
|
||||
return self._compare(other) != 0
|
||||
|
||||
def __gt__(self, other):
|
||||
return self._compare(other) > 0
|
||||
|
||||
def __ge__(self, other):
|
||||
return self._compare(other) >= 0
|
||||
|
||||
def __repr__(self):
|
||||
return "NumpyVersion(%s)" % self.vstring
|
||||
@@ -0,0 +1,17 @@
|
||||
__all__: list[str]
|
||||
|
||||
class NumpyVersion:
|
||||
vstring: str
|
||||
version: str
|
||||
major: int
|
||||
minor: int
|
||||
bugfix: int
|
||||
pre_release: str
|
||||
is_devversion: bool
|
||||
def __init__(self, vstring: str) -> None: ...
|
||||
def __lt__(self, other: str | NumpyVersion) -> bool: ...
|
||||
def __le__(self, other: str | NumpyVersion) -> bool: ...
|
||||
def __eq__(self, other: str | NumpyVersion) -> bool: ... # type: ignore[override]
|
||||
def __ne__(self, other: str | NumpyVersion) -> bool: ... # type: ignore[override]
|
||||
def __gt__(self, other: str | NumpyVersion) -> bool: ...
|
||||
def __ge__(self, other: str | NumpyVersion) -> bool: ...
|
||||
@@ -0,0 +1,882 @@
|
||||
"""
|
||||
The arraypad module contains a group of functions to pad values onto the edges
|
||||
of an n-dimensional array.
|
||||
|
||||
"""
|
||||
import numpy as np
|
||||
from numpy.core.overrides import array_function_dispatch
|
||||
from numpy.lib.index_tricks import ndindex
|
||||
|
||||
|
||||
__all__ = ['pad']
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Private utility functions.
|
||||
|
||||
|
||||
def _round_if_needed(arr, dtype):
|
||||
"""
|
||||
Rounds arr inplace if destination dtype is integer.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
arr : ndarray
|
||||
Input array.
|
||||
dtype : dtype
|
||||
The dtype of the destination array.
|
||||
"""
|
||||
if np.issubdtype(dtype, np.integer):
|
||||
arr.round(out=arr)
|
||||
|
||||
|
||||
def _slice_at_axis(sl, axis):
|
||||
"""
|
||||
Construct tuple of slices to slice an array in the given dimension.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
sl : slice
|
||||
The slice for the given dimension.
|
||||
axis : int
|
||||
The axis to which `sl` is applied. All other dimensions are left
|
||||
"unsliced".
|
||||
|
||||
Returns
|
||||
-------
|
||||
sl : tuple of slices
|
||||
A tuple with slices matching `shape` in length.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> _slice_at_axis(slice(None, 3, -1), 1)
|
||||
(slice(None, None, None), slice(None, 3, -1), (...,))
|
||||
"""
|
||||
return (slice(None),) * axis + (sl,) + (...,)
|
||||
|
||||
|
||||
def _view_roi(array, original_area_slice, axis):
|
||||
"""
|
||||
Get a view of the current region of interest during iterative padding.
|
||||
|
||||
When padding multiple dimensions iteratively corner values are
|
||||
unnecessarily overwritten multiple times. This function reduces the
|
||||
working area for the first dimensions so that corners are excluded.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
array : ndarray
|
||||
The array with the region of interest.
|
||||
original_area_slice : tuple of slices
|
||||
Denotes the area with original values of the unpadded array.
|
||||
axis : int
|
||||
The currently padded dimension assuming that `axis` is padded before
|
||||
`axis` + 1.
|
||||
|
||||
Returns
|
||||
-------
|
||||
roi : ndarray
|
||||
The region of interest of the original `array`.
|
||||
"""
|
||||
axis += 1
|
||||
sl = (slice(None),) * axis + original_area_slice[axis:]
|
||||
return array[sl]
|
||||
|
||||
|
||||
def _pad_simple(array, pad_width, fill_value=None):
|
||||
"""
|
||||
Pad array on all sides with either a single value or undefined values.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
array : ndarray
|
||||
Array to grow.
|
||||
pad_width : sequence of tuple[int, int]
|
||||
Pad width on both sides for each dimension in `arr`.
|
||||
fill_value : scalar, optional
|
||||
If provided the padded area is filled with this value, otherwise
|
||||
the pad area left undefined.
|
||||
|
||||
Returns
|
||||
-------
|
||||
padded : ndarray
|
||||
The padded array with the same dtype as`array`. Its order will default
|
||||
to C-style if `array` is not F-contiguous.
|
||||
original_area_slice : tuple
|
||||
A tuple of slices pointing to the area of the original array.
|
||||
"""
|
||||
# Allocate grown array
|
||||
new_shape = tuple(
|
||||
left + size + right
|
||||
for size, (left, right) in zip(array.shape, pad_width)
|
||||
)
|
||||
order = 'F' if array.flags.fnc else 'C' # Fortran and not also C-order
|
||||
padded = np.empty(new_shape, dtype=array.dtype, order=order)
|
||||
|
||||
if fill_value is not None:
|
||||
padded.fill(fill_value)
|
||||
|
||||
# Copy old array into correct space
|
||||
original_area_slice = tuple(
|
||||
slice(left, left + size)
|
||||
for size, (left, right) in zip(array.shape, pad_width)
|
||||
)
|
||||
padded[original_area_slice] = array
|
||||
|
||||
return padded, original_area_slice
|
||||
|
||||
|
||||
def _set_pad_area(padded, axis, width_pair, value_pair):
|
||||
"""
|
||||
Set empty-padded area in given dimension.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
padded : ndarray
|
||||
Array with the pad area which is modified inplace.
|
||||
axis : int
|
||||
Dimension with the pad area to set.
|
||||
width_pair : (int, int)
|
||||
Pair of widths that mark the pad area on both sides in the given
|
||||
dimension.
|
||||
value_pair : tuple of scalars or ndarrays
|
||||
Values inserted into the pad area on each side. It must match or be
|
||||
broadcastable to the shape of `arr`.
|
||||
"""
|
||||
left_slice = _slice_at_axis(slice(None, width_pair[0]), axis)
|
||||
padded[left_slice] = value_pair[0]
|
||||
|
||||
right_slice = _slice_at_axis(
|
||||
slice(padded.shape[axis] - width_pair[1], None), axis)
|
||||
padded[right_slice] = value_pair[1]
|
||||
|
||||
|
||||
def _get_edges(padded, axis, width_pair):
|
||||
"""
|
||||
Retrieve edge values from empty-padded array in given dimension.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
padded : ndarray
|
||||
Empty-padded array.
|
||||
axis : int
|
||||
Dimension in which the edges are considered.
|
||||
width_pair : (int, int)
|
||||
Pair of widths that mark the pad area on both sides in the given
|
||||
dimension.
|
||||
|
||||
Returns
|
||||
-------
|
||||
left_edge, right_edge : ndarray
|
||||
Edge values of the valid area in `padded` in the given dimension. Its
|
||||
shape will always match `padded` except for the dimension given by
|
||||
`axis` which will have a length of 1.
|
||||
"""
|
||||
left_index = width_pair[0]
|
||||
left_slice = _slice_at_axis(slice(left_index, left_index + 1), axis)
|
||||
left_edge = padded[left_slice]
|
||||
|
||||
right_index = padded.shape[axis] - width_pair[1]
|
||||
right_slice = _slice_at_axis(slice(right_index - 1, right_index), axis)
|
||||
right_edge = padded[right_slice]
|
||||
|
||||
return left_edge, right_edge
|
||||
|
||||
|
||||
def _get_linear_ramps(padded, axis, width_pair, end_value_pair):
|
||||
"""
|
||||
Construct linear ramps for empty-padded array in given dimension.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
padded : ndarray
|
||||
Empty-padded array.
|
||||
axis : int
|
||||
Dimension in which the ramps are constructed.
|
||||
width_pair : (int, int)
|
||||
Pair of widths that mark the pad area on both sides in the given
|
||||
dimension.
|
||||
end_value_pair : (scalar, scalar)
|
||||
End values for the linear ramps which form the edge of the fully padded
|
||||
array. These values are included in the linear ramps.
|
||||
|
||||
Returns
|
||||
-------
|
||||
left_ramp, right_ramp : ndarray
|
||||
Linear ramps to set on both sides of `padded`.
|
||||
"""
|
||||
edge_pair = _get_edges(padded, axis, width_pair)
|
||||
|
||||
left_ramp, right_ramp = (
|
||||
np.linspace(
|
||||
start=end_value,
|
||||
stop=edge.squeeze(axis), # Dimension is replaced by linspace
|
||||
num=width,
|
||||
endpoint=False,
|
||||
dtype=padded.dtype,
|
||||
axis=axis
|
||||
)
|
||||
for end_value, edge, width in zip(
|
||||
end_value_pair, edge_pair, width_pair
|
||||
)
|
||||
)
|
||||
|
||||
# Reverse linear space in appropriate dimension
|
||||
right_ramp = right_ramp[_slice_at_axis(slice(None, None, -1), axis)]
|
||||
|
||||
return left_ramp, right_ramp
|
||||
|
||||
|
||||
def _get_stats(padded, axis, width_pair, length_pair, stat_func):
|
||||
"""
|
||||
Calculate statistic for the empty-padded array in given dimension.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
padded : ndarray
|
||||
Empty-padded array.
|
||||
axis : int
|
||||
Dimension in which the statistic is calculated.
|
||||
width_pair : (int, int)
|
||||
Pair of widths that mark the pad area on both sides in the given
|
||||
dimension.
|
||||
length_pair : 2-element sequence of None or int
|
||||
Gives the number of values in valid area from each side that is
|
||||
taken into account when calculating the statistic. If None the entire
|
||||
valid area in `padded` is considered.
|
||||
stat_func : function
|
||||
Function to compute statistic. The expected signature is
|
||||
``stat_func(x: ndarray, axis: int, keepdims: bool) -> ndarray``.
|
||||
|
||||
Returns
|
||||
-------
|
||||
left_stat, right_stat : ndarray
|
||||
Calculated statistic for both sides of `padded`.
|
||||
"""
|
||||
# Calculate indices of the edges of the area with original values
|
||||
left_index = width_pair[0]
|
||||
right_index = padded.shape[axis] - width_pair[1]
|
||||
# as well as its length
|
||||
max_length = right_index - left_index
|
||||
|
||||
# Limit stat_lengths to max_length
|
||||
left_length, right_length = length_pair
|
||||
if left_length is None or max_length < left_length:
|
||||
left_length = max_length
|
||||
if right_length is None or max_length < right_length:
|
||||
right_length = max_length
|
||||
|
||||
if (left_length == 0 or right_length == 0) \
|
||||
and stat_func in {np.amax, np.amin}:
|
||||
# amax and amin can't operate on an empty array,
|
||||
# raise a more descriptive warning here instead of the default one
|
||||
raise ValueError("stat_length of 0 yields no value for padding")
|
||||
|
||||
# Calculate statistic for the left side
|
||||
left_slice = _slice_at_axis(
|
||||
slice(left_index, left_index + left_length), axis)
|
||||
left_chunk = padded[left_slice]
|
||||
left_stat = stat_func(left_chunk, axis=axis, keepdims=True)
|
||||
_round_if_needed(left_stat, padded.dtype)
|
||||
|
||||
if left_length == right_length == max_length:
|
||||
# return early as right_stat must be identical to left_stat
|
||||
return left_stat, left_stat
|
||||
|
||||
# Calculate statistic for the right side
|
||||
right_slice = _slice_at_axis(
|
||||
slice(right_index - right_length, right_index), axis)
|
||||
right_chunk = padded[right_slice]
|
||||
right_stat = stat_func(right_chunk, axis=axis, keepdims=True)
|
||||
_round_if_needed(right_stat, padded.dtype)
|
||||
|
||||
return left_stat, right_stat
|
||||
|
||||
|
||||
def _set_reflect_both(padded, axis, width_pair, method, include_edge=False):
|
||||
"""
|
||||
Pad `axis` of `arr` with reflection.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
padded : ndarray
|
||||
Input array of arbitrary shape.
|
||||
axis : int
|
||||
Axis along which to pad `arr`.
|
||||
width_pair : (int, int)
|
||||
Pair of widths that mark the pad area on both sides in the given
|
||||
dimension.
|
||||
method : str
|
||||
Controls method of reflection; options are 'even' or 'odd'.
|
||||
include_edge : bool
|
||||
If true, edge value is included in reflection, otherwise the edge
|
||||
value forms the symmetric axis to the reflection.
|
||||
|
||||
Returns
|
||||
-------
|
||||
pad_amt : tuple of ints, length 2
|
||||
New index positions of padding to do along the `axis`. If these are
|
||||
both 0, padding is done in this dimension.
|
||||
"""
|
||||
left_pad, right_pad = width_pair
|
||||
old_length = padded.shape[axis] - right_pad - left_pad
|
||||
|
||||
if include_edge:
|
||||
# Edge is included, we need to offset the pad amount by 1
|
||||
edge_offset = 1
|
||||
else:
|
||||
edge_offset = 0 # Edge is not included, no need to offset pad amount
|
||||
old_length -= 1 # but must be omitted from the chunk
|
||||
|
||||
if left_pad > 0:
|
||||
# Pad with reflected values on left side:
|
||||
# First limit chunk size which can't be larger than pad area
|
||||
chunk_length = min(old_length, left_pad)
|
||||
# Slice right to left, stop on or next to edge, start relative to stop
|
||||
stop = left_pad - edge_offset
|
||||
start = stop + chunk_length
|
||||
left_slice = _slice_at_axis(slice(start, stop, -1), axis)
|
||||
left_chunk = padded[left_slice]
|
||||
|
||||
if method == "odd":
|
||||
# Negate chunk and align with edge
|
||||
edge_slice = _slice_at_axis(slice(left_pad, left_pad + 1), axis)
|
||||
left_chunk = 2 * padded[edge_slice] - left_chunk
|
||||
|
||||
# Insert chunk into padded area
|
||||
start = left_pad - chunk_length
|
||||
stop = left_pad
|
||||
pad_area = _slice_at_axis(slice(start, stop), axis)
|
||||
padded[pad_area] = left_chunk
|
||||
# Adjust pointer to left edge for next iteration
|
||||
left_pad -= chunk_length
|
||||
|
||||
if right_pad > 0:
|
||||
# Pad with reflected values on right side:
|
||||
# First limit chunk size which can't be larger than pad area
|
||||
chunk_length = min(old_length, right_pad)
|
||||
# Slice right to left, start on or next to edge, stop relative to start
|
||||
start = -right_pad + edge_offset - 2
|
||||
stop = start - chunk_length
|
||||
right_slice = _slice_at_axis(slice(start, stop, -1), axis)
|
||||
right_chunk = padded[right_slice]
|
||||
|
||||
if method == "odd":
|
||||
# Negate chunk and align with edge
|
||||
edge_slice = _slice_at_axis(
|
||||
slice(-right_pad - 1, -right_pad), axis)
|
||||
right_chunk = 2 * padded[edge_slice] - right_chunk
|
||||
|
||||
# Insert chunk into padded area
|
||||
start = padded.shape[axis] - right_pad
|
||||
stop = start + chunk_length
|
||||
pad_area = _slice_at_axis(slice(start, stop), axis)
|
||||
padded[pad_area] = right_chunk
|
||||
# Adjust pointer to right edge for next iteration
|
||||
right_pad -= chunk_length
|
||||
|
||||
return left_pad, right_pad
|
||||
|
||||
|
||||
def _set_wrap_both(padded, axis, width_pair, original_period):
|
||||
"""
|
||||
Pad `axis` of `arr` with wrapped values.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
padded : ndarray
|
||||
Input array of arbitrary shape.
|
||||
axis : int
|
||||
Axis along which to pad `arr`.
|
||||
width_pair : (int, int)
|
||||
Pair of widths that mark the pad area on both sides in the given
|
||||
dimension.
|
||||
original_period : int
|
||||
Original length of data on `axis` of `arr`.
|
||||
|
||||
Returns
|
||||
-------
|
||||
pad_amt : tuple of ints, length 2
|
||||
New index positions of padding to do along the `axis`. If these are
|
||||
both 0, padding is done in this dimension.
|
||||
"""
|
||||
left_pad, right_pad = width_pair
|
||||
period = padded.shape[axis] - right_pad - left_pad
|
||||
# Avoid wrapping with only a subset of the original area by ensuring period
|
||||
# can only be a multiple of the original area's length.
|
||||
period = period // original_period * original_period
|
||||
|
||||
# If the current dimension of `arr` doesn't contain enough valid values
|
||||
# (not part of the undefined pad area) we need to pad multiple times.
|
||||
# Each time the pad area shrinks on both sides which is communicated with
|
||||
# these variables.
|
||||
new_left_pad = 0
|
||||
new_right_pad = 0
|
||||
|
||||
if left_pad > 0:
|
||||
# Pad with wrapped values on left side
|
||||
# First slice chunk from left side of the non-pad area.
|
||||
# Use min(period, left_pad) to ensure that chunk is not larger than
|
||||
# pad area.
|
||||
slice_end = left_pad + period
|
||||
slice_start = slice_end - min(period, left_pad)
|
||||
right_slice = _slice_at_axis(slice(slice_start, slice_end), axis)
|
||||
right_chunk = padded[right_slice]
|
||||
|
||||
if left_pad > period:
|
||||
# Chunk is smaller than pad area
|
||||
pad_area = _slice_at_axis(slice(left_pad - period, left_pad), axis)
|
||||
new_left_pad = left_pad - period
|
||||
else:
|
||||
# Chunk matches pad area
|
||||
pad_area = _slice_at_axis(slice(None, left_pad), axis)
|
||||
padded[pad_area] = right_chunk
|
||||
|
||||
if right_pad > 0:
|
||||
# Pad with wrapped values on right side
|
||||
# First slice chunk from right side of the non-pad area.
|
||||
# Use min(period, right_pad) to ensure that chunk is not larger than
|
||||
# pad area.
|
||||
slice_start = -right_pad - period
|
||||
slice_end = slice_start + min(period, right_pad)
|
||||
left_slice = _slice_at_axis(slice(slice_start, slice_end), axis)
|
||||
left_chunk = padded[left_slice]
|
||||
|
||||
if right_pad > period:
|
||||
# Chunk is smaller than pad area
|
||||
pad_area = _slice_at_axis(
|
||||
slice(-right_pad, -right_pad + period), axis)
|
||||
new_right_pad = right_pad - period
|
||||
else:
|
||||
# Chunk matches pad area
|
||||
pad_area = _slice_at_axis(slice(-right_pad, None), axis)
|
||||
padded[pad_area] = left_chunk
|
||||
|
||||
return new_left_pad, new_right_pad
|
||||
|
||||
|
||||
def _as_pairs(x, ndim, as_index=False):
|
||||
"""
|
||||
Broadcast `x` to an array with the shape (`ndim`, 2).
|
||||
|
||||
A helper function for `pad` that prepares and validates arguments like
|
||||
`pad_width` for iteration in pairs.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : {None, scalar, array-like}
|
||||
The object to broadcast to the shape (`ndim`, 2).
|
||||
ndim : int
|
||||
Number of pairs the broadcasted `x` will have.
|
||||
as_index : bool, optional
|
||||
If `x` is not None, try to round each element of `x` to an integer
|
||||
(dtype `np.intp`) and ensure every element is positive.
|
||||
|
||||
Returns
|
||||
-------
|
||||
pairs : nested iterables, shape (`ndim`, 2)
|
||||
The broadcasted version of `x`.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If `as_index` is True and `x` contains negative elements.
|
||||
Or if `x` is not broadcastable to the shape (`ndim`, 2).
|
||||
"""
|
||||
if x is None:
|
||||
# Pass through None as a special case, otherwise np.round(x) fails
|
||||
# with an AttributeError
|
||||
return ((None, None),) * ndim
|
||||
|
||||
x = np.array(x)
|
||||
if as_index:
|
||||
x = np.round(x).astype(np.intp, copy=False)
|
||||
|
||||
if x.ndim < 3:
|
||||
# Optimization: Possibly use faster paths for cases where `x` has
|
||||
# only 1 or 2 elements. `np.broadcast_to` could handle these as well
|
||||
# but is currently slower
|
||||
|
||||
if x.size == 1:
|
||||
# x was supplied as a single value
|
||||
x = x.ravel() # Ensure x[0] works for x.ndim == 0, 1, 2
|
||||
if as_index and x < 0:
|
||||
raise ValueError("index can't contain negative values")
|
||||
return ((x[0], x[0]),) * ndim
|
||||
|
||||
if x.size == 2 and x.shape != (2, 1):
|
||||
# x was supplied with a single value for each side
|
||||
# but except case when each dimension has a single value
|
||||
# which should be broadcasted to a pair,
|
||||
# e.g. [[1], [2]] -> [[1, 1], [2, 2]] not [[1, 2], [1, 2]]
|
||||
x = x.ravel() # Ensure x[0], x[1] works
|
||||
if as_index and (x[0] < 0 or x[1] < 0):
|
||||
raise ValueError("index can't contain negative values")
|
||||
return ((x[0], x[1]),) * ndim
|
||||
|
||||
if as_index and x.min() < 0:
|
||||
raise ValueError("index can't contain negative values")
|
||||
|
||||
# Converting the array with `tolist` seems to improve performance
|
||||
# when iterating and indexing the result (see usage in `pad`)
|
||||
return np.broadcast_to(x, (ndim, 2)).tolist()
|
||||
|
||||
|
||||
def _pad_dispatcher(array, pad_width, mode=None, **kwargs):
|
||||
return (array,)
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Public functions
|
||||
|
||||
|
||||
@array_function_dispatch(_pad_dispatcher, module='numpy')
|
||||
def pad(array, pad_width, mode='constant', **kwargs):
|
||||
"""
|
||||
Pad an array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
array : array_like of rank N
|
||||
The array to pad.
|
||||
pad_width : {sequence, array_like, int}
|
||||
Number of values padded to the edges of each axis.
|
||||
``((before_1, after_1), ... (before_N, after_N))`` unique pad widths
|
||||
for each axis.
|
||||
``(before, after)`` or ``((before, after),)`` yields same before
|
||||
and after pad for each axis.
|
||||
``(pad,)`` or ``int`` is a shortcut for before = after = pad width
|
||||
for all axes.
|
||||
mode : str or function, optional
|
||||
One of the following string values or a user supplied function.
|
||||
|
||||
'constant' (default)
|
||||
Pads with a constant value.
|
||||
'edge'
|
||||
Pads with the edge values of array.
|
||||
'linear_ramp'
|
||||
Pads with the linear ramp between end_value and the
|
||||
array edge value.
|
||||
'maximum'
|
||||
Pads with the maximum value of all or part of the
|
||||
vector along each axis.
|
||||
'mean'
|
||||
Pads with the mean value of all or part of the
|
||||
vector along each axis.
|
||||
'median'
|
||||
Pads with the median value of all or part of the
|
||||
vector along each axis.
|
||||
'minimum'
|
||||
Pads with the minimum value of all or part of the
|
||||
vector along each axis.
|
||||
'reflect'
|
||||
Pads with the reflection of the vector mirrored on
|
||||
the first and last values of the vector along each
|
||||
axis.
|
||||
'symmetric'
|
||||
Pads with the reflection of the vector mirrored
|
||||
along the edge of the array.
|
||||
'wrap'
|
||||
Pads with the wrap of the vector along the axis.
|
||||
The first values are used to pad the end and the
|
||||
end values are used to pad the beginning.
|
||||
'empty'
|
||||
Pads with undefined values.
|
||||
|
||||
.. versionadded:: 1.17
|
||||
|
||||
<function>
|
||||
Padding function, see Notes.
|
||||
stat_length : sequence or int, optional
|
||||
Used in 'maximum', 'mean', 'median', and 'minimum'. Number of
|
||||
values at edge of each axis used to calculate the statistic value.
|
||||
|
||||
``((before_1, after_1), ... (before_N, after_N))`` unique statistic
|
||||
lengths for each axis.
|
||||
|
||||
``(before, after)`` or ``((before, after),)`` yields same before
|
||||
and after statistic lengths for each axis.
|
||||
|
||||
``(stat_length,)`` or ``int`` is a shortcut for
|
||||
``before = after = statistic`` length for all axes.
|
||||
|
||||
Default is ``None``, to use the entire axis.
|
||||
constant_values : sequence or scalar, optional
|
||||
Used in 'constant'. The values to set the padded values for each
|
||||
axis.
|
||||
|
||||
``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
|
||||
for each axis.
|
||||
|
||||
``(before, after)`` or ``((before, after),)`` yields same before
|
||||
and after constants for each axis.
|
||||
|
||||
``(constant,)`` or ``constant`` is a shortcut for
|
||||
``before = after = constant`` for all axes.
|
||||
|
||||
Default is 0.
|
||||
end_values : sequence or scalar, optional
|
||||
Used in 'linear_ramp'. The values used for the ending value of the
|
||||
linear_ramp and that will form the edge of the padded array.
|
||||
|
||||
``((before_1, after_1), ... (before_N, after_N))`` unique end values
|
||||
for each axis.
|
||||
|
||||
``(before, after)`` or ``((before, after),)`` yields same before
|
||||
and after end values for each axis.
|
||||
|
||||
``(constant,)`` or ``constant`` is a shortcut for
|
||||
``before = after = constant`` for all axes.
|
||||
|
||||
Default is 0.
|
||||
reflect_type : {'even', 'odd'}, optional
|
||||
Used in 'reflect', and 'symmetric'. The 'even' style is the
|
||||
default with an unaltered reflection around the edge value. For
|
||||
the 'odd' style, the extended part of the array is created by
|
||||
subtracting the reflected values from two times the edge value.
|
||||
|
||||
Returns
|
||||
-------
|
||||
pad : ndarray
|
||||
Padded array of rank equal to `array` with shape increased
|
||||
according to `pad_width`.
|
||||
|
||||
Notes
|
||||
-----
|
||||
.. versionadded:: 1.7.0
|
||||
|
||||
For an array with rank greater than 1, some of the padding of later
|
||||
axes is calculated from padding of previous axes. This is easiest to
|
||||
think about with a rank 2 array where the corners of the padded array
|
||||
are calculated by using padded values from the first axis.
|
||||
|
||||
The padding function, if used, should modify a rank 1 array in-place. It
|
||||
has the following signature::
|
||||
|
||||
padding_func(vector, iaxis_pad_width, iaxis, kwargs)
|
||||
|
||||
where
|
||||
|
||||
vector : ndarray
|
||||
A rank 1 array already padded with zeros. Padded values are
|
||||
vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
|
||||
iaxis_pad_width : tuple
|
||||
A 2-tuple of ints, iaxis_pad_width[0] represents the number of
|
||||
values padded at the beginning of vector where
|
||||
iaxis_pad_width[1] represents the number of values padded at
|
||||
the end of vector.
|
||||
iaxis : int
|
||||
The axis currently being calculated.
|
||||
kwargs : dict
|
||||
Any keyword arguments the function requires.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = [1, 2, 3, 4, 5]
|
||||
>>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
|
||||
array([4, 4, 1, ..., 6, 6, 6])
|
||||
|
||||
>>> np.pad(a, (2, 3), 'edge')
|
||||
array([1, 1, 1, ..., 5, 5, 5])
|
||||
|
||||
>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
|
||||
array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])
|
||||
|
||||
>>> np.pad(a, (2,), 'maximum')
|
||||
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
|
||||
|
||||
>>> np.pad(a, (2,), 'mean')
|
||||
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
|
||||
|
||||
>>> np.pad(a, (2,), 'median')
|
||||
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
|
||||
|
||||
>>> a = [[1, 2], [3, 4]]
|
||||
>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
|
||||
array([[1, 1, 1, 2, 1, 1, 1],
|
||||
[1, 1, 1, 2, 1, 1, 1],
|
||||
[1, 1, 1, 2, 1, 1, 1],
|
||||
[1, 1, 1, 2, 1, 1, 1],
|
||||
[3, 3, 3, 4, 3, 3, 3],
|
||||
[1, 1, 1, 2, 1, 1, 1],
|
||||
[1, 1, 1, 2, 1, 1, 1]])
|
||||
|
||||
>>> a = [1, 2, 3, 4, 5]
|
||||
>>> np.pad(a, (2, 3), 'reflect')
|
||||
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
|
||||
|
||||
>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
|
||||
array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
|
||||
|
||||
>>> np.pad(a, (2, 3), 'symmetric')
|
||||
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
|
||||
|
||||
>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
|
||||
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
|
||||
|
||||
>>> np.pad(a, (2, 3), 'wrap')
|
||||
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
|
||||
|
||||
>>> def pad_with(vector, pad_width, iaxis, kwargs):
|
||||
... pad_value = kwargs.get('padder', 10)
|
||||
... vector[:pad_width[0]] = pad_value
|
||||
... vector[-pad_width[1]:] = pad_value
|
||||
>>> a = np.arange(6)
|
||||
>>> a = a.reshape((2, 3))
|
||||
>>> np.pad(a, 2, pad_with)
|
||||
array([[10, 10, 10, 10, 10, 10, 10],
|
||||
[10, 10, 10, 10, 10, 10, 10],
|
||||
[10, 10, 0, 1, 2, 10, 10],
|
||||
[10, 10, 3, 4, 5, 10, 10],
|
||||
[10, 10, 10, 10, 10, 10, 10],
|
||||
[10, 10, 10, 10, 10, 10, 10]])
|
||||
>>> np.pad(a, 2, pad_with, padder=100)
|
||||
array([[100, 100, 100, 100, 100, 100, 100],
|
||||
[100, 100, 100, 100, 100, 100, 100],
|
||||
[100, 100, 0, 1, 2, 100, 100],
|
||||
[100, 100, 3, 4, 5, 100, 100],
|
||||
[100, 100, 100, 100, 100, 100, 100],
|
||||
[100, 100, 100, 100, 100, 100, 100]])
|
||||
"""
|
||||
array = np.asarray(array)
|
||||
pad_width = np.asarray(pad_width)
|
||||
|
||||
if not pad_width.dtype.kind == 'i':
|
||||
raise TypeError('`pad_width` must be of integral type.')
|
||||
|
||||
# Broadcast to shape (array.ndim, 2)
|
||||
pad_width = _as_pairs(pad_width, array.ndim, as_index=True)
|
||||
|
||||
if callable(mode):
|
||||
# Old behavior: Use user-supplied function with np.apply_along_axis
|
||||
function = mode
|
||||
# Create a new zero padded array
|
||||
padded, _ = _pad_simple(array, pad_width, fill_value=0)
|
||||
# And apply along each axis
|
||||
|
||||
for axis in range(padded.ndim):
|
||||
# Iterate using ndindex as in apply_along_axis, but assuming that
|
||||
# function operates inplace on the padded array.
|
||||
|
||||
# view with the iteration axis at the end
|
||||
view = np.moveaxis(padded, axis, -1)
|
||||
|
||||
# compute indices for the iteration axes, and append a trailing
|
||||
# ellipsis to prevent 0d arrays decaying to scalars (gh-8642)
|
||||
inds = ndindex(view.shape[:-1])
|
||||
inds = (ind + (Ellipsis,) for ind in inds)
|
||||
for ind in inds:
|
||||
function(view[ind], pad_width[axis], axis, kwargs)
|
||||
|
||||
return padded
|
||||
|
||||
# Make sure that no unsupported keywords were passed for the current mode
|
||||
allowed_kwargs = {
|
||||
'empty': [], 'edge': [], 'wrap': [],
|
||||
'constant': ['constant_values'],
|
||||
'linear_ramp': ['end_values'],
|
||||
'maximum': ['stat_length'],
|
||||
'mean': ['stat_length'],
|
||||
'median': ['stat_length'],
|
||||
'minimum': ['stat_length'],
|
||||
'reflect': ['reflect_type'],
|
||||
'symmetric': ['reflect_type'],
|
||||
}
|
||||
try:
|
||||
unsupported_kwargs = set(kwargs) - set(allowed_kwargs[mode])
|
||||
except KeyError:
|
||||
raise ValueError("mode '{}' is not supported".format(mode)) from None
|
||||
if unsupported_kwargs:
|
||||
raise ValueError("unsupported keyword arguments for mode '{}': {}"
|
||||
.format(mode, unsupported_kwargs))
|
||||
|
||||
stat_functions = {"maximum": np.amax, "minimum": np.amin,
|
||||
"mean": np.mean, "median": np.median}
|
||||
|
||||
# Create array with final shape and original values
|
||||
# (padded area is undefined)
|
||||
padded, original_area_slice = _pad_simple(array, pad_width)
|
||||
# And prepare iteration over all dimensions
|
||||
# (zipping may be more readable than using enumerate)
|
||||
axes = range(padded.ndim)
|
||||
|
||||
if mode == "constant":
|
||||
values = kwargs.get("constant_values", 0)
|
||||
values = _as_pairs(values, padded.ndim)
|
||||
for axis, width_pair, value_pair in zip(axes, pad_width, values):
|
||||
roi = _view_roi(padded, original_area_slice, axis)
|
||||
_set_pad_area(roi, axis, width_pair, value_pair)
|
||||
|
||||
elif mode == "empty":
|
||||
pass # Do nothing as _pad_simple already returned the correct result
|
||||
|
||||
elif array.size == 0:
|
||||
# Only modes "constant" and "empty" can extend empty axes, all other
|
||||
# modes depend on `array` not being empty
|
||||
# -> ensure every empty axis is only "padded with 0"
|
||||
for axis, width_pair in zip(axes, pad_width):
|
||||
if array.shape[axis] == 0 and any(width_pair):
|
||||
raise ValueError(
|
||||
"can't extend empty axis {} using modes other than "
|
||||
"'constant' or 'empty'".format(axis)
|
||||
)
|
||||
# passed, don't need to do anything more as _pad_simple already
|
||||
# returned the correct result
|
||||
|
||||
elif mode == "edge":
|
||||
for axis, width_pair in zip(axes, pad_width):
|
||||
roi = _view_roi(padded, original_area_slice, axis)
|
||||
edge_pair = _get_edges(roi, axis, width_pair)
|
||||
_set_pad_area(roi, axis, width_pair, edge_pair)
|
||||
|
||||
elif mode == "linear_ramp":
|
||||
end_values = kwargs.get("end_values", 0)
|
||||
end_values = _as_pairs(end_values, padded.ndim)
|
||||
for axis, width_pair, value_pair in zip(axes, pad_width, end_values):
|
||||
roi = _view_roi(padded, original_area_slice, axis)
|
||||
ramp_pair = _get_linear_ramps(roi, axis, width_pair, value_pair)
|
||||
_set_pad_area(roi, axis, width_pair, ramp_pair)
|
||||
|
||||
elif mode in stat_functions:
|
||||
func = stat_functions[mode]
|
||||
length = kwargs.get("stat_length", None)
|
||||
length = _as_pairs(length, padded.ndim, as_index=True)
|
||||
for axis, width_pair, length_pair in zip(axes, pad_width, length):
|
||||
roi = _view_roi(padded, original_area_slice, axis)
|
||||
stat_pair = _get_stats(roi, axis, width_pair, length_pair, func)
|
||||
_set_pad_area(roi, axis, width_pair, stat_pair)
|
||||
|
||||
elif mode in {"reflect", "symmetric"}:
|
||||
method = kwargs.get("reflect_type", "even")
|
||||
include_edge = True if mode == "symmetric" else False
|
||||
for axis, (left_index, right_index) in zip(axes, pad_width):
|
||||
if array.shape[axis] == 1 and (left_index > 0 or right_index > 0):
|
||||
# Extending singleton dimension for 'reflect' is legacy
|
||||
# behavior; it really should raise an error.
|
||||
edge_pair = _get_edges(padded, axis, (left_index, right_index))
|
||||
_set_pad_area(
|
||||
padded, axis, (left_index, right_index), edge_pair)
|
||||
continue
|
||||
|
||||
roi = _view_roi(padded, original_area_slice, axis)
|
||||
while left_index > 0 or right_index > 0:
|
||||
# Iteratively pad until dimension is filled with reflected
|
||||
# values. This is necessary if the pad area is larger than
|
||||
# the length of the original values in the current dimension.
|
||||
left_index, right_index = _set_reflect_both(
|
||||
roi, axis, (left_index, right_index),
|
||||
method, include_edge
|
||||
)
|
||||
|
||||
elif mode == "wrap":
|
||||
for axis, (left_index, right_index) in zip(axes, pad_width):
|
||||
roi = _view_roi(padded, original_area_slice, axis)
|
||||
original_period = padded.shape[axis] - right_index - left_index
|
||||
while left_index > 0 or right_index > 0:
|
||||
# Iteratively pad until dimension is filled with wrapped
|
||||
# values. This is necessary if the pad area is larger than
|
||||
# the length of the original values in the current dimension.
|
||||
left_index, right_index = _set_wrap_both(
|
||||
roi, axis, (left_index, right_index), original_period)
|
||||
|
||||
return padded
|
||||
@@ -0,0 +1,85 @@
|
||||
from typing import (
|
||||
Literal as L,
|
||||
Any,
|
||||
overload,
|
||||
TypeVar,
|
||||
Protocol,
|
||||
)
|
||||
|
||||
from numpy import generic
|
||||
|
||||
from numpy._typing import (
|
||||
ArrayLike,
|
||||
NDArray,
|
||||
_ArrayLikeInt,
|
||||
_ArrayLike,
|
||||
)
|
||||
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
|
||||
class _ModeFunc(Protocol):
|
||||
def __call__(
|
||||
self,
|
||||
vector: NDArray[Any],
|
||||
iaxis_pad_width: tuple[int, int],
|
||||
iaxis: int,
|
||||
kwargs: dict[str, Any],
|
||||
/,
|
||||
) -> None: ...
|
||||
|
||||
_ModeKind = L[
|
||||
"constant",
|
||||
"edge",
|
||||
"linear_ramp",
|
||||
"maximum",
|
||||
"mean",
|
||||
"median",
|
||||
"minimum",
|
||||
"reflect",
|
||||
"symmetric",
|
||||
"wrap",
|
||||
"empty",
|
||||
]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# TODO: In practice each keyword argument is exclusive to one or more
|
||||
# specific modes. Consider adding more overloads to express this in the future.
|
||||
|
||||
# Expand `**kwargs` into explicit keyword-only arguments
|
||||
@overload
|
||||
def pad(
|
||||
array: _ArrayLike[_SCT],
|
||||
pad_width: _ArrayLikeInt,
|
||||
mode: _ModeKind = ...,
|
||||
*,
|
||||
stat_length: None | _ArrayLikeInt = ...,
|
||||
constant_values: ArrayLike = ...,
|
||||
end_values: ArrayLike = ...,
|
||||
reflect_type: L["odd", "even"] = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def pad(
|
||||
array: ArrayLike,
|
||||
pad_width: _ArrayLikeInt,
|
||||
mode: _ModeKind = ...,
|
||||
*,
|
||||
stat_length: None | _ArrayLikeInt = ...,
|
||||
constant_values: ArrayLike = ...,
|
||||
end_values: ArrayLike = ...,
|
||||
reflect_type: L["odd", "even"] = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def pad(
|
||||
array: _ArrayLike[_SCT],
|
||||
pad_width: _ArrayLikeInt,
|
||||
mode: _ModeFunc,
|
||||
**kwargs: Any,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def pad(
|
||||
array: ArrayLike,
|
||||
pad_width: _ArrayLikeInt,
|
||||
mode: _ModeFunc,
|
||||
**kwargs: Any,
|
||||
) -> NDArray[Any]: ...
|
||||
@@ -0,0 +1,981 @@
|
||||
"""
|
||||
Set operations for arrays based on sorting.
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
For floating point arrays, inaccurate results may appear due to usual round-off
|
||||
and floating point comparison issues.
|
||||
|
||||
Speed could be gained in some operations by an implementation of
|
||||
`numpy.sort`, that can provide directly the permutation vectors, thus avoiding
|
||||
calls to `numpy.argsort`.
|
||||
|
||||
Original author: Robert Cimrman
|
||||
|
||||
"""
|
||||
import functools
|
||||
|
||||
import numpy as np
|
||||
from numpy.core import overrides
|
||||
|
||||
|
||||
array_function_dispatch = functools.partial(
|
||||
overrides.array_function_dispatch, module='numpy')
|
||||
|
||||
|
||||
__all__ = [
|
||||
'ediff1d', 'intersect1d', 'setxor1d', 'union1d', 'setdiff1d', 'unique',
|
||||
'in1d', 'isin'
|
||||
]
|
||||
|
||||
|
||||
def _ediff1d_dispatcher(ary, to_end=None, to_begin=None):
|
||||
return (ary, to_end, to_begin)
|
||||
|
||||
|
||||
@array_function_dispatch(_ediff1d_dispatcher)
|
||||
def ediff1d(ary, to_end=None, to_begin=None):
|
||||
"""
|
||||
The differences between consecutive elements of an array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ary : array_like
|
||||
If necessary, will be flattened before the differences are taken.
|
||||
to_end : array_like, optional
|
||||
Number(s) to append at the end of the returned differences.
|
||||
to_begin : array_like, optional
|
||||
Number(s) to prepend at the beginning of the returned differences.
|
||||
|
||||
Returns
|
||||
-------
|
||||
ediff1d : ndarray
|
||||
The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
|
||||
|
||||
See Also
|
||||
--------
|
||||
diff, gradient
|
||||
|
||||
Notes
|
||||
-----
|
||||
When applied to masked arrays, this function drops the mask information
|
||||
if the `to_begin` and/or `to_end` parameters are used.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> x = np.array([1, 2, 4, 7, 0])
|
||||
>>> np.ediff1d(x)
|
||||
array([ 1, 2, 3, -7])
|
||||
|
||||
>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
|
||||
array([-99, 1, 2, ..., -7, 88, 99])
|
||||
|
||||
The returned array is always 1D.
|
||||
|
||||
>>> y = [[1, 2, 4], [1, 6, 24]]
|
||||
>>> np.ediff1d(y)
|
||||
array([ 1, 2, -3, 5, 18])
|
||||
|
||||
"""
|
||||
# force a 1d array
|
||||
ary = np.asanyarray(ary).ravel()
|
||||
|
||||
# enforce that the dtype of `ary` is used for the output
|
||||
dtype_req = ary.dtype
|
||||
|
||||
# fast track default case
|
||||
if to_begin is None and to_end is None:
|
||||
return ary[1:] - ary[:-1]
|
||||
|
||||
if to_begin is None:
|
||||
l_begin = 0
|
||||
else:
|
||||
to_begin = np.asanyarray(to_begin)
|
||||
if not np.can_cast(to_begin, dtype_req, casting="same_kind"):
|
||||
raise TypeError("dtype of `to_begin` must be compatible "
|
||||
"with input `ary` under the `same_kind` rule.")
|
||||
|
||||
to_begin = to_begin.ravel()
|
||||
l_begin = len(to_begin)
|
||||
|
||||
if to_end is None:
|
||||
l_end = 0
|
||||
else:
|
||||
to_end = np.asanyarray(to_end)
|
||||
if not np.can_cast(to_end, dtype_req, casting="same_kind"):
|
||||
raise TypeError("dtype of `to_end` must be compatible "
|
||||
"with input `ary` under the `same_kind` rule.")
|
||||
|
||||
to_end = to_end.ravel()
|
||||
l_end = len(to_end)
|
||||
|
||||
# do the calculation in place and copy to_begin and to_end
|
||||
l_diff = max(len(ary) - 1, 0)
|
||||
result = np.empty(l_diff + l_begin + l_end, dtype=ary.dtype)
|
||||
result = ary.__array_wrap__(result)
|
||||
if l_begin > 0:
|
||||
result[:l_begin] = to_begin
|
||||
if l_end > 0:
|
||||
result[l_begin + l_diff:] = to_end
|
||||
np.subtract(ary[1:], ary[:-1], result[l_begin:l_begin + l_diff])
|
||||
return result
|
||||
|
||||
|
||||
def _unpack_tuple(x):
|
||||
""" Unpacks one-element tuples for use as return values """
|
||||
if len(x) == 1:
|
||||
return x[0]
|
||||
else:
|
||||
return x
|
||||
|
||||
|
||||
def _unique_dispatcher(ar, return_index=None, return_inverse=None,
|
||||
return_counts=None, axis=None, *, equal_nan=None):
|
||||
return (ar,)
|
||||
|
||||
|
||||
@array_function_dispatch(_unique_dispatcher)
|
||||
def unique(ar, return_index=False, return_inverse=False,
|
||||
return_counts=False, axis=None, *, equal_nan=True):
|
||||
"""
|
||||
Find the unique elements of an array.
|
||||
|
||||
Returns the sorted unique elements of an array. There are three optional
|
||||
outputs in addition to the unique elements:
|
||||
|
||||
* the indices of the input array that give the unique values
|
||||
* the indices of the unique array that reconstruct the input array
|
||||
* the number of times each unique value comes up in the input array
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ar : array_like
|
||||
Input array. Unless `axis` is specified, this will be flattened if it
|
||||
is not already 1-D.
|
||||
return_index : bool, optional
|
||||
If True, also return the indices of `ar` (along the specified axis,
|
||||
if provided, or in the flattened array) that result in the unique array.
|
||||
return_inverse : bool, optional
|
||||
If True, also return the indices of the unique array (for the specified
|
||||
axis, if provided) that can be used to reconstruct `ar`.
|
||||
return_counts : bool, optional
|
||||
If True, also return the number of times each unique item appears
|
||||
in `ar`.
|
||||
axis : int or None, optional
|
||||
The axis to operate on. If None, `ar` will be flattened. If an integer,
|
||||
the subarrays indexed by the given axis will be flattened and treated
|
||||
as the elements of a 1-D array with the dimension of the given axis,
|
||||
see the notes for more details. Object arrays or structured arrays
|
||||
that contain objects are not supported if the `axis` kwarg is used. The
|
||||
default is None.
|
||||
|
||||
.. versionadded:: 1.13.0
|
||||
|
||||
equal_nan : bool, optional
|
||||
If True, collapses multiple NaN values in the return array into one.
|
||||
|
||||
.. versionadded:: 1.24
|
||||
|
||||
Returns
|
||||
-------
|
||||
unique : ndarray
|
||||
The sorted unique values.
|
||||
unique_indices : ndarray, optional
|
||||
The indices of the first occurrences of the unique values in the
|
||||
original array. Only provided if `return_index` is True.
|
||||
unique_inverse : ndarray, optional
|
||||
The indices to reconstruct the original array from the
|
||||
unique array. Only provided if `return_inverse` is True.
|
||||
unique_counts : ndarray, optional
|
||||
The number of times each of the unique values comes up in the
|
||||
original array. Only provided if `return_counts` is True.
|
||||
|
||||
.. versionadded:: 1.9.0
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.lib.arraysetops : Module with a number of other functions for
|
||||
performing set operations on arrays.
|
||||
repeat : Repeat elements of an array.
|
||||
|
||||
Notes
|
||||
-----
|
||||
When an axis is specified the subarrays indexed by the axis are sorted.
|
||||
This is done by making the specified axis the first dimension of the array
|
||||
(move the axis to the first dimension to keep the order of the other axes)
|
||||
and then flattening the subarrays in C order. The flattened subarrays are
|
||||
then viewed as a structured type with each element given a label, with the
|
||||
effect that we end up with a 1-D array of structured types that can be
|
||||
treated in the same way as any other 1-D array. The result is that the
|
||||
flattened subarrays are sorted in lexicographic order starting with the
|
||||
first element.
|
||||
|
||||
.. versionchanged: NumPy 1.21
|
||||
If nan values are in the input array, a single nan is put
|
||||
to the end of the sorted unique values.
|
||||
|
||||
Also for complex arrays all NaN values are considered equivalent
|
||||
(no matter whether the NaN is in the real or imaginary part).
|
||||
As the representant for the returned array the smallest one in the
|
||||
lexicographical order is chosen - see np.sort for how the lexicographical
|
||||
order is defined for complex arrays.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.unique([1, 1, 2, 2, 3, 3])
|
||||
array([1, 2, 3])
|
||||
>>> a = np.array([[1, 1], [2, 3]])
|
||||
>>> np.unique(a)
|
||||
array([1, 2, 3])
|
||||
|
||||
Return the unique rows of a 2D array
|
||||
|
||||
>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
|
||||
>>> np.unique(a, axis=0)
|
||||
array([[1, 0, 0], [2, 3, 4]])
|
||||
|
||||
Return the indices of the original array that give the unique values:
|
||||
|
||||
>>> a = np.array(['a', 'b', 'b', 'c', 'a'])
|
||||
>>> u, indices = np.unique(a, return_index=True)
|
||||
>>> u
|
||||
array(['a', 'b', 'c'], dtype='<U1')
|
||||
>>> indices
|
||||
array([0, 1, 3])
|
||||
>>> a[indices]
|
||||
array(['a', 'b', 'c'], dtype='<U1')
|
||||
|
||||
Reconstruct the input array from the unique values and inverse:
|
||||
|
||||
>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
|
||||
>>> u, indices = np.unique(a, return_inverse=True)
|
||||
>>> u
|
||||
array([1, 2, 3, 4, 6])
|
||||
>>> indices
|
||||
array([0, 1, 4, 3, 1, 2, 1])
|
||||
>>> u[indices]
|
||||
array([1, 2, 6, 4, 2, 3, 2])
|
||||
|
||||
Reconstruct the input values from the unique values and counts:
|
||||
|
||||
>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
|
||||
>>> values, counts = np.unique(a, return_counts=True)
|
||||
>>> values
|
||||
array([1, 2, 3, 4, 6])
|
||||
>>> counts
|
||||
array([1, 3, 1, 1, 1])
|
||||
>>> np.repeat(values, counts)
|
||||
array([1, 2, 2, 2, 3, 4, 6]) # original order not preserved
|
||||
|
||||
"""
|
||||
ar = np.asanyarray(ar)
|
||||
if axis is None:
|
||||
ret = _unique1d(ar, return_index, return_inverse, return_counts,
|
||||
equal_nan=equal_nan)
|
||||
return _unpack_tuple(ret)
|
||||
|
||||
# axis was specified and not None
|
||||
try:
|
||||
ar = np.moveaxis(ar, axis, 0)
|
||||
except np.AxisError:
|
||||
# this removes the "axis1" or "axis2" prefix from the error message
|
||||
raise np.AxisError(axis, ar.ndim) from None
|
||||
|
||||
# Must reshape to a contiguous 2D array for this to work...
|
||||
orig_shape, orig_dtype = ar.shape, ar.dtype
|
||||
ar = ar.reshape(orig_shape[0], np.prod(orig_shape[1:], dtype=np.intp))
|
||||
ar = np.ascontiguousarray(ar)
|
||||
dtype = [('f{i}'.format(i=i), ar.dtype) for i in range(ar.shape[1])]
|
||||
|
||||
# At this point, `ar` has shape `(n, m)`, and `dtype` is a structured
|
||||
# data type with `m` fields where each field has the data type of `ar`.
|
||||
# In the following, we create the array `consolidated`, which has
|
||||
# shape `(n,)` with data type `dtype`.
|
||||
try:
|
||||
if ar.shape[1] > 0:
|
||||
consolidated = ar.view(dtype)
|
||||
else:
|
||||
# If ar.shape[1] == 0, then dtype will be `np.dtype([])`, which is
|
||||
# a data type with itemsize 0, and the call `ar.view(dtype)` will
|
||||
# fail. Instead, we'll use `np.empty` to explicitly create the
|
||||
# array with shape `(len(ar),)`. Because `dtype` in this case has
|
||||
# itemsize 0, the total size of the result is still 0 bytes.
|
||||
consolidated = np.empty(len(ar), dtype=dtype)
|
||||
except TypeError as e:
|
||||
# There's no good way to do this for object arrays, etc...
|
||||
msg = 'The axis argument to unique is not supported for dtype {dt}'
|
||||
raise TypeError(msg.format(dt=ar.dtype)) from e
|
||||
|
||||
def reshape_uniq(uniq):
|
||||
n = len(uniq)
|
||||
uniq = uniq.view(orig_dtype)
|
||||
uniq = uniq.reshape(n, *orig_shape[1:])
|
||||
uniq = np.moveaxis(uniq, 0, axis)
|
||||
return uniq
|
||||
|
||||
output = _unique1d(consolidated, return_index,
|
||||
return_inverse, return_counts, equal_nan=equal_nan)
|
||||
output = (reshape_uniq(output[0]),) + output[1:]
|
||||
return _unpack_tuple(output)
|
||||
|
||||
|
||||
def _unique1d(ar, return_index=False, return_inverse=False,
|
||||
return_counts=False, *, equal_nan=True):
|
||||
"""
|
||||
Find the unique elements of an array, ignoring shape.
|
||||
"""
|
||||
ar = np.asanyarray(ar).flatten()
|
||||
|
||||
optional_indices = return_index or return_inverse
|
||||
|
||||
if optional_indices:
|
||||
perm = ar.argsort(kind='mergesort' if return_index else 'quicksort')
|
||||
aux = ar[perm]
|
||||
else:
|
||||
ar.sort()
|
||||
aux = ar
|
||||
mask = np.empty(aux.shape, dtype=np.bool_)
|
||||
mask[:1] = True
|
||||
if (equal_nan and aux.shape[0] > 0 and aux.dtype.kind in "cfmM" and
|
||||
np.isnan(aux[-1])):
|
||||
if aux.dtype.kind == "c": # for complex all NaNs are considered equivalent
|
||||
aux_firstnan = np.searchsorted(np.isnan(aux), True, side='left')
|
||||
else:
|
||||
aux_firstnan = np.searchsorted(aux, aux[-1], side='left')
|
||||
if aux_firstnan > 0:
|
||||
mask[1:aux_firstnan] = (
|
||||
aux[1:aux_firstnan] != aux[:aux_firstnan - 1])
|
||||
mask[aux_firstnan] = True
|
||||
mask[aux_firstnan + 1:] = False
|
||||
else:
|
||||
mask[1:] = aux[1:] != aux[:-1]
|
||||
|
||||
ret = (aux[mask],)
|
||||
if return_index:
|
||||
ret += (perm[mask],)
|
||||
if return_inverse:
|
||||
imask = np.cumsum(mask) - 1
|
||||
inv_idx = np.empty(mask.shape, dtype=np.intp)
|
||||
inv_idx[perm] = imask
|
||||
ret += (inv_idx,)
|
||||
if return_counts:
|
||||
idx = np.concatenate(np.nonzero(mask) + ([mask.size],))
|
||||
ret += (np.diff(idx),)
|
||||
return ret
|
||||
|
||||
|
||||
def _intersect1d_dispatcher(
|
||||
ar1, ar2, assume_unique=None, return_indices=None):
|
||||
return (ar1, ar2)
|
||||
|
||||
|
||||
@array_function_dispatch(_intersect1d_dispatcher)
|
||||
def intersect1d(ar1, ar2, assume_unique=False, return_indices=False):
|
||||
"""
|
||||
Find the intersection of two arrays.
|
||||
|
||||
Return the sorted, unique values that are in both of the input arrays.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ar1, ar2 : array_like
|
||||
Input arrays. Will be flattened if not already 1D.
|
||||
assume_unique : bool
|
||||
If True, the input arrays are both assumed to be unique, which
|
||||
can speed up the calculation. If True but ``ar1`` or ``ar2`` are not
|
||||
unique, incorrect results and out-of-bounds indices could result.
|
||||
Default is False.
|
||||
return_indices : bool
|
||||
If True, the indices which correspond to the intersection of the two
|
||||
arrays are returned. The first instance of a value is used if there are
|
||||
multiple. Default is False.
|
||||
|
||||
.. versionadded:: 1.15.0
|
||||
|
||||
Returns
|
||||
-------
|
||||
intersect1d : ndarray
|
||||
Sorted 1D array of common and unique elements.
|
||||
comm1 : ndarray
|
||||
The indices of the first occurrences of the common values in `ar1`.
|
||||
Only provided if `return_indices` is True.
|
||||
comm2 : ndarray
|
||||
The indices of the first occurrences of the common values in `ar2`.
|
||||
Only provided if `return_indices` is True.
|
||||
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.lib.arraysetops : Module with a number of other functions for
|
||||
performing set operations on arrays.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
|
||||
array([1, 3])
|
||||
|
||||
To intersect more than two arrays, use functools.reduce:
|
||||
|
||||
>>> from functools import reduce
|
||||
>>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
|
||||
array([3])
|
||||
|
||||
To return the indices of the values common to the input arrays
|
||||
along with the intersected values:
|
||||
|
||||
>>> x = np.array([1, 1, 2, 3, 4])
|
||||
>>> y = np.array([2, 1, 4, 6])
|
||||
>>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
|
||||
>>> x_ind, y_ind
|
||||
(array([0, 2, 4]), array([1, 0, 2]))
|
||||
>>> xy, x[x_ind], y[y_ind]
|
||||
(array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))
|
||||
|
||||
"""
|
||||
ar1 = np.asanyarray(ar1)
|
||||
ar2 = np.asanyarray(ar2)
|
||||
|
||||
if not assume_unique:
|
||||
if return_indices:
|
||||
ar1, ind1 = unique(ar1, return_index=True)
|
||||
ar2, ind2 = unique(ar2, return_index=True)
|
||||
else:
|
||||
ar1 = unique(ar1)
|
||||
ar2 = unique(ar2)
|
||||
else:
|
||||
ar1 = ar1.ravel()
|
||||
ar2 = ar2.ravel()
|
||||
|
||||
aux = np.concatenate((ar1, ar2))
|
||||
if return_indices:
|
||||
aux_sort_indices = np.argsort(aux, kind='mergesort')
|
||||
aux = aux[aux_sort_indices]
|
||||
else:
|
||||
aux.sort()
|
||||
|
||||
mask = aux[1:] == aux[:-1]
|
||||
int1d = aux[:-1][mask]
|
||||
|
||||
if return_indices:
|
||||
ar1_indices = aux_sort_indices[:-1][mask]
|
||||
ar2_indices = aux_sort_indices[1:][mask] - ar1.size
|
||||
if not assume_unique:
|
||||
ar1_indices = ind1[ar1_indices]
|
||||
ar2_indices = ind2[ar2_indices]
|
||||
|
||||
return int1d, ar1_indices, ar2_indices
|
||||
else:
|
||||
return int1d
|
||||
|
||||
|
||||
def _setxor1d_dispatcher(ar1, ar2, assume_unique=None):
|
||||
return (ar1, ar2)
|
||||
|
||||
|
||||
@array_function_dispatch(_setxor1d_dispatcher)
|
||||
def setxor1d(ar1, ar2, assume_unique=False):
|
||||
"""
|
||||
Find the set exclusive-or of two arrays.
|
||||
|
||||
Return the sorted, unique values that are in only one (not both) of the
|
||||
input arrays.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ar1, ar2 : array_like
|
||||
Input arrays.
|
||||
assume_unique : bool
|
||||
If True, the input arrays are both assumed to be unique, which
|
||||
can speed up the calculation. Default is False.
|
||||
|
||||
Returns
|
||||
-------
|
||||
setxor1d : ndarray
|
||||
Sorted 1D array of unique values that are in only one of the input
|
||||
arrays.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.array([1, 2, 3, 2, 4])
|
||||
>>> b = np.array([2, 3, 5, 7, 5])
|
||||
>>> np.setxor1d(a,b)
|
||||
array([1, 4, 5, 7])
|
||||
|
||||
"""
|
||||
if not assume_unique:
|
||||
ar1 = unique(ar1)
|
||||
ar2 = unique(ar2)
|
||||
|
||||
aux = np.concatenate((ar1, ar2))
|
||||
if aux.size == 0:
|
||||
return aux
|
||||
|
||||
aux.sort()
|
||||
flag = np.concatenate(([True], aux[1:] != aux[:-1], [True]))
|
||||
return aux[flag[1:] & flag[:-1]]
|
||||
|
||||
|
||||
def _in1d_dispatcher(ar1, ar2, assume_unique=None, invert=None, *,
|
||||
kind=None):
|
||||
return (ar1, ar2)
|
||||
|
||||
|
||||
@array_function_dispatch(_in1d_dispatcher)
|
||||
def in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None):
|
||||
"""
|
||||
Test whether each element of a 1-D array is also present in a second array.
|
||||
|
||||
Returns a boolean array the same length as `ar1` that is True
|
||||
where an element of `ar1` is in `ar2` and False otherwise.
|
||||
|
||||
We recommend using :func:`isin` instead of `in1d` for new code.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ar1 : (M,) array_like
|
||||
Input array.
|
||||
ar2 : array_like
|
||||
The values against which to test each value of `ar1`.
|
||||
assume_unique : bool, optional
|
||||
If True, the input arrays are both assumed to be unique, which
|
||||
can speed up the calculation. Default is False.
|
||||
invert : bool, optional
|
||||
If True, the values in the returned array are inverted (that is,
|
||||
False where an element of `ar1` is in `ar2` and True otherwise).
|
||||
Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
|
||||
to (but is faster than) ``np.invert(in1d(a, b))``.
|
||||
kind : {None, 'sort', 'table'}, optional
|
||||
The algorithm to use. This will not affect the final result,
|
||||
but will affect the speed and memory use. The default, None,
|
||||
will select automatically based on memory considerations.
|
||||
|
||||
* If 'sort', will use a mergesort-based approach. This will have
|
||||
a memory usage of roughly 6 times the sum of the sizes of
|
||||
`ar1` and `ar2`, not accounting for size of dtypes.
|
||||
* If 'table', will use a lookup table approach similar
|
||||
to a counting sort. This is only available for boolean and
|
||||
integer arrays. This will have a memory usage of the
|
||||
size of `ar1` plus the max-min value of `ar2`. `assume_unique`
|
||||
has no effect when the 'table' option is used.
|
||||
* If None, will automatically choose 'table' if
|
||||
the required memory allocation is less than or equal to
|
||||
6 times the sum of the sizes of `ar1` and `ar2`,
|
||||
otherwise will use 'sort'. This is done to not use
|
||||
a large amount of memory by default, even though
|
||||
'table' may be faster in most cases. If 'table' is chosen,
|
||||
`assume_unique` will have no effect.
|
||||
|
||||
.. versionadded:: 1.8.0
|
||||
|
||||
Returns
|
||||
-------
|
||||
in1d : (M,) ndarray, bool
|
||||
The values `ar1[in1d]` are in `ar2`.
|
||||
|
||||
See Also
|
||||
--------
|
||||
isin : Version of this function that preserves the
|
||||
shape of ar1.
|
||||
numpy.lib.arraysetops : Module with a number of other functions for
|
||||
performing set operations on arrays.
|
||||
|
||||
Notes
|
||||
-----
|
||||
`in1d` can be considered as an element-wise function version of the
|
||||
python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
|
||||
equivalent to ``np.array([item in b for item in a])``.
|
||||
However, this idea fails if `ar2` is a set, or similar (non-sequence)
|
||||
container: As ``ar2`` is converted to an array, in those cases
|
||||
``asarray(ar2)`` is an object array rather than the expected array of
|
||||
contained values.
|
||||
|
||||
Using ``kind='table'`` tends to be faster than `kind='sort'` if the
|
||||
following relationship is true:
|
||||
``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
|
||||
but may use greater memory. The default value for `kind` will
|
||||
be automatically selected based only on memory usage, so one may
|
||||
manually set ``kind='table'`` if memory constraints can be relaxed.
|
||||
|
||||
.. versionadded:: 1.4.0
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> test = np.array([0, 1, 2, 5, 0])
|
||||
>>> states = [0, 2]
|
||||
>>> mask = np.in1d(test, states)
|
||||
>>> mask
|
||||
array([ True, False, True, False, True])
|
||||
>>> test[mask]
|
||||
array([0, 2, 0])
|
||||
>>> mask = np.in1d(test, states, invert=True)
|
||||
>>> mask
|
||||
array([False, True, False, True, False])
|
||||
>>> test[mask]
|
||||
array([1, 5])
|
||||
"""
|
||||
# Ravel both arrays, behavior for the first array could be different
|
||||
ar1 = np.asarray(ar1).ravel()
|
||||
ar2 = np.asarray(ar2).ravel()
|
||||
|
||||
# Ensure that iteration through object arrays yields size-1 arrays
|
||||
if ar2.dtype == object:
|
||||
ar2 = ar2.reshape(-1, 1)
|
||||
|
||||
if kind not in {None, 'sort', 'table'}:
|
||||
raise ValueError(
|
||||
f"Invalid kind: '{kind}'. Please use None, 'sort' or 'table'.")
|
||||
|
||||
# Can use the table method if all arrays are integers or boolean:
|
||||
is_int_arrays = all(ar.dtype.kind in ("u", "i", "b") for ar in (ar1, ar2))
|
||||
use_table_method = is_int_arrays and kind in {None, 'table'}
|
||||
|
||||
if use_table_method:
|
||||
if ar2.size == 0:
|
||||
if invert:
|
||||
return np.ones_like(ar1, dtype=bool)
|
||||
else:
|
||||
return np.zeros_like(ar1, dtype=bool)
|
||||
|
||||
# Convert booleans to uint8 so we can use the fast integer algorithm
|
||||
if ar1.dtype == bool:
|
||||
ar1 = ar1.astype(np.uint8)
|
||||
if ar2.dtype == bool:
|
||||
ar2 = ar2.astype(np.uint8)
|
||||
|
||||
ar2_min = np.min(ar2)
|
||||
ar2_max = np.max(ar2)
|
||||
|
||||
ar2_range = int(ar2_max) - int(ar2_min)
|
||||
|
||||
# Constraints on whether we can actually use the table method:
|
||||
# 1. Assert memory usage is not too large
|
||||
below_memory_constraint = ar2_range <= 6 * (ar1.size + ar2.size)
|
||||
# 2. Check overflows for (ar2 - ar2_min); dtype=ar2.dtype
|
||||
range_safe_from_overflow = ar2_range <= np.iinfo(ar2.dtype).max
|
||||
# 3. Check overflows for (ar1 - ar2_min); dtype=ar1.dtype
|
||||
if ar1.size > 0:
|
||||
ar1_min = np.min(ar1)
|
||||
ar1_max = np.max(ar1)
|
||||
|
||||
# After masking, the range of ar1 is guaranteed to be
|
||||
# within the range of ar2:
|
||||
ar1_upper = min(int(ar1_max), int(ar2_max))
|
||||
ar1_lower = max(int(ar1_min), int(ar2_min))
|
||||
|
||||
range_safe_from_overflow &= all((
|
||||
ar1_upper - int(ar2_min) <= np.iinfo(ar1.dtype).max,
|
||||
ar1_lower - int(ar2_min) >= np.iinfo(ar1.dtype).min
|
||||
))
|
||||
|
||||
# Optimal performance is for approximately
|
||||
# log10(size) > (log10(range) - 2.27) / 0.927.
|
||||
# However, here we set the requirement that by default
|
||||
# the intermediate array can only be 6x
|
||||
# the combined memory allocation of the original
|
||||
# arrays. See discussion on
|
||||
# https://github.com/numpy/numpy/pull/12065.
|
||||
|
||||
if (
|
||||
range_safe_from_overflow and
|
||||
(below_memory_constraint or kind == 'table')
|
||||
):
|
||||
|
||||
if invert:
|
||||
outgoing_array = np.ones_like(ar1, dtype=bool)
|
||||
else:
|
||||
outgoing_array = np.zeros_like(ar1, dtype=bool)
|
||||
|
||||
# Make elements 1 where the integer exists in ar2
|
||||
if invert:
|
||||
isin_helper_ar = np.ones(ar2_range + 1, dtype=bool)
|
||||
isin_helper_ar[ar2 - ar2_min] = 0
|
||||
else:
|
||||
isin_helper_ar = np.zeros(ar2_range + 1, dtype=bool)
|
||||
isin_helper_ar[ar2 - ar2_min] = 1
|
||||
|
||||
# Mask out elements we know won't work
|
||||
basic_mask = (ar1 <= ar2_max) & (ar1 >= ar2_min)
|
||||
outgoing_array[basic_mask] = isin_helper_ar[ar1[basic_mask] -
|
||||
ar2_min]
|
||||
|
||||
return outgoing_array
|
||||
elif kind == 'table': # not range_safe_from_overflow
|
||||
raise RuntimeError(
|
||||
"You have specified kind='table', "
|
||||
"but the range of values in `ar2` or `ar1` exceed the "
|
||||
"maximum integer of the datatype. "
|
||||
"Please set `kind` to None or 'sort'."
|
||||
)
|
||||
elif kind == 'table':
|
||||
raise ValueError(
|
||||
"The 'table' method is only "
|
||||
"supported for boolean or integer arrays. "
|
||||
"Please select 'sort' or None for kind."
|
||||
)
|
||||
|
||||
|
||||
# Check if one of the arrays may contain arbitrary objects
|
||||
contains_object = ar1.dtype.hasobject or ar2.dtype.hasobject
|
||||
|
||||
# This code is run when
|
||||
# a) the first condition is true, making the code significantly faster
|
||||
# b) the second condition is true (i.e. `ar1` or `ar2` may contain
|
||||
# arbitrary objects), since then sorting is not guaranteed to work
|
||||
if len(ar2) < 10 * len(ar1) ** 0.145 or contains_object:
|
||||
if invert:
|
||||
mask = np.ones(len(ar1), dtype=bool)
|
||||
for a in ar2:
|
||||
mask &= (ar1 != a)
|
||||
else:
|
||||
mask = np.zeros(len(ar1), dtype=bool)
|
||||
for a in ar2:
|
||||
mask |= (ar1 == a)
|
||||
return mask
|
||||
|
||||
# Otherwise use sorting
|
||||
if not assume_unique:
|
||||
ar1, rev_idx = np.unique(ar1, return_inverse=True)
|
||||
ar2 = np.unique(ar2)
|
||||
|
||||
ar = np.concatenate((ar1, ar2))
|
||||
# We need this to be a stable sort, so always use 'mergesort'
|
||||
# here. The values from the first array should always come before
|
||||
# the values from the second array.
|
||||
order = ar.argsort(kind='mergesort')
|
||||
sar = ar[order]
|
||||
if invert:
|
||||
bool_ar = (sar[1:] != sar[:-1])
|
||||
else:
|
||||
bool_ar = (sar[1:] == sar[:-1])
|
||||
flag = np.concatenate((bool_ar, [invert]))
|
||||
ret = np.empty(ar.shape, dtype=bool)
|
||||
ret[order] = flag
|
||||
|
||||
if assume_unique:
|
||||
return ret[:len(ar1)]
|
||||
else:
|
||||
return ret[rev_idx]
|
||||
|
||||
|
||||
def _isin_dispatcher(element, test_elements, assume_unique=None, invert=None,
|
||||
*, kind=None):
|
||||
return (element, test_elements)
|
||||
|
||||
|
||||
@array_function_dispatch(_isin_dispatcher)
|
||||
def isin(element, test_elements, assume_unique=False, invert=False, *,
|
||||
kind=None):
|
||||
"""
|
||||
Calculates ``element in test_elements``, broadcasting over `element` only.
|
||||
Returns a boolean array of the same shape as `element` that is True
|
||||
where an element of `element` is in `test_elements` and False otherwise.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
element : array_like
|
||||
Input array.
|
||||
test_elements : array_like
|
||||
The values against which to test each value of `element`.
|
||||
This argument is flattened if it is an array or array_like.
|
||||
See notes for behavior with non-array-like parameters.
|
||||
assume_unique : bool, optional
|
||||
If True, the input arrays are both assumed to be unique, which
|
||||
can speed up the calculation. Default is False.
|
||||
invert : bool, optional
|
||||
If True, the values in the returned array are inverted, as if
|
||||
calculating `element not in test_elements`. Default is False.
|
||||
``np.isin(a, b, invert=True)`` is equivalent to (but faster
|
||||
than) ``np.invert(np.isin(a, b))``.
|
||||
kind : {None, 'sort', 'table'}, optional
|
||||
The algorithm to use. This will not affect the final result,
|
||||
but will affect the speed and memory use. The default, None,
|
||||
will select automatically based on memory considerations.
|
||||
|
||||
* If 'sort', will use a mergesort-based approach. This will have
|
||||
a memory usage of roughly 6 times the sum of the sizes of
|
||||
`ar1` and `ar2`, not accounting for size of dtypes.
|
||||
* If 'table', will use a lookup table approach similar
|
||||
to a counting sort. This is only available for boolean and
|
||||
integer arrays. This will have a memory usage of the
|
||||
size of `ar1` plus the max-min value of `ar2`. `assume_unique`
|
||||
has no effect when the 'table' option is used.
|
||||
* If None, will automatically choose 'table' if
|
||||
the required memory allocation is less than or equal to
|
||||
6 times the sum of the sizes of `ar1` and `ar2`,
|
||||
otherwise will use 'sort'. This is done to not use
|
||||
a large amount of memory by default, even though
|
||||
'table' may be faster in most cases. If 'table' is chosen,
|
||||
`assume_unique` will have no effect.
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
isin : ndarray, bool
|
||||
Has the same shape as `element`. The values `element[isin]`
|
||||
are in `test_elements`.
|
||||
|
||||
See Also
|
||||
--------
|
||||
in1d : Flattened version of this function.
|
||||
numpy.lib.arraysetops : Module with a number of other functions for
|
||||
performing set operations on arrays.
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
`isin` is an element-wise function version of the python keyword `in`.
|
||||
``isin(a, b)`` is roughly equivalent to
|
||||
``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
|
||||
|
||||
`element` and `test_elements` are converted to arrays if they are not
|
||||
already. If `test_elements` is a set (or other non-sequence collection)
|
||||
it will be converted to an object array with one element, rather than an
|
||||
array of the values contained in `test_elements`. This is a consequence
|
||||
of the `array` constructor's way of handling non-sequence collections.
|
||||
Converting the set to a list usually gives the desired behavior.
|
||||
|
||||
Using ``kind='table'`` tends to be faster than `kind='sort'` if the
|
||||
following relationship is true:
|
||||
``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
|
||||
but may use greater memory. The default value for `kind` will
|
||||
be automatically selected based only on memory usage, so one may
|
||||
manually set ``kind='table'`` if memory constraints can be relaxed.
|
||||
|
||||
.. versionadded:: 1.13.0
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> element = 2*np.arange(4).reshape((2, 2))
|
||||
>>> element
|
||||
array([[0, 2],
|
||||
[4, 6]])
|
||||
>>> test_elements = [1, 2, 4, 8]
|
||||
>>> mask = np.isin(element, test_elements)
|
||||
>>> mask
|
||||
array([[False, True],
|
||||
[ True, False]])
|
||||
>>> element[mask]
|
||||
array([2, 4])
|
||||
|
||||
The indices of the matched values can be obtained with `nonzero`:
|
||||
|
||||
>>> np.nonzero(mask)
|
||||
(array([0, 1]), array([1, 0]))
|
||||
|
||||
The test can also be inverted:
|
||||
|
||||
>>> mask = np.isin(element, test_elements, invert=True)
|
||||
>>> mask
|
||||
array([[ True, False],
|
||||
[False, True]])
|
||||
>>> element[mask]
|
||||
array([0, 6])
|
||||
|
||||
Because of how `array` handles sets, the following does not
|
||||
work as expected:
|
||||
|
||||
>>> test_set = {1, 2, 4, 8}
|
||||
>>> np.isin(element, test_set)
|
||||
array([[False, False],
|
||||
[False, False]])
|
||||
|
||||
Casting the set to a list gives the expected result:
|
||||
|
||||
>>> np.isin(element, list(test_set))
|
||||
array([[False, True],
|
||||
[ True, False]])
|
||||
"""
|
||||
element = np.asarray(element)
|
||||
return in1d(element, test_elements, assume_unique=assume_unique,
|
||||
invert=invert, kind=kind).reshape(element.shape)
|
||||
|
||||
|
||||
def _union1d_dispatcher(ar1, ar2):
|
||||
return (ar1, ar2)
|
||||
|
||||
|
||||
@array_function_dispatch(_union1d_dispatcher)
|
||||
def union1d(ar1, ar2):
|
||||
"""
|
||||
Find the union of two arrays.
|
||||
|
||||
Return the unique, sorted array of values that are in either of the two
|
||||
input arrays.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ar1, ar2 : array_like
|
||||
Input arrays. They are flattened if they are not already 1D.
|
||||
|
||||
Returns
|
||||
-------
|
||||
union1d : ndarray
|
||||
Unique, sorted union of the input arrays.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.lib.arraysetops : Module with a number of other functions for
|
||||
performing set operations on arrays.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.union1d([-1, 0, 1], [-2, 0, 2])
|
||||
array([-2, -1, 0, 1, 2])
|
||||
|
||||
To find the union of more than two arrays, use functools.reduce:
|
||||
|
||||
>>> from functools import reduce
|
||||
>>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
|
||||
array([1, 2, 3, 4, 6])
|
||||
"""
|
||||
return unique(np.concatenate((ar1, ar2), axis=None))
|
||||
|
||||
|
||||
def _setdiff1d_dispatcher(ar1, ar2, assume_unique=None):
|
||||
return (ar1, ar2)
|
||||
|
||||
|
||||
@array_function_dispatch(_setdiff1d_dispatcher)
|
||||
def setdiff1d(ar1, ar2, assume_unique=False):
|
||||
"""
|
||||
Find the set difference of two arrays.
|
||||
|
||||
Return the unique values in `ar1` that are not in `ar2`.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
ar1 : array_like
|
||||
Input array.
|
||||
ar2 : array_like
|
||||
Input comparison array.
|
||||
assume_unique : bool
|
||||
If True, the input arrays are both assumed to be unique, which
|
||||
can speed up the calculation. Default is False.
|
||||
|
||||
Returns
|
||||
-------
|
||||
setdiff1d : ndarray
|
||||
1D array of values in `ar1` that are not in `ar2`. The result
|
||||
is sorted when `assume_unique=False`, but otherwise only sorted
|
||||
if the input is sorted.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.lib.arraysetops : Module with a number of other functions for
|
||||
performing set operations on arrays.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.array([1, 2, 3, 2, 4, 1])
|
||||
>>> b = np.array([3, 4, 5, 6])
|
||||
>>> np.setdiff1d(a, b)
|
||||
array([1, 2])
|
||||
|
||||
"""
|
||||
if assume_unique:
|
||||
ar1 = np.asarray(ar1).ravel()
|
||||
else:
|
||||
ar1 = unique(ar1)
|
||||
ar2 = unique(ar2)
|
||||
return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]
|
||||
@@ -0,0 +1,362 @@
|
||||
from typing import (
|
||||
Literal as L,
|
||||
Any,
|
||||
TypeVar,
|
||||
overload,
|
||||
SupportsIndex,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
generic,
|
||||
number,
|
||||
bool_,
|
||||
ushort,
|
||||
ubyte,
|
||||
uintc,
|
||||
uint,
|
||||
ulonglong,
|
||||
short,
|
||||
int8,
|
||||
byte,
|
||||
intc,
|
||||
int_,
|
||||
intp,
|
||||
longlong,
|
||||
half,
|
||||
single,
|
||||
double,
|
||||
longdouble,
|
||||
csingle,
|
||||
cdouble,
|
||||
clongdouble,
|
||||
timedelta64,
|
||||
datetime64,
|
||||
object_,
|
||||
str_,
|
||||
bytes_,
|
||||
void,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
ArrayLike,
|
||||
NDArray,
|
||||
_ArrayLike,
|
||||
_ArrayLikeBool_co,
|
||||
_ArrayLikeDT64_co,
|
||||
_ArrayLikeTD64_co,
|
||||
_ArrayLikeObject_co,
|
||||
_ArrayLikeNumber_co,
|
||||
)
|
||||
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
_NumberType = TypeVar("_NumberType", bound=number[Any])
|
||||
|
||||
# Explicitly set all allowed values to prevent accidental castings to
|
||||
# abstract dtypes (their common super-type).
|
||||
#
|
||||
# Only relevant if two or more arguments are parametrized, (e.g. `setdiff1d`)
|
||||
# which could result in, for example, `int64` and `float64`producing a
|
||||
# `number[_64Bit]` array
|
||||
_SCTNoCast = TypeVar(
|
||||
"_SCTNoCast",
|
||||
bool_,
|
||||
ushort,
|
||||
ubyte,
|
||||
uintc,
|
||||
uint,
|
||||
ulonglong,
|
||||
short,
|
||||
byte,
|
||||
intc,
|
||||
int_,
|
||||
longlong,
|
||||
half,
|
||||
single,
|
||||
double,
|
||||
longdouble,
|
||||
csingle,
|
||||
cdouble,
|
||||
clongdouble,
|
||||
timedelta64,
|
||||
datetime64,
|
||||
object_,
|
||||
str_,
|
||||
bytes_,
|
||||
void,
|
||||
)
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
@overload
|
||||
def ediff1d(
|
||||
ary: _ArrayLikeBool_co,
|
||||
to_end: None | ArrayLike = ...,
|
||||
to_begin: None | ArrayLike = ...,
|
||||
) -> NDArray[int8]: ...
|
||||
@overload
|
||||
def ediff1d(
|
||||
ary: _ArrayLike[_NumberType],
|
||||
to_end: None | ArrayLike = ...,
|
||||
to_begin: None | ArrayLike = ...,
|
||||
) -> NDArray[_NumberType]: ...
|
||||
@overload
|
||||
def ediff1d(
|
||||
ary: _ArrayLikeNumber_co,
|
||||
to_end: None | ArrayLike = ...,
|
||||
to_begin: None | ArrayLike = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def ediff1d(
|
||||
ary: _ArrayLikeDT64_co | _ArrayLikeTD64_co,
|
||||
to_end: None | ArrayLike = ...,
|
||||
to_begin: None | ArrayLike = ...,
|
||||
) -> NDArray[timedelta64]: ...
|
||||
@overload
|
||||
def ediff1d(
|
||||
ary: _ArrayLikeObject_co,
|
||||
to_end: None | ArrayLike = ...,
|
||||
to_begin: None | ArrayLike = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[False] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[False] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[False] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: _ArrayLike[_SCT],
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def unique(
|
||||
ar: ArrayLike,
|
||||
return_index: L[True] = ...,
|
||||
return_inverse: L[True] = ...,
|
||||
return_counts: L[True] = ...,
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
equal_nan: bool = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
|
||||
|
||||
@overload
|
||||
def intersect1d(
|
||||
ar1: _ArrayLike[_SCTNoCast],
|
||||
ar2: _ArrayLike[_SCTNoCast],
|
||||
assume_unique: bool = ...,
|
||||
return_indices: L[False] = ...,
|
||||
) -> NDArray[_SCTNoCast]: ...
|
||||
@overload
|
||||
def intersect1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
assume_unique: bool = ...,
|
||||
return_indices: L[False] = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def intersect1d(
|
||||
ar1: _ArrayLike[_SCTNoCast],
|
||||
ar2: _ArrayLike[_SCTNoCast],
|
||||
assume_unique: bool = ...,
|
||||
return_indices: L[True] = ...,
|
||||
) -> tuple[NDArray[_SCTNoCast], NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def intersect1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
assume_unique: bool = ...,
|
||||
return_indices: L[True] = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
|
||||
|
||||
@overload
|
||||
def setxor1d(
|
||||
ar1: _ArrayLike[_SCTNoCast],
|
||||
ar2: _ArrayLike[_SCTNoCast],
|
||||
assume_unique: bool = ...,
|
||||
) -> NDArray[_SCTNoCast]: ...
|
||||
@overload
|
||||
def setxor1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
assume_unique: bool = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def in1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
assume_unique: bool = ...,
|
||||
invert: bool = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
|
||||
def isin(
|
||||
element: ArrayLike,
|
||||
test_elements: ArrayLike,
|
||||
assume_unique: bool = ...,
|
||||
invert: bool = ...,
|
||||
*,
|
||||
kind: None | str = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def union1d(
|
||||
ar1: _ArrayLike[_SCTNoCast],
|
||||
ar2: _ArrayLike[_SCTNoCast],
|
||||
) -> NDArray[_SCTNoCast]: ...
|
||||
@overload
|
||||
def union1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def setdiff1d(
|
||||
ar1: _ArrayLike[_SCTNoCast],
|
||||
ar2: _ArrayLike[_SCTNoCast],
|
||||
assume_unique: bool = ...,
|
||||
) -> NDArray[_SCTNoCast]: ...
|
||||
@overload
|
||||
def setdiff1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
assume_unique: bool = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@@ -0,0 +1,219 @@
|
||||
"""
|
||||
A buffered iterator for big arrays.
|
||||
|
||||
This module solves the problem of iterating over a big file-based array
|
||||
without having to read it into memory. The `Arrayterator` class wraps
|
||||
an array object, and when iterated it will return sub-arrays with at most
|
||||
a user-specified number of elements.
|
||||
|
||||
"""
|
||||
from operator import mul
|
||||
from functools import reduce
|
||||
|
||||
__all__ = ['Arrayterator']
|
||||
|
||||
|
||||
class Arrayterator:
|
||||
"""
|
||||
Buffered iterator for big arrays.
|
||||
|
||||
`Arrayterator` creates a buffered iterator for reading big arrays in small
|
||||
contiguous blocks. The class is useful for objects stored in the
|
||||
file system. It allows iteration over the object *without* reading
|
||||
everything in memory; instead, small blocks are read and iterated over.
|
||||
|
||||
`Arrayterator` can be used with any object that supports multidimensional
|
||||
slices. This includes NumPy arrays, but also variables from
|
||||
Scientific.IO.NetCDF or pynetcdf for example.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
var : array_like
|
||||
The object to iterate over.
|
||||
buf_size : int, optional
|
||||
The buffer size. If `buf_size` is supplied, the maximum amount of
|
||||
data that will be read into memory is `buf_size` elements.
|
||||
Default is None, which will read as many element as possible
|
||||
into memory.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
var
|
||||
buf_size
|
||||
start
|
||||
stop
|
||||
step
|
||||
shape
|
||||
flat
|
||||
|
||||
See Also
|
||||
--------
|
||||
ndenumerate : Multidimensional array iterator.
|
||||
flatiter : Flat array iterator.
|
||||
memmap : Create a memory-map to an array stored in a binary file on disk.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The algorithm works by first finding a "running dimension", along which
|
||||
the blocks will be extracted. Given an array of dimensions
|
||||
``(d1, d2, ..., dn)``, e.g. if `buf_size` is smaller than ``d1``, the
|
||||
first dimension will be used. If, on the other hand,
|
||||
``d1 < buf_size < d1*d2`` the second dimension will be used, and so on.
|
||||
Blocks are extracted along this dimension, and when the last block is
|
||||
returned the process continues from the next dimension, until all
|
||||
elements have been read.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
|
||||
>>> a_itor = np.lib.Arrayterator(a, 2)
|
||||
>>> a_itor.shape
|
||||
(3, 4, 5, 6)
|
||||
|
||||
Now we can iterate over ``a_itor``, and it will return arrays of size
|
||||
two. Since `buf_size` was smaller than any dimension, the first
|
||||
dimension will be iterated over first:
|
||||
|
||||
>>> for subarr in a_itor:
|
||||
... if not subarr.all():
|
||||
... print(subarr, subarr.shape) # doctest: +SKIP
|
||||
>>> # [[[[0 1]]]] (1, 1, 1, 2)
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, var, buf_size=None):
|
||||
self.var = var
|
||||
self.buf_size = buf_size
|
||||
|
||||
self.start = [0 for dim in var.shape]
|
||||
self.stop = [dim for dim in var.shape]
|
||||
self.step = [1 for dim in var.shape]
|
||||
|
||||
def __getattr__(self, attr):
|
||||
return getattr(self.var, attr)
|
||||
|
||||
def __getitem__(self, index):
|
||||
"""
|
||||
Return a new arrayterator.
|
||||
|
||||
"""
|
||||
# Fix index, handling ellipsis and incomplete slices.
|
||||
if not isinstance(index, tuple):
|
||||
index = (index,)
|
||||
fixed = []
|
||||
length, dims = len(index), self.ndim
|
||||
for slice_ in index:
|
||||
if slice_ is Ellipsis:
|
||||
fixed.extend([slice(None)] * (dims-length+1))
|
||||
length = len(fixed)
|
||||
elif isinstance(slice_, int):
|
||||
fixed.append(slice(slice_, slice_+1, 1))
|
||||
else:
|
||||
fixed.append(slice_)
|
||||
index = tuple(fixed)
|
||||
if len(index) < dims:
|
||||
index += (slice(None),) * (dims-len(index))
|
||||
|
||||
# Return a new arrayterator object.
|
||||
out = self.__class__(self.var, self.buf_size)
|
||||
for i, (start, stop, step, slice_) in enumerate(
|
||||
zip(self.start, self.stop, self.step, index)):
|
||||
out.start[i] = start + (slice_.start or 0)
|
||||
out.step[i] = step * (slice_.step or 1)
|
||||
out.stop[i] = start + (slice_.stop or stop-start)
|
||||
out.stop[i] = min(stop, out.stop[i])
|
||||
return out
|
||||
|
||||
def __array__(self):
|
||||
"""
|
||||
Return corresponding data.
|
||||
|
||||
"""
|
||||
slice_ = tuple(slice(*t) for t in zip(
|
||||
self.start, self.stop, self.step))
|
||||
return self.var[slice_]
|
||||
|
||||
@property
|
||||
def flat(self):
|
||||
"""
|
||||
A 1-D flat iterator for Arrayterator objects.
|
||||
|
||||
This iterator returns elements of the array to be iterated over in
|
||||
`Arrayterator` one by one. It is similar to `flatiter`.
|
||||
|
||||
See Also
|
||||
--------
|
||||
Arrayterator
|
||||
flatiter
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
|
||||
>>> a_itor = np.lib.Arrayterator(a, 2)
|
||||
|
||||
>>> for subarr in a_itor.flat:
|
||||
... if not subarr:
|
||||
... print(subarr, type(subarr))
|
||||
...
|
||||
0 <class 'numpy.int64'>
|
||||
|
||||
"""
|
||||
for block in self:
|
||||
yield from block.flat
|
||||
|
||||
@property
|
||||
def shape(self):
|
||||
"""
|
||||
The shape of the array to be iterated over.
|
||||
|
||||
For an example, see `Arrayterator`.
|
||||
|
||||
"""
|
||||
return tuple(((stop-start-1)//step+1) for start, stop, step in
|
||||
zip(self.start, self.stop, self.step))
|
||||
|
||||
def __iter__(self):
|
||||
# Skip arrays with degenerate dimensions
|
||||
if [dim for dim in self.shape if dim <= 0]:
|
||||
return
|
||||
|
||||
start = self.start[:]
|
||||
stop = self.stop[:]
|
||||
step = self.step[:]
|
||||
ndims = self.var.ndim
|
||||
|
||||
while True:
|
||||
count = self.buf_size or reduce(mul, self.shape)
|
||||
|
||||
# iterate over each dimension, looking for the
|
||||
# running dimension (ie, the dimension along which
|
||||
# the blocks will be built from)
|
||||
rundim = 0
|
||||
for i in range(ndims-1, -1, -1):
|
||||
# if count is zero we ran out of elements to read
|
||||
# along higher dimensions, so we read only a single position
|
||||
if count == 0:
|
||||
stop[i] = start[i]+1
|
||||
elif count <= self.shape[i]:
|
||||
# limit along this dimension
|
||||
stop[i] = start[i] + count*step[i]
|
||||
rundim = i
|
||||
else:
|
||||
# read everything along this dimension
|
||||
stop[i] = self.stop[i]
|
||||
stop[i] = min(self.stop[i], stop[i])
|
||||
count = count//self.shape[i]
|
||||
|
||||
# yield a block
|
||||
slice_ = tuple(slice(*t) for t in zip(start, stop, step))
|
||||
yield self.var[slice_]
|
||||
|
||||
# Update start position, taking care of overflow to
|
||||
# other dimensions
|
||||
start[rundim] = stop[rundim] # start where we stopped
|
||||
for i in range(ndims-1, 0, -1):
|
||||
if start[i] >= self.stop[i]:
|
||||
start[i] = self.start[i]
|
||||
start[i-1] += self.step[i-1]
|
||||
if start[0] >= self.stop[0]:
|
||||
return
|
||||
@@ -0,0 +1,49 @@
|
||||
from collections.abc import Generator
|
||||
from typing import (
|
||||
Any,
|
||||
TypeVar,
|
||||
Union,
|
||||
overload,
|
||||
)
|
||||
|
||||
from numpy import ndarray, dtype, generic
|
||||
from numpy._typing import DTypeLike
|
||||
|
||||
# TODO: Set a shape bound once we've got proper shape support
|
||||
_Shape = TypeVar("_Shape", bound=Any)
|
||||
_DType = TypeVar("_DType", bound=dtype[Any])
|
||||
_ScalarType = TypeVar("_ScalarType", bound=generic)
|
||||
|
||||
_Index = Union[
|
||||
Union[ellipsis, int, slice],
|
||||
tuple[Union[ellipsis, int, slice], ...],
|
||||
]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# NOTE: In reality `Arrayterator` does not actually inherit from `ndarray`,
|
||||
# but its ``__getattr__` method does wrap around the former and thus has
|
||||
# access to all its methods
|
||||
|
||||
class Arrayterator(ndarray[_Shape, _DType]):
|
||||
var: ndarray[_Shape, _DType] # type: ignore[assignment]
|
||||
buf_size: None | int
|
||||
start: list[int]
|
||||
stop: list[int]
|
||||
step: list[int]
|
||||
|
||||
@property # type: ignore[misc]
|
||||
def shape(self) -> tuple[int, ...]: ...
|
||||
@property
|
||||
def flat( # type: ignore[override]
|
||||
self: ndarray[Any, dtype[_ScalarType]]
|
||||
) -> Generator[_ScalarType, None, None]: ...
|
||||
def __init__(
|
||||
self, var: ndarray[_Shape, _DType], buf_size: None | int = ...
|
||||
) -> None: ...
|
||||
@overload
|
||||
def __array__(self, dtype: None = ...) -> ndarray[Any, _DType]: ...
|
||||
@overload
|
||||
def __array__(self, dtype: DTypeLike) -> ndarray[Any, dtype[Any]]: ...
|
||||
def __getitem__(self, index: _Index) -> Arrayterator[Any, _DType]: ...
|
||||
def __iter__(self) -> Generator[ndarray[Any, _DType], None, None]: ...
|
||||
@@ -0,0 +1,976 @@
|
||||
"""
|
||||
Binary serialization
|
||||
|
||||
NPY format
|
||||
==========
|
||||
|
||||
A simple format for saving numpy arrays to disk with the full
|
||||
information about them.
|
||||
|
||||
The ``.npy`` format is the standard binary file format in NumPy for
|
||||
persisting a *single* arbitrary NumPy array on disk. The format stores all
|
||||
of the shape and dtype information necessary to reconstruct the array
|
||||
correctly even on another machine with a different architecture.
|
||||
The format is designed to be as simple as possible while achieving
|
||||
its limited goals.
|
||||
|
||||
The ``.npz`` format is the standard format for persisting *multiple* NumPy
|
||||
arrays on disk. A ``.npz`` file is a zip file containing multiple ``.npy``
|
||||
files, one for each array.
|
||||
|
||||
Capabilities
|
||||
------------
|
||||
|
||||
- Can represent all NumPy arrays including nested record arrays and
|
||||
object arrays.
|
||||
|
||||
- Represents the data in its native binary form.
|
||||
|
||||
- Supports Fortran-contiguous arrays directly.
|
||||
|
||||
- Stores all of the necessary information to reconstruct the array
|
||||
including shape and dtype on a machine of a different
|
||||
architecture. Both little-endian and big-endian arrays are
|
||||
supported, and a file with little-endian numbers will yield
|
||||
a little-endian array on any machine reading the file. The
|
||||
types are described in terms of their actual sizes. For example,
|
||||
if a machine with a 64-bit C "long int" writes out an array with
|
||||
"long ints", a reading machine with 32-bit C "long ints" will yield
|
||||
an array with 64-bit integers.
|
||||
|
||||
- Is straightforward to reverse engineer. Datasets often live longer than
|
||||
the programs that created them. A competent developer should be
|
||||
able to create a solution in their preferred programming language to
|
||||
read most ``.npy`` files that they have been given without much
|
||||
documentation.
|
||||
|
||||
- Allows memory-mapping of the data. See `open_memmap`.
|
||||
|
||||
- Can be read from a filelike stream object instead of an actual file.
|
||||
|
||||
- Stores object arrays, i.e. arrays containing elements that are arbitrary
|
||||
Python objects. Files with object arrays are not to be mmapable, but
|
||||
can be read and written to disk.
|
||||
|
||||
Limitations
|
||||
-----------
|
||||
|
||||
- Arbitrary subclasses of numpy.ndarray are not completely preserved.
|
||||
Subclasses will be accepted for writing, but only the array data will
|
||||
be written out. A regular numpy.ndarray object will be created
|
||||
upon reading the file.
|
||||
|
||||
.. warning::
|
||||
|
||||
Due to limitations in the interpretation of structured dtypes, dtypes
|
||||
with fields with empty names will have the names replaced by 'f0', 'f1',
|
||||
etc. Such arrays will not round-trip through the format entirely
|
||||
accurately. The data is intact; only the field names will differ. We are
|
||||
working on a fix for this. This fix will not require a change in the
|
||||
file format. The arrays with such structures can still be saved and
|
||||
restored, and the correct dtype may be restored by using the
|
||||
``loadedarray.view(correct_dtype)`` method.
|
||||
|
||||
File extensions
|
||||
---------------
|
||||
|
||||
We recommend using the ``.npy`` and ``.npz`` extensions for files saved
|
||||
in this format. This is by no means a requirement; applications may wish
|
||||
to use these file formats but use an extension specific to the
|
||||
application. In the absence of an obvious alternative, however,
|
||||
we suggest using ``.npy`` and ``.npz``.
|
||||
|
||||
Version numbering
|
||||
-----------------
|
||||
|
||||
The version numbering of these formats is independent of NumPy version
|
||||
numbering. If the format is upgraded, the code in `numpy.io` will still
|
||||
be able to read and write Version 1.0 files.
|
||||
|
||||
Format Version 1.0
|
||||
------------------
|
||||
|
||||
The first 6 bytes are a magic string: exactly ``\\x93NUMPY``.
|
||||
|
||||
The next 1 byte is an unsigned byte: the major version number of the file
|
||||
format, e.g. ``\\x01``.
|
||||
|
||||
The next 1 byte is an unsigned byte: the minor version number of the file
|
||||
format, e.g. ``\\x00``. Note: the version of the file format is not tied
|
||||
to the version of the numpy package.
|
||||
|
||||
The next 2 bytes form a little-endian unsigned short int: the length of
|
||||
the header data HEADER_LEN.
|
||||
|
||||
The next HEADER_LEN bytes form the header data describing the array's
|
||||
format. It is an ASCII string which contains a Python literal expression
|
||||
of a dictionary. It is terminated by a newline (``\\n``) and padded with
|
||||
spaces (``\\x20``) to make the total of
|
||||
``len(magic string) + 2 + len(length) + HEADER_LEN`` be evenly divisible
|
||||
by 64 for alignment purposes.
|
||||
|
||||
The dictionary contains three keys:
|
||||
|
||||
"descr" : dtype.descr
|
||||
An object that can be passed as an argument to the `numpy.dtype`
|
||||
constructor to create the array's dtype.
|
||||
"fortran_order" : bool
|
||||
Whether the array data is Fortran-contiguous or not. Since
|
||||
Fortran-contiguous arrays are a common form of non-C-contiguity,
|
||||
we allow them to be written directly to disk for efficiency.
|
||||
"shape" : tuple of int
|
||||
The shape of the array.
|
||||
|
||||
For repeatability and readability, the dictionary keys are sorted in
|
||||
alphabetic order. This is for convenience only. A writer SHOULD implement
|
||||
this if possible. A reader MUST NOT depend on this.
|
||||
|
||||
Following the header comes the array data. If the dtype contains Python
|
||||
objects (i.e. ``dtype.hasobject is True``), then the data is a Python
|
||||
pickle of the array. Otherwise the data is the contiguous (either C-
|
||||
or Fortran-, depending on ``fortran_order``) bytes of the array.
|
||||
Consumers can figure out the number of bytes by multiplying the number
|
||||
of elements given by the shape (noting that ``shape=()`` means there is
|
||||
1 element) by ``dtype.itemsize``.
|
||||
|
||||
Format Version 2.0
|
||||
------------------
|
||||
|
||||
The version 1.0 format only allowed the array header to have a total size of
|
||||
65535 bytes. This can be exceeded by structured arrays with a large number of
|
||||
columns. The version 2.0 format extends the header size to 4 GiB.
|
||||
`numpy.save` will automatically save in 2.0 format if the data requires it,
|
||||
else it will always use the more compatible 1.0 format.
|
||||
|
||||
The description of the fourth element of the header therefore has become:
|
||||
"The next 4 bytes form a little-endian unsigned int: the length of the header
|
||||
data HEADER_LEN."
|
||||
|
||||
Format Version 3.0
|
||||
------------------
|
||||
|
||||
This version replaces the ASCII string (which in practice was latin1) with
|
||||
a utf8-encoded string, so supports structured types with any unicode field
|
||||
names.
|
||||
|
||||
Notes
|
||||
-----
|
||||
The ``.npy`` format, including motivation for creating it and a comparison of
|
||||
alternatives, is described in the
|
||||
:doc:`"npy-format" NEP <neps:nep-0001-npy-format>`, however details have
|
||||
evolved with time and this document is more current.
|
||||
|
||||
"""
|
||||
import numpy
|
||||
import warnings
|
||||
from numpy.lib.utils import safe_eval, drop_metadata
|
||||
from numpy.compat import (
|
||||
isfileobj, os_fspath, pickle
|
||||
)
|
||||
|
||||
|
||||
__all__ = []
|
||||
|
||||
|
||||
EXPECTED_KEYS = {'descr', 'fortran_order', 'shape'}
|
||||
MAGIC_PREFIX = b'\x93NUMPY'
|
||||
MAGIC_LEN = len(MAGIC_PREFIX) + 2
|
||||
ARRAY_ALIGN = 64 # plausible values are powers of 2 between 16 and 4096
|
||||
BUFFER_SIZE = 2**18 # size of buffer for reading npz files in bytes
|
||||
# allow growth within the address space of a 64 bit machine along one axis
|
||||
GROWTH_AXIS_MAX_DIGITS = 21 # = len(str(8*2**64-1)) hypothetical int1 dtype
|
||||
|
||||
# difference between version 1.0 and 2.0 is a 4 byte (I) header length
|
||||
# instead of 2 bytes (H) allowing storage of large structured arrays
|
||||
_header_size_info = {
|
||||
(1, 0): ('<H', 'latin1'),
|
||||
(2, 0): ('<I', 'latin1'),
|
||||
(3, 0): ('<I', 'utf8'),
|
||||
}
|
||||
|
||||
# Python's literal_eval is not actually safe for large inputs, since parsing
|
||||
# may become slow or even cause interpreter crashes.
|
||||
# This is an arbitrary, low limit which should make it safe in practice.
|
||||
_MAX_HEADER_SIZE = 10000
|
||||
|
||||
def _check_version(version):
|
||||
if version not in [(1, 0), (2, 0), (3, 0), None]:
|
||||
msg = "we only support format version (1,0), (2,0), and (3,0), not %s"
|
||||
raise ValueError(msg % (version,))
|
||||
|
||||
def magic(major, minor):
|
||||
""" Return the magic string for the given file format version.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
major : int in [0, 255]
|
||||
minor : int in [0, 255]
|
||||
|
||||
Returns
|
||||
-------
|
||||
magic : str
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError if the version cannot be formatted.
|
||||
"""
|
||||
if major < 0 or major > 255:
|
||||
raise ValueError("major version must be 0 <= major < 256")
|
||||
if minor < 0 or minor > 255:
|
||||
raise ValueError("minor version must be 0 <= minor < 256")
|
||||
return MAGIC_PREFIX + bytes([major, minor])
|
||||
|
||||
def read_magic(fp):
|
||||
""" Read the magic string to get the version of the file format.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : filelike object
|
||||
|
||||
Returns
|
||||
-------
|
||||
major : int
|
||||
minor : int
|
||||
"""
|
||||
magic_str = _read_bytes(fp, MAGIC_LEN, "magic string")
|
||||
if magic_str[:-2] != MAGIC_PREFIX:
|
||||
msg = "the magic string is not correct; expected %r, got %r"
|
||||
raise ValueError(msg % (MAGIC_PREFIX, magic_str[:-2]))
|
||||
major, minor = magic_str[-2:]
|
||||
return major, minor
|
||||
|
||||
|
||||
def dtype_to_descr(dtype):
|
||||
"""
|
||||
Get a serializable descriptor from the dtype.
|
||||
|
||||
The .descr attribute of a dtype object cannot be round-tripped through
|
||||
the dtype() constructor. Simple types, like dtype('float32'), have
|
||||
a descr which looks like a record array with one field with '' as
|
||||
a name. The dtype() constructor interprets this as a request to give
|
||||
a default name. Instead, we construct descriptor that can be passed to
|
||||
dtype().
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dtype : dtype
|
||||
The dtype of the array that will be written to disk.
|
||||
|
||||
Returns
|
||||
-------
|
||||
descr : object
|
||||
An object that can be passed to `numpy.dtype()` in order to
|
||||
replicate the input dtype.
|
||||
|
||||
"""
|
||||
# NOTE: that drop_metadata may not return the right dtype e.g. for user
|
||||
# dtypes. In that case our code below would fail the same, though.
|
||||
new_dtype = drop_metadata(dtype)
|
||||
if new_dtype is not dtype:
|
||||
warnings.warn("metadata on a dtype is not saved to an npy/npz. "
|
||||
"Use another format (such as pickle) to store it.",
|
||||
UserWarning, stacklevel=2)
|
||||
if dtype.names is not None:
|
||||
# This is a record array. The .descr is fine. XXX: parts of the
|
||||
# record array with an empty name, like padding bytes, still get
|
||||
# fiddled with. This needs to be fixed in the C implementation of
|
||||
# dtype().
|
||||
return dtype.descr
|
||||
else:
|
||||
return dtype.str
|
||||
|
||||
def descr_to_dtype(descr):
|
||||
"""
|
||||
Returns a dtype based off the given description.
|
||||
|
||||
This is essentially the reverse of `dtype_to_descr()`. It will remove
|
||||
the valueless padding fields created by, i.e. simple fields like
|
||||
dtype('float32'), and then convert the description to its corresponding
|
||||
dtype.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
descr : object
|
||||
The object retrieved by dtype.descr. Can be passed to
|
||||
`numpy.dtype()` in order to replicate the input dtype.
|
||||
|
||||
Returns
|
||||
-------
|
||||
dtype : dtype
|
||||
The dtype constructed by the description.
|
||||
|
||||
"""
|
||||
if isinstance(descr, str):
|
||||
# No padding removal needed
|
||||
return numpy.dtype(descr)
|
||||
elif isinstance(descr, tuple):
|
||||
# subtype, will always have a shape descr[1]
|
||||
dt = descr_to_dtype(descr[0])
|
||||
return numpy.dtype((dt, descr[1]))
|
||||
|
||||
titles = []
|
||||
names = []
|
||||
formats = []
|
||||
offsets = []
|
||||
offset = 0
|
||||
for field in descr:
|
||||
if len(field) == 2:
|
||||
name, descr_str = field
|
||||
dt = descr_to_dtype(descr_str)
|
||||
else:
|
||||
name, descr_str, shape = field
|
||||
dt = numpy.dtype((descr_to_dtype(descr_str), shape))
|
||||
|
||||
# Ignore padding bytes, which will be void bytes with '' as name
|
||||
# Once support for blank names is removed, only "if name == ''" needed)
|
||||
is_pad = (name == '' and dt.type is numpy.void and dt.names is None)
|
||||
if not is_pad:
|
||||
title, name = name if isinstance(name, tuple) else (None, name)
|
||||
titles.append(title)
|
||||
names.append(name)
|
||||
formats.append(dt)
|
||||
offsets.append(offset)
|
||||
offset += dt.itemsize
|
||||
|
||||
return numpy.dtype({'names': names, 'formats': formats, 'titles': titles,
|
||||
'offsets': offsets, 'itemsize': offset})
|
||||
|
||||
def header_data_from_array_1_0(array):
|
||||
""" Get the dictionary of header metadata from a numpy.ndarray.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
array : numpy.ndarray
|
||||
|
||||
Returns
|
||||
-------
|
||||
d : dict
|
||||
This has the appropriate entries for writing its string representation
|
||||
to the header of the file.
|
||||
"""
|
||||
d = {'shape': array.shape}
|
||||
if array.flags.c_contiguous:
|
||||
d['fortran_order'] = False
|
||||
elif array.flags.f_contiguous:
|
||||
d['fortran_order'] = True
|
||||
else:
|
||||
# Totally non-contiguous data. We will have to make it C-contiguous
|
||||
# before writing. Note that we need to test for C_CONTIGUOUS first
|
||||
# because a 1-D array is both C_CONTIGUOUS and F_CONTIGUOUS.
|
||||
d['fortran_order'] = False
|
||||
|
||||
d['descr'] = dtype_to_descr(array.dtype)
|
||||
return d
|
||||
|
||||
|
||||
def _wrap_header(header, version):
|
||||
"""
|
||||
Takes a stringified header, and attaches the prefix and padding to it
|
||||
"""
|
||||
import struct
|
||||
assert version is not None
|
||||
fmt, encoding = _header_size_info[version]
|
||||
header = header.encode(encoding)
|
||||
hlen = len(header) + 1
|
||||
padlen = ARRAY_ALIGN - ((MAGIC_LEN + struct.calcsize(fmt) + hlen) % ARRAY_ALIGN)
|
||||
try:
|
||||
header_prefix = magic(*version) + struct.pack(fmt, hlen + padlen)
|
||||
except struct.error:
|
||||
msg = "Header length {} too big for version={}".format(hlen, version)
|
||||
raise ValueError(msg) from None
|
||||
|
||||
# Pad the header with spaces and a final newline such that the magic
|
||||
# string, the header-length short and the header are aligned on a
|
||||
# ARRAY_ALIGN byte boundary. This supports memory mapping of dtypes
|
||||
# aligned up to ARRAY_ALIGN on systems like Linux where mmap()
|
||||
# offset must be page-aligned (i.e. the beginning of the file).
|
||||
return header_prefix + header + b' '*padlen + b'\n'
|
||||
|
||||
|
||||
def _wrap_header_guess_version(header):
|
||||
"""
|
||||
Like `_wrap_header`, but chooses an appropriate version given the contents
|
||||
"""
|
||||
try:
|
||||
return _wrap_header(header, (1, 0))
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
try:
|
||||
ret = _wrap_header(header, (2, 0))
|
||||
except UnicodeEncodeError:
|
||||
pass
|
||||
else:
|
||||
warnings.warn("Stored array in format 2.0. It can only be"
|
||||
"read by NumPy >= 1.9", UserWarning, stacklevel=2)
|
||||
return ret
|
||||
|
||||
header = _wrap_header(header, (3, 0))
|
||||
warnings.warn("Stored array in format 3.0. It can only be "
|
||||
"read by NumPy >= 1.17", UserWarning, stacklevel=2)
|
||||
return header
|
||||
|
||||
|
||||
def _write_array_header(fp, d, version=None):
|
||||
""" Write the header for an array and returns the version used
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : filelike object
|
||||
d : dict
|
||||
This has the appropriate entries for writing its string representation
|
||||
to the header of the file.
|
||||
version : tuple or None
|
||||
None means use oldest that works. Providing an explicit version will
|
||||
raise a ValueError if the format does not allow saving this data.
|
||||
Default: None
|
||||
"""
|
||||
header = ["{"]
|
||||
for key, value in sorted(d.items()):
|
||||
# Need to use repr here, since we eval these when reading
|
||||
header.append("'%s': %s, " % (key, repr(value)))
|
||||
header.append("}")
|
||||
header = "".join(header)
|
||||
|
||||
# Add some spare space so that the array header can be modified in-place
|
||||
# when changing the array size, e.g. when growing it by appending data at
|
||||
# the end.
|
||||
shape = d['shape']
|
||||
header += " " * ((GROWTH_AXIS_MAX_DIGITS - len(repr(
|
||||
shape[-1 if d['fortran_order'] else 0]
|
||||
))) if len(shape) > 0 else 0)
|
||||
|
||||
if version is None:
|
||||
header = _wrap_header_guess_version(header)
|
||||
else:
|
||||
header = _wrap_header(header, version)
|
||||
fp.write(header)
|
||||
|
||||
def write_array_header_1_0(fp, d):
|
||||
""" Write the header for an array using the 1.0 format.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : filelike object
|
||||
d : dict
|
||||
This has the appropriate entries for writing its string
|
||||
representation to the header of the file.
|
||||
"""
|
||||
_write_array_header(fp, d, (1, 0))
|
||||
|
||||
|
||||
def write_array_header_2_0(fp, d):
|
||||
""" Write the header for an array using the 2.0 format.
|
||||
The 2.0 format allows storing very large structured arrays.
|
||||
|
||||
.. versionadded:: 1.9.0
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : filelike object
|
||||
d : dict
|
||||
This has the appropriate entries for writing its string
|
||||
representation to the header of the file.
|
||||
"""
|
||||
_write_array_header(fp, d, (2, 0))
|
||||
|
||||
def read_array_header_1_0(fp, max_header_size=_MAX_HEADER_SIZE):
|
||||
"""
|
||||
Read an array header from a filelike object using the 1.0 file format
|
||||
version.
|
||||
|
||||
This will leave the file object located just after the header.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : filelike object
|
||||
A file object or something with a `.read()` method like a file.
|
||||
|
||||
Returns
|
||||
-------
|
||||
shape : tuple of int
|
||||
The shape of the array.
|
||||
fortran_order : bool
|
||||
The array data will be written out directly if it is either
|
||||
C-contiguous or Fortran-contiguous. Otherwise, it will be made
|
||||
contiguous before writing it out.
|
||||
dtype : dtype
|
||||
The dtype of the file's data.
|
||||
max_header_size : int, optional
|
||||
Maximum allowed size of the header. Large headers may not be safe
|
||||
to load securely and thus require explicitly passing a larger value.
|
||||
See :py:func:`ast.literal_eval()` for details.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the data is invalid.
|
||||
|
||||
"""
|
||||
return _read_array_header(
|
||||
fp, version=(1, 0), max_header_size=max_header_size)
|
||||
|
||||
def read_array_header_2_0(fp, max_header_size=_MAX_HEADER_SIZE):
|
||||
"""
|
||||
Read an array header from a filelike object using the 2.0 file format
|
||||
version.
|
||||
|
||||
This will leave the file object located just after the header.
|
||||
|
||||
.. versionadded:: 1.9.0
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : filelike object
|
||||
A file object or something with a `.read()` method like a file.
|
||||
max_header_size : int, optional
|
||||
Maximum allowed size of the header. Large headers may not be safe
|
||||
to load securely and thus require explicitly passing a larger value.
|
||||
See :py:func:`ast.literal_eval()` for details.
|
||||
|
||||
Returns
|
||||
-------
|
||||
shape : tuple of int
|
||||
The shape of the array.
|
||||
fortran_order : bool
|
||||
The array data will be written out directly if it is either
|
||||
C-contiguous or Fortran-contiguous. Otherwise, it will be made
|
||||
contiguous before writing it out.
|
||||
dtype : dtype
|
||||
The dtype of the file's data.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the data is invalid.
|
||||
|
||||
"""
|
||||
return _read_array_header(
|
||||
fp, version=(2, 0), max_header_size=max_header_size)
|
||||
|
||||
|
||||
def _filter_header(s):
|
||||
"""Clean up 'L' in npz header ints.
|
||||
|
||||
Cleans up the 'L' in strings representing integers. Needed to allow npz
|
||||
headers produced in Python2 to be read in Python3.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
s : string
|
||||
Npy file header.
|
||||
|
||||
Returns
|
||||
-------
|
||||
header : str
|
||||
Cleaned up header.
|
||||
|
||||
"""
|
||||
import tokenize
|
||||
from io import StringIO
|
||||
|
||||
tokens = []
|
||||
last_token_was_number = False
|
||||
for token in tokenize.generate_tokens(StringIO(s).readline):
|
||||
token_type = token[0]
|
||||
token_string = token[1]
|
||||
if (last_token_was_number and
|
||||
token_type == tokenize.NAME and
|
||||
token_string == "L"):
|
||||
continue
|
||||
else:
|
||||
tokens.append(token)
|
||||
last_token_was_number = (token_type == tokenize.NUMBER)
|
||||
return tokenize.untokenize(tokens)
|
||||
|
||||
|
||||
def _read_array_header(fp, version, max_header_size=_MAX_HEADER_SIZE):
|
||||
"""
|
||||
see read_array_header_1_0
|
||||
"""
|
||||
# Read an unsigned, little-endian short int which has the length of the
|
||||
# header.
|
||||
import struct
|
||||
hinfo = _header_size_info.get(version)
|
||||
if hinfo is None:
|
||||
raise ValueError("Invalid version {!r}".format(version))
|
||||
hlength_type, encoding = hinfo
|
||||
|
||||
hlength_str = _read_bytes(fp, struct.calcsize(hlength_type), "array header length")
|
||||
header_length = struct.unpack(hlength_type, hlength_str)[0]
|
||||
header = _read_bytes(fp, header_length, "array header")
|
||||
header = header.decode(encoding)
|
||||
if len(header) > max_header_size:
|
||||
raise ValueError(
|
||||
f"Header info length ({len(header)}) is large and may not be safe "
|
||||
"to load securely.\n"
|
||||
"To allow loading, adjust `max_header_size` or fully trust "
|
||||
"the `.npy` file using `allow_pickle=True`.\n"
|
||||
"For safety against large resource use or crashes, sandboxing "
|
||||
"may be necessary.")
|
||||
|
||||
# The header is a pretty-printed string representation of a literal
|
||||
# Python dictionary with trailing newlines padded to a ARRAY_ALIGN byte
|
||||
# boundary. The keys are strings.
|
||||
# "shape" : tuple of int
|
||||
# "fortran_order" : bool
|
||||
# "descr" : dtype.descr
|
||||
# Versions (2, 0) and (1, 0) could have been created by a Python 2
|
||||
# implementation before header filtering was implemented.
|
||||
#
|
||||
# For performance reasons, we try without _filter_header first though
|
||||
try:
|
||||
d = safe_eval(header)
|
||||
except SyntaxError as e:
|
||||
if version <= (2, 0):
|
||||
header = _filter_header(header)
|
||||
try:
|
||||
d = safe_eval(header)
|
||||
except SyntaxError as e2:
|
||||
msg = "Cannot parse header: {!r}"
|
||||
raise ValueError(msg.format(header)) from e2
|
||||
else:
|
||||
warnings.warn(
|
||||
"Reading `.npy` or `.npz` file required additional "
|
||||
"header parsing as it was created on Python 2. Save the "
|
||||
"file again to speed up loading and avoid this warning.",
|
||||
UserWarning, stacklevel=4)
|
||||
else:
|
||||
msg = "Cannot parse header: {!r}"
|
||||
raise ValueError(msg.format(header)) from e
|
||||
if not isinstance(d, dict):
|
||||
msg = "Header is not a dictionary: {!r}"
|
||||
raise ValueError(msg.format(d))
|
||||
|
||||
if EXPECTED_KEYS != d.keys():
|
||||
keys = sorted(d.keys())
|
||||
msg = "Header does not contain the correct keys: {!r}"
|
||||
raise ValueError(msg.format(keys))
|
||||
|
||||
# Sanity-check the values.
|
||||
if (not isinstance(d['shape'], tuple) or
|
||||
not all(isinstance(x, int) for x in d['shape'])):
|
||||
msg = "shape is not valid: {!r}"
|
||||
raise ValueError(msg.format(d['shape']))
|
||||
if not isinstance(d['fortran_order'], bool):
|
||||
msg = "fortran_order is not a valid bool: {!r}"
|
||||
raise ValueError(msg.format(d['fortran_order']))
|
||||
try:
|
||||
dtype = descr_to_dtype(d['descr'])
|
||||
except TypeError as e:
|
||||
msg = "descr is not a valid dtype descriptor: {!r}"
|
||||
raise ValueError(msg.format(d['descr'])) from e
|
||||
|
||||
return d['shape'], d['fortran_order'], dtype
|
||||
|
||||
def write_array(fp, array, version=None, allow_pickle=True, pickle_kwargs=None):
|
||||
"""
|
||||
Write an array to an NPY file, including a header.
|
||||
|
||||
If the array is neither C-contiguous nor Fortran-contiguous AND the
|
||||
file_like object is not a real file object, this function will have to
|
||||
copy data in memory.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : file_like object
|
||||
An open, writable file object, or similar object with a
|
||||
``.write()`` method.
|
||||
array : ndarray
|
||||
The array to write to disk.
|
||||
version : (int, int) or None, optional
|
||||
The version number of the format. None means use the oldest
|
||||
supported version that is able to store the data. Default: None
|
||||
allow_pickle : bool, optional
|
||||
Whether to allow writing pickled data. Default: True
|
||||
pickle_kwargs : dict, optional
|
||||
Additional keyword arguments to pass to pickle.dump, excluding
|
||||
'protocol'. These are only useful when pickling objects in object
|
||||
arrays on Python 3 to Python 2 compatible format.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the array cannot be persisted. This includes the case of
|
||||
allow_pickle=False and array being an object array.
|
||||
Various other errors
|
||||
If the array contains Python objects as part of its dtype, the
|
||||
process of pickling them may raise various errors if the objects
|
||||
are not picklable.
|
||||
|
||||
"""
|
||||
_check_version(version)
|
||||
_write_array_header(fp, header_data_from_array_1_0(array), version)
|
||||
|
||||
if array.itemsize == 0:
|
||||
buffersize = 0
|
||||
else:
|
||||
# Set buffer size to 16 MiB to hide the Python loop overhead.
|
||||
buffersize = max(16 * 1024 ** 2 // array.itemsize, 1)
|
||||
|
||||
if array.dtype.hasobject:
|
||||
# We contain Python objects so we cannot write out the data
|
||||
# directly. Instead, we will pickle it out
|
||||
if not allow_pickle:
|
||||
raise ValueError("Object arrays cannot be saved when "
|
||||
"allow_pickle=False")
|
||||
if pickle_kwargs is None:
|
||||
pickle_kwargs = {}
|
||||
pickle.dump(array, fp, protocol=3, **pickle_kwargs)
|
||||
elif array.flags.f_contiguous and not array.flags.c_contiguous:
|
||||
if isfileobj(fp):
|
||||
array.T.tofile(fp)
|
||||
else:
|
||||
for chunk in numpy.nditer(
|
||||
array, flags=['external_loop', 'buffered', 'zerosize_ok'],
|
||||
buffersize=buffersize, order='F'):
|
||||
fp.write(chunk.tobytes('C'))
|
||||
else:
|
||||
if isfileobj(fp):
|
||||
array.tofile(fp)
|
||||
else:
|
||||
for chunk in numpy.nditer(
|
||||
array, flags=['external_loop', 'buffered', 'zerosize_ok'],
|
||||
buffersize=buffersize, order='C'):
|
||||
fp.write(chunk.tobytes('C'))
|
||||
|
||||
|
||||
def read_array(fp, allow_pickle=False, pickle_kwargs=None, *,
|
||||
max_header_size=_MAX_HEADER_SIZE):
|
||||
"""
|
||||
Read an array from an NPY file.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fp : file_like object
|
||||
If this is not a real file object, then this may take extra memory
|
||||
and time.
|
||||
allow_pickle : bool, optional
|
||||
Whether to allow writing pickled data. Default: False
|
||||
|
||||
.. versionchanged:: 1.16.3
|
||||
Made default False in response to CVE-2019-6446.
|
||||
|
||||
pickle_kwargs : dict
|
||||
Additional keyword arguments to pass to pickle.load. These are only
|
||||
useful when loading object arrays saved on Python 2 when using
|
||||
Python 3.
|
||||
max_header_size : int, optional
|
||||
Maximum allowed size of the header. Large headers may not be safe
|
||||
to load securely and thus require explicitly passing a larger value.
|
||||
See :py:func:`ast.literal_eval()` for details.
|
||||
This option is ignored when `allow_pickle` is passed. In that case
|
||||
the file is by definition trusted and the limit is unnecessary.
|
||||
|
||||
Returns
|
||||
-------
|
||||
array : ndarray
|
||||
The array from the data on disk.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the data is invalid, or allow_pickle=False and the file contains
|
||||
an object array.
|
||||
|
||||
"""
|
||||
if allow_pickle:
|
||||
# Effectively ignore max_header_size, since `allow_pickle` indicates
|
||||
# that the input is fully trusted.
|
||||
max_header_size = 2**64
|
||||
|
||||
version = read_magic(fp)
|
||||
_check_version(version)
|
||||
shape, fortran_order, dtype = _read_array_header(
|
||||
fp, version, max_header_size=max_header_size)
|
||||
if len(shape) == 0:
|
||||
count = 1
|
||||
else:
|
||||
count = numpy.multiply.reduce(shape, dtype=numpy.int64)
|
||||
|
||||
# Now read the actual data.
|
||||
if dtype.hasobject:
|
||||
# The array contained Python objects. We need to unpickle the data.
|
||||
if not allow_pickle:
|
||||
raise ValueError("Object arrays cannot be loaded when "
|
||||
"allow_pickle=False")
|
||||
if pickle_kwargs is None:
|
||||
pickle_kwargs = {}
|
||||
try:
|
||||
array = pickle.load(fp, **pickle_kwargs)
|
||||
except UnicodeError as err:
|
||||
# Friendlier error message
|
||||
raise UnicodeError("Unpickling a python object failed: %r\n"
|
||||
"You may need to pass the encoding= option "
|
||||
"to numpy.load" % (err,)) from err
|
||||
else:
|
||||
if isfileobj(fp):
|
||||
# We can use the fast fromfile() function.
|
||||
array = numpy.fromfile(fp, dtype=dtype, count=count)
|
||||
else:
|
||||
# This is not a real file. We have to read it the
|
||||
# memory-intensive way.
|
||||
# crc32 module fails on reads greater than 2 ** 32 bytes,
|
||||
# breaking large reads from gzip streams. Chunk reads to
|
||||
# BUFFER_SIZE bytes to avoid issue and reduce memory overhead
|
||||
# of the read. In non-chunked case count < max_read_count, so
|
||||
# only one read is performed.
|
||||
|
||||
# Use np.ndarray instead of np.empty since the latter does
|
||||
# not correctly instantiate zero-width string dtypes; see
|
||||
# https://github.com/numpy/numpy/pull/6430
|
||||
array = numpy.ndarray(count, dtype=dtype)
|
||||
|
||||
if dtype.itemsize > 0:
|
||||
# If dtype.itemsize == 0 then there's nothing more to read
|
||||
max_read_count = BUFFER_SIZE // min(BUFFER_SIZE, dtype.itemsize)
|
||||
|
||||
for i in range(0, count, max_read_count):
|
||||
read_count = min(max_read_count, count - i)
|
||||
read_size = int(read_count * dtype.itemsize)
|
||||
data = _read_bytes(fp, read_size, "array data")
|
||||
array[i:i+read_count] = numpy.frombuffer(data, dtype=dtype,
|
||||
count=read_count)
|
||||
|
||||
if fortran_order:
|
||||
array.shape = shape[::-1]
|
||||
array = array.transpose()
|
||||
else:
|
||||
array.shape = shape
|
||||
|
||||
return array
|
||||
|
||||
|
||||
def open_memmap(filename, mode='r+', dtype=None, shape=None,
|
||||
fortran_order=False, version=None, *,
|
||||
max_header_size=_MAX_HEADER_SIZE):
|
||||
"""
|
||||
Open a .npy file as a memory-mapped array.
|
||||
|
||||
This may be used to read an existing file or create a new one.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
filename : str or path-like
|
||||
The name of the file on disk. This may *not* be a file-like
|
||||
object.
|
||||
mode : str, optional
|
||||
The mode in which to open the file; the default is 'r+'. In
|
||||
addition to the standard file modes, 'c' is also accepted to mean
|
||||
"copy on write." See `memmap` for the available mode strings.
|
||||
dtype : data-type, optional
|
||||
The data type of the array if we are creating a new file in "write"
|
||||
mode, if not, `dtype` is ignored. The default value is None, which
|
||||
results in a data-type of `float64`.
|
||||
shape : tuple of int
|
||||
The shape of the array if we are creating a new file in "write"
|
||||
mode, in which case this parameter is required. Otherwise, this
|
||||
parameter is ignored and is thus optional.
|
||||
fortran_order : bool, optional
|
||||
Whether the array should be Fortran-contiguous (True) or
|
||||
C-contiguous (False, the default) if we are creating a new file in
|
||||
"write" mode.
|
||||
version : tuple of int (major, minor) or None
|
||||
If the mode is a "write" mode, then this is the version of the file
|
||||
format used to create the file. None means use the oldest
|
||||
supported version that is able to store the data. Default: None
|
||||
max_header_size : int, optional
|
||||
Maximum allowed size of the header. Large headers may not be safe
|
||||
to load securely and thus require explicitly passing a larger value.
|
||||
See :py:func:`ast.literal_eval()` for details.
|
||||
|
||||
Returns
|
||||
-------
|
||||
marray : memmap
|
||||
The memory-mapped array.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the data or the mode is invalid.
|
||||
OSError
|
||||
If the file is not found or cannot be opened correctly.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.memmap
|
||||
|
||||
"""
|
||||
if isfileobj(filename):
|
||||
raise ValueError("Filename must be a string or a path-like object."
|
||||
" Memmap cannot use existing file handles.")
|
||||
|
||||
if 'w' in mode:
|
||||
# We are creating the file, not reading it.
|
||||
# Check if we ought to create the file.
|
||||
_check_version(version)
|
||||
# Ensure that the given dtype is an authentic dtype object rather
|
||||
# than just something that can be interpreted as a dtype object.
|
||||
dtype = numpy.dtype(dtype)
|
||||
if dtype.hasobject:
|
||||
msg = "Array can't be memory-mapped: Python objects in dtype."
|
||||
raise ValueError(msg)
|
||||
d = dict(
|
||||
descr=dtype_to_descr(dtype),
|
||||
fortran_order=fortran_order,
|
||||
shape=shape,
|
||||
)
|
||||
# If we got here, then it should be safe to create the file.
|
||||
with open(os_fspath(filename), mode+'b') as fp:
|
||||
_write_array_header(fp, d, version)
|
||||
offset = fp.tell()
|
||||
else:
|
||||
# Read the header of the file first.
|
||||
with open(os_fspath(filename), 'rb') as fp:
|
||||
version = read_magic(fp)
|
||||
_check_version(version)
|
||||
|
||||
shape, fortran_order, dtype = _read_array_header(
|
||||
fp, version, max_header_size=max_header_size)
|
||||
if dtype.hasobject:
|
||||
msg = "Array can't be memory-mapped: Python objects in dtype."
|
||||
raise ValueError(msg)
|
||||
offset = fp.tell()
|
||||
|
||||
if fortran_order:
|
||||
order = 'F'
|
||||
else:
|
||||
order = 'C'
|
||||
|
||||
# We need to change a write-only mode to a read-write mode since we've
|
||||
# already written data to the file.
|
||||
if mode == 'w+':
|
||||
mode = 'r+'
|
||||
|
||||
marray = numpy.memmap(filename, dtype=dtype, shape=shape, order=order,
|
||||
mode=mode, offset=offset)
|
||||
|
||||
return marray
|
||||
|
||||
|
||||
def _read_bytes(fp, size, error_template="ran out of data"):
|
||||
"""
|
||||
Read from file-like object until size bytes are read.
|
||||
Raises ValueError if not EOF is encountered before size bytes are read.
|
||||
Non-blocking objects only supported if they derive from io objects.
|
||||
|
||||
Required as e.g. ZipExtFile in python 2.6 can return less data than
|
||||
requested.
|
||||
"""
|
||||
data = bytes()
|
||||
while True:
|
||||
# io files (default in python3) return None or raise on
|
||||
# would-block, python2 file will truncate, probably nothing can be
|
||||
# done about that. note that regular files can't be non-blocking
|
||||
try:
|
||||
r = fp.read(size - len(data))
|
||||
data += r
|
||||
if len(r) == 0 or len(data) == size:
|
||||
break
|
||||
except BlockingIOError:
|
||||
pass
|
||||
if len(data) != size:
|
||||
msg = "EOF: reading %s, expected %d bytes got %d"
|
||||
raise ValueError(msg % (error_template, size, len(data)))
|
||||
else:
|
||||
return data
|
||||
@@ -0,0 +1,22 @@
|
||||
from typing import Any, Literal, Final
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
EXPECTED_KEYS: Final[set[str]]
|
||||
MAGIC_PREFIX: Final[bytes]
|
||||
MAGIC_LEN: Literal[8]
|
||||
ARRAY_ALIGN: Literal[64]
|
||||
BUFFER_SIZE: Literal[262144] # 2**18
|
||||
|
||||
def magic(major, minor): ...
|
||||
def read_magic(fp): ...
|
||||
def dtype_to_descr(dtype): ...
|
||||
def descr_to_dtype(descr): ...
|
||||
def header_data_from_array_1_0(array): ...
|
||||
def write_array_header_1_0(fp, d): ...
|
||||
def write_array_header_2_0(fp, d): ...
|
||||
def read_array_header_1_0(fp): ...
|
||||
def read_array_header_2_0(fp): ...
|
||||
def write_array(fp, array, version=..., allow_pickle=..., pickle_kwargs=...): ...
|
||||
def read_array(fp, allow_pickle=..., pickle_kwargs=...): ...
|
||||
def open_memmap(filename, mode=..., dtype=..., shape=..., fortran_order=..., version=...): ...
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,697 @@
|
||||
import sys
|
||||
from collections.abc import Sequence, Iterator, Callable, Iterable
|
||||
from typing import (
|
||||
Literal as L,
|
||||
Any,
|
||||
TypeVar,
|
||||
overload,
|
||||
Protocol,
|
||||
SupportsIndex,
|
||||
SupportsInt,
|
||||
)
|
||||
|
||||
if sys.version_info >= (3, 10):
|
||||
from typing import TypeGuard
|
||||
else:
|
||||
from typing_extensions import TypeGuard
|
||||
|
||||
from numpy import (
|
||||
vectorize as vectorize,
|
||||
ufunc,
|
||||
generic,
|
||||
floating,
|
||||
complexfloating,
|
||||
intp,
|
||||
float64,
|
||||
complex128,
|
||||
timedelta64,
|
||||
datetime64,
|
||||
object_,
|
||||
_OrderKACF,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
ArrayLike,
|
||||
DTypeLike,
|
||||
_ShapeLike,
|
||||
_ScalarLike_co,
|
||||
_DTypeLike,
|
||||
_ArrayLike,
|
||||
_ArrayLikeInt_co,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
_ArrayLikeTD64_co,
|
||||
_ArrayLikeDT64_co,
|
||||
_ArrayLikeObject_co,
|
||||
_FloatLike_co,
|
||||
_ComplexLike_co,
|
||||
)
|
||||
|
||||
from numpy.core.function_base import (
|
||||
add_newdoc as add_newdoc,
|
||||
)
|
||||
|
||||
from numpy.core.multiarray import (
|
||||
add_docstring as add_docstring,
|
||||
bincount as bincount,
|
||||
)
|
||||
|
||||
from numpy.core.umath import _add_newdoc_ufunc
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_T_co = TypeVar("_T_co", covariant=True)
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
|
||||
|
||||
_2Tuple = tuple[_T, _T]
|
||||
|
||||
class _TrimZerosSequence(Protocol[_T_co]):
|
||||
def __len__(self) -> int: ...
|
||||
def __getitem__(self, key: slice, /) -> _T_co: ...
|
||||
def __iter__(self) -> Iterator[Any]: ...
|
||||
|
||||
class _SupportsWriteFlush(Protocol):
|
||||
def write(self, s: str, /) -> object: ...
|
||||
def flush(self) -> object: ...
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# NOTE: This is in reality a re-export of `np.core.umath._add_newdoc_ufunc`
|
||||
def add_newdoc_ufunc(ufunc: ufunc, new_docstring: str, /) -> None: ...
|
||||
|
||||
@overload
|
||||
def rot90(
|
||||
m: _ArrayLike[_SCT],
|
||||
k: int = ...,
|
||||
axes: tuple[int, int] = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def rot90(
|
||||
m: ArrayLike,
|
||||
k: int = ...,
|
||||
axes: tuple[int, int] = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def flip(m: _SCT, axis: None = ...) -> _SCT: ...
|
||||
@overload
|
||||
def flip(m: _ScalarLike_co, axis: None = ...) -> Any: ...
|
||||
@overload
|
||||
def flip(m: _ArrayLike[_SCT], axis: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def flip(m: ArrayLike, axis: None | _ShapeLike = ...) -> NDArray[Any]: ...
|
||||
|
||||
def iterable(y: object) -> TypeGuard[Iterable[Any]]: ...
|
||||
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
weights: None | _ArrayLikeFloat_co= ...,
|
||||
returned: L[False] = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> floating[Any]: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeComplex_co,
|
||||
axis: None = ...,
|
||||
weights: None | _ArrayLikeComplex_co = ...,
|
||||
returned: L[False] = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeObject_co,
|
||||
axis: None = ...,
|
||||
weights: None | Any = ...,
|
||||
returned: L[False] = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
weights: None | _ArrayLikeFloat_co= ...,
|
||||
returned: L[True] = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> _2Tuple[floating[Any]]: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeComplex_co,
|
||||
axis: None = ...,
|
||||
weights: None | _ArrayLikeComplex_co = ...,
|
||||
returned: L[True] = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> _2Tuple[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeObject_co,
|
||||
axis: None = ...,
|
||||
weights: None | Any = ...,
|
||||
returned: L[True] = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> _2Tuple[Any]: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
axis: None | _ShapeLike = ...,
|
||||
weights: None | Any = ...,
|
||||
returned: L[False] = ...,
|
||||
keepdims: bool = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def average(
|
||||
a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
axis: None | _ShapeLike = ...,
|
||||
weights: None | Any = ...,
|
||||
returned: L[True] = ...,
|
||||
keepdims: bool = ...,
|
||||
) -> _2Tuple[Any]: ...
|
||||
|
||||
@overload
|
||||
def asarray_chkfinite(
|
||||
a: _ArrayLike[_SCT],
|
||||
dtype: None = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def asarray_chkfinite(
|
||||
a: object,
|
||||
dtype: None = ...,
|
||||
order: _OrderKACF = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def asarray_chkfinite(
|
||||
a: Any,
|
||||
dtype: _DTypeLike[_SCT],
|
||||
order: _OrderKACF = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def asarray_chkfinite(
|
||||
a: Any,
|
||||
dtype: DTypeLike,
|
||||
order: _OrderKACF = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
# TODO: Use PEP 612 `ParamSpec` once mypy supports `Concatenate`
|
||||
# xref python/mypy#8645
|
||||
@overload
|
||||
def piecewise(
|
||||
x: _ArrayLike[_SCT],
|
||||
condlist: ArrayLike,
|
||||
funclist: Sequence[Any | Callable[..., Any]],
|
||||
*args: Any,
|
||||
**kw: Any,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def piecewise(
|
||||
x: ArrayLike,
|
||||
condlist: ArrayLike,
|
||||
funclist: Sequence[Any | Callable[..., Any]],
|
||||
*args: Any,
|
||||
**kw: Any,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def select(
|
||||
condlist: Sequence[ArrayLike],
|
||||
choicelist: Sequence[ArrayLike],
|
||||
default: ArrayLike = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def copy(
|
||||
a: _ArrayType,
|
||||
order: _OrderKACF,
|
||||
subok: L[True],
|
||||
) -> _ArrayType: ...
|
||||
@overload
|
||||
def copy(
|
||||
a: _ArrayType,
|
||||
order: _OrderKACF = ...,
|
||||
*,
|
||||
subok: L[True],
|
||||
) -> _ArrayType: ...
|
||||
@overload
|
||||
def copy(
|
||||
a: _ArrayLike[_SCT],
|
||||
order: _OrderKACF = ...,
|
||||
subok: L[False] = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def copy(
|
||||
a: ArrayLike,
|
||||
order: _OrderKACF = ...,
|
||||
subok: L[False] = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def gradient(
|
||||
f: ArrayLike,
|
||||
*varargs: ArrayLike,
|
||||
axis: None | _ShapeLike = ...,
|
||||
edge_order: L[1, 2] = ...,
|
||||
) -> Any: ...
|
||||
|
||||
@overload
|
||||
def diff(
|
||||
a: _T,
|
||||
n: L[0],
|
||||
axis: SupportsIndex = ...,
|
||||
prepend: ArrayLike = ...,
|
||||
append: ArrayLike = ...,
|
||||
) -> _T: ...
|
||||
@overload
|
||||
def diff(
|
||||
a: ArrayLike,
|
||||
n: int = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
prepend: ArrayLike = ...,
|
||||
append: ArrayLike = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def interp(
|
||||
x: _ArrayLikeFloat_co,
|
||||
xp: _ArrayLikeFloat_co,
|
||||
fp: _ArrayLikeFloat_co,
|
||||
left: None | _FloatLike_co = ...,
|
||||
right: None | _FloatLike_co = ...,
|
||||
period: None | _FloatLike_co = ...,
|
||||
) -> NDArray[float64]: ...
|
||||
@overload
|
||||
def interp(
|
||||
x: _ArrayLikeFloat_co,
|
||||
xp: _ArrayLikeFloat_co,
|
||||
fp: _ArrayLikeComplex_co,
|
||||
left: None | _ComplexLike_co = ...,
|
||||
right: None | _ComplexLike_co = ...,
|
||||
period: None | _FloatLike_co = ...,
|
||||
) -> NDArray[complex128]: ...
|
||||
|
||||
@overload
|
||||
def angle(z: _ComplexLike_co, deg: bool = ...) -> floating[Any]: ...
|
||||
@overload
|
||||
def angle(z: object_, deg: bool = ...) -> Any: ...
|
||||
@overload
|
||||
def angle(z: _ArrayLikeComplex_co, deg: bool = ...) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def angle(z: _ArrayLikeObject_co, deg: bool = ...) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def unwrap(
|
||||
p: _ArrayLikeFloat_co,
|
||||
discont: None | float = ...,
|
||||
axis: int = ...,
|
||||
*,
|
||||
period: float = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def unwrap(
|
||||
p: _ArrayLikeObject_co,
|
||||
discont: None | float = ...,
|
||||
axis: int = ...,
|
||||
*,
|
||||
period: float = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
def sort_complex(a: ArrayLike) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
def trim_zeros(
|
||||
filt: _TrimZerosSequence[_T],
|
||||
trim: L["f", "b", "fb", "bf"] = ...,
|
||||
) -> _T: ...
|
||||
|
||||
@overload
|
||||
def extract(condition: ArrayLike, arr: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def extract(condition: ArrayLike, arr: ArrayLike) -> NDArray[Any]: ...
|
||||
|
||||
def place(arr: NDArray[Any], mask: ArrayLike, vals: Any) -> None: ...
|
||||
|
||||
def disp(
|
||||
mesg: object,
|
||||
device: None | _SupportsWriteFlush = ...,
|
||||
linefeed: bool = ...,
|
||||
) -> None: ...
|
||||
|
||||
@overload
|
||||
def cov(
|
||||
m: _ArrayLikeFloat_co,
|
||||
y: None | _ArrayLikeFloat_co = ...,
|
||||
rowvar: bool = ...,
|
||||
bias: bool = ...,
|
||||
ddof: None | SupportsIndex | SupportsInt = ...,
|
||||
fweights: None | ArrayLike = ...,
|
||||
aweights: None | ArrayLike = ...,
|
||||
*,
|
||||
dtype: None = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def cov(
|
||||
m: _ArrayLikeComplex_co,
|
||||
y: None | _ArrayLikeComplex_co = ...,
|
||||
rowvar: bool = ...,
|
||||
bias: bool = ...,
|
||||
ddof: None | SupportsIndex | SupportsInt = ...,
|
||||
fweights: None | ArrayLike = ...,
|
||||
aweights: None | ArrayLike = ...,
|
||||
*,
|
||||
dtype: None = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def cov(
|
||||
m: _ArrayLikeComplex_co,
|
||||
y: None | _ArrayLikeComplex_co = ...,
|
||||
rowvar: bool = ...,
|
||||
bias: bool = ...,
|
||||
ddof: None | SupportsIndex | SupportsInt = ...,
|
||||
fweights: None | ArrayLike = ...,
|
||||
aweights: None | ArrayLike = ...,
|
||||
*,
|
||||
dtype: _DTypeLike[_SCT],
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def cov(
|
||||
m: _ArrayLikeComplex_co,
|
||||
y: None | _ArrayLikeComplex_co = ...,
|
||||
rowvar: bool = ...,
|
||||
bias: bool = ...,
|
||||
ddof: None | SupportsIndex | SupportsInt = ...,
|
||||
fweights: None | ArrayLike = ...,
|
||||
aweights: None | ArrayLike = ...,
|
||||
*,
|
||||
dtype: DTypeLike,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
# NOTE `bias` and `ddof` have been deprecated
|
||||
@overload
|
||||
def corrcoef(
|
||||
m: _ArrayLikeFloat_co,
|
||||
y: None | _ArrayLikeFloat_co = ...,
|
||||
rowvar: bool = ...,
|
||||
*,
|
||||
dtype: None = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def corrcoef(
|
||||
m: _ArrayLikeComplex_co,
|
||||
y: None | _ArrayLikeComplex_co = ...,
|
||||
rowvar: bool = ...,
|
||||
*,
|
||||
dtype: None = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def corrcoef(
|
||||
m: _ArrayLikeComplex_co,
|
||||
y: None | _ArrayLikeComplex_co = ...,
|
||||
rowvar: bool = ...,
|
||||
*,
|
||||
dtype: _DTypeLike[_SCT],
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def corrcoef(
|
||||
m: _ArrayLikeComplex_co,
|
||||
y: None | _ArrayLikeComplex_co = ...,
|
||||
rowvar: bool = ...,
|
||||
*,
|
||||
dtype: DTypeLike,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def blackman(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
|
||||
|
||||
def bartlett(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
|
||||
|
||||
def hanning(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
|
||||
|
||||
def hamming(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
|
||||
|
||||
def i0(x: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
|
||||
|
||||
def kaiser(
|
||||
M: _FloatLike_co,
|
||||
beta: _FloatLike_co,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
|
||||
@overload
|
||||
def sinc(x: _FloatLike_co) -> floating[Any]: ...
|
||||
@overload
|
||||
def sinc(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def sinc(x: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def sinc(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
# NOTE: Deprecated
|
||||
# def msort(a: ArrayLike) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def median(
|
||||
a: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> floating[Any]: ...
|
||||
@overload
|
||||
def median(
|
||||
a: _ArrayLikeComplex_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def median(
|
||||
a: _ArrayLikeTD64_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> timedelta64: ...
|
||||
@overload
|
||||
def median(
|
||||
a: _ArrayLikeObject_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def median(
|
||||
a: _ArrayLikeFloat_co | _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
|
||||
axis: None | _ShapeLike = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
keepdims: bool = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def median(
|
||||
a: _ArrayLikeFloat_co | _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
|
||||
axis: None | _ShapeLike = ...,
|
||||
out: _ArrayType = ...,
|
||||
overwrite_input: bool = ...,
|
||||
keepdims: bool = ...,
|
||||
) -> _ArrayType: ...
|
||||
|
||||
_MethodKind = L[
|
||||
"inverted_cdf",
|
||||
"averaged_inverted_cdf",
|
||||
"closest_observation",
|
||||
"interpolated_inverted_cdf",
|
||||
"hazen",
|
||||
"weibull",
|
||||
"linear",
|
||||
"median_unbiased",
|
||||
"normal_unbiased",
|
||||
"lower",
|
||||
"higher",
|
||||
"midpoint",
|
||||
"nearest",
|
||||
]
|
||||
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeFloat_co,
|
||||
q: _FloatLike_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> floating[Any]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeComplex_co,
|
||||
q: _FloatLike_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeTD64_co,
|
||||
q: _FloatLike_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> timedelta64: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeDT64_co,
|
||||
q: _FloatLike_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> datetime64: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeObject_co,
|
||||
q: _FloatLike_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeFloat_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeComplex_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeTD64_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> NDArray[timedelta64]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeDT64_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> NDArray[datetime64]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeObject_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: L[False] = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None | _ShapeLike = ...,
|
||||
out: None = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: bool = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def percentile(
|
||||
a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
|
||||
q: _ArrayLikeFloat_co,
|
||||
axis: None | _ShapeLike = ...,
|
||||
out: _ArrayType = ...,
|
||||
overwrite_input: bool = ...,
|
||||
method: _MethodKind = ...,
|
||||
keepdims: bool = ...,
|
||||
) -> _ArrayType: ...
|
||||
|
||||
# NOTE: Not an alias, but they do have identical signatures
|
||||
# (that we can reuse)
|
||||
quantile = percentile
|
||||
|
||||
# TODO: Returns a scalar for <= 1D array-likes; returns an ndarray otherwise
|
||||
def trapz(
|
||||
y: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
|
||||
x: None | _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co = ...,
|
||||
dx: float = ...,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> Any: ...
|
||||
|
||||
def meshgrid(
|
||||
*xi: ArrayLike,
|
||||
copy: bool = ...,
|
||||
sparse: bool = ...,
|
||||
indexing: L["xy", "ij"] = ...,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
@overload
|
||||
def delete(
|
||||
arr: _ArrayLike[_SCT],
|
||||
obj: slice | _ArrayLikeInt_co,
|
||||
axis: None | SupportsIndex = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def delete(
|
||||
arr: ArrayLike,
|
||||
obj: slice | _ArrayLikeInt_co,
|
||||
axis: None | SupportsIndex = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def insert(
|
||||
arr: _ArrayLike[_SCT],
|
||||
obj: slice | _ArrayLikeInt_co,
|
||||
values: ArrayLike,
|
||||
axis: None | SupportsIndex = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def insert(
|
||||
arr: ArrayLike,
|
||||
obj: slice | _ArrayLikeInt_co,
|
||||
values: ArrayLike,
|
||||
axis: None | SupportsIndex = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def append(
|
||||
arr: ArrayLike,
|
||||
values: ArrayLike,
|
||||
axis: None | SupportsIndex = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def digitize(
|
||||
x: _FloatLike_co,
|
||||
bins: _ArrayLikeFloat_co,
|
||||
right: bool = ...,
|
||||
) -> intp: ...
|
||||
@overload
|
||||
def digitize(
|
||||
x: _ArrayLikeFloat_co,
|
||||
bins: _ArrayLikeFloat_co,
|
||||
right: bool = ...,
|
||||
) -> NDArray[intp]: ...
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,47 @@
|
||||
from collections.abc import Sequence
|
||||
from typing import (
|
||||
Literal as L,
|
||||
Any,
|
||||
SupportsIndex,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
ArrayLike,
|
||||
)
|
||||
|
||||
_BinKind = L[
|
||||
"stone",
|
||||
"auto",
|
||||
"doane",
|
||||
"fd",
|
||||
"rice",
|
||||
"scott",
|
||||
"sqrt",
|
||||
"sturges",
|
||||
]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
def histogram_bin_edges(
|
||||
a: ArrayLike,
|
||||
bins: _BinKind | SupportsIndex | ArrayLike = ...,
|
||||
range: None | tuple[float, float] = ...,
|
||||
weights: None | ArrayLike = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def histogram(
|
||||
a: ArrayLike,
|
||||
bins: _BinKind | SupportsIndex | ArrayLike = ...,
|
||||
range: None | tuple[float, float] = ...,
|
||||
density: bool = ...,
|
||||
weights: None | ArrayLike = ...,
|
||||
) -> tuple[NDArray[Any], NDArray[Any]]: ...
|
||||
|
||||
def histogramdd(
|
||||
sample: ArrayLike,
|
||||
bins: SupportsIndex | ArrayLike = ...,
|
||||
range: Sequence[tuple[float, float]] = ...,
|
||||
density: None | bool = ...,
|
||||
weights: None | ArrayLike = ...,
|
||||
) -> tuple[NDArray[Any], list[NDArray[Any]]]: ...
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,162 @@
|
||||
from collections.abc import Sequence
|
||||
from typing import (
|
||||
Any,
|
||||
TypeVar,
|
||||
Generic,
|
||||
overload,
|
||||
Literal,
|
||||
SupportsIndex,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
# Circumvent a naming conflict with `AxisConcatenator.matrix`
|
||||
matrix as _Matrix,
|
||||
ndenumerate as ndenumerate,
|
||||
ndindex as ndindex,
|
||||
ndarray,
|
||||
dtype,
|
||||
integer,
|
||||
str_,
|
||||
bytes_,
|
||||
bool_,
|
||||
int_,
|
||||
float_,
|
||||
complex_,
|
||||
intp,
|
||||
_OrderCF,
|
||||
_ModeKind,
|
||||
)
|
||||
from numpy._typing import (
|
||||
# Arrays
|
||||
ArrayLike,
|
||||
_NestedSequence,
|
||||
_FiniteNestedSequence,
|
||||
NDArray,
|
||||
_ArrayLikeInt,
|
||||
|
||||
# DTypes
|
||||
DTypeLike,
|
||||
_SupportsDType,
|
||||
|
||||
# Shapes
|
||||
_ShapeLike,
|
||||
)
|
||||
|
||||
from numpy.core.multiarray import (
|
||||
unravel_index as unravel_index,
|
||||
ravel_multi_index as ravel_multi_index,
|
||||
)
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_DType = TypeVar("_DType", bound=dtype[Any])
|
||||
_BoolType = TypeVar("_BoolType", Literal[True], Literal[False])
|
||||
_TupType = TypeVar("_TupType", bound=tuple[Any, ...])
|
||||
_ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
@overload
|
||||
def ix_(*args: _FiniteNestedSequence[_SupportsDType[_DType]]) -> tuple[ndarray[Any, _DType], ...]: ...
|
||||
@overload
|
||||
def ix_(*args: str | _NestedSequence[str]) -> tuple[NDArray[str_], ...]: ...
|
||||
@overload
|
||||
def ix_(*args: bytes | _NestedSequence[bytes]) -> tuple[NDArray[bytes_], ...]: ...
|
||||
@overload
|
||||
def ix_(*args: bool | _NestedSequence[bool]) -> tuple[NDArray[bool_], ...]: ...
|
||||
@overload
|
||||
def ix_(*args: int | _NestedSequence[int]) -> tuple[NDArray[int_], ...]: ...
|
||||
@overload
|
||||
def ix_(*args: float | _NestedSequence[float]) -> tuple[NDArray[float_], ...]: ...
|
||||
@overload
|
||||
def ix_(*args: complex | _NestedSequence[complex]) -> tuple[NDArray[complex_], ...]: ...
|
||||
|
||||
class nd_grid(Generic[_BoolType]):
|
||||
sparse: _BoolType
|
||||
def __init__(self, sparse: _BoolType = ...) -> None: ...
|
||||
@overload
|
||||
def __getitem__(
|
||||
self: nd_grid[Literal[False]],
|
||||
key: slice | Sequence[slice],
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def __getitem__(
|
||||
self: nd_grid[Literal[True]],
|
||||
key: slice | Sequence[slice],
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
class MGridClass(nd_grid[Literal[False]]):
|
||||
def __init__(self) -> None: ...
|
||||
|
||||
mgrid: MGridClass
|
||||
|
||||
class OGridClass(nd_grid[Literal[True]]):
|
||||
def __init__(self) -> None: ...
|
||||
|
||||
ogrid: OGridClass
|
||||
|
||||
class AxisConcatenator:
|
||||
axis: int
|
||||
matrix: bool
|
||||
ndmin: int
|
||||
trans1d: int
|
||||
def __init__(
|
||||
self,
|
||||
axis: int = ...,
|
||||
matrix: bool = ...,
|
||||
ndmin: int = ...,
|
||||
trans1d: int = ...,
|
||||
) -> None: ...
|
||||
@staticmethod
|
||||
@overload
|
||||
def concatenate( # type: ignore[misc]
|
||||
*a: ArrayLike, axis: SupportsIndex = ..., out: None = ...
|
||||
) -> NDArray[Any]: ...
|
||||
@staticmethod
|
||||
@overload
|
||||
def concatenate(
|
||||
*a: ArrayLike, axis: SupportsIndex = ..., out: _ArrayType = ...
|
||||
) -> _ArrayType: ...
|
||||
@staticmethod
|
||||
def makemat(
|
||||
data: ArrayLike, dtype: DTypeLike = ..., copy: bool = ...
|
||||
) -> _Matrix[Any, Any]: ...
|
||||
|
||||
# TODO: Sort out this `__getitem__` method
|
||||
def __getitem__(self, key: Any) -> Any: ...
|
||||
|
||||
class RClass(AxisConcatenator):
|
||||
axis: Literal[0]
|
||||
matrix: Literal[False]
|
||||
ndmin: Literal[1]
|
||||
trans1d: Literal[-1]
|
||||
def __init__(self) -> None: ...
|
||||
|
||||
r_: RClass
|
||||
|
||||
class CClass(AxisConcatenator):
|
||||
axis: Literal[-1]
|
||||
matrix: Literal[False]
|
||||
ndmin: Literal[2]
|
||||
trans1d: Literal[0]
|
||||
def __init__(self) -> None: ...
|
||||
|
||||
c_: CClass
|
||||
|
||||
class IndexExpression(Generic[_BoolType]):
|
||||
maketuple: _BoolType
|
||||
def __init__(self, maketuple: _BoolType) -> None: ...
|
||||
@overload
|
||||
def __getitem__(self, item: _TupType) -> _TupType: ... # type: ignore[misc]
|
||||
@overload
|
||||
def __getitem__(self: IndexExpression[Literal[True]], item: _T) -> tuple[_T]: ...
|
||||
@overload
|
||||
def __getitem__(self: IndexExpression[Literal[False]], item: _T) -> _T: ...
|
||||
|
||||
index_exp: IndexExpression[Literal[True]]
|
||||
s_: IndexExpression[Literal[False]]
|
||||
|
||||
def fill_diagonal(a: ndarray[Any, Any], val: Any, wrap: bool = ...) -> None: ...
|
||||
def diag_indices(n: int, ndim: int = ...) -> tuple[NDArray[int_], ...]: ...
|
||||
def diag_indices_from(arr: ArrayLike) -> tuple[NDArray[int_], ...]: ...
|
||||
|
||||
# NOTE: see `numpy/__init__.pyi` for `ndenumerate` and `ndindex`
|
||||
@@ -0,0 +1,177 @@
|
||||
"""Mixin classes for custom array types that don't inherit from ndarray."""
|
||||
from numpy.core import umath as um
|
||||
|
||||
|
||||
__all__ = ['NDArrayOperatorsMixin']
|
||||
|
||||
|
||||
def _disables_array_ufunc(obj):
|
||||
"""True when __array_ufunc__ is set to None."""
|
||||
try:
|
||||
return obj.__array_ufunc__ is None
|
||||
except AttributeError:
|
||||
return False
|
||||
|
||||
|
||||
def _binary_method(ufunc, name):
|
||||
"""Implement a forward binary method with a ufunc, e.g., __add__."""
|
||||
def func(self, other):
|
||||
if _disables_array_ufunc(other):
|
||||
return NotImplemented
|
||||
return ufunc(self, other)
|
||||
func.__name__ = '__{}__'.format(name)
|
||||
return func
|
||||
|
||||
|
||||
def _reflected_binary_method(ufunc, name):
|
||||
"""Implement a reflected binary method with a ufunc, e.g., __radd__."""
|
||||
def func(self, other):
|
||||
if _disables_array_ufunc(other):
|
||||
return NotImplemented
|
||||
return ufunc(other, self)
|
||||
func.__name__ = '__r{}__'.format(name)
|
||||
return func
|
||||
|
||||
|
||||
def _inplace_binary_method(ufunc, name):
|
||||
"""Implement an in-place binary method with a ufunc, e.g., __iadd__."""
|
||||
def func(self, other):
|
||||
return ufunc(self, other, out=(self,))
|
||||
func.__name__ = '__i{}__'.format(name)
|
||||
return func
|
||||
|
||||
|
||||
def _numeric_methods(ufunc, name):
|
||||
"""Implement forward, reflected and inplace binary methods with a ufunc."""
|
||||
return (_binary_method(ufunc, name),
|
||||
_reflected_binary_method(ufunc, name),
|
||||
_inplace_binary_method(ufunc, name))
|
||||
|
||||
|
||||
def _unary_method(ufunc, name):
|
||||
"""Implement a unary special method with a ufunc."""
|
||||
def func(self):
|
||||
return ufunc(self)
|
||||
func.__name__ = '__{}__'.format(name)
|
||||
return func
|
||||
|
||||
|
||||
class NDArrayOperatorsMixin:
|
||||
"""Mixin defining all operator special methods using __array_ufunc__.
|
||||
|
||||
This class implements the special methods for almost all of Python's
|
||||
builtin operators defined in the `operator` module, including comparisons
|
||||
(``==``, ``>``, etc.) and arithmetic (``+``, ``*``, ``-``, etc.), by
|
||||
deferring to the ``__array_ufunc__`` method, which subclasses must
|
||||
implement.
|
||||
|
||||
It is useful for writing classes that do not inherit from `numpy.ndarray`,
|
||||
but that should support arithmetic and numpy universal functions like
|
||||
arrays as described in `A Mechanism for Overriding Ufuncs
|
||||
<https://numpy.org/neps/nep-0013-ufunc-overrides.html>`_.
|
||||
|
||||
As an trivial example, consider this implementation of an ``ArrayLike``
|
||||
class that simply wraps a NumPy array and ensures that the result of any
|
||||
arithmetic operation is also an ``ArrayLike`` object::
|
||||
|
||||
class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
|
||||
def __init__(self, value):
|
||||
self.value = np.asarray(value)
|
||||
|
||||
# One might also consider adding the built-in list type to this
|
||||
# list, to support operations like np.add(array_like, list)
|
||||
_HANDLED_TYPES = (np.ndarray, numbers.Number)
|
||||
|
||||
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
|
||||
out = kwargs.get('out', ())
|
||||
for x in inputs + out:
|
||||
# Only support operations with instances of _HANDLED_TYPES.
|
||||
# Use ArrayLike instead of type(self) for isinstance to
|
||||
# allow subclasses that don't override __array_ufunc__ to
|
||||
# handle ArrayLike objects.
|
||||
if not isinstance(x, self._HANDLED_TYPES + (ArrayLike,)):
|
||||
return NotImplemented
|
||||
|
||||
# Defer to the implementation of the ufunc on unwrapped values.
|
||||
inputs = tuple(x.value if isinstance(x, ArrayLike) else x
|
||||
for x in inputs)
|
||||
if out:
|
||||
kwargs['out'] = tuple(
|
||||
x.value if isinstance(x, ArrayLike) else x
|
||||
for x in out)
|
||||
result = getattr(ufunc, method)(*inputs, **kwargs)
|
||||
|
||||
if type(result) is tuple:
|
||||
# multiple return values
|
||||
return tuple(type(self)(x) for x in result)
|
||||
elif method == 'at':
|
||||
# no return value
|
||||
return None
|
||||
else:
|
||||
# one return value
|
||||
return type(self)(result)
|
||||
|
||||
def __repr__(self):
|
||||
return '%s(%r)' % (type(self).__name__, self.value)
|
||||
|
||||
In interactions between ``ArrayLike`` objects and numbers or numpy arrays,
|
||||
the result is always another ``ArrayLike``:
|
||||
|
||||
>>> x = ArrayLike([1, 2, 3])
|
||||
>>> x - 1
|
||||
ArrayLike(array([0, 1, 2]))
|
||||
>>> 1 - x
|
||||
ArrayLike(array([ 0, -1, -2]))
|
||||
>>> np.arange(3) - x
|
||||
ArrayLike(array([-1, -1, -1]))
|
||||
>>> x - np.arange(3)
|
||||
ArrayLike(array([1, 1, 1]))
|
||||
|
||||
Note that unlike ``numpy.ndarray``, ``ArrayLike`` does not allow operations
|
||||
with arbitrary, unrecognized types. This ensures that interactions with
|
||||
ArrayLike preserve a well-defined casting hierarchy.
|
||||
|
||||
.. versionadded:: 1.13
|
||||
"""
|
||||
__slots__ = ()
|
||||
# Like np.ndarray, this mixin class implements "Option 1" from the ufunc
|
||||
# overrides NEP.
|
||||
|
||||
# comparisons don't have reflected and in-place versions
|
||||
__lt__ = _binary_method(um.less, 'lt')
|
||||
__le__ = _binary_method(um.less_equal, 'le')
|
||||
__eq__ = _binary_method(um.equal, 'eq')
|
||||
__ne__ = _binary_method(um.not_equal, 'ne')
|
||||
__gt__ = _binary_method(um.greater, 'gt')
|
||||
__ge__ = _binary_method(um.greater_equal, 'ge')
|
||||
|
||||
# numeric methods
|
||||
__add__, __radd__, __iadd__ = _numeric_methods(um.add, 'add')
|
||||
__sub__, __rsub__, __isub__ = _numeric_methods(um.subtract, 'sub')
|
||||
__mul__, __rmul__, __imul__ = _numeric_methods(um.multiply, 'mul')
|
||||
__matmul__, __rmatmul__, __imatmul__ = _numeric_methods(
|
||||
um.matmul, 'matmul')
|
||||
# Python 3 does not use __div__, __rdiv__, or __idiv__
|
||||
__truediv__, __rtruediv__, __itruediv__ = _numeric_methods(
|
||||
um.true_divide, 'truediv')
|
||||
__floordiv__, __rfloordiv__, __ifloordiv__ = _numeric_methods(
|
||||
um.floor_divide, 'floordiv')
|
||||
__mod__, __rmod__, __imod__ = _numeric_methods(um.remainder, 'mod')
|
||||
__divmod__ = _binary_method(um.divmod, 'divmod')
|
||||
__rdivmod__ = _reflected_binary_method(um.divmod, 'divmod')
|
||||
# __idivmod__ does not exist
|
||||
# TODO: handle the optional third argument for __pow__?
|
||||
__pow__, __rpow__, __ipow__ = _numeric_methods(um.power, 'pow')
|
||||
__lshift__, __rlshift__, __ilshift__ = _numeric_methods(
|
||||
um.left_shift, 'lshift')
|
||||
__rshift__, __rrshift__, __irshift__ = _numeric_methods(
|
||||
um.right_shift, 'rshift')
|
||||
__and__, __rand__, __iand__ = _numeric_methods(um.bitwise_and, 'and')
|
||||
__xor__, __rxor__, __ixor__ = _numeric_methods(um.bitwise_xor, 'xor')
|
||||
__or__, __ror__, __ior__ = _numeric_methods(um.bitwise_or, 'or')
|
||||
|
||||
# unary methods
|
||||
__neg__ = _unary_method(um.negative, 'neg')
|
||||
__pos__ = _unary_method(um.positive, 'pos')
|
||||
__abs__ = _unary_method(um.absolute, 'abs')
|
||||
__invert__ = _unary_method(um.invert, 'invert')
|
||||
@@ -0,0 +1,74 @@
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from typing import Literal as L, Any
|
||||
|
||||
from numpy import ufunc
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# NOTE: `NDArrayOperatorsMixin` is not formally an abstract baseclass,
|
||||
# even though it's reliant on subclasses implementing `__array_ufunc__`
|
||||
|
||||
# NOTE: The accepted input- and output-types of the various dunders are
|
||||
# completely dependent on how `__array_ufunc__` is implemented.
|
||||
# As such, only little type safety can be provided here.
|
||||
|
||||
class NDArrayOperatorsMixin(metaclass=ABCMeta):
|
||||
@abstractmethod
|
||||
def __array_ufunc__(
|
||||
self,
|
||||
ufunc: ufunc,
|
||||
method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "inner"],
|
||||
*inputs: Any,
|
||||
**kwargs: Any,
|
||||
) -> Any: ...
|
||||
def __lt__(self, other: Any) -> Any: ...
|
||||
def __le__(self, other: Any) -> Any: ...
|
||||
def __eq__(self, other: Any) -> Any: ...
|
||||
def __ne__(self, other: Any) -> Any: ...
|
||||
def __gt__(self, other: Any) -> Any: ...
|
||||
def __ge__(self, other: Any) -> Any: ...
|
||||
def __add__(self, other: Any) -> Any: ...
|
||||
def __radd__(self, other: Any) -> Any: ...
|
||||
def __iadd__(self, other: Any) -> Any: ...
|
||||
def __sub__(self, other: Any) -> Any: ...
|
||||
def __rsub__(self, other: Any) -> Any: ...
|
||||
def __isub__(self, other: Any) -> Any: ...
|
||||
def __mul__(self, other: Any) -> Any: ...
|
||||
def __rmul__(self, other: Any) -> Any: ...
|
||||
def __imul__(self, other: Any) -> Any: ...
|
||||
def __matmul__(self, other: Any) -> Any: ...
|
||||
def __rmatmul__(self, other: Any) -> Any: ...
|
||||
def __imatmul__(self, other: Any) -> Any: ...
|
||||
def __truediv__(self, other: Any) -> Any: ...
|
||||
def __rtruediv__(self, other: Any) -> Any: ...
|
||||
def __itruediv__(self, other: Any) -> Any: ...
|
||||
def __floordiv__(self, other: Any) -> Any: ...
|
||||
def __rfloordiv__(self, other: Any) -> Any: ...
|
||||
def __ifloordiv__(self, other: Any) -> Any: ...
|
||||
def __mod__(self, other: Any) -> Any: ...
|
||||
def __rmod__(self, other: Any) -> Any: ...
|
||||
def __imod__(self, other: Any) -> Any: ...
|
||||
def __divmod__(self, other: Any) -> Any: ...
|
||||
def __rdivmod__(self, other: Any) -> Any: ...
|
||||
def __pow__(self, other: Any) -> Any: ...
|
||||
def __rpow__(self, other: Any) -> Any: ...
|
||||
def __ipow__(self, other: Any) -> Any: ...
|
||||
def __lshift__(self, other: Any) -> Any: ...
|
||||
def __rlshift__(self, other: Any) -> Any: ...
|
||||
def __ilshift__(self, other: Any) -> Any: ...
|
||||
def __rshift__(self, other: Any) -> Any: ...
|
||||
def __rrshift__(self, other: Any) -> Any: ...
|
||||
def __irshift__(self, other: Any) -> Any: ...
|
||||
def __and__(self, other: Any) -> Any: ...
|
||||
def __rand__(self, other: Any) -> Any: ...
|
||||
def __iand__(self, other: Any) -> Any: ...
|
||||
def __xor__(self, other: Any) -> Any: ...
|
||||
def __rxor__(self, other: Any) -> Any: ...
|
||||
def __ixor__(self, other: Any) -> Any: ...
|
||||
def __or__(self, other: Any) -> Any: ...
|
||||
def __ror__(self, other: Any) -> Any: ...
|
||||
def __ior__(self, other: Any) -> Any: ...
|
||||
def __neg__(self) -> Any: ...
|
||||
def __pos__(self) -> Any: ...
|
||||
def __abs__(self) -> Any: ...
|
||||
def __invert__(self) -> Any: ...
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,38 @@
|
||||
from numpy.core.fromnumeric import (
|
||||
amin,
|
||||
amax,
|
||||
argmin,
|
||||
argmax,
|
||||
sum,
|
||||
prod,
|
||||
cumsum,
|
||||
cumprod,
|
||||
mean,
|
||||
var,
|
||||
std
|
||||
)
|
||||
|
||||
from numpy.lib.function_base import (
|
||||
median,
|
||||
percentile,
|
||||
quantile,
|
||||
)
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
# NOTE: In reaility these functions are not aliases but distinct functions
|
||||
# with identical signatures.
|
||||
nanmin = amin
|
||||
nanmax = amax
|
||||
nanargmin = argmin
|
||||
nanargmax = argmax
|
||||
nansum = sum
|
||||
nanprod = prod
|
||||
nancumsum = cumsum
|
||||
nancumprod = cumprod
|
||||
nanmean = mean
|
||||
nanvar = var
|
||||
nanstd = std
|
||||
nanmedian = median
|
||||
nanpercentile = percentile
|
||||
nanquantile = quantile
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,330 @@
|
||||
import os
|
||||
import sys
|
||||
import zipfile
|
||||
import types
|
||||
from re import Pattern
|
||||
from collections.abc import Collection, Mapping, Iterator, Sequence, Callable, Iterable
|
||||
from typing import (
|
||||
Literal as L,
|
||||
Any,
|
||||
TypeVar,
|
||||
Generic,
|
||||
IO,
|
||||
overload,
|
||||
Protocol,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
DataSource as DataSource,
|
||||
ndarray,
|
||||
recarray,
|
||||
dtype,
|
||||
generic,
|
||||
float64,
|
||||
void,
|
||||
record,
|
||||
)
|
||||
|
||||
from numpy.ma.mrecords import MaskedRecords
|
||||
from numpy._typing import (
|
||||
ArrayLike,
|
||||
DTypeLike,
|
||||
NDArray,
|
||||
_DTypeLike,
|
||||
_SupportsArrayFunc,
|
||||
)
|
||||
|
||||
from numpy.core.multiarray import (
|
||||
packbits as packbits,
|
||||
unpackbits as unpackbits,
|
||||
)
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_T_contra = TypeVar("_T_contra", contravariant=True)
|
||||
_T_co = TypeVar("_T_co", covariant=True)
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
_CharType_co = TypeVar("_CharType_co", str, bytes, covariant=True)
|
||||
_CharType_contra = TypeVar("_CharType_contra", str, bytes, contravariant=True)
|
||||
|
||||
class _SupportsGetItem(Protocol[_T_contra, _T_co]):
|
||||
def __getitem__(self, key: _T_contra, /) -> _T_co: ...
|
||||
|
||||
class _SupportsRead(Protocol[_CharType_co]):
|
||||
def read(self) -> _CharType_co: ...
|
||||
|
||||
class _SupportsReadSeek(Protocol[_CharType_co]):
|
||||
def read(self, n: int, /) -> _CharType_co: ...
|
||||
def seek(self, offset: int, whence: int, /) -> object: ...
|
||||
|
||||
class _SupportsWrite(Protocol[_CharType_contra]):
|
||||
def write(self, s: _CharType_contra, /) -> object: ...
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
class BagObj(Generic[_T_co]):
|
||||
def __init__(self, obj: _SupportsGetItem[str, _T_co]) -> None: ...
|
||||
def __getattribute__(self, key: str) -> _T_co: ...
|
||||
def __dir__(self) -> list[str]: ...
|
||||
|
||||
class NpzFile(Mapping[str, NDArray[Any]]):
|
||||
zip: zipfile.ZipFile
|
||||
fid: None | IO[str]
|
||||
files: list[str]
|
||||
allow_pickle: bool
|
||||
pickle_kwargs: None | Mapping[str, Any]
|
||||
_MAX_REPR_ARRAY_COUNT: int
|
||||
# Represent `f` as a mutable property so we can access the type of `self`
|
||||
@property
|
||||
def f(self: _T) -> BagObj[_T]: ...
|
||||
@f.setter
|
||||
def f(self: _T, value: BagObj[_T]) -> None: ...
|
||||
def __init__(
|
||||
self,
|
||||
fid: IO[str],
|
||||
own_fid: bool = ...,
|
||||
allow_pickle: bool = ...,
|
||||
pickle_kwargs: None | Mapping[str, Any] = ...,
|
||||
) -> None: ...
|
||||
def __enter__(self: _T) -> _T: ...
|
||||
def __exit__(
|
||||
self,
|
||||
exc_type: None | type[BaseException],
|
||||
exc_value: None | BaseException,
|
||||
traceback: None | types.TracebackType,
|
||||
/,
|
||||
) -> None: ...
|
||||
def close(self) -> None: ...
|
||||
def __del__(self) -> None: ...
|
||||
def __iter__(self) -> Iterator[str]: ...
|
||||
def __len__(self) -> int: ...
|
||||
def __getitem__(self, key: str) -> NDArray[Any]: ...
|
||||
def __contains__(self, key: str) -> bool: ...
|
||||
def __repr__(self) -> str: ...
|
||||
|
||||
# NOTE: Returns a `NpzFile` if file is a zip file;
|
||||
# returns an `ndarray`/`memmap` otherwise
|
||||
def load(
|
||||
file: str | bytes | os.PathLike[Any] | _SupportsReadSeek[bytes],
|
||||
mmap_mode: L[None, "r+", "r", "w+", "c"] = ...,
|
||||
allow_pickle: bool = ...,
|
||||
fix_imports: bool = ...,
|
||||
encoding: L["ASCII", "latin1", "bytes"] = ...,
|
||||
) -> Any: ...
|
||||
|
||||
def save(
|
||||
file: str | os.PathLike[str] | _SupportsWrite[bytes],
|
||||
arr: ArrayLike,
|
||||
allow_pickle: bool = ...,
|
||||
fix_imports: bool = ...,
|
||||
) -> None: ...
|
||||
|
||||
def savez(
|
||||
file: str | os.PathLike[str] | _SupportsWrite[bytes],
|
||||
*args: ArrayLike,
|
||||
**kwds: ArrayLike,
|
||||
) -> None: ...
|
||||
|
||||
def savez_compressed(
|
||||
file: str | os.PathLike[str] | _SupportsWrite[bytes],
|
||||
*args: ArrayLike,
|
||||
**kwds: ArrayLike,
|
||||
) -> None: ...
|
||||
|
||||
# File-like objects only have to implement `__iter__` and,
|
||||
# optionally, `encoding`
|
||||
@overload
|
||||
def loadtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
dtype: None = ...,
|
||||
comments: None | str | Sequence[str] = ...,
|
||||
delimiter: None | str = ...,
|
||||
converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
|
||||
skiprows: int = ...,
|
||||
usecols: int | Sequence[int] = ...,
|
||||
unpack: bool = ...,
|
||||
ndmin: L[0, 1, 2] = ...,
|
||||
encoding: None | str = ...,
|
||||
max_rows: None | int = ...,
|
||||
*,
|
||||
quotechar: None | str = ...,
|
||||
like: None | _SupportsArrayFunc = ...
|
||||
) -> NDArray[float64]: ...
|
||||
@overload
|
||||
def loadtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
dtype: _DTypeLike[_SCT],
|
||||
comments: None | str | Sequence[str] = ...,
|
||||
delimiter: None | str = ...,
|
||||
converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
|
||||
skiprows: int = ...,
|
||||
usecols: int | Sequence[int] = ...,
|
||||
unpack: bool = ...,
|
||||
ndmin: L[0, 1, 2] = ...,
|
||||
encoding: None | str = ...,
|
||||
max_rows: None | int = ...,
|
||||
*,
|
||||
quotechar: None | str = ...,
|
||||
like: None | _SupportsArrayFunc = ...
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def loadtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
dtype: DTypeLike,
|
||||
comments: None | str | Sequence[str] = ...,
|
||||
delimiter: None | str = ...,
|
||||
converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
|
||||
skiprows: int = ...,
|
||||
usecols: int | Sequence[int] = ...,
|
||||
unpack: bool = ...,
|
||||
ndmin: L[0, 1, 2] = ...,
|
||||
encoding: None | str = ...,
|
||||
max_rows: None | int = ...,
|
||||
*,
|
||||
quotechar: None | str = ...,
|
||||
like: None | _SupportsArrayFunc = ...
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def savetxt(
|
||||
fname: str | os.PathLike[str] | _SupportsWrite[str] | _SupportsWrite[bytes],
|
||||
X: ArrayLike,
|
||||
fmt: str | Sequence[str] = ...,
|
||||
delimiter: str = ...,
|
||||
newline: str = ...,
|
||||
header: str = ...,
|
||||
footer: str = ...,
|
||||
comments: str = ...,
|
||||
encoding: None | str = ...,
|
||||
) -> None: ...
|
||||
|
||||
@overload
|
||||
def fromregex(
|
||||
file: str | os.PathLike[str] | _SupportsRead[str] | _SupportsRead[bytes],
|
||||
regexp: str | bytes | Pattern[Any],
|
||||
dtype: _DTypeLike[_SCT],
|
||||
encoding: None | str = ...
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def fromregex(
|
||||
file: str | os.PathLike[str] | _SupportsRead[str] | _SupportsRead[bytes],
|
||||
regexp: str | bytes | Pattern[Any],
|
||||
dtype: DTypeLike,
|
||||
encoding: None | str = ...
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def genfromtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
dtype: None = ...,
|
||||
comments: str = ...,
|
||||
delimiter: None | str | int | Iterable[int] = ...,
|
||||
skip_header: int = ...,
|
||||
skip_footer: int = ...,
|
||||
converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
|
||||
missing_values: Any = ...,
|
||||
filling_values: Any = ...,
|
||||
usecols: None | Sequence[int] = ...,
|
||||
names: L[None, True] | str | Collection[str] = ...,
|
||||
excludelist: None | Sequence[str] = ...,
|
||||
deletechars: str = ...,
|
||||
replace_space: str = ...,
|
||||
autostrip: bool = ...,
|
||||
case_sensitive: bool | L['upper', 'lower'] = ...,
|
||||
defaultfmt: str = ...,
|
||||
unpack: None | bool = ...,
|
||||
usemask: bool = ...,
|
||||
loose: bool = ...,
|
||||
invalid_raise: bool = ...,
|
||||
max_rows: None | int = ...,
|
||||
encoding: str = ...,
|
||||
*,
|
||||
ndmin: L[0, 1, 2] = ...,
|
||||
like: None | _SupportsArrayFunc = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def genfromtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
dtype: _DTypeLike[_SCT],
|
||||
comments: str = ...,
|
||||
delimiter: None | str | int | Iterable[int] = ...,
|
||||
skip_header: int = ...,
|
||||
skip_footer: int = ...,
|
||||
converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
|
||||
missing_values: Any = ...,
|
||||
filling_values: Any = ...,
|
||||
usecols: None | Sequence[int] = ...,
|
||||
names: L[None, True] | str | Collection[str] = ...,
|
||||
excludelist: None | Sequence[str] = ...,
|
||||
deletechars: str = ...,
|
||||
replace_space: str = ...,
|
||||
autostrip: bool = ...,
|
||||
case_sensitive: bool | L['upper', 'lower'] = ...,
|
||||
defaultfmt: str = ...,
|
||||
unpack: None | bool = ...,
|
||||
usemask: bool = ...,
|
||||
loose: bool = ...,
|
||||
invalid_raise: bool = ...,
|
||||
max_rows: None | int = ...,
|
||||
encoding: str = ...,
|
||||
*,
|
||||
ndmin: L[0, 1, 2] = ...,
|
||||
like: None | _SupportsArrayFunc = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def genfromtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
dtype: DTypeLike,
|
||||
comments: str = ...,
|
||||
delimiter: None | str | int | Iterable[int] = ...,
|
||||
skip_header: int = ...,
|
||||
skip_footer: int = ...,
|
||||
converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
|
||||
missing_values: Any = ...,
|
||||
filling_values: Any = ...,
|
||||
usecols: None | Sequence[int] = ...,
|
||||
names: L[None, True] | str | Collection[str] = ...,
|
||||
excludelist: None | Sequence[str] = ...,
|
||||
deletechars: str = ...,
|
||||
replace_space: str = ...,
|
||||
autostrip: bool = ...,
|
||||
case_sensitive: bool | L['upper', 'lower'] = ...,
|
||||
defaultfmt: str = ...,
|
||||
unpack: None | bool = ...,
|
||||
usemask: bool = ...,
|
||||
loose: bool = ...,
|
||||
invalid_raise: bool = ...,
|
||||
max_rows: None | int = ...,
|
||||
encoding: str = ...,
|
||||
*,
|
||||
ndmin: L[0, 1, 2] = ...,
|
||||
like: None | _SupportsArrayFunc = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def recfromtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
*,
|
||||
usemask: L[False] = ...,
|
||||
**kwargs: Any,
|
||||
) -> recarray[Any, dtype[record]]: ...
|
||||
@overload
|
||||
def recfromtxt(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
*,
|
||||
usemask: L[True],
|
||||
**kwargs: Any,
|
||||
) -> MaskedRecords[Any, dtype[void]]: ...
|
||||
|
||||
@overload
|
||||
def recfromcsv(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
*,
|
||||
usemask: L[False] = ...,
|
||||
**kwargs: Any,
|
||||
) -> recarray[Any, dtype[record]]: ...
|
||||
@overload
|
||||
def recfromcsv(
|
||||
fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
|
||||
*,
|
||||
usemask: L[True],
|
||||
**kwargs: Any,
|
||||
) -> MaskedRecords[Any, dtype[void]]: ...
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,303 @@
|
||||
from typing import (
|
||||
Literal as L,
|
||||
overload,
|
||||
Any,
|
||||
SupportsInt,
|
||||
SupportsIndex,
|
||||
TypeVar,
|
||||
NoReturn,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
RankWarning as RankWarning,
|
||||
poly1d as poly1d,
|
||||
unsignedinteger,
|
||||
signedinteger,
|
||||
floating,
|
||||
complexfloating,
|
||||
bool_,
|
||||
int32,
|
||||
int64,
|
||||
float64,
|
||||
complex128,
|
||||
object_,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
ArrayLike,
|
||||
_ArrayLikeBool_co,
|
||||
_ArrayLikeUInt_co,
|
||||
_ArrayLikeInt_co,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
_ArrayLikeObject_co,
|
||||
)
|
||||
|
||||
_T = TypeVar("_T")
|
||||
|
||||
_2Tup = tuple[_T, _T]
|
||||
_5Tup = tuple[
|
||||
_T,
|
||||
NDArray[float64],
|
||||
NDArray[int32],
|
||||
NDArray[float64],
|
||||
NDArray[float64],
|
||||
]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
def poly(seq_of_zeros: ArrayLike) -> NDArray[floating[Any]]: ...
|
||||
|
||||
# Returns either a float or complex array depending on the input values.
|
||||
# See `np.linalg.eigvals`.
|
||||
def roots(p: ArrayLike) -> NDArray[complexfloating[Any, Any]] | NDArray[floating[Any]]: ...
|
||||
|
||||
@overload
|
||||
def polyint(
|
||||
p: poly1d,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
k: None | _ArrayLikeComplex_co | _ArrayLikeObject_co = ...,
|
||||
) -> poly1d: ...
|
||||
@overload
|
||||
def polyint(
|
||||
p: _ArrayLikeFloat_co,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
k: None | _ArrayLikeFloat_co = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def polyint(
|
||||
p: _ArrayLikeComplex_co,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
k: None | _ArrayLikeComplex_co = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def polyint(
|
||||
p: _ArrayLikeObject_co,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
k: None | _ArrayLikeObject_co = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def polyder(
|
||||
p: poly1d,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
) -> poly1d: ...
|
||||
@overload
|
||||
def polyder(
|
||||
p: _ArrayLikeFloat_co,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def polyder(
|
||||
p: _ArrayLikeComplex_co,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def polyder(
|
||||
p: _ArrayLikeObject_co,
|
||||
m: SupportsInt | SupportsIndex = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def polyfit(
|
||||
x: _ArrayLikeFloat_co,
|
||||
y: _ArrayLikeFloat_co,
|
||||
deg: SupportsIndex | SupportsInt,
|
||||
rcond: None | float = ...,
|
||||
full: L[False] = ...,
|
||||
w: None | _ArrayLikeFloat_co = ...,
|
||||
cov: L[False] = ...,
|
||||
) -> NDArray[float64]: ...
|
||||
@overload
|
||||
def polyfit(
|
||||
x: _ArrayLikeComplex_co,
|
||||
y: _ArrayLikeComplex_co,
|
||||
deg: SupportsIndex | SupportsInt,
|
||||
rcond: None | float = ...,
|
||||
full: L[False] = ...,
|
||||
w: None | _ArrayLikeFloat_co = ...,
|
||||
cov: L[False] = ...,
|
||||
) -> NDArray[complex128]: ...
|
||||
@overload
|
||||
def polyfit(
|
||||
x: _ArrayLikeFloat_co,
|
||||
y: _ArrayLikeFloat_co,
|
||||
deg: SupportsIndex | SupportsInt,
|
||||
rcond: None | float = ...,
|
||||
full: L[False] = ...,
|
||||
w: None | _ArrayLikeFloat_co = ...,
|
||||
cov: L[True, "unscaled"] = ...,
|
||||
) -> _2Tup[NDArray[float64]]: ...
|
||||
@overload
|
||||
def polyfit(
|
||||
x: _ArrayLikeComplex_co,
|
||||
y: _ArrayLikeComplex_co,
|
||||
deg: SupportsIndex | SupportsInt,
|
||||
rcond: None | float = ...,
|
||||
full: L[False] = ...,
|
||||
w: None | _ArrayLikeFloat_co = ...,
|
||||
cov: L[True, "unscaled"] = ...,
|
||||
) -> _2Tup[NDArray[complex128]]: ...
|
||||
@overload
|
||||
def polyfit(
|
||||
x: _ArrayLikeFloat_co,
|
||||
y: _ArrayLikeFloat_co,
|
||||
deg: SupportsIndex | SupportsInt,
|
||||
rcond: None | float = ...,
|
||||
full: L[True] = ...,
|
||||
w: None | _ArrayLikeFloat_co = ...,
|
||||
cov: bool | L["unscaled"] = ...,
|
||||
) -> _5Tup[NDArray[float64]]: ...
|
||||
@overload
|
||||
def polyfit(
|
||||
x: _ArrayLikeComplex_co,
|
||||
y: _ArrayLikeComplex_co,
|
||||
deg: SupportsIndex | SupportsInt,
|
||||
rcond: None | float = ...,
|
||||
full: L[True] = ...,
|
||||
w: None | _ArrayLikeFloat_co = ...,
|
||||
cov: bool | L["unscaled"] = ...,
|
||||
) -> _5Tup[NDArray[complex128]]: ...
|
||||
|
||||
@overload
|
||||
def polyval(
|
||||
p: _ArrayLikeBool_co,
|
||||
x: _ArrayLikeBool_co,
|
||||
) -> NDArray[int64]: ...
|
||||
@overload
|
||||
def polyval(
|
||||
p: _ArrayLikeUInt_co,
|
||||
x: _ArrayLikeUInt_co,
|
||||
) -> NDArray[unsignedinteger[Any]]: ...
|
||||
@overload
|
||||
def polyval(
|
||||
p: _ArrayLikeInt_co,
|
||||
x: _ArrayLikeInt_co,
|
||||
) -> NDArray[signedinteger[Any]]: ...
|
||||
@overload
|
||||
def polyval(
|
||||
p: _ArrayLikeFloat_co,
|
||||
x: _ArrayLikeFloat_co,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def polyval(
|
||||
p: _ArrayLikeComplex_co,
|
||||
x: _ArrayLikeComplex_co,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def polyval(
|
||||
p: _ArrayLikeObject_co,
|
||||
x: _ArrayLikeObject_co,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: poly1d,
|
||||
a2: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
) -> poly1d: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
a2: poly1d,
|
||||
) -> poly1d: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeBool_co,
|
||||
a2: _ArrayLikeBool_co,
|
||||
) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeUInt_co,
|
||||
a2: _ArrayLikeUInt_co,
|
||||
) -> NDArray[unsignedinteger[Any]]: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeInt_co,
|
||||
a2: _ArrayLikeInt_co,
|
||||
) -> NDArray[signedinteger[Any]]: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeFloat_co,
|
||||
a2: _ArrayLikeFloat_co,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeComplex_co,
|
||||
a2: _ArrayLikeComplex_co,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def polyadd(
|
||||
a1: _ArrayLikeObject_co,
|
||||
a2: _ArrayLikeObject_co,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def polysub(
|
||||
a1: poly1d,
|
||||
a2: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
) -> poly1d: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
a2: poly1d,
|
||||
) -> poly1d: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeBool_co,
|
||||
a2: _ArrayLikeBool_co,
|
||||
) -> NoReturn: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeUInt_co,
|
||||
a2: _ArrayLikeUInt_co,
|
||||
) -> NDArray[unsignedinteger[Any]]: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeInt_co,
|
||||
a2: _ArrayLikeInt_co,
|
||||
) -> NDArray[signedinteger[Any]]: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeFloat_co,
|
||||
a2: _ArrayLikeFloat_co,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeComplex_co,
|
||||
a2: _ArrayLikeComplex_co,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def polysub(
|
||||
a1: _ArrayLikeObject_co,
|
||||
a2: _ArrayLikeObject_co,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
# NOTE: Not an alias, but they do have the same signature (that we can reuse)
|
||||
polymul = polyadd
|
||||
|
||||
@overload
|
||||
def polydiv(
|
||||
u: poly1d,
|
||||
v: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
) -> _2Tup[poly1d]: ...
|
||||
@overload
|
||||
def polydiv(
|
||||
u: _ArrayLikeComplex_co | _ArrayLikeObject_co,
|
||||
v: poly1d,
|
||||
) -> _2Tup[poly1d]: ...
|
||||
@overload
|
||||
def polydiv(
|
||||
u: _ArrayLikeFloat_co,
|
||||
v: _ArrayLikeFloat_co,
|
||||
) -> _2Tup[NDArray[floating[Any]]]: ...
|
||||
@overload
|
||||
def polydiv(
|
||||
u: _ArrayLikeComplex_co,
|
||||
v: _ArrayLikeComplex_co,
|
||||
) -> _2Tup[NDArray[complexfloating[Any, Any]]]: ...
|
||||
@overload
|
||||
def polydiv(
|
||||
u: _ArrayLikeObject_co,
|
||||
v: _ArrayLikeObject_co,
|
||||
) -> _2Tup[NDArray[Any]]: ...
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,625 @@
|
||||
"""
|
||||
Wrapper functions to more user-friendly calling of certain math functions
|
||||
whose output data-type is different than the input data-type in certain
|
||||
domains of the input.
|
||||
|
||||
For example, for functions like `log` with branch cuts, the versions in this
|
||||
module provide the mathematically valid answers in the complex plane::
|
||||
|
||||
>>> import math
|
||||
>>> np.emath.log(-math.exp(1)) == (1+1j*math.pi)
|
||||
True
|
||||
|
||||
Similarly, `sqrt`, other base logarithms, `power` and trig functions are
|
||||
correctly handled. See their respective docstrings for specific examples.
|
||||
|
||||
Functions
|
||||
---------
|
||||
|
||||
.. autosummary::
|
||||
:toctree: generated/
|
||||
|
||||
sqrt
|
||||
log
|
||||
log2
|
||||
logn
|
||||
log10
|
||||
power
|
||||
arccos
|
||||
arcsin
|
||||
arctanh
|
||||
|
||||
"""
|
||||
import numpy.core.numeric as nx
|
||||
import numpy.core.numerictypes as nt
|
||||
from numpy.core.numeric import asarray, any
|
||||
from numpy.core.overrides import array_function_dispatch
|
||||
from numpy.lib.type_check import isreal
|
||||
|
||||
|
||||
__all__ = [
|
||||
'sqrt', 'log', 'log2', 'logn', 'log10', 'power', 'arccos', 'arcsin',
|
||||
'arctanh'
|
||||
]
|
||||
|
||||
|
||||
_ln2 = nx.log(2.0)
|
||||
|
||||
|
||||
def _tocomplex(arr):
|
||||
"""Convert its input `arr` to a complex array.
|
||||
|
||||
The input is returned as a complex array of the smallest type that will fit
|
||||
the original data: types like single, byte, short, etc. become csingle,
|
||||
while others become cdouble.
|
||||
|
||||
A copy of the input is always made.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
arr : array
|
||||
|
||||
Returns
|
||||
-------
|
||||
array
|
||||
An array with the same input data as the input but in complex form.
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
First, consider an input of type short:
|
||||
|
||||
>>> a = np.array([1,2,3],np.short)
|
||||
|
||||
>>> ac = np.lib.scimath._tocomplex(a); ac
|
||||
array([1.+0.j, 2.+0.j, 3.+0.j], dtype=complex64)
|
||||
|
||||
>>> ac.dtype
|
||||
dtype('complex64')
|
||||
|
||||
If the input is of type double, the output is correspondingly of the
|
||||
complex double type as well:
|
||||
|
||||
>>> b = np.array([1,2,3],np.double)
|
||||
|
||||
>>> bc = np.lib.scimath._tocomplex(b); bc
|
||||
array([1.+0.j, 2.+0.j, 3.+0.j])
|
||||
|
||||
>>> bc.dtype
|
||||
dtype('complex128')
|
||||
|
||||
Note that even if the input was complex to begin with, a copy is still
|
||||
made, since the astype() method always copies:
|
||||
|
||||
>>> c = np.array([1,2,3],np.csingle)
|
||||
|
||||
>>> cc = np.lib.scimath._tocomplex(c); cc
|
||||
array([1.+0.j, 2.+0.j, 3.+0.j], dtype=complex64)
|
||||
|
||||
>>> c *= 2; c
|
||||
array([2.+0.j, 4.+0.j, 6.+0.j], dtype=complex64)
|
||||
|
||||
>>> cc
|
||||
array([1.+0.j, 2.+0.j, 3.+0.j], dtype=complex64)
|
||||
"""
|
||||
if issubclass(arr.dtype.type, (nt.single, nt.byte, nt.short, nt.ubyte,
|
||||
nt.ushort, nt.csingle)):
|
||||
return arr.astype(nt.csingle)
|
||||
else:
|
||||
return arr.astype(nt.cdouble)
|
||||
|
||||
|
||||
def _fix_real_lt_zero(x):
|
||||
"""Convert `x` to complex if it has real, negative components.
|
||||
|
||||
Otherwise, output is just the array version of the input (via asarray).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
|
||||
Returns
|
||||
-------
|
||||
array
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.lib.scimath._fix_real_lt_zero([1,2])
|
||||
array([1, 2])
|
||||
|
||||
>>> np.lib.scimath._fix_real_lt_zero([-1,2])
|
||||
array([-1.+0.j, 2.+0.j])
|
||||
|
||||
"""
|
||||
x = asarray(x)
|
||||
if any(isreal(x) & (x < 0)):
|
||||
x = _tocomplex(x)
|
||||
return x
|
||||
|
||||
|
||||
def _fix_int_lt_zero(x):
|
||||
"""Convert `x` to double if it has real, negative components.
|
||||
|
||||
Otherwise, output is just the array version of the input (via asarray).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
|
||||
Returns
|
||||
-------
|
||||
array
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.lib.scimath._fix_int_lt_zero([1,2])
|
||||
array([1, 2])
|
||||
|
||||
>>> np.lib.scimath._fix_int_lt_zero([-1,2])
|
||||
array([-1., 2.])
|
||||
"""
|
||||
x = asarray(x)
|
||||
if any(isreal(x) & (x < 0)):
|
||||
x = x * 1.0
|
||||
return x
|
||||
|
||||
|
||||
def _fix_real_abs_gt_1(x):
|
||||
"""Convert `x` to complex if it has real components x_i with abs(x_i)>1.
|
||||
|
||||
Otherwise, output is just the array version of the input (via asarray).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
|
||||
Returns
|
||||
-------
|
||||
array
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.lib.scimath._fix_real_abs_gt_1([0,1])
|
||||
array([0, 1])
|
||||
|
||||
>>> np.lib.scimath._fix_real_abs_gt_1([0,2])
|
||||
array([0.+0.j, 2.+0.j])
|
||||
"""
|
||||
x = asarray(x)
|
||||
if any(isreal(x) & (abs(x) > 1)):
|
||||
x = _tocomplex(x)
|
||||
return x
|
||||
|
||||
|
||||
def _unary_dispatcher(x):
|
||||
return (x,)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def sqrt(x):
|
||||
"""
|
||||
Compute the square root of x.
|
||||
|
||||
For negative input elements, a complex value is returned
|
||||
(unlike `numpy.sqrt` which returns NaN).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The input value(s).
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The square root of `x`. If `x` was a scalar, so is `out`,
|
||||
otherwise an array is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.sqrt
|
||||
|
||||
Examples
|
||||
--------
|
||||
For real, non-negative inputs this works just like `numpy.sqrt`:
|
||||
|
||||
>>> np.emath.sqrt(1)
|
||||
1.0
|
||||
>>> np.emath.sqrt([1, 4])
|
||||
array([1., 2.])
|
||||
|
||||
But it automatically handles negative inputs:
|
||||
|
||||
>>> np.emath.sqrt(-1)
|
||||
1j
|
||||
>>> np.emath.sqrt([-1,4])
|
||||
array([0.+1.j, 2.+0.j])
|
||||
|
||||
Different results are expected because:
|
||||
floating point 0.0 and -0.0 are distinct.
|
||||
|
||||
For more control, explicitly use complex() as follows:
|
||||
|
||||
>>> np.emath.sqrt(complex(-4.0, 0.0))
|
||||
2j
|
||||
>>> np.emath.sqrt(complex(-4.0, -0.0))
|
||||
-2j
|
||||
"""
|
||||
x = _fix_real_lt_zero(x)
|
||||
return nx.sqrt(x)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def log(x):
|
||||
"""
|
||||
Compute the natural logarithm of `x`.
|
||||
|
||||
Return the "principal value" (for a description of this, see `numpy.log`)
|
||||
of :math:`log_e(x)`. For real `x > 0`, this is a real number (``log(0)``
|
||||
returns ``-inf`` and ``log(np.inf)`` returns ``inf``). Otherwise, the
|
||||
complex principle value is returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The value(s) whose log is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The log of the `x` value(s). If `x` was a scalar, so is `out`,
|
||||
otherwise an array is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.log
|
||||
|
||||
Notes
|
||||
-----
|
||||
For a log() that returns ``NAN`` when real `x < 0`, use `numpy.log`
|
||||
(note, however, that otherwise `numpy.log` and this `log` are identical,
|
||||
i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`, and,
|
||||
notably, the complex principle value if ``x.imag != 0``).
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.emath.log(np.exp(1))
|
||||
1.0
|
||||
|
||||
Negative arguments are handled "correctly" (recall that
|
||||
``exp(log(x)) == x`` does *not* hold for real ``x < 0``):
|
||||
|
||||
>>> np.emath.log(-np.exp(1)) == (1 + np.pi * 1j)
|
||||
True
|
||||
|
||||
"""
|
||||
x = _fix_real_lt_zero(x)
|
||||
return nx.log(x)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def log10(x):
|
||||
"""
|
||||
Compute the logarithm base 10 of `x`.
|
||||
|
||||
Return the "principal value" (for a description of this, see
|
||||
`numpy.log10`) of :math:`log_{10}(x)`. For real `x > 0`, this
|
||||
is a real number (``log10(0)`` returns ``-inf`` and ``log10(np.inf)``
|
||||
returns ``inf``). Otherwise, the complex principle value is returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like or scalar
|
||||
The value(s) whose log base 10 is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The log base 10 of the `x` value(s). If `x` was a scalar, so is `out`,
|
||||
otherwise an array object is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.log10
|
||||
|
||||
Notes
|
||||
-----
|
||||
For a log10() that returns ``NAN`` when real `x < 0`, use `numpy.log10`
|
||||
(note, however, that otherwise `numpy.log10` and this `log10` are
|
||||
identical, i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`,
|
||||
and, notably, the complex principle value if ``x.imag != 0``).
|
||||
|
||||
Examples
|
||||
--------
|
||||
|
||||
(We set the printing precision so the example can be auto-tested)
|
||||
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> np.emath.log10(10**1)
|
||||
1.0
|
||||
|
||||
>>> np.emath.log10([-10**1, -10**2, 10**2])
|
||||
array([1.+1.3644j, 2.+1.3644j, 2.+0.j ])
|
||||
|
||||
"""
|
||||
x = _fix_real_lt_zero(x)
|
||||
return nx.log10(x)
|
||||
|
||||
|
||||
def _logn_dispatcher(n, x):
|
||||
return (n, x,)
|
||||
|
||||
|
||||
@array_function_dispatch(_logn_dispatcher)
|
||||
def logn(n, x):
|
||||
"""
|
||||
Take log base n of x.
|
||||
|
||||
If `x` contains negative inputs, the answer is computed and returned in the
|
||||
complex domain.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
n : array_like
|
||||
The integer base(s) in which the log is taken.
|
||||
x : array_like
|
||||
The value(s) whose log base `n` is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The log base `n` of the `x` value(s). If `x` was a scalar, so is
|
||||
`out`, otherwise an array is returned.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> np.emath.logn(2, [4, 8])
|
||||
array([2., 3.])
|
||||
>>> np.emath.logn(2, [-4, -8, 8])
|
||||
array([2.+4.5324j, 3.+4.5324j, 3.+0.j ])
|
||||
|
||||
"""
|
||||
x = _fix_real_lt_zero(x)
|
||||
n = _fix_real_lt_zero(n)
|
||||
return nx.log(x)/nx.log(n)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def log2(x):
|
||||
"""
|
||||
Compute the logarithm base 2 of `x`.
|
||||
|
||||
Return the "principal value" (for a description of this, see
|
||||
`numpy.log2`) of :math:`log_2(x)`. For real `x > 0`, this is
|
||||
a real number (``log2(0)`` returns ``-inf`` and ``log2(np.inf)`` returns
|
||||
``inf``). Otherwise, the complex principle value is returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The value(s) whose log base 2 is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The log base 2 of the `x` value(s). If `x` was a scalar, so is `out`,
|
||||
otherwise an array is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.log2
|
||||
|
||||
Notes
|
||||
-----
|
||||
For a log2() that returns ``NAN`` when real `x < 0`, use `numpy.log2`
|
||||
(note, however, that otherwise `numpy.log2` and this `log2` are
|
||||
identical, i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`,
|
||||
and, notably, the complex principle value if ``x.imag != 0``).
|
||||
|
||||
Examples
|
||||
--------
|
||||
We set the printing precision so the example can be auto-tested:
|
||||
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> np.emath.log2(8)
|
||||
3.0
|
||||
>>> np.emath.log2([-4, -8, 8])
|
||||
array([2.+4.5324j, 3.+4.5324j, 3.+0.j ])
|
||||
|
||||
"""
|
||||
x = _fix_real_lt_zero(x)
|
||||
return nx.log2(x)
|
||||
|
||||
|
||||
def _power_dispatcher(x, p):
|
||||
return (x, p)
|
||||
|
||||
|
||||
@array_function_dispatch(_power_dispatcher)
|
||||
def power(x, p):
|
||||
"""
|
||||
Return x to the power p, (x**p).
|
||||
|
||||
If `x` contains negative values, the output is converted to the
|
||||
complex domain.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The input value(s).
|
||||
p : array_like of ints
|
||||
The power(s) to which `x` is raised. If `x` contains multiple values,
|
||||
`p` has to either be a scalar, or contain the same number of values
|
||||
as `x`. In the latter case, the result is
|
||||
``x[0]**p[0], x[1]**p[1], ...``.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The result of ``x**p``. If `x` and `p` are scalars, so is `out`,
|
||||
otherwise an array is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.power
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> np.emath.power([2, 4], 2)
|
||||
array([ 4, 16])
|
||||
>>> np.emath.power([2, 4], -2)
|
||||
array([0.25 , 0.0625])
|
||||
>>> np.emath.power([-2, 4], 2)
|
||||
array([ 4.-0.j, 16.+0.j])
|
||||
|
||||
"""
|
||||
x = _fix_real_lt_zero(x)
|
||||
p = _fix_int_lt_zero(p)
|
||||
return nx.power(x, p)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def arccos(x):
|
||||
"""
|
||||
Compute the inverse cosine of x.
|
||||
|
||||
Return the "principal value" (for a description of this, see
|
||||
`numpy.arccos`) of the inverse cosine of `x`. For real `x` such that
|
||||
`abs(x) <= 1`, this is a real number in the closed interval
|
||||
:math:`[0, \\pi]`. Otherwise, the complex principle value is returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like or scalar
|
||||
The value(s) whose arccos is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The inverse cosine(s) of the `x` value(s). If `x` was a scalar, so
|
||||
is `out`, otherwise an array object is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.arccos
|
||||
|
||||
Notes
|
||||
-----
|
||||
For an arccos() that returns ``NAN`` when real `x` is not in the
|
||||
interval ``[-1,1]``, use `numpy.arccos`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> np.emath.arccos(1) # a scalar is returned
|
||||
0.0
|
||||
|
||||
>>> np.emath.arccos([1,2])
|
||||
array([0.-0.j , 0.-1.317j])
|
||||
|
||||
"""
|
||||
x = _fix_real_abs_gt_1(x)
|
||||
return nx.arccos(x)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def arcsin(x):
|
||||
"""
|
||||
Compute the inverse sine of x.
|
||||
|
||||
Return the "principal value" (for a description of this, see
|
||||
`numpy.arcsin`) of the inverse sine of `x`. For real `x` such that
|
||||
`abs(x) <= 1`, this is a real number in the closed interval
|
||||
:math:`[-\\pi/2, \\pi/2]`. Otherwise, the complex principle value is
|
||||
returned.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like or scalar
|
||||
The value(s) whose arcsin is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The inverse sine(s) of the `x` value(s). If `x` was a scalar, so
|
||||
is `out`, otherwise an array object is returned.
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.arcsin
|
||||
|
||||
Notes
|
||||
-----
|
||||
For an arcsin() that returns ``NAN`` when real `x` is not in the
|
||||
interval ``[-1,1]``, use `numpy.arcsin`.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> np.emath.arcsin(0)
|
||||
0.0
|
||||
|
||||
>>> np.emath.arcsin([0,1])
|
||||
array([0. , 1.5708])
|
||||
|
||||
"""
|
||||
x = _fix_real_abs_gt_1(x)
|
||||
return nx.arcsin(x)
|
||||
|
||||
|
||||
@array_function_dispatch(_unary_dispatcher)
|
||||
def arctanh(x):
|
||||
"""
|
||||
Compute the inverse hyperbolic tangent of `x`.
|
||||
|
||||
Return the "principal value" (for a description of this, see
|
||||
`numpy.arctanh`) of ``arctanh(x)``. For real `x` such that
|
||||
``abs(x) < 1``, this is a real number. If `abs(x) > 1`, or if `x` is
|
||||
complex, the result is complex. Finally, `x = 1` returns``inf`` and
|
||||
``x=-1`` returns ``-inf``.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The value(s) whose arctanh is (are) required.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The inverse hyperbolic tangent(s) of the `x` value(s). If `x` was
|
||||
a scalar so is `out`, otherwise an array is returned.
|
||||
|
||||
|
||||
See Also
|
||||
--------
|
||||
numpy.arctanh
|
||||
|
||||
Notes
|
||||
-----
|
||||
For an arctanh() that returns ``NAN`` when real `x` is not in the
|
||||
interval ``(-1,1)``, use `numpy.arctanh` (this latter, however, does
|
||||
return +/-inf for ``x = +/-1``).
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.set_printoptions(precision=4)
|
||||
|
||||
>>> from numpy.testing import suppress_warnings
|
||||
>>> with suppress_warnings() as sup:
|
||||
... sup.filter(RuntimeWarning)
|
||||
... np.emath.arctanh(np.eye(2))
|
||||
array([[inf, 0.],
|
||||
[ 0., inf]])
|
||||
>>> np.emath.arctanh([1j])
|
||||
array([0.+0.7854j])
|
||||
|
||||
"""
|
||||
x = _fix_real_abs_gt_1(x)
|
||||
return nx.arctanh(x)
|
||||
@@ -0,0 +1,94 @@
|
||||
from typing import overload, Any
|
||||
|
||||
from numpy import complexfloating
|
||||
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
_ComplexLike_co,
|
||||
_FloatLike_co,
|
||||
)
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
@overload
|
||||
def sqrt(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def sqrt(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def sqrt(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def sqrt(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def log(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def log(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def log(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def log(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def log10(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def log10(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def log10(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def log10(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def log2(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def log2(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def log2(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def log2(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def logn(n: _FloatLike_co, x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def logn(n: _ComplexLike_co, x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def logn(n: _ArrayLikeFloat_co, x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def logn(n: _ArrayLikeComplex_co, x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def power(x: _FloatLike_co, p: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def power(x: _ComplexLike_co, p: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def power(x: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def power(x: _ArrayLikeComplex_co, p: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def arccos(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def arccos(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def arccos(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def arccos(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def arcsin(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def arcsin(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def arcsin(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def arcsin(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
|
||||
@overload
|
||||
def arctanh(x: _FloatLike_co) -> Any: ...
|
||||
@overload
|
||||
def arctanh(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
|
||||
@overload
|
||||
def arctanh(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
|
||||
@overload
|
||||
def arctanh(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@@ -0,0 +1,12 @@
|
||||
def configuration(parent_package='',top_path=None):
|
||||
from numpy.distutils.misc_util import Configuration
|
||||
|
||||
config = Configuration('lib', parent_package, top_path)
|
||||
config.add_subpackage('tests')
|
||||
config.add_data_dir('tests/data')
|
||||
config.add_data_files('*.pyi')
|
||||
return config
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils.core import setup
|
||||
setup(configuration=configuration)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,220 @@
|
||||
import sys
|
||||
from collections.abc import Callable, Sequence
|
||||
from typing import TypeVar, Any, overload, SupportsIndex, Protocol
|
||||
|
||||
if sys.version_info >= (3, 10):
|
||||
from typing import ParamSpec, Concatenate
|
||||
else:
|
||||
from typing_extensions import ParamSpec, Concatenate
|
||||
|
||||
from numpy import (
|
||||
generic,
|
||||
integer,
|
||||
ufunc,
|
||||
bool_,
|
||||
unsignedinteger,
|
||||
signedinteger,
|
||||
floating,
|
||||
complexfloating,
|
||||
object_,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
ArrayLike,
|
||||
NDArray,
|
||||
_ShapeLike,
|
||||
_ArrayLike,
|
||||
_ArrayLikeBool_co,
|
||||
_ArrayLikeUInt_co,
|
||||
_ArrayLikeInt_co,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
_ArrayLikeObject_co,
|
||||
)
|
||||
|
||||
from numpy.core.shape_base import vstack
|
||||
|
||||
_P = ParamSpec("_P")
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
|
||||
# The signatures of `__array_wrap__` and `__array_prepare__` are the same;
|
||||
# give them unique names for the sake of clarity
|
||||
class _ArrayWrap(Protocol):
|
||||
def __call__(
|
||||
self,
|
||||
array: NDArray[Any],
|
||||
context: None | tuple[ufunc, tuple[Any, ...], int] = ...,
|
||||
/,
|
||||
) -> Any: ...
|
||||
|
||||
class _ArrayPrepare(Protocol):
|
||||
def __call__(
|
||||
self,
|
||||
array: NDArray[Any],
|
||||
context: None | tuple[ufunc, tuple[Any, ...], int] = ...,
|
||||
/,
|
||||
) -> Any: ...
|
||||
|
||||
class _SupportsArrayWrap(Protocol):
|
||||
@property
|
||||
def __array_wrap__(self) -> _ArrayWrap: ...
|
||||
|
||||
class _SupportsArrayPrepare(Protocol):
|
||||
@property
|
||||
def __array_prepare__(self) -> _ArrayPrepare: ...
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
row_stack = vstack
|
||||
|
||||
def take_along_axis(
|
||||
arr: _SCT | NDArray[_SCT],
|
||||
indices: NDArray[integer[Any]],
|
||||
axis: None | int,
|
||||
) -> NDArray[_SCT]: ...
|
||||
|
||||
def put_along_axis(
|
||||
arr: NDArray[_SCT],
|
||||
indices: NDArray[integer[Any]],
|
||||
values: ArrayLike,
|
||||
axis: None | int,
|
||||
) -> None: ...
|
||||
|
||||
@overload
|
||||
def apply_along_axis(
|
||||
func1d: Callable[Concatenate[NDArray[Any], _P], _ArrayLike[_SCT]],
|
||||
axis: SupportsIndex,
|
||||
arr: ArrayLike,
|
||||
*args: _P.args,
|
||||
**kwargs: _P.kwargs,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def apply_along_axis(
|
||||
func1d: Callable[Concatenate[NDArray[Any], _P], ArrayLike],
|
||||
axis: SupportsIndex,
|
||||
arr: ArrayLike,
|
||||
*args: _P.args,
|
||||
**kwargs: _P.kwargs,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def apply_over_axes(
|
||||
func: Callable[[NDArray[Any], int], NDArray[_SCT]],
|
||||
a: ArrayLike,
|
||||
axes: int | Sequence[int],
|
||||
) -> NDArray[_SCT]: ...
|
||||
|
||||
@overload
|
||||
def expand_dims(
|
||||
a: _ArrayLike[_SCT],
|
||||
axis: _ShapeLike,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def expand_dims(
|
||||
a: ArrayLike,
|
||||
axis: _ShapeLike,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def column_stack(tup: Sequence[_ArrayLike[_SCT]]) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def column_stack(tup: Sequence[ArrayLike]) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def dstack(tup: Sequence[_ArrayLike[_SCT]]) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def dstack(tup: Sequence[ArrayLike]) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def array_split(
|
||||
ary: _ArrayLike[_SCT],
|
||||
indices_or_sections: _ShapeLike,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> list[NDArray[_SCT]]: ...
|
||||
@overload
|
||||
def array_split(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: _ShapeLike,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
@overload
|
||||
def split(
|
||||
ary: _ArrayLike[_SCT],
|
||||
indices_or_sections: _ShapeLike,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> list[NDArray[_SCT]]: ...
|
||||
@overload
|
||||
def split(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: _ShapeLike,
|
||||
axis: SupportsIndex = ...,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
@overload
|
||||
def hsplit(
|
||||
ary: _ArrayLike[_SCT],
|
||||
indices_or_sections: _ShapeLike,
|
||||
) -> list[NDArray[_SCT]]: ...
|
||||
@overload
|
||||
def hsplit(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: _ShapeLike,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
@overload
|
||||
def vsplit(
|
||||
ary: _ArrayLike[_SCT],
|
||||
indices_or_sections: _ShapeLike,
|
||||
) -> list[NDArray[_SCT]]: ...
|
||||
@overload
|
||||
def vsplit(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: _ShapeLike,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
@overload
|
||||
def dsplit(
|
||||
ary: _ArrayLike[_SCT],
|
||||
indices_or_sections: _ShapeLike,
|
||||
) -> list[NDArray[_SCT]]: ...
|
||||
@overload
|
||||
def dsplit(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: _ShapeLike,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
|
||||
@overload
|
||||
def get_array_prepare(*args: _SupportsArrayPrepare) -> _ArrayPrepare: ...
|
||||
@overload
|
||||
def get_array_prepare(*args: object) -> None | _ArrayPrepare: ...
|
||||
|
||||
@overload
|
||||
def get_array_wrap(*args: _SupportsArrayWrap) -> _ArrayWrap: ...
|
||||
@overload
|
||||
def get_array_wrap(*args: object) -> None | _ArrayWrap: ...
|
||||
|
||||
@overload
|
||||
def kron(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc]
|
||||
@overload
|
||||
def kron(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc]
|
||||
@overload
|
||||
def kron(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc]
|
||||
@overload
|
||||
def kron(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc]
|
||||
@overload
|
||||
def kron(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def kron(a: _ArrayLikeObject_co, b: Any) -> NDArray[object_]: ...
|
||||
@overload
|
||||
def kron(a: Any, b: _ArrayLikeObject_co) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def tile(
|
||||
A: _ArrayLike[_SCT],
|
||||
reps: int | Sequence[int],
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def tile(
|
||||
A: ArrayLike,
|
||||
reps: int | Sequence[int],
|
||||
) -> NDArray[Any]: ...
|
||||
@@ -0,0 +1,547 @@
|
||||
"""
|
||||
Utilities that manipulate strides to achieve desirable effects.
|
||||
|
||||
An explanation of strides can be found in the "ndarray.rst" file in the
|
||||
NumPy reference guide.
|
||||
|
||||
"""
|
||||
import numpy as np
|
||||
from numpy.core.numeric import normalize_axis_tuple
|
||||
from numpy.core.overrides import array_function_dispatch, set_module
|
||||
|
||||
__all__ = ['broadcast_to', 'broadcast_arrays', 'broadcast_shapes']
|
||||
|
||||
|
||||
class DummyArray:
|
||||
"""Dummy object that just exists to hang __array_interface__ dictionaries
|
||||
and possibly keep alive a reference to a base array.
|
||||
"""
|
||||
|
||||
def __init__(self, interface, base=None):
|
||||
self.__array_interface__ = interface
|
||||
self.base = base
|
||||
|
||||
|
||||
def _maybe_view_as_subclass(original_array, new_array):
|
||||
if type(original_array) is not type(new_array):
|
||||
# if input was an ndarray subclass and subclasses were OK,
|
||||
# then view the result as that subclass.
|
||||
new_array = new_array.view(type=type(original_array))
|
||||
# Since we have done something akin to a view from original_array, we
|
||||
# should let the subclass finalize (if it has it implemented, i.e., is
|
||||
# not None).
|
||||
if new_array.__array_finalize__:
|
||||
new_array.__array_finalize__(original_array)
|
||||
return new_array
|
||||
|
||||
|
||||
def as_strided(x, shape=None, strides=None, subok=False, writeable=True):
|
||||
"""
|
||||
Create a view into the array with the given shape and strides.
|
||||
|
||||
.. warning:: This function has to be used with extreme care, see notes.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : ndarray
|
||||
Array to create a new.
|
||||
shape : sequence of int, optional
|
||||
The shape of the new array. Defaults to ``x.shape``.
|
||||
strides : sequence of int, optional
|
||||
The strides of the new array. Defaults to ``x.strides``.
|
||||
subok : bool, optional
|
||||
.. versionadded:: 1.10
|
||||
|
||||
If True, subclasses are preserved.
|
||||
writeable : bool, optional
|
||||
.. versionadded:: 1.12
|
||||
|
||||
If set to False, the returned array will always be readonly.
|
||||
Otherwise it will be writable if the original array was. It
|
||||
is advisable to set this to False if possible (see Notes).
|
||||
|
||||
Returns
|
||||
-------
|
||||
view : ndarray
|
||||
|
||||
See also
|
||||
--------
|
||||
broadcast_to : broadcast an array to a given shape.
|
||||
reshape : reshape an array.
|
||||
lib.stride_tricks.sliding_window_view :
|
||||
userfriendly and safe function for the creation of sliding window views.
|
||||
|
||||
Notes
|
||||
-----
|
||||
``as_strided`` creates a view into the array given the exact strides
|
||||
and shape. This means it manipulates the internal data structure of
|
||||
ndarray and, if done incorrectly, the array elements can point to
|
||||
invalid memory and can corrupt results or crash your program.
|
||||
It is advisable to always use the original ``x.strides`` when
|
||||
calculating new strides to avoid reliance on a contiguous memory
|
||||
layout.
|
||||
|
||||
Furthermore, arrays created with this function often contain self
|
||||
overlapping memory, so that two elements are identical.
|
||||
Vectorized write operations on such arrays will typically be
|
||||
unpredictable. They may even give different results for small, large,
|
||||
or transposed arrays.
|
||||
|
||||
Since writing to these arrays has to be tested and done with great
|
||||
care, you may want to use ``writeable=False`` to avoid accidental write
|
||||
operations.
|
||||
|
||||
For these reasons it is advisable to avoid ``as_strided`` when
|
||||
possible.
|
||||
"""
|
||||
# first convert input to array, possibly keeping subclass
|
||||
x = np.array(x, copy=False, subok=subok)
|
||||
interface = dict(x.__array_interface__)
|
||||
if shape is not None:
|
||||
interface['shape'] = tuple(shape)
|
||||
if strides is not None:
|
||||
interface['strides'] = tuple(strides)
|
||||
|
||||
array = np.asarray(DummyArray(interface, base=x))
|
||||
# The route via `__interface__` does not preserve structured
|
||||
# dtypes. Since dtype should remain unchanged, we set it explicitly.
|
||||
array.dtype = x.dtype
|
||||
|
||||
view = _maybe_view_as_subclass(x, array)
|
||||
|
||||
if view.flags.writeable and not writeable:
|
||||
view.flags.writeable = False
|
||||
|
||||
return view
|
||||
|
||||
|
||||
def _sliding_window_view_dispatcher(x, window_shape, axis=None, *,
|
||||
subok=None, writeable=None):
|
||||
return (x,)
|
||||
|
||||
|
||||
@array_function_dispatch(_sliding_window_view_dispatcher)
|
||||
def sliding_window_view(x, window_shape, axis=None, *,
|
||||
subok=False, writeable=False):
|
||||
"""
|
||||
Create a sliding window view into the array with the given window shape.
|
||||
|
||||
Also known as rolling or moving window, the window slides across all
|
||||
dimensions of the array and extracts subsets of the array at all window
|
||||
positions.
|
||||
|
||||
.. versionadded:: 1.20.0
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
Array to create the sliding window view from.
|
||||
window_shape : int or tuple of int
|
||||
Size of window over each axis that takes part in the sliding window.
|
||||
If `axis` is not present, must have same length as the number of input
|
||||
array dimensions. Single integers `i` are treated as if they were the
|
||||
tuple `(i,)`.
|
||||
axis : int or tuple of int, optional
|
||||
Axis or axes along which the sliding window is applied.
|
||||
By default, the sliding window is applied to all axes and
|
||||
`window_shape[i]` will refer to axis `i` of `x`.
|
||||
If `axis` is given as a `tuple of int`, `window_shape[i]` will refer to
|
||||
the axis `axis[i]` of `x`.
|
||||
Single integers `i` are treated as if they were the tuple `(i,)`.
|
||||
subok : bool, optional
|
||||
If True, sub-classes will be passed-through, otherwise the returned
|
||||
array will be forced to be a base-class array (default).
|
||||
writeable : bool, optional
|
||||
When true, allow writing to the returned view. The default is false,
|
||||
as this should be used with caution: the returned view contains the
|
||||
same memory location multiple times, so writing to one location will
|
||||
cause others to change.
|
||||
|
||||
Returns
|
||||
-------
|
||||
view : ndarray
|
||||
Sliding window view of the array. The sliding window dimensions are
|
||||
inserted at the end, and the original dimensions are trimmed as
|
||||
required by the size of the sliding window.
|
||||
That is, ``view.shape = x_shape_trimmed + window_shape``, where
|
||||
``x_shape_trimmed`` is ``x.shape`` with every entry reduced by one less
|
||||
than the corresponding window size.
|
||||
|
||||
See Also
|
||||
--------
|
||||
lib.stride_tricks.as_strided: A lower-level and less safe routine for
|
||||
creating arbitrary views from custom shape and strides.
|
||||
broadcast_to: broadcast an array to a given shape.
|
||||
|
||||
Notes
|
||||
-----
|
||||
For many applications using a sliding window view can be convenient, but
|
||||
potentially very slow. Often specialized solutions exist, for example:
|
||||
|
||||
- `scipy.signal.fftconvolve`
|
||||
|
||||
- filtering functions in `scipy.ndimage`
|
||||
|
||||
- moving window functions provided by
|
||||
`bottleneck <https://github.com/pydata/bottleneck>`_.
|
||||
|
||||
As a rough estimate, a sliding window approach with an input size of `N`
|
||||
and a window size of `W` will scale as `O(N*W)` where frequently a special
|
||||
algorithm can achieve `O(N)`. That means that the sliding window variant
|
||||
for a window size of 100 can be a 100 times slower than a more specialized
|
||||
version.
|
||||
|
||||
Nevertheless, for small window sizes, when no custom algorithm exists, or
|
||||
as a prototyping and developing tool, this function can be a good solution.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> x = np.arange(6)
|
||||
>>> x.shape
|
||||
(6,)
|
||||
>>> v = sliding_window_view(x, 3)
|
||||
>>> v.shape
|
||||
(4, 3)
|
||||
>>> v
|
||||
array([[0, 1, 2],
|
||||
[1, 2, 3],
|
||||
[2, 3, 4],
|
||||
[3, 4, 5]])
|
||||
|
||||
This also works in more dimensions, e.g.
|
||||
|
||||
>>> i, j = np.ogrid[:3, :4]
|
||||
>>> x = 10*i + j
|
||||
>>> x.shape
|
||||
(3, 4)
|
||||
>>> x
|
||||
array([[ 0, 1, 2, 3],
|
||||
[10, 11, 12, 13],
|
||||
[20, 21, 22, 23]])
|
||||
>>> shape = (2,2)
|
||||
>>> v = sliding_window_view(x, shape)
|
||||
>>> v.shape
|
||||
(2, 3, 2, 2)
|
||||
>>> v
|
||||
array([[[[ 0, 1],
|
||||
[10, 11]],
|
||||
[[ 1, 2],
|
||||
[11, 12]],
|
||||
[[ 2, 3],
|
||||
[12, 13]]],
|
||||
[[[10, 11],
|
||||
[20, 21]],
|
||||
[[11, 12],
|
||||
[21, 22]],
|
||||
[[12, 13],
|
||||
[22, 23]]]])
|
||||
|
||||
The axis can be specified explicitly:
|
||||
|
||||
>>> v = sliding_window_view(x, 3, 0)
|
||||
>>> v.shape
|
||||
(1, 4, 3)
|
||||
>>> v
|
||||
array([[[ 0, 10, 20],
|
||||
[ 1, 11, 21],
|
||||
[ 2, 12, 22],
|
||||
[ 3, 13, 23]]])
|
||||
|
||||
The same axis can be used several times. In that case, every use reduces
|
||||
the corresponding original dimension:
|
||||
|
||||
>>> v = sliding_window_view(x, (2, 3), (1, 1))
|
||||
>>> v.shape
|
||||
(3, 1, 2, 3)
|
||||
>>> v
|
||||
array([[[[ 0, 1, 2],
|
||||
[ 1, 2, 3]]],
|
||||
[[[10, 11, 12],
|
||||
[11, 12, 13]]],
|
||||
[[[20, 21, 22],
|
||||
[21, 22, 23]]]])
|
||||
|
||||
Combining with stepped slicing (`::step`), this can be used to take sliding
|
||||
views which skip elements:
|
||||
|
||||
>>> x = np.arange(7)
|
||||
>>> sliding_window_view(x, 5)[:, ::2]
|
||||
array([[0, 2, 4],
|
||||
[1, 3, 5],
|
||||
[2, 4, 6]])
|
||||
|
||||
or views which move by multiple elements
|
||||
|
||||
>>> x = np.arange(7)
|
||||
>>> sliding_window_view(x, 3)[::2, :]
|
||||
array([[0, 1, 2],
|
||||
[2, 3, 4],
|
||||
[4, 5, 6]])
|
||||
|
||||
A common application of `sliding_window_view` is the calculation of running
|
||||
statistics. The simplest example is the
|
||||
`moving average <https://en.wikipedia.org/wiki/Moving_average>`_:
|
||||
|
||||
>>> x = np.arange(6)
|
||||
>>> x.shape
|
||||
(6,)
|
||||
>>> v = sliding_window_view(x, 3)
|
||||
>>> v.shape
|
||||
(4, 3)
|
||||
>>> v
|
||||
array([[0, 1, 2],
|
||||
[1, 2, 3],
|
||||
[2, 3, 4],
|
||||
[3, 4, 5]])
|
||||
>>> moving_average = v.mean(axis=-1)
|
||||
>>> moving_average
|
||||
array([1., 2., 3., 4.])
|
||||
|
||||
Note that a sliding window approach is often **not** optimal (see Notes).
|
||||
"""
|
||||
window_shape = (tuple(window_shape)
|
||||
if np.iterable(window_shape)
|
||||
else (window_shape,))
|
||||
# first convert input to array, possibly keeping subclass
|
||||
x = np.array(x, copy=False, subok=subok)
|
||||
|
||||
window_shape_array = np.array(window_shape)
|
||||
if np.any(window_shape_array < 0):
|
||||
raise ValueError('`window_shape` cannot contain negative values')
|
||||
|
||||
if axis is None:
|
||||
axis = tuple(range(x.ndim))
|
||||
if len(window_shape) != len(axis):
|
||||
raise ValueError(f'Since axis is `None`, must provide '
|
||||
f'window_shape for all dimensions of `x`; '
|
||||
f'got {len(window_shape)} window_shape elements '
|
||||
f'and `x.ndim` is {x.ndim}.')
|
||||
else:
|
||||
axis = normalize_axis_tuple(axis, x.ndim, allow_duplicate=True)
|
||||
if len(window_shape) != len(axis):
|
||||
raise ValueError(f'Must provide matching length window_shape and '
|
||||
f'axis; got {len(window_shape)} window_shape '
|
||||
f'elements and {len(axis)} axes elements.')
|
||||
|
||||
out_strides = x.strides + tuple(x.strides[ax] for ax in axis)
|
||||
|
||||
# note: same axis can be windowed repeatedly
|
||||
x_shape_trimmed = list(x.shape)
|
||||
for ax, dim in zip(axis, window_shape):
|
||||
if x_shape_trimmed[ax] < dim:
|
||||
raise ValueError(
|
||||
'window shape cannot be larger than input array shape')
|
||||
x_shape_trimmed[ax] -= dim - 1
|
||||
out_shape = tuple(x_shape_trimmed) + window_shape
|
||||
return as_strided(x, strides=out_strides, shape=out_shape,
|
||||
subok=subok, writeable=writeable)
|
||||
|
||||
|
||||
def _broadcast_to(array, shape, subok, readonly):
|
||||
shape = tuple(shape) if np.iterable(shape) else (shape,)
|
||||
array = np.array(array, copy=False, subok=subok)
|
||||
if not shape and array.shape:
|
||||
raise ValueError('cannot broadcast a non-scalar to a scalar array')
|
||||
if any(size < 0 for size in shape):
|
||||
raise ValueError('all elements of broadcast shape must be non-'
|
||||
'negative')
|
||||
extras = []
|
||||
it = np.nditer(
|
||||
(array,), flags=['multi_index', 'refs_ok', 'zerosize_ok'] + extras,
|
||||
op_flags=['readonly'], itershape=shape, order='C')
|
||||
with it:
|
||||
# never really has writebackifcopy semantics
|
||||
broadcast = it.itviews[0]
|
||||
result = _maybe_view_as_subclass(array, broadcast)
|
||||
# In a future version this will go away
|
||||
if not readonly and array.flags._writeable_no_warn:
|
||||
result.flags.writeable = True
|
||||
result.flags._warn_on_write = True
|
||||
return result
|
||||
|
||||
|
||||
def _broadcast_to_dispatcher(array, shape, subok=None):
|
||||
return (array,)
|
||||
|
||||
|
||||
@array_function_dispatch(_broadcast_to_dispatcher, module='numpy')
|
||||
def broadcast_to(array, shape, subok=False):
|
||||
"""Broadcast an array to a new shape.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
array : array_like
|
||||
The array to broadcast.
|
||||
shape : tuple or int
|
||||
The shape of the desired array. A single integer ``i`` is interpreted
|
||||
as ``(i,)``.
|
||||
subok : bool, optional
|
||||
If True, then sub-classes will be passed-through, otherwise
|
||||
the returned array will be forced to be a base-class array (default).
|
||||
|
||||
Returns
|
||||
-------
|
||||
broadcast : array
|
||||
A readonly view on the original array with the given shape. It is
|
||||
typically not contiguous. Furthermore, more than one element of a
|
||||
broadcasted array may refer to a single memory location.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the array is not compatible with the new shape according to NumPy's
|
||||
broadcasting rules.
|
||||
|
||||
See Also
|
||||
--------
|
||||
broadcast
|
||||
broadcast_arrays
|
||||
broadcast_shapes
|
||||
|
||||
Notes
|
||||
-----
|
||||
.. versionadded:: 1.10.0
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> x = np.array([1, 2, 3])
|
||||
>>> np.broadcast_to(x, (3, 3))
|
||||
array([[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[1, 2, 3]])
|
||||
"""
|
||||
return _broadcast_to(array, shape, subok=subok, readonly=True)
|
||||
|
||||
|
||||
def _broadcast_shape(*args):
|
||||
"""Returns the shape of the arrays that would result from broadcasting the
|
||||
supplied arrays against each other.
|
||||
"""
|
||||
# use the old-iterator because np.nditer does not handle size 0 arrays
|
||||
# consistently
|
||||
b = np.broadcast(*args[:32])
|
||||
# unfortunately, it cannot handle 32 or more arguments directly
|
||||
for pos in range(32, len(args), 31):
|
||||
# ironically, np.broadcast does not properly handle np.broadcast
|
||||
# objects (it treats them as scalars)
|
||||
# use broadcasting to avoid allocating the full array
|
||||
b = broadcast_to(0, b.shape)
|
||||
b = np.broadcast(b, *args[pos:(pos + 31)])
|
||||
return b.shape
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def broadcast_shapes(*args):
|
||||
"""
|
||||
Broadcast the input shapes into a single shape.
|
||||
|
||||
:ref:`Learn more about broadcasting here <basics.broadcasting>`.
|
||||
|
||||
.. versionadded:: 1.20.0
|
||||
|
||||
Parameters
|
||||
----------
|
||||
`*args` : tuples of ints, or ints
|
||||
The shapes to be broadcast against each other.
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple
|
||||
Broadcasted shape.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the shapes are not compatible and cannot be broadcast according
|
||||
to NumPy's broadcasting rules.
|
||||
|
||||
See Also
|
||||
--------
|
||||
broadcast
|
||||
broadcast_arrays
|
||||
broadcast_to
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
|
||||
(3, 2)
|
||||
|
||||
>>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))
|
||||
(5, 6, 7)
|
||||
"""
|
||||
arrays = [np.empty(x, dtype=[]) for x in args]
|
||||
return _broadcast_shape(*arrays)
|
||||
|
||||
|
||||
def _broadcast_arrays_dispatcher(*args, subok=None):
|
||||
return args
|
||||
|
||||
|
||||
@array_function_dispatch(_broadcast_arrays_dispatcher, module='numpy')
|
||||
def broadcast_arrays(*args, subok=False):
|
||||
"""
|
||||
Broadcast any number of arrays against each other.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
`*args` : array_likes
|
||||
The arrays to broadcast.
|
||||
|
||||
subok : bool, optional
|
||||
If True, then sub-classes will be passed-through, otherwise
|
||||
the returned arrays will be forced to be a base-class array (default).
|
||||
|
||||
Returns
|
||||
-------
|
||||
broadcasted : list of arrays
|
||||
These arrays are views on the original arrays. They are typically
|
||||
not contiguous. Furthermore, more than one element of a
|
||||
broadcasted array may refer to a single memory location. If you need
|
||||
to write to the arrays, make copies first. While you can set the
|
||||
``writable`` flag True, writing to a single output value may end up
|
||||
changing more than one location in the output array.
|
||||
|
||||
.. deprecated:: 1.17
|
||||
The output is currently marked so that if written to, a deprecation
|
||||
warning will be emitted. A future version will set the
|
||||
``writable`` flag False so writing to it will raise an error.
|
||||
|
||||
See Also
|
||||
--------
|
||||
broadcast
|
||||
broadcast_to
|
||||
broadcast_shapes
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> x = np.array([[1,2,3]])
|
||||
>>> y = np.array([[4],[5]])
|
||||
>>> np.broadcast_arrays(x, y)
|
||||
[array([[1, 2, 3],
|
||||
[1, 2, 3]]), array([[4, 4, 4],
|
||||
[5, 5, 5]])]
|
||||
|
||||
Here is a useful idiom for getting contiguous copies instead of
|
||||
non-contiguous views.
|
||||
|
||||
>>> [np.array(a) for a in np.broadcast_arrays(x, y)]
|
||||
[array([[1, 2, 3],
|
||||
[1, 2, 3]]), array([[4, 4, 4],
|
||||
[5, 5, 5]])]
|
||||
|
||||
"""
|
||||
# nditer is not used here to avoid the limit of 32 arrays.
|
||||
# Otherwise, something like the following one-liner would suffice:
|
||||
# return np.nditer(args, flags=['multi_index', 'zerosize_ok'],
|
||||
# order='C').itviews
|
||||
|
||||
args = [np.array(_m, copy=False, subok=subok) for _m in args]
|
||||
|
||||
shape = _broadcast_shape(*args)
|
||||
|
||||
if all(array.shape == shape for array in args):
|
||||
# Common case where nothing needs to be broadcasted.
|
||||
return args
|
||||
|
||||
return [_broadcast_to(array, shape, subok=subok, readonly=False)
|
||||
for array in args]
|
||||
@@ -0,0 +1,80 @@
|
||||
from collections.abc import Iterable
|
||||
from typing import Any, TypeVar, overload, SupportsIndex
|
||||
|
||||
from numpy import generic
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
ArrayLike,
|
||||
_ShapeLike,
|
||||
_Shape,
|
||||
_ArrayLike
|
||||
)
|
||||
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
class DummyArray:
|
||||
__array_interface__: dict[str, Any]
|
||||
base: None | NDArray[Any]
|
||||
def __init__(
|
||||
self,
|
||||
interface: dict[str, Any],
|
||||
base: None | NDArray[Any] = ...,
|
||||
) -> None: ...
|
||||
|
||||
@overload
|
||||
def as_strided(
|
||||
x: _ArrayLike[_SCT],
|
||||
shape: None | Iterable[int] = ...,
|
||||
strides: None | Iterable[int] = ...,
|
||||
subok: bool = ...,
|
||||
writeable: bool = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def as_strided(
|
||||
x: ArrayLike,
|
||||
shape: None | Iterable[int] = ...,
|
||||
strides: None | Iterable[int] = ...,
|
||||
subok: bool = ...,
|
||||
writeable: bool = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def sliding_window_view(
|
||||
x: _ArrayLike[_SCT],
|
||||
window_shape: int | Iterable[int],
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
subok: bool = ...,
|
||||
writeable: bool = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def sliding_window_view(
|
||||
x: ArrayLike,
|
||||
window_shape: int | Iterable[int],
|
||||
axis: None | SupportsIndex = ...,
|
||||
*,
|
||||
subok: bool = ...,
|
||||
writeable: bool = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def broadcast_to(
|
||||
array: _ArrayLike[_SCT],
|
||||
shape: int | Iterable[int],
|
||||
subok: bool = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def broadcast_to(
|
||||
array: ArrayLike,
|
||||
shape: int | Iterable[int],
|
||||
subok: bool = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
def broadcast_shapes(*args: _ShapeLike) -> _Shape: ...
|
||||
|
||||
def broadcast_arrays(
|
||||
*args: ArrayLike,
|
||||
subok: bool = ...,
|
||||
) -> list[NDArray[Any]]: ...
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,350 @@
|
||||
import os
|
||||
import pytest
|
||||
from tempfile import mkdtemp, mkstemp, NamedTemporaryFile
|
||||
from shutil import rmtree
|
||||
|
||||
import numpy.lib._datasource as datasource
|
||||
from numpy.testing import assert_, assert_equal, assert_raises
|
||||
|
||||
import urllib.request as urllib_request
|
||||
from urllib.parse import urlparse
|
||||
from urllib.error import URLError
|
||||
|
||||
|
||||
def urlopen_stub(url, data=None):
|
||||
'''Stub to replace urlopen for testing.'''
|
||||
if url == valid_httpurl():
|
||||
tmpfile = NamedTemporaryFile(prefix='urltmp_')
|
||||
return tmpfile
|
||||
else:
|
||||
raise URLError('Name or service not known')
|
||||
|
||||
# setup and teardown
|
||||
old_urlopen = None
|
||||
|
||||
|
||||
def setup_module():
|
||||
global old_urlopen
|
||||
|
||||
old_urlopen = urllib_request.urlopen
|
||||
urllib_request.urlopen = urlopen_stub
|
||||
|
||||
|
||||
def teardown_module():
|
||||
urllib_request.urlopen = old_urlopen
|
||||
|
||||
# A valid website for more robust testing
|
||||
http_path = 'http://www.google.com/'
|
||||
http_file = 'index.html'
|
||||
|
||||
http_fakepath = 'http://fake.abc.web/site/'
|
||||
http_fakefile = 'fake.txt'
|
||||
|
||||
malicious_files = ['/etc/shadow', '../../shadow',
|
||||
'..\\system.dat', 'c:\\windows\\system.dat']
|
||||
|
||||
magic_line = b'three is the magic number'
|
||||
|
||||
|
||||
# Utility functions used by many tests
|
||||
def valid_textfile(filedir):
|
||||
# Generate and return a valid temporary file.
|
||||
fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir, text=True)
|
||||
os.close(fd)
|
||||
return path
|
||||
|
||||
|
||||
def invalid_textfile(filedir):
|
||||
# Generate and return an invalid filename.
|
||||
fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir)
|
||||
os.close(fd)
|
||||
os.remove(path)
|
||||
return path
|
||||
|
||||
|
||||
def valid_httpurl():
|
||||
return http_path+http_file
|
||||
|
||||
|
||||
def invalid_httpurl():
|
||||
return http_fakepath+http_fakefile
|
||||
|
||||
|
||||
def valid_baseurl():
|
||||
return http_path
|
||||
|
||||
|
||||
def invalid_baseurl():
|
||||
return http_fakepath
|
||||
|
||||
|
||||
def valid_httpfile():
|
||||
return http_file
|
||||
|
||||
|
||||
def invalid_httpfile():
|
||||
return http_fakefile
|
||||
|
||||
|
||||
class TestDataSourceOpen:
|
||||
def setup_method(self):
|
||||
self.tmpdir = mkdtemp()
|
||||
self.ds = datasource.DataSource(self.tmpdir)
|
||||
|
||||
def teardown_method(self):
|
||||
rmtree(self.tmpdir)
|
||||
del self.ds
|
||||
|
||||
def test_ValidHTTP(self):
|
||||
fh = self.ds.open(valid_httpurl())
|
||||
assert_(fh)
|
||||
fh.close()
|
||||
|
||||
def test_InvalidHTTP(self):
|
||||
url = invalid_httpurl()
|
||||
assert_raises(OSError, self.ds.open, url)
|
||||
try:
|
||||
self.ds.open(url)
|
||||
except OSError as e:
|
||||
# Regression test for bug fixed in r4342.
|
||||
assert_(e.errno is None)
|
||||
|
||||
def test_InvalidHTTPCacheURLError(self):
|
||||
assert_raises(URLError, self.ds._cache, invalid_httpurl())
|
||||
|
||||
def test_ValidFile(self):
|
||||
local_file = valid_textfile(self.tmpdir)
|
||||
fh = self.ds.open(local_file)
|
||||
assert_(fh)
|
||||
fh.close()
|
||||
|
||||
def test_InvalidFile(self):
|
||||
invalid_file = invalid_textfile(self.tmpdir)
|
||||
assert_raises(OSError, self.ds.open, invalid_file)
|
||||
|
||||
def test_ValidGzipFile(self):
|
||||
try:
|
||||
import gzip
|
||||
except ImportError:
|
||||
# We don't have the gzip capabilities to test.
|
||||
pytest.skip()
|
||||
# Test datasource's internal file_opener for Gzip files.
|
||||
filepath = os.path.join(self.tmpdir, 'foobar.txt.gz')
|
||||
fp = gzip.open(filepath, 'w')
|
||||
fp.write(magic_line)
|
||||
fp.close()
|
||||
fp = self.ds.open(filepath)
|
||||
result = fp.readline()
|
||||
fp.close()
|
||||
assert_equal(magic_line, result)
|
||||
|
||||
def test_ValidBz2File(self):
|
||||
try:
|
||||
import bz2
|
||||
except ImportError:
|
||||
# We don't have the bz2 capabilities to test.
|
||||
pytest.skip()
|
||||
# Test datasource's internal file_opener for BZip2 files.
|
||||
filepath = os.path.join(self.tmpdir, 'foobar.txt.bz2')
|
||||
fp = bz2.BZ2File(filepath, 'w')
|
||||
fp.write(magic_line)
|
||||
fp.close()
|
||||
fp = self.ds.open(filepath)
|
||||
result = fp.readline()
|
||||
fp.close()
|
||||
assert_equal(magic_line, result)
|
||||
|
||||
|
||||
class TestDataSourceExists:
|
||||
def setup_method(self):
|
||||
self.tmpdir = mkdtemp()
|
||||
self.ds = datasource.DataSource(self.tmpdir)
|
||||
|
||||
def teardown_method(self):
|
||||
rmtree(self.tmpdir)
|
||||
del self.ds
|
||||
|
||||
def test_ValidHTTP(self):
|
||||
assert_(self.ds.exists(valid_httpurl()))
|
||||
|
||||
def test_InvalidHTTP(self):
|
||||
assert_equal(self.ds.exists(invalid_httpurl()), False)
|
||||
|
||||
def test_ValidFile(self):
|
||||
# Test valid file in destpath
|
||||
tmpfile = valid_textfile(self.tmpdir)
|
||||
assert_(self.ds.exists(tmpfile))
|
||||
# Test valid local file not in destpath
|
||||
localdir = mkdtemp()
|
||||
tmpfile = valid_textfile(localdir)
|
||||
assert_(self.ds.exists(tmpfile))
|
||||
rmtree(localdir)
|
||||
|
||||
def test_InvalidFile(self):
|
||||
tmpfile = invalid_textfile(self.tmpdir)
|
||||
assert_equal(self.ds.exists(tmpfile), False)
|
||||
|
||||
|
||||
class TestDataSourceAbspath:
|
||||
def setup_method(self):
|
||||
self.tmpdir = os.path.abspath(mkdtemp())
|
||||
self.ds = datasource.DataSource(self.tmpdir)
|
||||
|
||||
def teardown_method(self):
|
||||
rmtree(self.tmpdir)
|
||||
del self.ds
|
||||
|
||||
def test_ValidHTTP(self):
|
||||
scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
|
||||
local_path = os.path.join(self.tmpdir, netloc,
|
||||
upath.strip(os.sep).strip('/'))
|
||||
assert_equal(local_path, self.ds.abspath(valid_httpurl()))
|
||||
|
||||
def test_ValidFile(self):
|
||||
tmpfile = valid_textfile(self.tmpdir)
|
||||
tmpfilename = os.path.split(tmpfile)[-1]
|
||||
# Test with filename only
|
||||
assert_equal(tmpfile, self.ds.abspath(tmpfilename))
|
||||
# Test filename with complete path
|
||||
assert_equal(tmpfile, self.ds.abspath(tmpfile))
|
||||
|
||||
def test_InvalidHTTP(self):
|
||||
scheme, netloc, upath, pms, qry, frg = urlparse(invalid_httpurl())
|
||||
invalidhttp = os.path.join(self.tmpdir, netloc,
|
||||
upath.strip(os.sep).strip('/'))
|
||||
assert_(invalidhttp != self.ds.abspath(valid_httpurl()))
|
||||
|
||||
def test_InvalidFile(self):
|
||||
invalidfile = valid_textfile(self.tmpdir)
|
||||
tmpfile = valid_textfile(self.tmpdir)
|
||||
tmpfilename = os.path.split(tmpfile)[-1]
|
||||
# Test with filename only
|
||||
assert_(invalidfile != self.ds.abspath(tmpfilename))
|
||||
# Test filename with complete path
|
||||
assert_(invalidfile != self.ds.abspath(tmpfile))
|
||||
|
||||
def test_sandboxing(self):
|
||||
tmpfile = valid_textfile(self.tmpdir)
|
||||
tmpfilename = os.path.split(tmpfile)[-1]
|
||||
|
||||
tmp_path = lambda x: os.path.abspath(self.ds.abspath(x))
|
||||
|
||||
assert_(tmp_path(valid_httpurl()).startswith(self.tmpdir))
|
||||
assert_(tmp_path(invalid_httpurl()).startswith(self.tmpdir))
|
||||
assert_(tmp_path(tmpfile).startswith(self.tmpdir))
|
||||
assert_(tmp_path(tmpfilename).startswith(self.tmpdir))
|
||||
for fn in malicious_files:
|
||||
assert_(tmp_path(http_path+fn).startswith(self.tmpdir))
|
||||
assert_(tmp_path(fn).startswith(self.tmpdir))
|
||||
|
||||
def test_windows_os_sep(self):
|
||||
orig_os_sep = os.sep
|
||||
try:
|
||||
os.sep = '\\'
|
||||
self.test_ValidHTTP()
|
||||
self.test_ValidFile()
|
||||
self.test_InvalidHTTP()
|
||||
self.test_InvalidFile()
|
||||
self.test_sandboxing()
|
||||
finally:
|
||||
os.sep = orig_os_sep
|
||||
|
||||
|
||||
class TestRepositoryAbspath:
|
||||
def setup_method(self):
|
||||
self.tmpdir = os.path.abspath(mkdtemp())
|
||||
self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
|
||||
|
||||
def teardown_method(self):
|
||||
rmtree(self.tmpdir)
|
||||
del self.repos
|
||||
|
||||
def test_ValidHTTP(self):
|
||||
scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
|
||||
local_path = os.path.join(self.repos._destpath, netloc,
|
||||
upath.strip(os.sep).strip('/'))
|
||||
filepath = self.repos.abspath(valid_httpfile())
|
||||
assert_equal(local_path, filepath)
|
||||
|
||||
def test_sandboxing(self):
|
||||
tmp_path = lambda x: os.path.abspath(self.repos.abspath(x))
|
||||
assert_(tmp_path(valid_httpfile()).startswith(self.tmpdir))
|
||||
for fn in malicious_files:
|
||||
assert_(tmp_path(http_path+fn).startswith(self.tmpdir))
|
||||
assert_(tmp_path(fn).startswith(self.tmpdir))
|
||||
|
||||
def test_windows_os_sep(self):
|
||||
orig_os_sep = os.sep
|
||||
try:
|
||||
os.sep = '\\'
|
||||
self.test_ValidHTTP()
|
||||
self.test_sandboxing()
|
||||
finally:
|
||||
os.sep = orig_os_sep
|
||||
|
||||
|
||||
class TestRepositoryExists:
|
||||
def setup_method(self):
|
||||
self.tmpdir = mkdtemp()
|
||||
self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
|
||||
|
||||
def teardown_method(self):
|
||||
rmtree(self.tmpdir)
|
||||
del self.repos
|
||||
|
||||
def test_ValidFile(self):
|
||||
# Create local temp file
|
||||
tmpfile = valid_textfile(self.tmpdir)
|
||||
assert_(self.repos.exists(tmpfile))
|
||||
|
||||
def test_InvalidFile(self):
|
||||
tmpfile = invalid_textfile(self.tmpdir)
|
||||
assert_equal(self.repos.exists(tmpfile), False)
|
||||
|
||||
def test_RemoveHTTPFile(self):
|
||||
assert_(self.repos.exists(valid_httpurl()))
|
||||
|
||||
def test_CachedHTTPFile(self):
|
||||
localfile = valid_httpurl()
|
||||
# Create a locally cached temp file with an URL based
|
||||
# directory structure. This is similar to what Repository.open
|
||||
# would do.
|
||||
scheme, netloc, upath, pms, qry, frg = urlparse(localfile)
|
||||
local_path = os.path.join(self.repos._destpath, netloc)
|
||||
os.mkdir(local_path, 0o0700)
|
||||
tmpfile = valid_textfile(local_path)
|
||||
assert_(self.repos.exists(tmpfile))
|
||||
|
||||
|
||||
class TestOpenFunc:
|
||||
def setup_method(self):
|
||||
self.tmpdir = mkdtemp()
|
||||
|
||||
def teardown_method(self):
|
||||
rmtree(self.tmpdir)
|
||||
|
||||
def test_DataSourceOpen(self):
|
||||
local_file = valid_textfile(self.tmpdir)
|
||||
# Test case where destpath is passed in
|
||||
fp = datasource.open(local_file, destpath=self.tmpdir)
|
||||
assert_(fp)
|
||||
fp.close()
|
||||
# Test case where default destpath is used
|
||||
fp = datasource.open(local_file)
|
||||
assert_(fp)
|
||||
fp.close()
|
||||
|
||||
def test_del_attr_handling():
|
||||
# DataSource __del__ can be called
|
||||
# even if __init__ fails when the
|
||||
# Exception object is caught by the
|
||||
# caller as happens in refguide_check
|
||||
# is_deprecated() function
|
||||
|
||||
ds = datasource.DataSource()
|
||||
# simulate failed __init__ by removing key attribute
|
||||
# produced within __init__ and expected by __del__
|
||||
del ds._istmpdest
|
||||
# should not raise an AttributeError if __del__
|
||||
# gracefully handles failed __init__:
|
||||
ds.__del__()
|
||||
@@ -0,0 +1,353 @@
|
||||
import time
|
||||
from datetime import date
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_allclose, assert_raises,
|
||||
)
|
||||
from numpy.lib._iotools import (
|
||||
LineSplitter, NameValidator, StringConverter,
|
||||
has_nested_fields, easy_dtype, flatten_dtype
|
||||
)
|
||||
|
||||
|
||||
class TestLineSplitter:
|
||||
"Tests the LineSplitter class."
|
||||
|
||||
def test_no_delimiter(self):
|
||||
"Test LineSplitter w/o delimiter"
|
||||
strg = " 1 2 3 4 5 # test"
|
||||
test = LineSplitter()(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '5'])
|
||||
test = LineSplitter('')(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '5'])
|
||||
|
||||
def test_space_delimiter(self):
|
||||
"Test space delimiter"
|
||||
strg = " 1 2 3 4 5 # test"
|
||||
test = LineSplitter(' ')(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '', '5'])
|
||||
test = LineSplitter(' ')(strg)
|
||||
assert_equal(test, ['1 2 3 4', '5'])
|
||||
|
||||
def test_tab_delimiter(self):
|
||||
"Test tab delimiter"
|
||||
strg = " 1\t 2\t 3\t 4\t 5 6"
|
||||
test = LineSplitter('\t')(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '5 6'])
|
||||
strg = " 1 2\t 3 4\t 5 6"
|
||||
test = LineSplitter('\t')(strg)
|
||||
assert_equal(test, ['1 2', '3 4', '5 6'])
|
||||
|
||||
def test_other_delimiter(self):
|
||||
"Test LineSplitter on delimiter"
|
||||
strg = "1,2,3,4,,5"
|
||||
test = LineSplitter(',')(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '', '5'])
|
||||
#
|
||||
strg = " 1,2,3,4,,5 # test"
|
||||
test = LineSplitter(',')(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '', '5'])
|
||||
|
||||
# gh-11028 bytes comment/delimiters should get encoded
|
||||
strg = b" 1,2,3,4,,5 % test"
|
||||
test = LineSplitter(delimiter=b',', comments=b'%')(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '', '5'])
|
||||
|
||||
def test_constant_fixed_width(self):
|
||||
"Test LineSplitter w/ fixed-width fields"
|
||||
strg = " 1 2 3 4 5 # test"
|
||||
test = LineSplitter(3)(strg)
|
||||
assert_equal(test, ['1', '2', '3', '4', '', '5', ''])
|
||||
#
|
||||
strg = " 1 3 4 5 6# test"
|
||||
test = LineSplitter(20)(strg)
|
||||
assert_equal(test, ['1 3 4 5 6'])
|
||||
#
|
||||
strg = " 1 3 4 5 6# test"
|
||||
test = LineSplitter(30)(strg)
|
||||
assert_equal(test, ['1 3 4 5 6'])
|
||||
|
||||
def test_variable_fixed_width(self):
|
||||
strg = " 1 3 4 5 6# test"
|
||||
test = LineSplitter((3, 6, 6, 3))(strg)
|
||||
assert_equal(test, ['1', '3', '4 5', '6'])
|
||||
#
|
||||
strg = " 1 3 4 5 6# test"
|
||||
test = LineSplitter((6, 6, 9))(strg)
|
||||
assert_equal(test, ['1', '3 4', '5 6'])
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TestNameValidator:
|
||||
|
||||
def test_case_sensitivity(self):
|
||||
"Test case sensitivity"
|
||||
names = ['A', 'a', 'b', 'c']
|
||||
test = NameValidator().validate(names)
|
||||
assert_equal(test, ['A', 'a', 'b', 'c'])
|
||||
test = NameValidator(case_sensitive=False).validate(names)
|
||||
assert_equal(test, ['A', 'A_1', 'B', 'C'])
|
||||
test = NameValidator(case_sensitive='upper').validate(names)
|
||||
assert_equal(test, ['A', 'A_1', 'B', 'C'])
|
||||
test = NameValidator(case_sensitive='lower').validate(names)
|
||||
assert_equal(test, ['a', 'a_1', 'b', 'c'])
|
||||
|
||||
# check exceptions
|
||||
assert_raises(ValueError, NameValidator, case_sensitive='foobar')
|
||||
|
||||
def test_excludelist(self):
|
||||
"Test excludelist"
|
||||
names = ['dates', 'data', 'Other Data', 'mask']
|
||||
validator = NameValidator(excludelist=['dates', 'data', 'mask'])
|
||||
test = validator.validate(names)
|
||||
assert_equal(test, ['dates_', 'data_', 'Other_Data', 'mask_'])
|
||||
|
||||
def test_missing_names(self):
|
||||
"Test validate missing names"
|
||||
namelist = ('a', 'b', 'c')
|
||||
validator = NameValidator()
|
||||
assert_equal(validator(namelist), ['a', 'b', 'c'])
|
||||
namelist = ('', 'b', 'c')
|
||||
assert_equal(validator(namelist), ['f0', 'b', 'c'])
|
||||
namelist = ('a', 'b', '')
|
||||
assert_equal(validator(namelist), ['a', 'b', 'f0'])
|
||||
namelist = ('', 'f0', '')
|
||||
assert_equal(validator(namelist), ['f1', 'f0', 'f2'])
|
||||
|
||||
def test_validate_nb_names(self):
|
||||
"Test validate nb names"
|
||||
namelist = ('a', 'b', 'c')
|
||||
validator = NameValidator()
|
||||
assert_equal(validator(namelist, nbfields=1), ('a',))
|
||||
assert_equal(validator(namelist, nbfields=5, defaultfmt="g%i"),
|
||||
['a', 'b', 'c', 'g0', 'g1'])
|
||||
|
||||
def test_validate_wo_names(self):
|
||||
"Test validate no names"
|
||||
namelist = None
|
||||
validator = NameValidator()
|
||||
assert_(validator(namelist) is None)
|
||||
assert_equal(validator(namelist, nbfields=3), ['f0', 'f1', 'f2'])
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _bytes_to_date(s):
|
||||
return date(*time.strptime(s, "%Y-%m-%d")[:3])
|
||||
|
||||
|
||||
class TestStringConverter:
|
||||
"Test StringConverter"
|
||||
|
||||
def test_creation(self):
|
||||
"Test creation of a StringConverter"
|
||||
converter = StringConverter(int, -99999)
|
||||
assert_equal(converter._status, 1)
|
||||
assert_equal(converter.default, -99999)
|
||||
|
||||
def test_upgrade(self):
|
||||
"Tests the upgrade method."
|
||||
|
||||
converter = StringConverter()
|
||||
assert_equal(converter._status, 0)
|
||||
|
||||
# test int
|
||||
assert_equal(converter.upgrade('0'), 0)
|
||||
assert_equal(converter._status, 1)
|
||||
|
||||
# On systems where long defaults to 32-bit, the statuses will be
|
||||
# offset by one, so we check for this here.
|
||||
import numpy.core.numeric as nx
|
||||
status_offset = int(nx.dtype(nx.int_).itemsize < nx.dtype(nx.int64).itemsize)
|
||||
|
||||
# test int > 2**32
|
||||
assert_equal(converter.upgrade('17179869184'), 17179869184)
|
||||
assert_equal(converter._status, 1 + status_offset)
|
||||
|
||||
# test float
|
||||
assert_allclose(converter.upgrade('0.'), 0.0)
|
||||
assert_equal(converter._status, 2 + status_offset)
|
||||
|
||||
# test complex
|
||||
assert_equal(converter.upgrade('0j'), complex('0j'))
|
||||
assert_equal(converter._status, 3 + status_offset)
|
||||
|
||||
# test str
|
||||
# note that the longdouble type has been skipped, so the
|
||||
# _status increases by 2. Everything should succeed with
|
||||
# unicode conversion (8).
|
||||
for s in ['a', b'a']:
|
||||
res = converter.upgrade(s)
|
||||
assert_(type(res) is str)
|
||||
assert_equal(res, 'a')
|
||||
assert_equal(converter._status, 8 + status_offset)
|
||||
|
||||
def test_missing(self):
|
||||
"Tests the use of missing values."
|
||||
converter = StringConverter(missing_values=('missing',
|
||||
'missed'))
|
||||
converter.upgrade('0')
|
||||
assert_equal(converter('0'), 0)
|
||||
assert_equal(converter(''), converter.default)
|
||||
assert_equal(converter('missing'), converter.default)
|
||||
assert_equal(converter('missed'), converter.default)
|
||||
try:
|
||||
converter('miss')
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def test_upgrademapper(self):
|
||||
"Tests updatemapper"
|
||||
dateparser = _bytes_to_date
|
||||
_original_mapper = StringConverter._mapper[:]
|
||||
try:
|
||||
StringConverter.upgrade_mapper(dateparser, date(2000, 1, 1))
|
||||
convert = StringConverter(dateparser, date(2000, 1, 1))
|
||||
test = convert('2001-01-01')
|
||||
assert_equal(test, date(2001, 1, 1))
|
||||
test = convert('2009-01-01')
|
||||
assert_equal(test, date(2009, 1, 1))
|
||||
test = convert('')
|
||||
assert_equal(test, date(2000, 1, 1))
|
||||
finally:
|
||||
StringConverter._mapper = _original_mapper
|
||||
|
||||
def test_string_to_object(self):
|
||||
"Make sure that string-to-object functions are properly recognized"
|
||||
old_mapper = StringConverter._mapper[:] # copy of list
|
||||
conv = StringConverter(_bytes_to_date)
|
||||
assert_equal(conv._mapper, old_mapper)
|
||||
assert_(hasattr(conv, 'default'))
|
||||
|
||||
def test_keep_default(self):
|
||||
"Make sure we don't lose an explicit default"
|
||||
converter = StringConverter(None, missing_values='',
|
||||
default=-999)
|
||||
converter.upgrade('3.14159265')
|
||||
assert_equal(converter.default, -999)
|
||||
assert_equal(converter.type, np.dtype(float))
|
||||
#
|
||||
converter = StringConverter(
|
||||
None, missing_values='', default=0)
|
||||
converter.upgrade('3.14159265')
|
||||
assert_equal(converter.default, 0)
|
||||
assert_equal(converter.type, np.dtype(float))
|
||||
|
||||
def test_keep_default_zero(self):
|
||||
"Check that we don't lose a default of 0"
|
||||
converter = StringConverter(int, default=0,
|
||||
missing_values="N/A")
|
||||
assert_equal(converter.default, 0)
|
||||
|
||||
def test_keep_missing_values(self):
|
||||
"Check that we're not losing missing values"
|
||||
converter = StringConverter(int, default=0,
|
||||
missing_values="N/A")
|
||||
assert_equal(
|
||||
converter.missing_values, {'', 'N/A'})
|
||||
|
||||
def test_int64_dtype(self):
|
||||
"Check that int64 integer types can be specified"
|
||||
converter = StringConverter(np.int64, default=0)
|
||||
val = "-9223372036854775807"
|
||||
assert_(converter(val) == -9223372036854775807)
|
||||
val = "9223372036854775807"
|
||||
assert_(converter(val) == 9223372036854775807)
|
||||
|
||||
def test_uint64_dtype(self):
|
||||
"Check that uint64 integer types can be specified"
|
||||
converter = StringConverter(np.uint64, default=0)
|
||||
val = "9223372043271415339"
|
||||
assert_(converter(val) == 9223372043271415339)
|
||||
|
||||
|
||||
class TestMiscFunctions:
|
||||
|
||||
def test_has_nested_dtype(self):
|
||||
"Test has_nested_dtype"
|
||||
ndtype = np.dtype(float)
|
||||
assert_equal(has_nested_fields(ndtype), False)
|
||||
ndtype = np.dtype([('A', '|S3'), ('B', float)])
|
||||
assert_equal(has_nested_fields(ndtype), False)
|
||||
ndtype = np.dtype([('A', int), ('B', [('BA', float), ('BB', '|S1')])])
|
||||
assert_equal(has_nested_fields(ndtype), True)
|
||||
|
||||
def test_easy_dtype(self):
|
||||
"Test ndtype on dtypes"
|
||||
# Simple case
|
||||
ndtype = float
|
||||
assert_equal(easy_dtype(ndtype), np.dtype(float))
|
||||
# As string w/o names
|
||||
ndtype = "i4, f8"
|
||||
assert_equal(easy_dtype(ndtype),
|
||||
np.dtype([('f0', "i4"), ('f1', "f8")]))
|
||||
# As string w/o names but different default format
|
||||
assert_equal(easy_dtype(ndtype, defaultfmt="field_%03i"),
|
||||
np.dtype([('field_000', "i4"), ('field_001', "f8")]))
|
||||
# As string w/ names
|
||||
ndtype = "i4, f8"
|
||||
assert_equal(easy_dtype(ndtype, names="a, b"),
|
||||
np.dtype([('a', "i4"), ('b', "f8")]))
|
||||
# As string w/ names (too many)
|
||||
ndtype = "i4, f8"
|
||||
assert_equal(easy_dtype(ndtype, names="a, b, c"),
|
||||
np.dtype([('a', "i4"), ('b', "f8")]))
|
||||
# As string w/ names (not enough)
|
||||
ndtype = "i4, f8"
|
||||
assert_equal(easy_dtype(ndtype, names=", b"),
|
||||
np.dtype([('f0', "i4"), ('b', "f8")]))
|
||||
# ... (with different default format)
|
||||
assert_equal(easy_dtype(ndtype, names="a", defaultfmt="f%02i"),
|
||||
np.dtype([('a', "i4"), ('f00', "f8")]))
|
||||
# As list of tuples w/o names
|
||||
ndtype = [('A', int), ('B', float)]
|
||||
assert_equal(easy_dtype(ndtype), np.dtype([('A', int), ('B', float)]))
|
||||
# As list of tuples w/ names
|
||||
assert_equal(easy_dtype(ndtype, names="a,b"),
|
||||
np.dtype([('a', int), ('b', float)]))
|
||||
# As list of tuples w/ not enough names
|
||||
assert_equal(easy_dtype(ndtype, names="a"),
|
||||
np.dtype([('a', int), ('f0', float)]))
|
||||
# As list of tuples w/ too many names
|
||||
assert_equal(easy_dtype(ndtype, names="a,b,c"),
|
||||
np.dtype([('a', int), ('b', float)]))
|
||||
# As list of types w/o names
|
||||
ndtype = (int, float, float)
|
||||
assert_equal(easy_dtype(ndtype),
|
||||
np.dtype([('f0', int), ('f1', float), ('f2', float)]))
|
||||
# As list of types w names
|
||||
ndtype = (int, float, float)
|
||||
assert_equal(easy_dtype(ndtype, names="a, b, c"),
|
||||
np.dtype([('a', int), ('b', float), ('c', float)]))
|
||||
# As simple dtype w/ names
|
||||
ndtype = np.dtype(float)
|
||||
assert_equal(easy_dtype(ndtype, names="a, b, c"),
|
||||
np.dtype([(_, float) for _ in ('a', 'b', 'c')]))
|
||||
# As simple dtype w/o names (but multiple fields)
|
||||
ndtype = np.dtype(float)
|
||||
assert_equal(
|
||||
easy_dtype(ndtype, names=['', '', ''], defaultfmt="f%02i"),
|
||||
np.dtype([(_, float) for _ in ('f00', 'f01', 'f02')]))
|
||||
|
||||
def test_flatten_dtype(self):
|
||||
"Testing flatten_dtype"
|
||||
# Standard dtype
|
||||
dt = np.dtype([("a", "f8"), ("b", "f8")])
|
||||
dt_flat = flatten_dtype(dt)
|
||||
assert_equal(dt_flat, [float, float])
|
||||
# Recursive dtype
|
||||
dt = np.dtype([("a", [("aa", '|S1'), ("ab", '|S2')]), ("b", int)])
|
||||
dt_flat = flatten_dtype(dt)
|
||||
assert_equal(dt_flat, [np.dtype('|S1'), np.dtype('|S2'), int])
|
||||
# dtype with shaped fields
|
||||
dt = np.dtype([("a", (float, 2)), ("b", (int, 3))])
|
||||
dt_flat = flatten_dtype(dt)
|
||||
assert_equal(dt_flat, [float, int])
|
||||
dt_flat = flatten_dtype(dt, True)
|
||||
assert_equal(dt_flat, [float] * 2 + [int] * 3)
|
||||
# dtype w/ titles
|
||||
dt = np.dtype([(("a", "A"), "f8"), (("b", "B"), "f8")])
|
||||
dt_flat = flatten_dtype(dt)
|
||||
assert_equal(dt_flat, [float, float])
|
||||
@@ -0,0 +1,64 @@
|
||||
"""Tests for the NumpyVersion class.
|
||||
|
||||
"""
|
||||
from numpy.testing import assert_, assert_raises
|
||||
from numpy.lib import NumpyVersion
|
||||
|
||||
|
||||
def test_main_versions():
|
||||
assert_(NumpyVersion('1.8.0') == '1.8.0')
|
||||
for ver in ['1.9.0', '2.0.0', '1.8.1', '10.0.1']:
|
||||
assert_(NumpyVersion('1.8.0') < ver)
|
||||
|
||||
for ver in ['1.7.0', '1.7.1', '0.9.9']:
|
||||
assert_(NumpyVersion('1.8.0') > ver)
|
||||
|
||||
|
||||
def test_version_1_point_10():
|
||||
# regression test for gh-2998.
|
||||
assert_(NumpyVersion('1.9.0') < '1.10.0')
|
||||
assert_(NumpyVersion('1.11.0') < '1.11.1')
|
||||
assert_(NumpyVersion('1.11.0') == '1.11.0')
|
||||
assert_(NumpyVersion('1.99.11') < '1.99.12')
|
||||
|
||||
|
||||
def test_alpha_beta_rc():
|
||||
assert_(NumpyVersion('1.8.0rc1') == '1.8.0rc1')
|
||||
for ver in ['1.8.0', '1.8.0rc2']:
|
||||
assert_(NumpyVersion('1.8.0rc1') < ver)
|
||||
|
||||
for ver in ['1.8.0a2', '1.8.0b3', '1.7.2rc4']:
|
||||
assert_(NumpyVersion('1.8.0rc1') > ver)
|
||||
|
||||
assert_(NumpyVersion('1.8.0b1') > '1.8.0a2')
|
||||
|
||||
|
||||
def test_dev_version():
|
||||
assert_(NumpyVersion('1.9.0.dev-Unknown') < '1.9.0')
|
||||
for ver in ['1.9.0', '1.9.0a1', '1.9.0b2', '1.9.0b2.dev-ffffffff']:
|
||||
assert_(NumpyVersion('1.9.0.dev-f16acvda') < ver)
|
||||
|
||||
assert_(NumpyVersion('1.9.0.dev-f16acvda') == '1.9.0.dev-11111111')
|
||||
|
||||
|
||||
def test_dev_a_b_rc_mixed():
|
||||
assert_(NumpyVersion('1.9.0a2.dev-f16acvda') == '1.9.0a2.dev-11111111')
|
||||
assert_(NumpyVersion('1.9.0a2.dev-6acvda54') < '1.9.0a2')
|
||||
|
||||
|
||||
def test_dev0_version():
|
||||
assert_(NumpyVersion('1.9.0.dev0+Unknown') < '1.9.0')
|
||||
for ver in ['1.9.0', '1.9.0a1', '1.9.0b2', '1.9.0b2.dev0+ffffffff']:
|
||||
assert_(NumpyVersion('1.9.0.dev0+f16acvda') < ver)
|
||||
|
||||
assert_(NumpyVersion('1.9.0.dev0+f16acvda') == '1.9.0.dev0+11111111')
|
||||
|
||||
|
||||
def test_dev0_a_b_rc_mixed():
|
||||
assert_(NumpyVersion('1.9.0a2.dev0+f16acvda') == '1.9.0a2.dev0+11111111')
|
||||
assert_(NumpyVersion('1.9.0a2.dev0+6acvda54') < '1.9.0a2')
|
||||
|
||||
|
||||
def test_raises():
|
||||
for ver in ['1.9', '1,9.0', '1.7.x']:
|
||||
assert_raises(ValueError, NumpyVersion, ver)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,944 @@
|
||||
"""Test functions for 1D array set operations.
|
||||
|
||||
"""
|
||||
import numpy as np
|
||||
|
||||
from numpy.testing import (assert_array_equal, assert_equal,
|
||||
assert_raises, assert_raises_regex)
|
||||
from numpy.lib.arraysetops import (
|
||||
ediff1d, intersect1d, setxor1d, union1d, setdiff1d, unique, in1d, isin
|
||||
)
|
||||
import pytest
|
||||
|
||||
|
||||
class TestSetOps:
|
||||
|
||||
def test_intersect1d(self):
|
||||
# unique inputs
|
||||
a = np.array([5, 7, 1, 2])
|
||||
b = np.array([2, 4, 3, 1, 5])
|
||||
|
||||
ec = np.array([1, 2, 5])
|
||||
c = intersect1d(a, b, assume_unique=True)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
# non-unique inputs
|
||||
a = np.array([5, 5, 7, 1, 2])
|
||||
b = np.array([2, 1, 4, 3, 3, 1, 5])
|
||||
|
||||
ed = np.array([1, 2, 5])
|
||||
c = intersect1d(a, b)
|
||||
assert_array_equal(c, ed)
|
||||
assert_array_equal([], intersect1d([], []))
|
||||
|
||||
def test_intersect1d_array_like(self):
|
||||
# See gh-11772
|
||||
class Test:
|
||||
def __array__(self):
|
||||
return np.arange(3)
|
||||
|
||||
a = Test()
|
||||
res = intersect1d(a, a)
|
||||
assert_array_equal(res, a)
|
||||
res = intersect1d([1, 2, 3], [1, 2, 3])
|
||||
assert_array_equal(res, [1, 2, 3])
|
||||
|
||||
def test_intersect1d_indices(self):
|
||||
# unique inputs
|
||||
a = np.array([1, 2, 3, 4])
|
||||
b = np.array([2, 1, 4, 6])
|
||||
c, i1, i2 = intersect1d(a, b, assume_unique=True, return_indices=True)
|
||||
ee = np.array([1, 2, 4])
|
||||
assert_array_equal(c, ee)
|
||||
assert_array_equal(a[i1], ee)
|
||||
assert_array_equal(b[i2], ee)
|
||||
|
||||
# non-unique inputs
|
||||
a = np.array([1, 2, 2, 3, 4, 3, 2])
|
||||
b = np.array([1, 8, 4, 2, 2, 3, 2, 3])
|
||||
c, i1, i2 = intersect1d(a, b, return_indices=True)
|
||||
ef = np.array([1, 2, 3, 4])
|
||||
assert_array_equal(c, ef)
|
||||
assert_array_equal(a[i1], ef)
|
||||
assert_array_equal(b[i2], ef)
|
||||
|
||||
# non1d, unique inputs
|
||||
a = np.array([[2, 4, 5, 6], [7, 8, 1, 15]])
|
||||
b = np.array([[3, 2, 7, 6], [10, 12, 8, 9]])
|
||||
c, i1, i2 = intersect1d(a, b, assume_unique=True, return_indices=True)
|
||||
ui1 = np.unravel_index(i1, a.shape)
|
||||
ui2 = np.unravel_index(i2, b.shape)
|
||||
ea = np.array([2, 6, 7, 8])
|
||||
assert_array_equal(ea, a[ui1])
|
||||
assert_array_equal(ea, b[ui2])
|
||||
|
||||
# non1d, not assumed to be uniqueinputs
|
||||
a = np.array([[2, 4, 5, 6, 6], [4, 7, 8, 7, 2]])
|
||||
b = np.array([[3, 2, 7, 7], [10, 12, 8, 7]])
|
||||
c, i1, i2 = intersect1d(a, b, return_indices=True)
|
||||
ui1 = np.unravel_index(i1, a.shape)
|
||||
ui2 = np.unravel_index(i2, b.shape)
|
||||
ea = np.array([2, 7, 8])
|
||||
assert_array_equal(ea, a[ui1])
|
||||
assert_array_equal(ea, b[ui2])
|
||||
|
||||
def test_setxor1d(self):
|
||||
a = np.array([5, 7, 1, 2])
|
||||
b = np.array([2, 4, 3, 1, 5])
|
||||
|
||||
ec = np.array([3, 4, 7])
|
||||
c = setxor1d(a, b)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([1, 2, 3])
|
||||
b = np.array([6, 5, 4])
|
||||
|
||||
ec = np.array([1, 2, 3, 4, 5, 6])
|
||||
c = setxor1d(a, b)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([1, 8, 2, 3])
|
||||
b = np.array([6, 5, 4, 8])
|
||||
|
||||
ec = np.array([1, 2, 3, 4, 5, 6])
|
||||
c = setxor1d(a, b)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
assert_array_equal([], setxor1d([], []))
|
||||
|
||||
def test_ediff1d(self):
|
||||
zero_elem = np.array([])
|
||||
one_elem = np.array([1])
|
||||
two_elem = np.array([1, 2])
|
||||
|
||||
assert_array_equal([], ediff1d(zero_elem))
|
||||
assert_array_equal([0], ediff1d(zero_elem, to_begin=0))
|
||||
assert_array_equal([0], ediff1d(zero_elem, to_end=0))
|
||||
assert_array_equal([-1, 0], ediff1d(zero_elem, to_begin=-1, to_end=0))
|
||||
assert_array_equal([], ediff1d(one_elem))
|
||||
assert_array_equal([1], ediff1d(two_elem))
|
||||
assert_array_equal([7, 1, 9], ediff1d(two_elem, to_begin=7, to_end=9))
|
||||
assert_array_equal([5, 6, 1, 7, 8],
|
||||
ediff1d(two_elem, to_begin=[5, 6], to_end=[7, 8]))
|
||||
assert_array_equal([1, 9], ediff1d(two_elem, to_end=9))
|
||||
assert_array_equal([1, 7, 8], ediff1d(two_elem, to_end=[7, 8]))
|
||||
assert_array_equal([7, 1], ediff1d(two_elem, to_begin=7))
|
||||
assert_array_equal([5, 6, 1], ediff1d(two_elem, to_begin=[5, 6]))
|
||||
|
||||
@pytest.mark.parametrize("ary, prepend, append, expected", [
|
||||
# should fail because trying to cast
|
||||
# np.nan standard floating point value
|
||||
# into an integer array:
|
||||
(np.array([1, 2, 3], dtype=np.int64),
|
||||
None,
|
||||
np.nan,
|
||||
'to_end'),
|
||||
# should fail because attempting
|
||||
# to downcast to int type:
|
||||
(np.array([1, 2, 3], dtype=np.int64),
|
||||
np.array([5, 7, 2], dtype=np.float32),
|
||||
None,
|
||||
'to_begin'),
|
||||
# should fail because attempting to cast
|
||||
# two special floating point values
|
||||
# to integers (on both sides of ary),
|
||||
# `to_begin` is in the error message as the impl checks this first:
|
||||
(np.array([1., 3., 9.], dtype=np.int8),
|
||||
np.nan,
|
||||
np.nan,
|
||||
'to_begin'),
|
||||
])
|
||||
def test_ediff1d_forbidden_type_casts(self, ary, prepend, append, expected):
|
||||
# verify resolution of gh-11490
|
||||
|
||||
# specifically, raise an appropriate
|
||||
# Exception when attempting to append or
|
||||
# prepend with an incompatible type
|
||||
msg = 'dtype of `{}` must be compatible'.format(expected)
|
||||
with assert_raises_regex(TypeError, msg):
|
||||
ediff1d(ary=ary,
|
||||
to_end=append,
|
||||
to_begin=prepend)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"ary,prepend,append,expected",
|
||||
[
|
||||
(np.array([1, 2, 3], dtype=np.int16),
|
||||
2**16, # will be cast to int16 under same kind rule.
|
||||
2**16 + 4,
|
||||
np.array([0, 1, 1, 4], dtype=np.int16)),
|
||||
(np.array([1, 2, 3], dtype=np.float32),
|
||||
np.array([5], dtype=np.float64),
|
||||
None,
|
||||
np.array([5, 1, 1], dtype=np.float32)),
|
||||
(np.array([1, 2, 3], dtype=np.int32),
|
||||
0,
|
||||
0,
|
||||
np.array([0, 1, 1, 0], dtype=np.int32)),
|
||||
(np.array([1, 2, 3], dtype=np.int64),
|
||||
3,
|
||||
-9,
|
||||
np.array([3, 1, 1, -9], dtype=np.int64)),
|
||||
]
|
||||
)
|
||||
def test_ediff1d_scalar_handling(self,
|
||||
ary,
|
||||
prepend,
|
||||
append,
|
||||
expected):
|
||||
# maintain backwards-compatibility
|
||||
# of scalar prepend / append behavior
|
||||
# in ediff1d following fix for gh-11490
|
||||
actual = np.ediff1d(ary=ary,
|
||||
to_end=append,
|
||||
to_begin=prepend)
|
||||
assert_equal(actual, expected)
|
||||
assert actual.dtype == expected.dtype
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_isin(self, kind):
|
||||
# the tests for in1d cover most of isin's behavior
|
||||
# if in1d is removed, would need to change those tests to test
|
||||
# isin instead.
|
||||
def _isin_slow(a, b):
|
||||
b = np.asarray(b).flatten().tolist()
|
||||
return a in b
|
||||
isin_slow = np.vectorize(_isin_slow, otypes=[bool], excluded={1})
|
||||
|
||||
def assert_isin_equal(a, b):
|
||||
x = isin(a, b, kind=kind)
|
||||
y = isin_slow(a, b)
|
||||
assert_array_equal(x, y)
|
||||
|
||||
# multidimensional arrays in both arguments
|
||||
a = np.arange(24).reshape([2, 3, 4])
|
||||
b = np.array([[10, 20, 30], [0, 1, 3], [11, 22, 33]])
|
||||
assert_isin_equal(a, b)
|
||||
|
||||
# array-likes as both arguments
|
||||
c = [(9, 8), (7, 6)]
|
||||
d = (9, 7)
|
||||
assert_isin_equal(c, d)
|
||||
|
||||
# zero-d array:
|
||||
f = np.array(3)
|
||||
assert_isin_equal(f, b)
|
||||
assert_isin_equal(a, f)
|
||||
assert_isin_equal(f, f)
|
||||
|
||||
# scalar:
|
||||
assert_isin_equal(5, b)
|
||||
assert_isin_equal(a, 6)
|
||||
assert_isin_equal(5, 6)
|
||||
|
||||
# empty array-like:
|
||||
if kind != "table":
|
||||
# An empty list will become float64,
|
||||
# which is invalid for kind="table"
|
||||
x = []
|
||||
assert_isin_equal(x, b)
|
||||
assert_isin_equal(a, x)
|
||||
assert_isin_equal(x, x)
|
||||
|
||||
# empty array with various types:
|
||||
for dtype in [bool, np.int64, np.float64]:
|
||||
if kind == "table" and dtype == np.float64:
|
||||
continue
|
||||
|
||||
if dtype in {np.int64, np.float64}:
|
||||
ar = np.array([10, 20, 30], dtype=dtype)
|
||||
elif dtype in {bool}:
|
||||
ar = np.array([True, False, False])
|
||||
|
||||
empty_array = np.array([], dtype=dtype)
|
||||
|
||||
assert_isin_equal(empty_array, ar)
|
||||
assert_isin_equal(ar, empty_array)
|
||||
assert_isin_equal(empty_array, empty_array)
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_in1d(self, kind):
|
||||
# we use two different sizes for the b array here to test the
|
||||
# two different paths in in1d().
|
||||
for mult in (1, 10):
|
||||
# One check without np.array to make sure lists are handled correct
|
||||
a = [5, 7, 1, 2]
|
||||
b = [2, 4, 3, 1, 5] * mult
|
||||
ec = np.array([True, False, True, True])
|
||||
c = in1d(a, b, assume_unique=True, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a[0] = 8
|
||||
ec = np.array([False, False, True, True])
|
||||
c = in1d(a, b, assume_unique=True, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a[0], a[3] = 4, 8
|
||||
ec = np.array([True, False, True, False])
|
||||
c = in1d(a, b, assume_unique=True, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5])
|
||||
b = [2, 3, 4] * mult
|
||||
ec = [False, True, False, True, True, True, True, True, True,
|
||||
False, True, False, False, False]
|
||||
c = in1d(a, b, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
b = b + [5, 5, 4] * mult
|
||||
ec = [True, True, True, True, True, True, True, True, True, True,
|
||||
True, False, True, True]
|
||||
c = in1d(a, b, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([5, 7, 1, 2])
|
||||
b = np.array([2, 4, 3, 1, 5] * mult)
|
||||
ec = np.array([True, False, True, True])
|
||||
c = in1d(a, b, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([5, 7, 1, 1, 2])
|
||||
b = np.array([2, 4, 3, 3, 1, 5] * mult)
|
||||
ec = np.array([True, False, True, True, True])
|
||||
c = in1d(a, b, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([5, 5])
|
||||
b = np.array([2, 2] * mult)
|
||||
ec = np.array([False, False])
|
||||
c = in1d(a, b, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.array([5])
|
||||
b = np.array([2])
|
||||
ec = np.array([False])
|
||||
c = in1d(a, b, kind=kind)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
if kind in {None, "sort"}:
|
||||
assert_array_equal(in1d([], [], kind=kind), [])
|
||||
|
||||
def test_in1d_char_array(self):
|
||||
a = np.array(['a', 'b', 'c', 'd', 'e', 'c', 'e', 'b'])
|
||||
b = np.array(['a', 'c'])
|
||||
|
||||
ec = np.array([True, False, True, False, False, True, False, False])
|
||||
c = in1d(a, b)
|
||||
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_in1d_invert(self, kind):
|
||||
"Test in1d's invert parameter"
|
||||
# We use two different sizes for the b array here to test the
|
||||
# two different paths in in1d().
|
||||
for mult in (1, 10):
|
||||
a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5])
|
||||
b = [2, 3, 4] * mult
|
||||
assert_array_equal(np.invert(in1d(a, b, kind=kind)),
|
||||
in1d(a, b, invert=True, kind=kind))
|
||||
|
||||
# float:
|
||||
if kind in {None, "sort"}:
|
||||
for mult in (1, 10):
|
||||
a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5],
|
||||
dtype=np.float32)
|
||||
b = [2, 3, 4] * mult
|
||||
b = np.array(b, dtype=np.float32)
|
||||
assert_array_equal(np.invert(in1d(a, b, kind=kind)),
|
||||
in1d(a, b, invert=True, kind=kind))
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_in1d_ravel(self, kind):
|
||||
# Test that in1d ravels its input arrays. This is not documented
|
||||
# behavior however. The test is to ensure consistentency.
|
||||
a = np.arange(6).reshape(2, 3)
|
||||
b = np.arange(3, 9).reshape(3, 2)
|
||||
long_b = np.arange(3, 63).reshape(30, 2)
|
||||
ec = np.array([False, False, False, True, True, True])
|
||||
|
||||
assert_array_equal(in1d(a, b, assume_unique=True, kind=kind),
|
||||
ec)
|
||||
assert_array_equal(in1d(a, b, assume_unique=False,
|
||||
kind=kind),
|
||||
ec)
|
||||
assert_array_equal(in1d(a, long_b, assume_unique=True,
|
||||
kind=kind),
|
||||
ec)
|
||||
assert_array_equal(in1d(a, long_b, assume_unique=False,
|
||||
kind=kind),
|
||||
ec)
|
||||
|
||||
def test_in1d_hit_alternate_algorithm(self):
|
||||
"""Hit the standard isin code with integers"""
|
||||
# Need extreme range to hit standard code
|
||||
# This hits it without the use of kind='table'
|
||||
a = np.array([5, 4, 5, 3, 4, 4, 1e9], dtype=np.int64)
|
||||
b = np.array([2, 3, 4, 1e9], dtype=np.int64)
|
||||
expected = np.array([0, 1, 0, 1, 1, 1, 1], dtype=bool)
|
||||
assert_array_equal(expected, in1d(a, b))
|
||||
assert_array_equal(np.invert(expected), in1d(a, b, invert=True))
|
||||
|
||||
a = np.array([5, 7, 1, 2], dtype=np.int64)
|
||||
b = np.array([2, 4, 3, 1, 5, 1e9], dtype=np.int64)
|
||||
ec = np.array([True, False, True, True])
|
||||
c = in1d(a, b, assume_unique=True)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_in1d_boolean(self, kind):
|
||||
"""Test that in1d works for boolean input"""
|
||||
a = np.array([True, False])
|
||||
b = np.array([False, False, False])
|
||||
expected = np.array([False, True])
|
||||
assert_array_equal(expected,
|
||||
in1d(a, b, kind=kind))
|
||||
assert_array_equal(np.invert(expected),
|
||||
in1d(a, b, invert=True, kind=kind))
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort"])
|
||||
def test_in1d_timedelta(self, kind):
|
||||
"""Test that in1d works for timedelta input"""
|
||||
rstate = np.random.RandomState(0)
|
||||
a = rstate.randint(0, 100, size=10)
|
||||
b = rstate.randint(0, 100, size=10)
|
||||
truth = in1d(a, b)
|
||||
a_timedelta = a.astype("timedelta64[s]")
|
||||
b_timedelta = b.astype("timedelta64[s]")
|
||||
assert_array_equal(truth, in1d(a_timedelta, b_timedelta, kind=kind))
|
||||
|
||||
def test_in1d_table_timedelta_fails(self):
|
||||
a = np.array([0, 1, 2], dtype="timedelta64[s]")
|
||||
b = a
|
||||
# Make sure it raises a value error:
|
||||
with pytest.raises(ValueError):
|
||||
in1d(a, b, kind="table")
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"dtype1,dtype2",
|
||||
[
|
||||
(np.int8, np.int16),
|
||||
(np.int16, np.int8),
|
||||
(np.uint8, np.uint16),
|
||||
(np.uint16, np.uint8),
|
||||
(np.uint8, np.int16),
|
||||
(np.int16, np.uint8),
|
||||
]
|
||||
)
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_in1d_mixed_dtype(self, dtype1, dtype2, kind):
|
||||
"""Test that in1d works as expected for mixed dtype input."""
|
||||
is_dtype2_signed = np.issubdtype(dtype2, np.signedinteger)
|
||||
ar1 = np.array([0, 0, 1, 1], dtype=dtype1)
|
||||
|
||||
if is_dtype2_signed:
|
||||
ar2 = np.array([-128, 0, 127], dtype=dtype2)
|
||||
else:
|
||||
ar2 = np.array([127, 0, 255], dtype=dtype2)
|
||||
|
||||
expected = np.array([True, True, False, False])
|
||||
|
||||
expect_failure = kind == "table" and any((
|
||||
dtype1 == np.int8 and dtype2 == np.int16,
|
||||
dtype1 == np.int16 and dtype2 == np.int8
|
||||
))
|
||||
|
||||
if expect_failure:
|
||||
with pytest.raises(RuntimeError, match="exceed the maximum"):
|
||||
in1d(ar1, ar2, kind=kind)
|
||||
else:
|
||||
assert_array_equal(in1d(ar1, ar2, kind=kind), expected)
|
||||
|
||||
@pytest.mark.parametrize("kind", [None, "sort", "table"])
|
||||
def test_in1d_mixed_boolean(self, kind):
|
||||
"""Test that in1d works as expected for bool/int input."""
|
||||
for dtype in np.typecodes["AllInteger"]:
|
||||
a = np.array([True, False, False], dtype=bool)
|
||||
b = np.array([0, 0, 0, 0], dtype=dtype)
|
||||
expected = np.array([False, True, True], dtype=bool)
|
||||
assert_array_equal(in1d(a, b, kind=kind), expected)
|
||||
|
||||
a, b = b, a
|
||||
expected = np.array([True, True, True, True], dtype=bool)
|
||||
assert_array_equal(in1d(a, b, kind=kind), expected)
|
||||
|
||||
def test_in1d_first_array_is_object(self):
|
||||
ar1 = [None]
|
||||
ar2 = np.array([1]*10)
|
||||
expected = np.array([False])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
def test_in1d_second_array_is_object(self):
|
||||
ar1 = 1
|
||||
ar2 = np.array([None]*10)
|
||||
expected = np.array([False])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
def test_in1d_both_arrays_are_object(self):
|
||||
ar1 = [None]
|
||||
ar2 = np.array([None]*10)
|
||||
expected = np.array([True])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
def test_in1d_both_arrays_have_structured_dtype(self):
|
||||
# Test arrays of a structured data type containing an integer field
|
||||
# and a field of dtype `object` allowing for arbitrary Python objects
|
||||
dt = np.dtype([('field1', int), ('field2', object)])
|
||||
ar1 = np.array([(1, None)], dtype=dt)
|
||||
ar2 = np.array([(1, None)]*10, dtype=dt)
|
||||
expected = np.array([True])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
def test_in1d_with_arrays_containing_tuples(self):
|
||||
ar1 = np.array([(1,), 2], dtype=object)
|
||||
ar2 = np.array([(1,), 2], dtype=object)
|
||||
expected = np.array([True, True])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
result = np.in1d(ar1, ar2, invert=True)
|
||||
assert_array_equal(result, np.invert(expected))
|
||||
|
||||
# An integer is added at the end of the array to make sure
|
||||
# that the array builder will create the array with tuples
|
||||
# and after it's created the integer is removed.
|
||||
# There's a bug in the array constructor that doesn't handle
|
||||
# tuples properly and adding the integer fixes that.
|
||||
ar1 = np.array([(1,), (2, 1), 1], dtype=object)
|
||||
ar1 = ar1[:-1]
|
||||
ar2 = np.array([(1,), (2, 1), 1], dtype=object)
|
||||
ar2 = ar2[:-1]
|
||||
expected = np.array([True, True])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
result = np.in1d(ar1, ar2, invert=True)
|
||||
assert_array_equal(result, np.invert(expected))
|
||||
|
||||
ar1 = np.array([(1,), (2, 3), 1], dtype=object)
|
||||
ar1 = ar1[:-1]
|
||||
ar2 = np.array([(1,), 2], dtype=object)
|
||||
expected = np.array([True, False])
|
||||
result = np.in1d(ar1, ar2)
|
||||
assert_array_equal(result, expected)
|
||||
result = np.in1d(ar1, ar2, invert=True)
|
||||
assert_array_equal(result, np.invert(expected))
|
||||
|
||||
def test_in1d_errors(self):
|
||||
"""Test that in1d raises expected errors."""
|
||||
|
||||
# Error 1: `kind` is not one of 'sort' 'table' or None.
|
||||
ar1 = np.array([1, 2, 3, 4, 5])
|
||||
ar2 = np.array([2, 4, 6, 8, 10])
|
||||
assert_raises(ValueError, in1d, ar1, ar2, kind='quicksort')
|
||||
|
||||
# Error 2: `kind="table"` does not work for non-integral arrays.
|
||||
obj_ar1 = np.array([1, 'a', 3, 'b', 5], dtype=object)
|
||||
obj_ar2 = np.array([1, 'a', 3, 'b', 5], dtype=object)
|
||||
assert_raises(ValueError, in1d, obj_ar1, obj_ar2, kind='table')
|
||||
|
||||
for dtype in [np.int32, np.int64]:
|
||||
ar1 = np.array([-1, 2, 3, 4, 5], dtype=dtype)
|
||||
# The range of this array will overflow:
|
||||
overflow_ar2 = np.array([-1, np.iinfo(dtype).max], dtype=dtype)
|
||||
|
||||
# Error 3: `kind="table"` will trigger a runtime error
|
||||
# if there is an integer overflow expected when computing the
|
||||
# range of ar2
|
||||
assert_raises(
|
||||
RuntimeError,
|
||||
in1d, ar1, overflow_ar2, kind='table'
|
||||
)
|
||||
|
||||
# Non-error: `kind=None` will *not* trigger a runtime error
|
||||
# if there is an integer overflow, it will switch to
|
||||
# the `sort` algorithm.
|
||||
result = np.in1d(ar1, overflow_ar2, kind=None)
|
||||
assert_array_equal(result, [True] + [False] * 4)
|
||||
result = np.in1d(ar1, overflow_ar2, kind='sort')
|
||||
assert_array_equal(result, [True] + [False] * 4)
|
||||
|
||||
def test_union1d(self):
|
||||
a = np.array([5, 4, 7, 1, 2])
|
||||
b = np.array([2, 4, 3, 3, 2, 1, 5])
|
||||
|
||||
ec = np.array([1, 2, 3, 4, 5, 7])
|
||||
c = union1d(a, b)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
# Tests gh-10340, arguments to union1d should be
|
||||
# flattened if they are not already 1D
|
||||
x = np.array([[0, 1, 2], [3, 4, 5]])
|
||||
y = np.array([0, 1, 2, 3, 4])
|
||||
ez = np.array([0, 1, 2, 3, 4, 5])
|
||||
z = union1d(x, y)
|
||||
assert_array_equal(z, ez)
|
||||
|
||||
assert_array_equal([], union1d([], []))
|
||||
|
||||
def test_setdiff1d(self):
|
||||
a = np.array([6, 5, 4, 7, 1, 2, 7, 4])
|
||||
b = np.array([2, 4, 3, 3, 2, 1, 5])
|
||||
|
||||
ec = np.array([6, 7])
|
||||
c = setdiff1d(a, b)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
a = np.arange(21)
|
||||
b = np.arange(19)
|
||||
ec = np.array([19, 20])
|
||||
c = setdiff1d(a, b)
|
||||
assert_array_equal(c, ec)
|
||||
|
||||
assert_array_equal([], setdiff1d([], []))
|
||||
a = np.array((), np.uint32)
|
||||
assert_equal(setdiff1d(a, []).dtype, np.uint32)
|
||||
|
||||
def test_setdiff1d_unique(self):
|
||||
a = np.array([3, 2, 1])
|
||||
b = np.array([7, 5, 2])
|
||||
expected = np.array([3, 1])
|
||||
actual = setdiff1d(a, b, assume_unique=True)
|
||||
assert_equal(actual, expected)
|
||||
|
||||
def test_setdiff1d_char_array(self):
|
||||
a = np.array(['a', 'b', 'c'])
|
||||
b = np.array(['a', 'b', 's'])
|
||||
assert_array_equal(setdiff1d(a, b), np.array(['c']))
|
||||
|
||||
def test_manyways(self):
|
||||
a = np.array([5, 7, 1, 2, 8])
|
||||
b = np.array([9, 8, 2, 4, 3, 1, 5])
|
||||
|
||||
c1 = setxor1d(a, b)
|
||||
aux1 = intersect1d(a, b)
|
||||
aux2 = union1d(a, b)
|
||||
c2 = setdiff1d(aux2, aux1)
|
||||
assert_array_equal(c1, c2)
|
||||
|
||||
|
||||
class TestUnique:
|
||||
|
||||
def test_unique_1d(self):
|
||||
|
||||
def check_all(a, b, i1, i2, c, dt):
|
||||
base_msg = 'check {0} failed for type {1}'
|
||||
|
||||
msg = base_msg.format('values', dt)
|
||||
v = unique(a)
|
||||
assert_array_equal(v, b, msg)
|
||||
|
||||
msg = base_msg.format('return_index', dt)
|
||||
v, j = unique(a, True, False, False)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j, i1, msg)
|
||||
|
||||
msg = base_msg.format('return_inverse', dt)
|
||||
v, j = unique(a, False, True, False)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j, i2, msg)
|
||||
|
||||
msg = base_msg.format('return_counts', dt)
|
||||
v, j = unique(a, False, False, True)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j, c, msg)
|
||||
|
||||
msg = base_msg.format('return_index and return_inverse', dt)
|
||||
v, j1, j2 = unique(a, True, True, False)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j1, i1, msg)
|
||||
assert_array_equal(j2, i2, msg)
|
||||
|
||||
msg = base_msg.format('return_index and return_counts', dt)
|
||||
v, j1, j2 = unique(a, True, False, True)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j1, i1, msg)
|
||||
assert_array_equal(j2, c, msg)
|
||||
|
||||
msg = base_msg.format('return_inverse and return_counts', dt)
|
||||
v, j1, j2 = unique(a, False, True, True)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j1, i2, msg)
|
||||
assert_array_equal(j2, c, msg)
|
||||
|
||||
msg = base_msg.format(('return_index, return_inverse '
|
||||
'and return_counts'), dt)
|
||||
v, j1, j2, j3 = unique(a, True, True, True)
|
||||
assert_array_equal(v, b, msg)
|
||||
assert_array_equal(j1, i1, msg)
|
||||
assert_array_equal(j2, i2, msg)
|
||||
assert_array_equal(j3, c, msg)
|
||||
|
||||
a = [5, 7, 1, 2, 1, 5, 7]*10
|
||||
b = [1, 2, 5, 7]
|
||||
i1 = [2, 3, 0, 1]
|
||||
i2 = [2, 3, 0, 1, 0, 2, 3]*10
|
||||
c = np.multiply([2, 1, 2, 2], 10)
|
||||
|
||||
# test for numeric arrays
|
||||
types = []
|
||||
types.extend(np.typecodes['AllInteger'])
|
||||
types.extend(np.typecodes['AllFloat'])
|
||||
types.append('datetime64[D]')
|
||||
types.append('timedelta64[D]')
|
||||
for dt in types:
|
||||
aa = np.array(a, dt)
|
||||
bb = np.array(b, dt)
|
||||
check_all(aa, bb, i1, i2, c, dt)
|
||||
|
||||
# test for object arrays
|
||||
dt = 'O'
|
||||
aa = np.empty(len(a), dt)
|
||||
aa[:] = a
|
||||
bb = np.empty(len(b), dt)
|
||||
bb[:] = b
|
||||
check_all(aa, bb, i1, i2, c, dt)
|
||||
|
||||
# test for structured arrays
|
||||
dt = [('', 'i'), ('', 'i')]
|
||||
aa = np.array(list(zip(a, a)), dt)
|
||||
bb = np.array(list(zip(b, b)), dt)
|
||||
check_all(aa, bb, i1, i2, c, dt)
|
||||
|
||||
# test for ticket #2799
|
||||
aa = [1. + 0.j, 1 - 1.j, 1]
|
||||
assert_array_equal(np.unique(aa), [1. - 1.j, 1. + 0.j])
|
||||
|
||||
# test for ticket #4785
|
||||
a = [(1, 2), (1, 2), (2, 3)]
|
||||
unq = [1, 2, 3]
|
||||
inv = [0, 1, 0, 1, 1, 2]
|
||||
a1 = unique(a)
|
||||
assert_array_equal(a1, unq)
|
||||
a2, a2_inv = unique(a, return_inverse=True)
|
||||
assert_array_equal(a2, unq)
|
||||
assert_array_equal(a2_inv, inv)
|
||||
|
||||
# test for chararrays with return_inverse (gh-5099)
|
||||
a = np.chararray(5)
|
||||
a[...] = ''
|
||||
a2, a2_inv = np.unique(a, return_inverse=True)
|
||||
assert_array_equal(a2_inv, np.zeros(5))
|
||||
|
||||
# test for ticket #9137
|
||||
a = []
|
||||
a1_idx = np.unique(a, return_index=True)[1]
|
||||
a2_inv = np.unique(a, return_inverse=True)[1]
|
||||
a3_idx, a3_inv = np.unique(a, return_index=True,
|
||||
return_inverse=True)[1:]
|
||||
assert_equal(a1_idx.dtype, np.intp)
|
||||
assert_equal(a2_inv.dtype, np.intp)
|
||||
assert_equal(a3_idx.dtype, np.intp)
|
||||
assert_equal(a3_inv.dtype, np.intp)
|
||||
|
||||
# test for ticket 2111 - float
|
||||
a = [2.0, np.nan, 1.0, np.nan]
|
||||
ua = [1.0, 2.0, np.nan]
|
||||
ua_idx = [2, 0, 1]
|
||||
ua_inv = [1, 2, 0, 2]
|
||||
ua_cnt = [1, 1, 2]
|
||||
assert_equal(np.unique(a), ua)
|
||||
assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
|
||||
assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
|
||||
assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
|
||||
|
||||
# test for ticket 2111 - complex
|
||||
a = [2.0-1j, np.nan, 1.0+1j, complex(0.0, np.nan), complex(1.0, np.nan)]
|
||||
ua = [1.0+1j, 2.0-1j, complex(0.0, np.nan)]
|
||||
ua_idx = [2, 0, 3]
|
||||
ua_inv = [1, 2, 0, 2, 2]
|
||||
ua_cnt = [1, 1, 3]
|
||||
assert_equal(np.unique(a), ua)
|
||||
assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
|
||||
assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
|
||||
assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
|
||||
|
||||
# test for ticket 2111 - datetime64
|
||||
nat = np.datetime64('nat')
|
||||
a = [np.datetime64('2020-12-26'), nat, np.datetime64('2020-12-24'), nat]
|
||||
ua = [np.datetime64('2020-12-24'), np.datetime64('2020-12-26'), nat]
|
||||
ua_idx = [2, 0, 1]
|
||||
ua_inv = [1, 2, 0, 2]
|
||||
ua_cnt = [1, 1, 2]
|
||||
assert_equal(np.unique(a), ua)
|
||||
assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
|
||||
assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
|
||||
assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
|
||||
|
||||
# test for ticket 2111 - timedelta
|
||||
nat = np.timedelta64('nat')
|
||||
a = [np.timedelta64(1, 'D'), nat, np.timedelta64(1, 'h'), nat]
|
||||
ua = [np.timedelta64(1, 'h'), np.timedelta64(1, 'D'), nat]
|
||||
ua_idx = [2, 0, 1]
|
||||
ua_inv = [1, 2, 0, 2]
|
||||
ua_cnt = [1, 1, 2]
|
||||
assert_equal(np.unique(a), ua)
|
||||
assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
|
||||
assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
|
||||
assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
|
||||
|
||||
# test for gh-19300
|
||||
all_nans = [np.nan] * 4
|
||||
ua = [np.nan]
|
||||
ua_idx = [0]
|
||||
ua_inv = [0, 0, 0, 0]
|
||||
ua_cnt = [4]
|
||||
assert_equal(np.unique(all_nans), ua)
|
||||
assert_equal(np.unique(all_nans, return_index=True), (ua, ua_idx))
|
||||
assert_equal(np.unique(all_nans, return_inverse=True), (ua, ua_inv))
|
||||
assert_equal(np.unique(all_nans, return_counts=True), (ua, ua_cnt))
|
||||
|
||||
def test_unique_axis_errors(self):
|
||||
assert_raises(TypeError, self._run_axis_tests, object)
|
||||
assert_raises(TypeError, self._run_axis_tests,
|
||||
[('a', int), ('b', object)])
|
||||
|
||||
assert_raises(np.AxisError, unique, np.arange(10), axis=2)
|
||||
assert_raises(np.AxisError, unique, np.arange(10), axis=-2)
|
||||
|
||||
def test_unique_axis_list(self):
|
||||
msg = "Unique failed on list of lists"
|
||||
inp = [[0, 1, 0], [0, 1, 0]]
|
||||
inp_arr = np.asarray(inp)
|
||||
assert_array_equal(unique(inp, axis=0), unique(inp_arr, axis=0), msg)
|
||||
assert_array_equal(unique(inp, axis=1), unique(inp_arr, axis=1), msg)
|
||||
|
||||
def test_unique_axis(self):
|
||||
types = []
|
||||
types.extend(np.typecodes['AllInteger'])
|
||||
types.extend(np.typecodes['AllFloat'])
|
||||
types.append('datetime64[D]')
|
||||
types.append('timedelta64[D]')
|
||||
types.append([('a', int), ('b', int)])
|
||||
types.append([('a', int), ('b', float)])
|
||||
|
||||
for dtype in types:
|
||||
self._run_axis_tests(dtype)
|
||||
|
||||
msg = 'Non-bitwise-equal booleans test failed'
|
||||
data = np.arange(10, dtype=np.uint8).reshape(-1, 2).view(bool)
|
||||
result = np.array([[False, True], [True, True]], dtype=bool)
|
||||
assert_array_equal(unique(data, axis=0), result, msg)
|
||||
|
||||
msg = 'Negative zero equality test failed'
|
||||
data = np.array([[-0.0, 0.0], [0.0, -0.0], [-0.0, 0.0], [0.0, -0.0]])
|
||||
result = np.array([[-0.0, 0.0]])
|
||||
assert_array_equal(unique(data, axis=0), result, msg)
|
||||
|
||||
@pytest.mark.parametrize("axis", [0, -1])
|
||||
def test_unique_1d_with_axis(self, axis):
|
||||
x = np.array([4, 3, 2, 3, 2, 1, 2, 2])
|
||||
uniq = unique(x, axis=axis)
|
||||
assert_array_equal(uniq, [1, 2, 3, 4])
|
||||
|
||||
def test_unique_axis_zeros(self):
|
||||
# issue 15559
|
||||
single_zero = np.empty(shape=(2, 0), dtype=np.int8)
|
||||
uniq, idx, inv, cnt = unique(single_zero, axis=0, return_index=True,
|
||||
return_inverse=True, return_counts=True)
|
||||
|
||||
# there's 1 element of shape (0,) along axis 0
|
||||
assert_equal(uniq.dtype, single_zero.dtype)
|
||||
assert_array_equal(uniq, np.empty(shape=(1, 0)))
|
||||
assert_array_equal(idx, np.array([0]))
|
||||
assert_array_equal(inv, np.array([0, 0]))
|
||||
assert_array_equal(cnt, np.array([2]))
|
||||
|
||||
# there's 0 elements of shape (2,) along axis 1
|
||||
uniq, idx, inv, cnt = unique(single_zero, axis=1, return_index=True,
|
||||
return_inverse=True, return_counts=True)
|
||||
|
||||
assert_equal(uniq.dtype, single_zero.dtype)
|
||||
assert_array_equal(uniq, np.empty(shape=(2, 0)))
|
||||
assert_array_equal(idx, np.array([]))
|
||||
assert_array_equal(inv, np.array([]))
|
||||
assert_array_equal(cnt, np.array([]))
|
||||
|
||||
# test a "complicated" shape
|
||||
shape = (0, 2, 0, 3, 0, 4, 0)
|
||||
multiple_zeros = np.empty(shape=shape)
|
||||
for axis in range(len(shape)):
|
||||
expected_shape = list(shape)
|
||||
if shape[axis] == 0:
|
||||
expected_shape[axis] = 0
|
||||
else:
|
||||
expected_shape[axis] = 1
|
||||
|
||||
assert_array_equal(unique(multiple_zeros, axis=axis),
|
||||
np.empty(shape=expected_shape))
|
||||
|
||||
def test_unique_masked(self):
|
||||
# issue 8664
|
||||
x = np.array([64, 0, 1, 2, 3, 63, 63, 0, 0, 0, 1, 2, 0, 63, 0],
|
||||
dtype='uint8')
|
||||
y = np.ma.masked_equal(x, 0)
|
||||
|
||||
v = np.unique(y)
|
||||
v2, i, c = np.unique(y, return_index=True, return_counts=True)
|
||||
|
||||
msg = 'Unique returned different results when asked for index'
|
||||
assert_array_equal(v.data, v2.data, msg)
|
||||
assert_array_equal(v.mask, v2.mask, msg)
|
||||
|
||||
def test_unique_sort_order_with_axis(self):
|
||||
# These tests fail if sorting along axis is done by treating subarrays
|
||||
# as unsigned byte strings. See gh-10495.
|
||||
fmt = "sort order incorrect for integer type '%s'"
|
||||
for dt in 'bhilq':
|
||||
a = np.array([[-1], [0]], dt)
|
||||
b = np.unique(a, axis=0)
|
||||
assert_array_equal(a, b, fmt % dt)
|
||||
|
||||
def _run_axis_tests(self, dtype):
|
||||
data = np.array([[0, 1, 0, 0],
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[1, 0, 0, 0]]).astype(dtype)
|
||||
|
||||
msg = 'Unique with 1d array and axis=0 failed'
|
||||
result = np.array([0, 1])
|
||||
assert_array_equal(unique(data), result.astype(dtype), msg)
|
||||
|
||||
msg = 'Unique with 2d array and axis=0 failed'
|
||||
result = np.array([[0, 1, 0, 0], [1, 0, 0, 0]])
|
||||
assert_array_equal(unique(data, axis=0), result.astype(dtype), msg)
|
||||
|
||||
msg = 'Unique with 2d array and axis=1 failed'
|
||||
result = np.array([[0, 0, 1], [0, 1, 0], [0, 0, 1], [0, 1, 0]])
|
||||
assert_array_equal(unique(data, axis=1), result.astype(dtype), msg)
|
||||
|
||||
msg = 'Unique with 3d array and axis=2 failed'
|
||||
data3d = np.array([[[1, 1],
|
||||
[1, 0]],
|
||||
[[0, 1],
|
||||
[0, 0]]]).astype(dtype)
|
||||
result = np.take(data3d, [1, 0], axis=2)
|
||||
assert_array_equal(unique(data3d, axis=2), result, msg)
|
||||
|
||||
uniq, idx, inv, cnt = unique(data, axis=0, return_index=True,
|
||||
return_inverse=True, return_counts=True)
|
||||
msg = "Unique's return_index=True failed with axis=0"
|
||||
assert_array_equal(data[idx], uniq, msg)
|
||||
msg = "Unique's return_inverse=True failed with axis=0"
|
||||
assert_array_equal(uniq[inv], data)
|
||||
msg = "Unique's return_counts=True failed with axis=0"
|
||||
assert_array_equal(cnt, np.array([2, 2]), msg)
|
||||
|
||||
uniq, idx, inv, cnt = unique(data, axis=1, return_index=True,
|
||||
return_inverse=True, return_counts=True)
|
||||
msg = "Unique's return_index=True failed with axis=1"
|
||||
assert_array_equal(data[:, idx], uniq)
|
||||
msg = "Unique's return_inverse=True failed with axis=1"
|
||||
assert_array_equal(uniq[:, inv], data)
|
||||
msg = "Unique's return_counts=True failed with axis=1"
|
||||
assert_array_equal(cnt, np.array([2, 1, 1]), msg)
|
||||
|
||||
def test_unique_nanequals(self):
|
||||
# issue 20326
|
||||
a = np.array([1, 1, np.nan, np.nan, np.nan])
|
||||
unq = np.unique(a)
|
||||
not_unq = np.unique(a, equal_nan=False)
|
||||
assert_array_equal(unq, np.array([1, np.nan]))
|
||||
assert_array_equal(not_unq, np.array([1, np.nan, np.nan, np.nan]))
|
||||
@@ -0,0 +1,46 @@
|
||||
from operator import mul
|
||||
from functools import reduce
|
||||
|
||||
import numpy as np
|
||||
from numpy.random import randint
|
||||
from numpy.lib import Arrayterator
|
||||
from numpy.testing import assert_
|
||||
|
||||
|
||||
def test():
|
||||
np.random.seed(np.arange(10))
|
||||
|
||||
# Create a random array
|
||||
ndims = randint(5)+1
|
||||
shape = tuple(randint(10)+1 for dim in range(ndims))
|
||||
els = reduce(mul, shape)
|
||||
a = np.arange(els)
|
||||
a.shape = shape
|
||||
|
||||
buf_size = randint(2*els)
|
||||
b = Arrayterator(a, buf_size)
|
||||
|
||||
# Check that each block has at most ``buf_size`` elements
|
||||
for block in b:
|
||||
assert_(len(block.flat) <= (buf_size or els))
|
||||
|
||||
# Check that all elements are iterated correctly
|
||||
assert_(list(b.flat) == list(a.flat))
|
||||
|
||||
# Slice arrayterator
|
||||
start = [randint(dim) for dim in shape]
|
||||
stop = [randint(dim)+1 for dim in shape]
|
||||
step = [randint(dim)+1 for dim in shape]
|
||||
slice_ = tuple(slice(*t) for t in zip(start, stop, step))
|
||||
c = b[slice_]
|
||||
d = a[slice_]
|
||||
|
||||
# Check that each block has at most ``buf_size`` elements
|
||||
for block in c:
|
||||
assert_(len(block.flat) <= (buf_size or els))
|
||||
|
||||
# Check that the arrayterator is sliced correctly
|
||||
assert_(np.all(c.__array__() == d))
|
||||
|
||||
# Check that all elements are iterated correctly
|
||||
assert_(list(c.flat) == list(d.flat))
|
||||
@@ -0,0 +1,11 @@
|
||||
import sys
|
||||
import pytest
|
||||
import numpy as np
|
||||
|
||||
|
||||
def test_financial_expired():
|
||||
match = 'NEP 32'
|
||||
with pytest.warns(DeprecationWarning, match=match):
|
||||
func = np.fv
|
||||
with pytest.raises(RuntimeError, match=match):
|
||||
func(1, 2, 3)
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,816 @@
|
||||
import numpy as np
|
||||
|
||||
from numpy.lib.histograms import histogram, histogramdd, histogram_bin_edges
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_almost_equal,
|
||||
assert_array_almost_equal, assert_raises, assert_allclose,
|
||||
assert_array_max_ulp, assert_raises_regex, suppress_warnings,
|
||||
)
|
||||
from numpy.testing._private.utils import requires_memory
|
||||
import pytest
|
||||
|
||||
|
||||
class TestHistogram:
|
||||
|
||||
def setup_method(self):
|
||||
pass
|
||||
|
||||
def teardown_method(self):
|
||||
pass
|
||||
|
||||
def test_simple(self):
|
||||
n = 100
|
||||
v = np.random.rand(n)
|
||||
(a, b) = histogram(v)
|
||||
# check if the sum of the bins equals the number of samples
|
||||
assert_equal(np.sum(a, axis=0), n)
|
||||
# check that the bin counts are evenly spaced when the data is from
|
||||
# a linear function
|
||||
(a, b) = histogram(np.linspace(0, 10, 100))
|
||||
assert_array_equal(a, 10)
|
||||
|
||||
def test_one_bin(self):
|
||||
# Ticket 632
|
||||
hist, edges = histogram([1, 2, 3, 4], [1, 2])
|
||||
assert_array_equal(hist, [2, ])
|
||||
assert_array_equal(edges, [1, 2])
|
||||
assert_raises(ValueError, histogram, [1, 2], bins=0)
|
||||
h, e = histogram([1, 2], bins=1)
|
||||
assert_equal(h, np.array([2]))
|
||||
assert_allclose(e, np.array([1., 2.]))
|
||||
|
||||
def test_density(self):
|
||||
# Check that the integral of the density equals 1.
|
||||
n = 100
|
||||
v = np.random.rand(n)
|
||||
a, b = histogram(v, density=True)
|
||||
area = np.sum(a * np.diff(b))
|
||||
assert_almost_equal(area, 1)
|
||||
|
||||
# Check with non-constant bin widths
|
||||
v = np.arange(10)
|
||||
bins = [0, 1, 3, 6, 10]
|
||||
a, b = histogram(v, bins, density=True)
|
||||
assert_array_equal(a, .1)
|
||||
assert_equal(np.sum(a * np.diff(b)), 1)
|
||||
|
||||
# Test that passing False works too
|
||||
a, b = histogram(v, bins, density=False)
|
||||
assert_array_equal(a, [1, 2, 3, 4])
|
||||
|
||||
# Variable bin widths are especially useful to deal with
|
||||
# infinities.
|
||||
v = np.arange(10)
|
||||
bins = [0, 1, 3, 6, np.inf]
|
||||
a, b = histogram(v, bins, density=True)
|
||||
assert_array_equal(a, [.1, .1, .1, 0.])
|
||||
|
||||
# Taken from a bug report from N. Becker on the numpy-discussion
|
||||
# mailing list Aug. 6, 2010.
|
||||
counts, dmy = np.histogram(
|
||||
[1, 2, 3, 4], [0.5, 1.5, np.inf], density=True)
|
||||
assert_equal(counts, [.25, 0])
|
||||
|
||||
def test_outliers(self):
|
||||
# Check that outliers are not tallied
|
||||
a = np.arange(10) + .5
|
||||
|
||||
# Lower outliers
|
||||
h, b = histogram(a, range=[0, 9])
|
||||
assert_equal(h.sum(), 9)
|
||||
|
||||
# Upper outliers
|
||||
h, b = histogram(a, range=[1, 10])
|
||||
assert_equal(h.sum(), 9)
|
||||
|
||||
# Normalization
|
||||
h, b = histogram(a, range=[1, 9], density=True)
|
||||
assert_almost_equal((h * np.diff(b)).sum(), 1, decimal=15)
|
||||
|
||||
# Weights
|
||||
w = np.arange(10) + .5
|
||||
h, b = histogram(a, range=[1, 9], weights=w, density=True)
|
||||
assert_equal((h * np.diff(b)).sum(), 1)
|
||||
|
||||
h, b = histogram(a, bins=8, range=[1, 9], weights=w)
|
||||
assert_equal(h, w[1:-1])
|
||||
|
||||
def test_arr_weights_mismatch(self):
|
||||
a = np.arange(10) + .5
|
||||
w = np.arange(11) + .5
|
||||
with assert_raises_regex(ValueError, "same shape as"):
|
||||
h, b = histogram(a, range=[1, 9], weights=w, density=True)
|
||||
|
||||
|
||||
def test_type(self):
|
||||
# Check the type of the returned histogram
|
||||
a = np.arange(10) + .5
|
||||
h, b = histogram(a)
|
||||
assert_(np.issubdtype(h.dtype, np.integer))
|
||||
|
||||
h, b = histogram(a, density=True)
|
||||
assert_(np.issubdtype(h.dtype, np.floating))
|
||||
|
||||
h, b = histogram(a, weights=np.ones(10, int))
|
||||
assert_(np.issubdtype(h.dtype, np.integer))
|
||||
|
||||
h, b = histogram(a, weights=np.ones(10, float))
|
||||
assert_(np.issubdtype(h.dtype, np.floating))
|
||||
|
||||
def test_f32_rounding(self):
|
||||
# gh-4799, check that the rounding of the edges works with float32
|
||||
x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
|
||||
y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
|
||||
counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
|
||||
assert_equal(counts_hist.sum(), 3.)
|
||||
|
||||
def test_bool_conversion(self):
|
||||
# gh-12107
|
||||
# Reference integer histogram
|
||||
a = np.array([1, 1, 0], dtype=np.uint8)
|
||||
int_hist, int_edges = np.histogram(a)
|
||||
|
||||
# Should raise an warning on booleans
|
||||
# Ensure that the histograms are equivalent, need to suppress
|
||||
# the warnings to get the actual outputs
|
||||
with suppress_warnings() as sup:
|
||||
rec = sup.record(RuntimeWarning, 'Converting input from .*')
|
||||
hist, edges = np.histogram([True, True, False])
|
||||
# A warning should be issued
|
||||
assert_equal(len(rec), 1)
|
||||
assert_array_equal(hist, int_hist)
|
||||
assert_array_equal(edges, int_edges)
|
||||
|
||||
def test_weights(self):
|
||||
v = np.random.rand(100)
|
||||
w = np.ones(100) * 5
|
||||
a, b = histogram(v)
|
||||
na, nb = histogram(v, density=True)
|
||||
wa, wb = histogram(v, weights=w)
|
||||
nwa, nwb = histogram(v, weights=w, density=True)
|
||||
assert_array_almost_equal(a * 5, wa)
|
||||
assert_array_almost_equal(na, nwa)
|
||||
|
||||
# Check weights are properly applied.
|
||||
v = np.linspace(0, 10, 10)
|
||||
w = np.concatenate((np.zeros(5), np.ones(5)))
|
||||
wa, wb = histogram(v, bins=np.arange(11), weights=w)
|
||||
assert_array_almost_equal(wa, w)
|
||||
|
||||
# Check with integer weights
|
||||
wa, wb = histogram([1, 2, 2, 4], bins=4, weights=[4, 3, 2, 1])
|
||||
assert_array_equal(wa, [4, 5, 0, 1])
|
||||
wa, wb = histogram(
|
||||
[1, 2, 2, 4], bins=4, weights=[4, 3, 2, 1], density=True)
|
||||
assert_array_almost_equal(wa, np.array([4, 5, 0, 1]) / 10. / 3. * 4)
|
||||
|
||||
# Check weights with non-uniform bin widths
|
||||
a, b = histogram(
|
||||
np.arange(9), [0, 1, 3, 6, 10],
|
||||
weights=[2, 1, 1, 1, 1, 1, 1, 1, 1], density=True)
|
||||
assert_almost_equal(a, [.2, .1, .1, .075])
|
||||
|
||||
def test_exotic_weights(self):
|
||||
|
||||
# Test the use of weights that are not integer or floats, but e.g.
|
||||
# complex numbers or object types.
|
||||
|
||||
# Complex weights
|
||||
values = np.array([1.3, 2.5, 2.3])
|
||||
weights = np.array([1, -1, 2]) + 1j * np.array([2, 1, 2])
|
||||
|
||||
# Check with custom bins
|
||||
wa, wb = histogram(values, bins=[0, 2, 3], weights=weights)
|
||||
assert_array_almost_equal(wa, np.array([1, 1]) + 1j * np.array([2, 3]))
|
||||
|
||||
# Check with even bins
|
||||
wa, wb = histogram(values, bins=2, range=[1, 3], weights=weights)
|
||||
assert_array_almost_equal(wa, np.array([1, 1]) + 1j * np.array([2, 3]))
|
||||
|
||||
# Decimal weights
|
||||
from decimal import Decimal
|
||||
values = np.array([1.3, 2.5, 2.3])
|
||||
weights = np.array([Decimal(1), Decimal(2), Decimal(3)])
|
||||
|
||||
# Check with custom bins
|
||||
wa, wb = histogram(values, bins=[0, 2, 3], weights=weights)
|
||||
assert_array_almost_equal(wa, [Decimal(1), Decimal(5)])
|
||||
|
||||
# Check with even bins
|
||||
wa, wb = histogram(values, bins=2, range=[1, 3], weights=weights)
|
||||
assert_array_almost_equal(wa, [Decimal(1), Decimal(5)])
|
||||
|
||||
def test_no_side_effects(self):
|
||||
# This is a regression test that ensures that values passed to
|
||||
# ``histogram`` are unchanged.
|
||||
values = np.array([1.3, 2.5, 2.3])
|
||||
np.histogram(values, range=[-10, 10], bins=100)
|
||||
assert_array_almost_equal(values, [1.3, 2.5, 2.3])
|
||||
|
||||
def test_empty(self):
|
||||
a, b = histogram([], bins=([0, 1]))
|
||||
assert_array_equal(a, np.array([0]))
|
||||
assert_array_equal(b, np.array([0, 1]))
|
||||
|
||||
def test_error_binnum_type (self):
|
||||
# Tests if right Error is raised if bins argument is float
|
||||
vals = np.linspace(0.0, 1.0, num=100)
|
||||
histogram(vals, 5)
|
||||
assert_raises(TypeError, histogram, vals, 2.4)
|
||||
|
||||
def test_finite_range(self):
|
||||
# Normal ranges should be fine
|
||||
vals = np.linspace(0.0, 1.0, num=100)
|
||||
histogram(vals, range=[0.25,0.75])
|
||||
assert_raises(ValueError, histogram, vals, range=[np.nan,0.75])
|
||||
assert_raises(ValueError, histogram, vals, range=[0.25,np.inf])
|
||||
|
||||
def test_invalid_range(self):
|
||||
# start of range must be < end of range
|
||||
vals = np.linspace(0.0, 1.0, num=100)
|
||||
with assert_raises_regex(ValueError, "max must be larger than"):
|
||||
np.histogram(vals, range=[0.1, 0.01])
|
||||
|
||||
def test_bin_edge_cases(self):
|
||||
# Ensure that floating-point computations correctly place edge cases.
|
||||
arr = np.array([337, 404, 739, 806, 1007, 1811, 2012])
|
||||
hist, edges = np.histogram(arr, bins=8296, range=(2, 2280))
|
||||
mask = hist > 0
|
||||
left_edges = edges[:-1][mask]
|
||||
right_edges = edges[1:][mask]
|
||||
for x, left, right in zip(arr, left_edges, right_edges):
|
||||
assert_(x >= left)
|
||||
assert_(x < right)
|
||||
|
||||
def test_last_bin_inclusive_range(self):
|
||||
arr = np.array([0., 0., 0., 1., 2., 3., 3., 4., 5.])
|
||||
hist, edges = np.histogram(arr, bins=30, range=(-0.5, 5))
|
||||
assert_equal(hist[-1], 1)
|
||||
|
||||
def test_bin_array_dims(self):
|
||||
# gracefully handle bins object > 1 dimension
|
||||
vals = np.linspace(0.0, 1.0, num=100)
|
||||
bins = np.array([[0, 0.5], [0.6, 1.0]])
|
||||
with assert_raises_regex(ValueError, "must be 1d"):
|
||||
np.histogram(vals, bins=bins)
|
||||
|
||||
def test_unsigned_monotonicity_check(self):
|
||||
# Ensures ValueError is raised if bins not increasing monotonically
|
||||
# when bins contain unsigned values (see #9222)
|
||||
arr = np.array([2])
|
||||
bins = np.array([1, 3, 1], dtype='uint64')
|
||||
with assert_raises(ValueError):
|
||||
hist, edges = np.histogram(arr, bins=bins)
|
||||
|
||||
def test_object_array_of_0d(self):
|
||||
# gh-7864
|
||||
assert_raises(ValueError,
|
||||
histogram, [np.array(0.4) for i in range(10)] + [-np.inf])
|
||||
assert_raises(ValueError,
|
||||
histogram, [np.array(0.4) for i in range(10)] + [np.inf])
|
||||
|
||||
# these should not crash
|
||||
np.histogram([np.array(0.5) for i in range(10)] + [.500000000000001])
|
||||
np.histogram([np.array(0.5) for i in range(10)] + [.5])
|
||||
|
||||
def test_some_nan_values(self):
|
||||
# gh-7503
|
||||
one_nan = np.array([0, 1, np.nan])
|
||||
all_nan = np.array([np.nan, np.nan])
|
||||
|
||||
# the internal comparisons with NaN give warnings
|
||||
sup = suppress_warnings()
|
||||
sup.filter(RuntimeWarning)
|
||||
with sup:
|
||||
# can't infer range with nan
|
||||
assert_raises(ValueError, histogram, one_nan, bins='auto')
|
||||
assert_raises(ValueError, histogram, all_nan, bins='auto')
|
||||
|
||||
# explicit range solves the problem
|
||||
h, b = histogram(one_nan, bins='auto', range=(0, 1))
|
||||
assert_equal(h.sum(), 2) # nan is not counted
|
||||
h, b = histogram(all_nan, bins='auto', range=(0, 1))
|
||||
assert_equal(h.sum(), 0) # nan is not counted
|
||||
|
||||
# as does an explicit set of bins
|
||||
h, b = histogram(one_nan, bins=[0, 1])
|
||||
assert_equal(h.sum(), 2) # nan is not counted
|
||||
h, b = histogram(all_nan, bins=[0, 1])
|
||||
assert_equal(h.sum(), 0) # nan is not counted
|
||||
|
||||
def test_datetime(self):
|
||||
begin = np.datetime64('2000-01-01', 'D')
|
||||
offsets = np.array([0, 0, 1, 1, 2, 3, 5, 10, 20])
|
||||
bins = np.array([0, 2, 7, 20])
|
||||
dates = begin + offsets
|
||||
date_bins = begin + bins
|
||||
|
||||
td = np.dtype('timedelta64[D]')
|
||||
|
||||
# Results should be the same for integer offsets or datetime values.
|
||||
# For now, only explicit bins are supported, since linspace does not
|
||||
# work on datetimes or timedeltas
|
||||
d_count, d_edge = histogram(dates, bins=date_bins)
|
||||
t_count, t_edge = histogram(offsets.astype(td), bins=bins.astype(td))
|
||||
i_count, i_edge = histogram(offsets, bins=bins)
|
||||
|
||||
assert_equal(d_count, i_count)
|
||||
assert_equal(t_count, i_count)
|
||||
|
||||
assert_equal((d_edge - begin).astype(int), i_edge)
|
||||
assert_equal(t_edge.astype(int), i_edge)
|
||||
|
||||
assert_equal(d_edge.dtype, dates.dtype)
|
||||
assert_equal(t_edge.dtype, td)
|
||||
|
||||
def do_signed_overflow_bounds(self, dtype):
|
||||
exponent = 8 * np.dtype(dtype).itemsize - 1
|
||||
arr = np.array([-2**exponent + 4, 2**exponent - 4], dtype=dtype)
|
||||
hist, e = histogram(arr, bins=2)
|
||||
assert_equal(e, [-2**exponent + 4, 0, 2**exponent - 4])
|
||||
assert_equal(hist, [1, 1])
|
||||
|
||||
def test_signed_overflow_bounds(self):
|
||||
self.do_signed_overflow_bounds(np.byte)
|
||||
self.do_signed_overflow_bounds(np.short)
|
||||
self.do_signed_overflow_bounds(np.intc)
|
||||
self.do_signed_overflow_bounds(np.int_)
|
||||
self.do_signed_overflow_bounds(np.longlong)
|
||||
|
||||
def do_precision_lower_bound(self, float_small, float_large):
|
||||
eps = np.finfo(float_large).eps
|
||||
|
||||
arr = np.array([1.0], float_small)
|
||||
range = np.array([1.0 + eps, 2.0], float_large)
|
||||
|
||||
# test is looking for behavior when the bounds change between dtypes
|
||||
if range.astype(float_small)[0] != 1:
|
||||
return
|
||||
|
||||
# previously crashed
|
||||
count, x_loc = np.histogram(arr, bins=1, range=range)
|
||||
assert_equal(count, [1])
|
||||
|
||||
# gh-10322 means that the type comes from arr - this may change
|
||||
assert_equal(x_loc.dtype, float_small)
|
||||
|
||||
def do_precision_upper_bound(self, float_small, float_large):
|
||||
eps = np.finfo(float_large).eps
|
||||
|
||||
arr = np.array([1.0], float_small)
|
||||
range = np.array([0.0, 1.0 - eps], float_large)
|
||||
|
||||
# test is looking for behavior when the bounds change between dtypes
|
||||
if range.astype(float_small)[-1] != 1:
|
||||
return
|
||||
|
||||
# previously crashed
|
||||
count, x_loc = np.histogram(arr, bins=1, range=range)
|
||||
assert_equal(count, [1])
|
||||
|
||||
# gh-10322 means that the type comes from arr - this may change
|
||||
assert_equal(x_loc.dtype, float_small)
|
||||
|
||||
def do_precision(self, float_small, float_large):
|
||||
self.do_precision_lower_bound(float_small, float_large)
|
||||
self.do_precision_upper_bound(float_small, float_large)
|
||||
|
||||
def test_precision(self):
|
||||
# not looping results in a useful stack trace upon failure
|
||||
self.do_precision(np.half, np.single)
|
||||
self.do_precision(np.half, np.double)
|
||||
self.do_precision(np.half, np.longdouble)
|
||||
self.do_precision(np.single, np.double)
|
||||
self.do_precision(np.single, np.longdouble)
|
||||
self.do_precision(np.double, np.longdouble)
|
||||
|
||||
def test_histogram_bin_edges(self):
|
||||
hist, e = histogram([1, 2, 3, 4], [1, 2])
|
||||
edges = histogram_bin_edges([1, 2, 3, 4], [1, 2])
|
||||
assert_array_equal(edges, e)
|
||||
|
||||
arr = np.array([0., 0., 0., 1., 2., 3., 3., 4., 5.])
|
||||
hist, e = histogram(arr, bins=30, range=(-0.5, 5))
|
||||
edges = histogram_bin_edges(arr, bins=30, range=(-0.5, 5))
|
||||
assert_array_equal(edges, e)
|
||||
|
||||
hist, e = histogram(arr, bins='auto', range=(0, 1))
|
||||
edges = histogram_bin_edges(arr, bins='auto', range=(0, 1))
|
||||
assert_array_equal(edges, e)
|
||||
|
||||
# @requires_memory(free_bytes=1e10)
|
||||
# @pytest.mark.slow
|
||||
@pytest.mark.skip(reason="Bad memory reports lead to OOM in ci testing")
|
||||
def test_big_arrays(self):
|
||||
sample = np.zeros([100000000, 3])
|
||||
xbins = 400
|
||||
ybins = 400
|
||||
zbins = np.arange(16000)
|
||||
hist = np.histogramdd(sample=sample, bins=(xbins, ybins, zbins))
|
||||
assert_equal(type(hist), type((1, 2)))
|
||||
|
||||
def test_gh_23110(self):
|
||||
hist, e = np.histogram(np.array([-0.9e-308], dtype='>f8'),
|
||||
bins=2,
|
||||
range=(-1e-308, -2e-313))
|
||||
expected_hist = np.array([1, 0])
|
||||
assert_array_equal(hist, expected_hist)
|
||||
|
||||
|
||||
class TestHistogramOptimBinNums:
|
||||
"""
|
||||
Provide test coverage when using provided estimators for optimal number of
|
||||
bins
|
||||
"""
|
||||
|
||||
def test_empty(self):
|
||||
estimator_list = ['fd', 'scott', 'rice', 'sturges',
|
||||
'doane', 'sqrt', 'auto', 'stone']
|
||||
# check it can deal with empty data
|
||||
for estimator in estimator_list:
|
||||
a, b = histogram([], bins=estimator)
|
||||
assert_array_equal(a, np.array([0]))
|
||||
assert_array_equal(b, np.array([0, 1]))
|
||||
|
||||
def test_simple(self):
|
||||
"""
|
||||
Straightforward testing with a mixture of linspace data (for
|
||||
consistency). All test values have been precomputed and the values
|
||||
shouldn't change
|
||||
"""
|
||||
# Some basic sanity checking, with some fixed data.
|
||||
# Checking for the correct number of bins
|
||||
basic_test = {50: {'fd': 4, 'scott': 4, 'rice': 8, 'sturges': 7,
|
||||
'doane': 8, 'sqrt': 8, 'auto': 7, 'stone': 2},
|
||||
500: {'fd': 8, 'scott': 8, 'rice': 16, 'sturges': 10,
|
||||
'doane': 12, 'sqrt': 23, 'auto': 10, 'stone': 9},
|
||||
5000: {'fd': 17, 'scott': 17, 'rice': 35, 'sturges': 14,
|
||||
'doane': 17, 'sqrt': 71, 'auto': 17, 'stone': 20}}
|
||||
|
||||
for testlen, expectedResults in basic_test.items():
|
||||
# Create some sort of non uniform data to test with
|
||||
# (2 peak uniform mixture)
|
||||
x1 = np.linspace(-10, -1, testlen // 5 * 2)
|
||||
x2 = np.linspace(1, 10, testlen // 5 * 3)
|
||||
x = np.concatenate((x1, x2))
|
||||
for estimator, numbins in expectedResults.items():
|
||||
a, b = np.histogram(x, estimator)
|
||||
assert_equal(len(a), numbins, err_msg="For the {0} estimator "
|
||||
"with datasize of {1}".format(estimator, testlen))
|
||||
|
||||
def test_small(self):
|
||||
"""
|
||||
Smaller datasets have the potential to cause issues with the data
|
||||
adaptive methods, especially the FD method. All bin numbers have been
|
||||
precalculated.
|
||||
"""
|
||||
small_dat = {1: {'fd': 1, 'scott': 1, 'rice': 1, 'sturges': 1,
|
||||
'doane': 1, 'sqrt': 1, 'stone': 1},
|
||||
2: {'fd': 2, 'scott': 1, 'rice': 3, 'sturges': 2,
|
||||
'doane': 1, 'sqrt': 2, 'stone': 1},
|
||||
3: {'fd': 2, 'scott': 2, 'rice': 3, 'sturges': 3,
|
||||
'doane': 3, 'sqrt': 2, 'stone': 1}}
|
||||
|
||||
for testlen, expectedResults in small_dat.items():
|
||||
testdat = np.arange(testlen)
|
||||
for estimator, expbins in expectedResults.items():
|
||||
a, b = np.histogram(testdat, estimator)
|
||||
assert_equal(len(a), expbins, err_msg="For the {0} estimator "
|
||||
"with datasize of {1}".format(estimator, testlen))
|
||||
|
||||
def test_incorrect_methods(self):
|
||||
"""
|
||||
Check a Value Error is thrown when an unknown string is passed in
|
||||
"""
|
||||
check_list = ['mad', 'freeman', 'histograms', 'IQR']
|
||||
for estimator in check_list:
|
||||
assert_raises(ValueError, histogram, [1, 2, 3], estimator)
|
||||
|
||||
def test_novariance(self):
|
||||
"""
|
||||
Check that methods handle no variance in data
|
||||
Primarily for Scott and FD as the SD and IQR are both 0 in this case
|
||||
"""
|
||||
novar_dataset = np.ones(100)
|
||||
novar_resultdict = {'fd': 1, 'scott': 1, 'rice': 1, 'sturges': 1,
|
||||
'doane': 1, 'sqrt': 1, 'auto': 1, 'stone': 1}
|
||||
|
||||
for estimator, numbins in novar_resultdict.items():
|
||||
a, b = np.histogram(novar_dataset, estimator)
|
||||
assert_equal(len(a), numbins, err_msg="{0} estimator, "
|
||||
"No Variance test".format(estimator))
|
||||
|
||||
def test_limited_variance(self):
|
||||
"""
|
||||
Check when IQR is 0, but variance exists, we return the sturges value
|
||||
and not the fd value.
|
||||
"""
|
||||
lim_var_data = np.ones(1000)
|
||||
lim_var_data[:3] = 0
|
||||
lim_var_data[-4:] = 100
|
||||
|
||||
edges_auto = histogram_bin_edges(lim_var_data, 'auto')
|
||||
assert_equal(edges_auto, np.linspace(0, 100, 12))
|
||||
|
||||
edges_fd = histogram_bin_edges(lim_var_data, 'fd')
|
||||
assert_equal(edges_fd, np.array([0, 100]))
|
||||
|
||||
edges_sturges = histogram_bin_edges(lim_var_data, 'sturges')
|
||||
assert_equal(edges_sturges, np.linspace(0, 100, 12))
|
||||
|
||||
def test_outlier(self):
|
||||
"""
|
||||
Check the FD, Scott and Doane with outliers.
|
||||
|
||||
The FD estimates a smaller binwidth since it's less affected by
|
||||
outliers. Since the range is so (artificially) large, this means more
|
||||
bins, most of which will be empty, but the data of interest usually is
|
||||
unaffected. The Scott estimator is more affected and returns fewer bins,
|
||||
despite most of the variance being in one area of the data. The Doane
|
||||
estimator lies somewhere between the other two.
|
||||
"""
|
||||
xcenter = np.linspace(-10, 10, 50)
|
||||
outlier_dataset = np.hstack((np.linspace(-110, -100, 5), xcenter))
|
||||
|
||||
outlier_resultdict = {'fd': 21, 'scott': 5, 'doane': 11, 'stone': 6}
|
||||
|
||||
for estimator, numbins in outlier_resultdict.items():
|
||||
a, b = np.histogram(outlier_dataset, estimator)
|
||||
assert_equal(len(a), numbins)
|
||||
|
||||
def test_scott_vs_stone(self):
|
||||
"""Verify that Scott's rule and Stone's rule converges for normally distributed data"""
|
||||
|
||||
def nbins_ratio(seed, size):
|
||||
rng = np.random.RandomState(seed)
|
||||
x = rng.normal(loc=0, scale=2, size=size)
|
||||
a, b = len(np.histogram(x, 'stone')[0]), len(np.histogram(x, 'scott')[0])
|
||||
return a / (a + b)
|
||||
|
||||
ll = [[nbins_ratio(seed, size) for size in np.geomspace(start=10, stop=100, num=4).round().astype(int)]
|
||||
for seed in range(10)]
|
||||
|
||||
# the average difference between the two methods decreases as the dataset size increases.
|
||||
avg = abs(np.mean(ll, axis=0) - 0.5)
|
||||
assert_almost_equal(avg, [0.15, 0.09, 0.08, 0.03], decimal=2)
|
||||
|
||||
def test_simple_range(self):
|
||||
"""
|
||||
Straightforward testing with a mixture of linspace data (for
|
||||
consistency). Adding in a 3rd mixture that will then be
|
||||
completely ignored. All test values have been precomputed and
|
||||
the shouldn't change.
|
||||
"""
|
||||
# some basic sanity checking, with some fixed data.
|
||||
# Checking for the correct number of bins
|
||||
basic_test = {
|
||||
50: {'fd': 8, 'scott': 8, 'rice': 15,
|
||||
'sturges': 14, 'auto': 14, 'stone': 8},
|
||||
500: {'fd': 15, 'scott': 16, 'rice': 32,
|
||||
'sturges': 20, 'auto': 20, 'stone': 80},
|
||||
5000: {'fd': 33, 'scott': 33, 'rice': 69,
|
||||
'sturges': 27, 'auto': 33, 'stone': 80}
|
||||
}
|
||||
|
||||
for testlen, expectedResults in basic_test.items():
|
||||
# create some sort of non uniform data to test with
|
||||
# (3 peak uniform mixture)
|
||||
x1 = np.linspace(-10, -1, testlen // 5 * 2)
|
||||
x2 = np.linspace(1, 10, testlen // 5 * 3)
|
||||
x3 = np.linspace(-100, -50, testlen)
|
||||
x = np.hstack((x1, x2, x3))
|
||||
for estimator, numbins in expectedResults.items():
|
||||
a, b = np.histogram(x, estimator, range = (-20, 20))
|
||||
msg = "For the {0} estimator".format(estimator)
|
||||
msg += " with datasize of {0}".format(testlen)
|
||||
assert_equal(len(a), numbins, err_msg=msg)
|
||||
|
||||
@pytest.mark.parametrize("bins", ['auto', 'fd', 'doane', 'scott',
|
||||
'stone', 'rice', 'sturges'])
|
||||
def test_signed_integer_data(self, bins):
|
||||
# Regression test for gh-14379.
|
||||
a = np.array([-2, 0, 127], dtype=np.int8)
|
||||
hist, edges = np.histogram(a, bins=bins)
|
||||
hist32, edges32 = np.histogram(a.astype(np.int32), bins=bins)
|
||||
assert_array_equal(hist, hist32)
|
||||
assert_array_equal(edges, edges32)
|
||||
|
||||
def test_simple_weighted(self):
|
||||
"""
|
||||
Check that weighted data raises a TypeError
|
||||
"""
|
||||
estimator_list = ['fd', 'scott', 'rice', 'sturges', 'auto']
|
||||
for estimator in estimator_list:
|
||||
assert_raises(TypeError, histogram, [1, 2, 3],
|
||||
estimator, weights=[1, 2, 3])
|
||||
|
||||
|
||||
class TestHistogramdd:
|
||||
|
||||
def test_simple(self):
|
||||
x = np.array([[-.5, .5, 1.5], [-.5, 1.5, 2.5], [-.5, 2.5, .5],
|
||||
[.5, .5, 1.5], [.5, 1.5, 2.5], [.5, 2.5, 2.5]])
|
||||
H, edges = histogramdd(x, (2, 3, 3),
|
||||
range=[[-1, 1], [0, 3], [0, 3]])
|
||||
answer = np.array([[[0, 1, 0], [0, 0, 1], [1, 0, 0]],
|
||||
[[0, 1, 0], [0, 0, 1], [0, 0, 1]]])
|
||||
assert_array_equal(H, answer)
|
||||
|
||||
# Check normalization
|
||||
ed = [[-2, 0, 2], [0, 1, 2, 3], [0, 1, 2, 3]]
|
||||
H, edges = histogramdd(x, bins=ed, density=True)
|
||||
assert_(np.all(H == answer / 12.))
|
||||
|
||||
# Check that H has the correct shape.
|
||||
H, edges = histogramdd(x, (2, 3, 4),
|
||||
range=[[-1, 1], [0, 3], [0, 4]],
|
||||
density=True)
|
||||
answer = np.array([[[0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0]],
|
||||
[[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 0]]])
|
||||
assert_array_almost_equal(H, answer / 6., 4)
|
||||
# Check that a sequence of arrays is accepted and H has the correct
|
||||
# shape.
|
||||
z = [np.squeeze(y) for y in np.split(x, 3, axis=1)]
|
||||
H, edges = histogramdd(
|
||||
z, bins=(4, 3, 2), range=[[-2, 2], [0, 3], [0, 2]])
|
||||
answer = np.array([[[0, 0], [0, 0], [0, 0]],
|
||||
[[0, 1], [0, 0], [1, 0]],
|
||||
[[0, 1], [0, 0], [0, 0]],
|
||||
[[0, 0], [0, 0], [0, 0]]])
|
||||
assert_array_equal(H, answer)
|
||||
|
||||
Z = np.zeros((5, 5, 5))
|
||||
Z[list(range(5)), list(range(5)), list(range(5))] = 1.
|
||||
H, edges = histogramdd([np.arange(5), np.arange(5), np.arange(5)], 5)
|
||||
assert_array_equal(H, Z)
|
||||
|
||||
def test_shape_3d(self):
|
||||
# All possible permutations for bins of different lengths in 3D.
|
||||
bins = ((5, 4, 6), (6, 4, 5), (5, 6, 4), (4, 6, 5), (6, 5, 4),
|
||||
(4, 5, 6))
|
||||
r = np.random.rand(10, 3)
|
||||
for b in bins:
|
||||
H, edges = histogramdd(r, b)
|
||||
assert_(H.shape == b)
|
||||
|
||||
def test_shape_4d(self):
|
||||
# All possible permutations for bins of different lengths in 4D.
|
||||
bins = ((7, 4, 5, 6), (4, 5, 7, 6), (5, 6, 4, 7), (7, 6, 5, 4),
|
||||
(5, 7, 6, 4), (4, 6, 7, 5), (6, 5, 7, 4), (7, 5, 4, 6),
|
||||
(7, 4, 6, 5), (6, 4, 7, 5), (6, 7, 5, 4), (4, 6, 5, 7),
|
||||
(4, 7, 5, 6), (5, 4, 6, 7), (5, 7, 4, 6), (6, 7, 4, 5),
|
||||
(6, 5, 4, 7), (4, 7, 6, 5), (4, 5, 6, 7), (7, 6, 4, 5),
|
||||
(5, 4, 7, 6), (5, 6, 7, 4), (6, 4, 5, 7), (7, 5, 6, 4))
|
||||
|
||||
r = np.random.rand(10, 4)
|
||||
for b in bins:
|
||||
H, edges = histogramdd(r, b)
|
||||
assert_(H.shape == b)
|
||||
|
||||
def test_weights(self):
|
||||
v = np.random.rand(100, 2)
|
||||
hist, edges = histogramdd(v)
|
||||
n_hist, edges = histogramdd(v, density=True)
|
||||
w_hist, edges = histogramdd(v, weights=np.ones(100))
|
||||
assert_array_equal(w_hist, hist)
|
||||
w_hist, edges = histogramdd(v, weights=np.ones(100) * 2, density=True)
|
||||
assert_array_equal(w_hist, n_hist)
|
||||
w_hist, edges = histogramdd(v, weights=np.ones(100, int) * 2)
|
||||
assert_array_equal(w_hist, 2 * hist)
|
||||
|
||||
def test_identical_samples(self):
|
||||
x = np.zeros((10, 2), int)
|
||||
hist, edges = histogramdd(x, bins=2)
|
||||
assert_array_equal(edges[0], np.array([-0.5, 0., 0.5]))
|
||||
|
||||
def test_empty(self):
|
||||
a, b = histogramdd([[], []], bins=([0, 1], [0, 1]))
|
||||
assert_array_max_ulp(a, np.array([[0.]]))
|
||||
a, b = np.histogramdd([[], [], []], bins=2)
|
||||
assert_array_max_ulp(a, np.zeros((2, 2, 2)))
|
||||
|
||||
def test_bins_errors(self):
|
||||
# There are two ways to specify bins. Check for the right errors
|
||||
# when mixing those.
|
||||
x = np.arange(8).reshape(2, 4)
|
||||
assert_raises(ValueError, np.histogramdd, x, bins=[-1, 2, 4, 5])
|
||||
assert_raises(ValueError, np.histogramdd, x, bins=[1, 0.99, 1, 1])
|
||||
assert_raises(
|
||||
ValueError, np.histogramdd, x, bins=[1, 1, 1, [1, 2, 3, -3]])
|
||||
assert_(np.histogramdd(x, bins=[1, 1, 1, [1, 2, 3, 4]]))
|
||||
|
||||
def test_inf_edges(self):
|
||||
# Test using +/-inf bin edges works. See #1788.
|
||||
with np.errstate(invalid='ignore'):
|
||||
x = np.arange(6).reshape(3, 2)
|
||||
expected = np.array([[1, 0], [0, 1], [0, 1]])
|
||||
h, e = np.histogramdd(x, bins=[3, [-np.inf, 2, 10]])
|
||||
assert_allclose(h, expected)
|
||||
h, e = np.histogramdd(x, bins=[3, np.array([-1, 2, np.inf])])
|
||||
assert_allclose(h, expected)
|
||||
h, e = np.histogramdd(x, bins=[3, [-np.inf, 3, np.inf]])
|
||||
assert_allclose(h, expected)
|
||||
|
||||
def test_rightmost_binedge(self):
|
||||
# Test event very close to rightmost binedge. See Github issue #4266
|
||||
x = [0.9999999995]
|
||||
bins = [[0., 0.5, 1.0]]
|
||||
hist, _ = histogramdd(x, bins=bins)
|
||||
assert_(hist[0] == 0.0)
|
||||
assert_(hist[1] == 1.)
|
||||
x = [1.0]
|
||||
bins = [[0., 0.5, 1.0]]
|
||||
hist, _ = histogramdd(x, bins=bins)
|
||||
assert_(hist[0] == 0.0)
|
||||
assert_(hist[1] == 1.)
|
||||
x = [1.0000000001]
|
||||
bins = [[0., 0.5, 1.0]]
|
||||
hist, _ = histogramdd(x, bins=bins)
|
||||
assert_(hist[0] == 0.0)
|
||||
assert_(hist[1] == 0.0)
|
||||
x = [1.0001]
|
||||
bins = [[0., 0.5, 1.0]]
|
||||
hist, _ = histogramdd(x, bins=bins)
|
||||
assert_(hist[0] == 0.0)
|
||||
assert_(hist[1] == 0.0)
|
||||
|
||||
def test_finite_range(self):
|
||||
vals = np.random.random((100, 3))
|
||||
histogramdd(vals, range=[[0.0, 1.0], [0.25, 0.75], [0.25, 0.5]])
|
||||
assert_raises(ValueError, histogramdd, vals,
|
||||
range=[[0.0, 1.0], [0.25, 0.75], [0.25, np.inf]])
|
||||
assert_raises(ValueError, histogramdd, vals,
|
||||
range=[[0.0, 1.0], [np.nan, 0.75], [0.25, 0.5]])
|
||||
|
||||
def test_equal_edges(self):
|
||||
""" Test that adjacent entries in an edge array can be equal """
|
||||
x = np.array([0, 1, 2])
|
||||
y = np.array([0, 1, 2])
|
||||
x_edges = np.array([0, 2, 2])
|
||||
y_edges = 1
|
||||
hist, edges = histogramdd((x, y), bins=(x_edges, y_edges))
|
||||
|
||||
hist_expected = np.array([
|
||||
[2.],
|
||||
[1.], # x == 2 falls in the final bin
|
||||
])
|
||||
assert_equal(hist, hist_expected)
|
||||
|
||||
def test_edge_dtype(self):
|
||||
""" Test that if an edge array is input, its type is preserved """
|
||||
x = np.array([0, 10, 20])
|
||||
y = x / 10
|
||||
x_edges = np.array([0, 5, 15, 20])
|
||||
y_edges = x_edges / 10
|
||||
hist, edges = histogramdd((x, y), bins=(x_edges, y_edges))
|
||||
|
||||
assert_equal(edges[0].dtype, x_edges.dtype)
|
||||
assert_equal(edges[1].dtype, y_edges.dtype)
|
||||
|
||||
def test_large_integers(self):
|
||||
big = 2**60 # Too large to represent with a full precision float
|
||||
|
||||
x = np.array([0], np.int64)
|
||||
x_edges = np.array([-1, +1], np.int64)
|
||||
y = big + x
|
||||
y_edges = big + x_edges
|
||||
|
||||
hist, edges = histogramdd((x, y), bins=(x_edges, y_edges))
|
||||
|
||||
assert_equal(hist[0, 0], 1)
|
||||
|
||||
def test_density_non_uniform_2d(self):
|
||||
# Defines the following grid:
|
||||
#
|
||||
# 0 2 8
|
||||
# 0+-+-----+
|
||||
# + | +
|
||||
# + | +
|
||||
# 6+-+-----+
|
||||
# 8+-+-----+
|
||||
x_edges = np.array([0, 2, 8])
|
||||
y_edges = np.array([0, 6, 8])
|
||||
relative_areas = np.array([
|
||||
[3, 9],
|
||||
[1, 3]])
|
||||
|
||||
# ensure the number of points in each region is proportional to its area
|
||||
x = np.array([1] + [1]*3 + [7]*3 + [7]*9)
|
||||
y = np.array([7] + [1]*3 + [7]*3 + [1]*9)
|
||||
|
||||
# sanity check that the above worked as intended
|
||||
hist, edges = histogramdd((y, x), bins=(y_edges, x_edges))
|
||||
assert_equal(hist, relative_areas)
|
||||
|
||||
# resulting histogram should be uniform, since counts and areas are proportional
|
||||
hist, edges = histogramdd((y, x), bins=(y_edges, x_edges), density=True)
|
||||
assert_equal(hist, 1 / (8*8))
|
||||
|
||||
def test_density_non_uniform_1d(self):
|
||||
# compare to histogram to show the results are the same
|
||||
v = np.arange(10)
|
||||
bins = np.array([0, 1, 3, 6, 10])
|
||||
hist, edges = histogram(v, bins, density=True)
|
||||
hist_dd, edges_dd = histogramdd((v,), (bins,), density=True)
|
||||
assert_equal(hist, hist_dd)
|
||||
assert_equal(edges, edges_dd[0])
|
||||
@@ -0,0 +1,551 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_almost_equal,
|
||||
assert_array_almost_equal, assert_raises, assert_raises_regex,
|
||||
)
|
||||
from numpy.lib.index_tricks import (
|
||||
mgrid, ogrid, ndenumerate, fill_diagonal, diag_indices, diag_indices_from,
|
||||
index_exp, ndindex, r_, s_, ix_
|
||||
)
|
||||
|
||||
|
||||
class TestRavelUnravelIndex:
|
||||
def test_basic(self):
|
||||
assert_equal(np.unravel_index(2, (2, 2)), (1, 0))
|
||||
|
||||
# test that new shape argument works properly
|
||||
assert_equal(np.unravel_index(indices=2,
|
||||
shape=(2, 2)),
|
||||
(1, 0))
|
||||
|
||||
# test that an invalid second keyword argument
|
||||
# is properly handled, including the old name `dims`.
|
||||
with assert_raises(TypeError):
|
||||
np.unravel_index(indices=2, hape=(2, 2))
|
||||
|
||||
with assert_raises(TypeError):
|
||||
np.unravel_index(2, hape=(2, 2))
|
||||
|
||||
with assert_raises(TypeError):
|
||||
np.unravel_index(254, ims=(17, 94))
|
||||
|
||||
with assert_raises(TypeError):
|
||||
np.unravel_index(254, dims=(17, 94))
|
||||
|
||||
assert_equal(np.ravel_multi_index((1, 0), (2, 2)), 2)
|
||||
assert_equal(np.unravel_index(254, (17, 94)), (2, 66))
|
||||
assert_equal(np.ravel_multi_index((2, 66), (17, 94)), 254)
|
||||
assert_raises(ValueError, np.unravel_index, -1, (2, 2))
|
||||
assert_raises(TypeError, np.unravel_index, 0.5, (2, 2))
|
||||
assert_raises(ValueError, np.unravel_index, 4, (2, 2))
|
||||
assert_raises(ValueError, np.ravel_multi_index, (-3, 1), (2, 2))
|
||||
assert_raises(ValueError, np.ravel_multi_index, (2, 1), (2, 2))
|
||||
assert_raises(ValueError, np.ravel_multi_index, (0, -3), (2, 2))
|
||||
assert_raises(ValueError, np.ravel_multi_index, (0, 2), (2, 2))
|
||||
assert_raises(TypeError, np.ravel_multi_index, (0.1, 0.), (2, 2))
|
||||
|
||||
assert_equal(np.unravel_index((2*3 + 1)*6 + 4, (4, 3, 6)), [2, 1, 4])
|
||||
assert_equal(
|
||||
np.ravel_multi_index([2, 1, 4], (4, 3, 6)), (2*3 + 1)*6 + 4)
|
||||
|
||||
arr = np.array([[3, 6, 6], [4, 5, 1]])
|
||||
assert_equal(np.ravel_multi_index(arr, (7, 6)), [22, 41, 37])
|
||||
assert_equal(
|
||||
np.ravel_multi_index(arr, (7, 6), order='F'), [31, 41, 13])
|
||||
assert_equal(
|
||||
np.ravel_multi_index(arr, (4, 6), mode='clip'), [22, 23, 19])
|
||||
assert_equal(np.ravel_multi_index(arr, (4, 4), mode=('clip', 'wrap')),
|
||||
[12, 13, 13])
|
||||
assert_equal(np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9)), 1621)
|
||||
|
||||
assert_equal(np.unravel_index(np.array([22, 41, 37]), (7, 6)),
|
||||
[[3, 6, 6], [4, 5, 1]])
|
||||
assert_equal(
|
||||
np.unravel_index(np.array([31, 41, 13]), (7, 6), order='F'),
|
||||
[[3, 6, 6], [4, 5, 1]])
|
||||
assert_equal(np.unravel_index(1621, (6, 7, 8, 9)), [3, 1, 4, 1])
|
||||
|
||||
def test_empty_indices(self):
|
||||
msg1 = 'indices must be integral: the provided empty sequence was'
|
||||
msg2 = 'only int indices permitted'
|
||||
assert_raises_regex(TypeError, msg1, np.unravel_index, [], (10, 3, 5))
|
||||
assert_raises_regex(TypeError, msg1, np.unravel_index, (), (10, 3, 5))
|
||||
assert_raises_regex(TypeError, msg2, np.unravel_index, np.array([]),
|
||||
(10, 3, 5))
|
||||
assert_equal(np.unravel_index(np.array([],dtype=int), (10, 3, 5)),
|
||||
[[], [], []])
|
||||
assert_raises_regex(TypeError, msg1, np.ravel_multi_index, ([], []),
|
||||
(10, 3))
|
||||
assert_raises_regex(TypeError, msg1, np.ravel_multi_index, ([], ['abc']),
|
||||
(10, 3))
|
||||
assert_raises_regex(TypeError, msg2, np.ravel_multi_index,
|
||||
(np.array([]), np.array([])), (5, 3))
|
||||
assert_equal(np.ravel_multi_index(
|
||||
(np.array([], dtype=int), np.array([], dtype=int)), (5, 3)), [])
|
||||
assert_equal(np.ravel_multi_index(np.array([[], []], dtype=int),
|
||||
(5, 3)), [])
|
||||
|
||||
def test_big_indices(self):
|
||||
# ravel_multi_index for big indices (issue #7546)
|
||||
if np.intp == np.int64:
|
||||
arr = ([1, 29], [3, 5], [3, 117], [19, 2],
|
||||
[2379, 1284], [2, 2], [0, 1])
|
||||
assert_equal(
|
||||
np.ravel_multi_index(arr, (41, 7, 120, 36, 2706, 8, 6)),
|
||||
[5627771580, 117259570957])
|
||||
|
||||
# test unravel_index for big indices (issue #9538)
|
||||
assert_raises(ValueError, np.unravel_index, 1, (2**32-1, 2**31+1))
|
||||
|
||||
# test overflow checking for too big array (issue #7546)
|
||||
dummy_arr = ([0],[0])
|
||||
half_max = np.iinfo(np.intp).max // 2
|
||||
assert_equal(
|
||||
np.ravel_multi_index(dummy_arr, (half_max, 2)), [0])
|
||||
assert_raises(ValueError,
|
||||
np.ravel_multi_index, dummy_arr, (half_max+1, 2))
|
||||
assert_equal(
|
||||
np.ravel_multi_index(dummy_arr, (half_max, 2), order='F'), [0])
|
||||
assert_raises(ValueError,
|
||||
np.ravel_multi_index, dummy_arr, (half_max+1, 2), order='F')
|
||||
|
||||
def test_dtypes(self):
|
||||
# Test with different data types
|
||||
for dtype in [np.int16, np.uint16, np.int32,
|
||||
np.uint32, np.int64, np.uint64]:
|
||||
coords = np.array(
|
||||
[[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0]], dtype=dtype)
|
||||
shape = (5, 8)
|
||||
uncoords = 8*coords[0]+coords[1]
|
||||
assert_equal(np.ravel_multi_index(coords, shape), uncoords)
|
||||
assert_equal(coords, np.unravel_index(uncoords, shape))
|
||||
uncoords = coords[0]+5*coords[1]
|
||||
assert_equal(
|
||||
np.ravel_multi_index(coords, shape, order='F'), uncoords)
|
||||
assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
|
||||
|
||||
coords = np.array(
|
||||
[[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0], [1, 3, 1, 0, 9, 5]],
|
||||
dtype=dtype)
|
||||
shape = (5, 8, 10)
|
||||
uncoords = 10*(8*coords[0]+coords[1])+coords[2]
|
||||
assert_equal(np.ravel_multi_index(coords, shape), uncoords)
|
||||
assert_equal(coords, np.unravel_index(uncoords, shape))
|
||||
uncoords = coords[0]+5*(coords[1]+8*coords[2])
|
||||
assert_equal(
|
||||
np.ravel_multi_index(coords, shape, order='F'), uncoords)
|
||||
assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
|
||||
|
||||
def test_clipmodes(self):
|
||||
# Test clipmodes
|
||||
assert_equal(
|
||||
np.ravel_multi_index([5, 1, -1, 2], (4, 3, 7, 12), mode='wrap'),
|
||||
np.ravel_multi_index([1, 1, 6, 2], (4, 3, 7, 12)))
|
||||
assert_equal(np.ravel_multi_index([5, 1, -1, 2], (4, 3, 7, 12),
|
||||
mode=(
|
||||
'wrap', 'raise', 'clip', 'raise')),
|
||||
np.ravel_multi_index([1, 1, 0, 2], (4, 3, 7, 12)))
|
||||
assert_raises(
|
||||
ValueError, np.ravel_multi_index, [5, 1, -1, 2], (4, 3, 7, 12))
|
||||
|
||||
def test_writeability(self):
|
||||
# See gh-7269
|
||||
x, y = np.unravel_index([1, 2, 3], (4, 5))
|
||||
assert_(x.flags.writeable)
|
||||
assert_(y.flags.writeable)
|
||||
|
||||
def test_0d(self):
|
||||
# gh-580
|
||||
x = np.unravel_index(0, ())
|
||||
assert_equal(x, ())
|
||||
|
||||
assert_raises_regex(ValueError, "0d array", np.unravel_index, [0], ())
|
||||
assert_raises_regex(
|
||||
ValueError, "out of bounds", np.unravel_index, [1], ())
|
||||
|
||||
@pytest.mark.parametrize("mode", ["clip", "wrap", "raise"])
|
||||
def test_empty_array_ravel(self, mode):
|
||||
res = np.ravel_multi_index(
|
||||
np.zeros((3, 0), dtype=np.intp), (2, 1, 0), mode=mode)
|
||||
assert(res.shape == (0,))
|
||||
|
||||
with assert_raises(ValueError):
|
||||
np.ravel_multi_index(
|
||||
np.zeros((3, 1), dtype=np.intp), (2, 1, 0), mode=mode)
|
||||
|
||||
def test_empty_array_unravel(self):
|
||||
res = np.unravel_index(np.zeros(0, dtype=np.intp), (2, 1, 0))
|
||||
# res is a tuple of three empty arrays
|
||||
assert(len(res) == 3)
|
||||
assert(all(a.shape == (0,) for a in res))
|
||||
|
||||
with assert_raises(ValueError):
|
||||
np.unravel_index([1], (2, 1, 0))
|
||||
|
||||
class TestGrid:
|
||||
def test_basic(self):
|
||||
a = mgrid[-1:1:10j]
|
||||
b = mgrid[-1:1:0.1]
|
||||
assert_(a.shape == (10,))
|
||||
assert_(b.shape == (20,))
|
||||
assert_(a[0] == -1)
|
||||
assert_almost_equal(a[-1], 1)
|
||||
assert_(b[0] == -1)
|
||||
assert_almost_equal(b[1]-b[0], 0.1, 11)
|
||||
assert_almost_equal(b[-1], b[0]+19*0.1, 11)
|
||||
assert_almost_equal(a[1]-a[0], 2.0/9.0, 11)
|
||||
|
||||
def test_linspace_equivalence(self):
|
||||
y, st = np.linspace(2, 10, retstep=True)
|
||||
assert_almost_equal(st, 8/49.0)
|
||||
assert_array_almost_equal(y, mgrid[2:10:50j], 13)
|
||||
|
||||
def test_nd(self):
|
||||
c = mgrid[-1:1:10j, -2:2:10j]
|
||||
d = mgrid[-1:1:0.1, -2:2:0.2]
|
||||
assert_(c.shape == (2, 10, 10))
|
||||
assert_(d.shape == (2, 20, 20))
|
||||
assert_array_equal(c[0][0, :], -np.ones(10, 'd'))
|
||||
assert_array_equal(c[1][:, 0], -2*np.ones(10, 'd'))
|
||||
assert_array_almost_equal(c[0][-1, :], np.ones(10, 'd'), 11)
|
||||
assert_array_almost_equal(c[1][:, -1], 2*np.ones(10, 'd'), 11)
|
||||
assert_array_almost_equal(d[0, 1, :] - d[0, 0, :],
|
||||
0.1*np.ones(20, 'd'), 11)
|
||||
assert_array_almost_equal(d[1, :, 1] - d[1, :, 0],
|
||||
0.2*np.ones(20, 'd'), 11)
|
||||
|
||||
def test_sparse(self):
|
||||
grid_full = mgrid[-1:1:10j, -2:2:10j]
|
||||
grid_sparse = ogrid[-1:1:10j, -2:2:10j]
|
||||
|
||||
# sparse grids can be made dense by broadcasting
|
||||
grid_broadcast = np.broadcast_arrays(*grid_sparse)
|
||||
for f, b in zip(grid_full, grid_broadcast):
|
||||
assert_equal(f, b)
|
||||
|
||||
@pytest.mark.parametrize("start, stop, step, expected", [
|
||||
(None, 10, 10j, (200, 10)),
|
||||
(-10, 20, None, (1800, 30)),
|
||||
])
|
||||
def test_mgrid_size_none_handling(self, start, stop, step, expected):
|
||||
# regression test None value handling for
|
||||
# start and step values used by mgrid;
|
||||
# internally, this aims to cover previously
|
||||
# unexplored code paths in nd_grid()
|
||||
grid = mgrid[start:stop:step, start:stop:step]
|
||||
# need a smaller grid to explore one of the
|
||||
# untested code paths
|
||||
grid_small = mgrid[start:stop:step]
|
||||
assert_equal(grid.size, expected[0])
|
||||
assert_equal(grid_small.size, expected[1])
|
||||
|
||||
def test_accepts_npfloating(self):
|
||||
# regression test for #16466
|
||||
grid64 = mgrid[0.1:0.33:0.1, ]
|
||||
grid32 = mgrid[np.float32(0.1):np.float32(0.33):np.float32(0.1), ]
|
||||
assert_(grid32.dtype == np.float64)
|
||||
assert_array_almost_equal(grid64, grid32)
|
||||
|
||||
# different code path for single slice
|
||||
grid64 = mgrid[0.1:0.33:0.1]
|
||||
grid32 = mgrid[np.float32(0.1):np.float32(0.33):np.float32(0.1)]
|
||||
assert_(grid32.dtype == np.float64)
|
||||
assert_array_almost_equal(grid64, grid32)
|
||||
|
||||
def test_accepts_longdouble(self):
|
||||
# regression tests for #16945
|
||||
grid64 = mgrid[0.1:0.33:0.1, ]
|
||||
grid128 = mgrid[
|
||||
np.longdouble(0.1):np.longdouble(0.33):np.longdouble(0.1),
|
||||
]
|
||||
assert_(grid128.dtype == np.longdouble)
|
||||
assert_array_almost_equal(grid64, grid128)
|
||||
|
||||
grid128c_a = mgrid[0:np.longdouble(1):3.4j]
|
||||
grid128c_b = mgrid[0:np.longdouble(1):3.4j, ]
|
||||
assert_(grid128c_a.dtype == grid128c_b.dtype == np.longdouble)
|
||||
assert_array_equal(grid128c_a, grid128c_b[0])
|
||||
|
||||
# different code path for single slice
|
||||
grid64 = mgrid[0.1:0.33:0.1]
|
||||
grid128 = mgrid[
|
||||
np.longdouble(0.1):np.longdouble(0.33):np.longdouble(0.1)
|
||||
]
|
||||
assert_(grid128.dtype == np.longdouble)
|
||||
assert_array_almost_equal(grid64, grid128)
|
||||
|
||||
def test_accepts_npcomplexfloating(self):
|
||||
# Related to #16466
|
||||
assert_array_almost_equal(
|
||||
mgrid[0.1:0.3:3j, ], mgrid[0.1:0.3:np.complex64(3j), ]
|
||||
)
|
||||
|
||||
# different code path for single slice
|
||||
assert_array_almost_equal(
|
||||
mgrid[0.1:0.3:3j], mgrid[0.1:0.3:np.complex64(3j)]
|
||||
)
|
||||
|
||||
# Related to #16945
|
||||
grid64_a = mgrid[0.1:0.3:3.3j]
|
||||
grid64_b = mgrid[0.1:0.3:3.3j, ][0]
|
||||
assert_(grid64_a.dtype == grid64_b.dtype == np.float64)
|
||||
assert_array_equal(grid64_a, grid64_b)
|
||||
|
||||
grid128_a = mgrid[0.1:0.3:np.clongdouble(3.3j)]
|
||||
grid128_b = mgrid[0.1:0.3:np.clongdouble(3.3j), ][0]
|
||||
assert_(grid128_a.dtype == grid128_b.dtype == np.longdouble)
|
||||
assert_array_equal(grid64_a, grid64_b)
|
||||
|
||||
|
||||
class TestConcatenator:
|
||||
def test_1d(self):
|
||||
assert_array_equal(r_[1, 2, 3, 4, 5, 6], np.array([1, 2, 3, 4, 5, 6]))
|
||||
b = np.ones(5)
|
||||
c = r_[b, 0, 0, b]
|
||||
assert_array_equal(c, [1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
|
||||
|
||||
def test_mixed_type(self):
|
||||
g = r_[10.1, 1:10]
|
||||
assert_(g.dtype == 'f8')
|
||||
|
||||
def test_more_mixed_type(self):
|
||||
g = r_[-10.1, np.array([1]), np.array([2, 3, 4]), 10.0]
|
||||
assert_(g.dtype == 'f8')
|
||||
|
||||
def test_complex_step(self):
|
||||
# Regression test for #12262
|
||||
g = r_[0:36:100j]
|
||||
assert_(g.shape == (100,))
|
||||
|
||||
# Related to #16466
|
||||
g = r_[0:36:np.complex64(100j)]
|
||||
assert_(g.shape == (100,))
|
||||
|
||||
def test_2d(self):
|
||||
b = np.random.rand(5, 5)
|
||||
c = np.random.rand(5, 5)
|
||||
d = r_['1', b, c] # append columns
|
||||
assert_(d.shape == (5, 10))
|
||||
assert_array_equal(d[:, :5], b)
|
||||
assert_array_equal(d[:, 5:], c)
|
||||
d = r_[b, c]
|
||||
assert_(d.shape == (10, 5))
|
||||
assert_array_equal(d[:5, :], b)
|
||||
assert_array_equal(d[5:, :], c)
|
||||
|
||||
def test_0d(self):
|
||||
assert_equal(r_[0, np.array(1), 2], [0, 1, 2])
|
||||
assert_equal(r_[[0, 1, 2], np.array(3)], [0, 1, 2, 3])
|
||||
assert_equal(r_[np.array(0), [1, 2, 3]], [0, 1, 2, 3])
|
||||
|
||||
|
||||
class TestNdenumerate:
|
||||
def test_basic(self):
|
||||
a = np.array([[1, 2], [3, 4]])
|
||||
assert_equal(list(ndenumerate(a)),
|
||||
[((0, 0), 1), ((0, 1), 2), ((1, 0), 3), ((1, 1), 4)])
|
||||
|
||||
|
||||
class TestIndexExpression:
|
||||
def test_regression_1(self):
|
||||
# ticket #1196
|
||||
a = np.arange(2)
|
||||
assert_equal(a[:-1], a[s_[:-1]])
|
||||
assert_equal(a[:-1], a[index_exp[:-1]])
|
||||
|
||||
def test_simple_1(self):
|
||||
a = np.random.rand(4, 5, 6)
|
||||
|
||||
assert_equal(a[:, :3, [1, 2]], a[index_exp[:, :3, [1, 2]]])
|
||||
assert_equal(a[:, :3, [1, 2]], a[s_[:, :3, [1, 2]]])
|
||||
|
||||
|
||||
class TestIx_:
|
||||
def test_regression_1(self):
|
||||
# Test empty untyped inputs create outputs of indexing type, gh-5804
|
||||
a, = np.ix_(range(0))
|
||||
assert_equal(a.dtype, np.intp)
|
||||
|
||||
a, = np.ix_([])
|
||||
assert_equal(a.dtype, np.intp)
|
||||
|
||||
# but if the type is specified, don't change it
|
||||
a, = np.ix_(np.array([], dtype=np.float32))
|
||||
assert_equal(a.dtype, np.float32)
|
||||
|
||||
def test_shape_and_dtype(self):
|
||||
sizes = (4, 5, 3, 2)
|
||||
# Test both lists and arrays
|
||||
for func in (range, np.arange):
|
||||
arrays = np.ix_(*[func(sz) for sz in sizes])
|
||||
for k, (a, sz) in enumerate(zip(arrays, sizes)):
|
||||
assert_equal(a.shape[k], sz)
|
||||
assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
|
||||
assert_(np.issubdtype(a.dtype, np.integer))
|
||||
|
||||
def test_bool(self):
|
||||
bool_a = [True, False, True, True]
|
||||
int_a, = np.nonzero(bool_a)
|
||||
assert_equal(np.ix_(bool_a)[0], int_a)
|
||||
|
||||
def test_1d_only(self):
|
||||
idx2d = [[1, 2, 3], [4, 5, 6]]
|
||||
assert_raises(ValueError, np.ix_, idx2d)
|
||||
|
||||
def test_repeated_input(self):
|
||||
length_of_vector = 5
|
||||
x = np.arange(length_of_vector)
|
||||
out = ix_(x, x)
|
||||
assert_equal(out[0].shape, (length_of_vector, 1))
|
||||
assert_equal(out[1].shape, (1, length_of_vector))
|
||||
# check that input shape is not modified
|
||||
assert_equal(x.shape, (length_of_vector,))
|
||||
|
||||
|
||||
def test_c_():
|
||||
a = np.c_[np.array([[1, 2, 3]]), 0, 0, np.array([[4, 5, 6]])]
|
||||
assert_equal(a, [[1, 2, 3, 0, 0, 4, 5, 6]])
|
||||
|
||||
|
||||
class TestFillDiagonal:
|
||||
def test_basic(self):
|
||||
a = np.zeros((3, 3), int)
|
||||
fill_diagonal(a, 5)
|
||||
assert_array_equal(
|
||||
a, np.array([[5, 0, 0],
|
||||
[0, 5, 0],
|
||||
[0, 0, 5]])
|
||||
)
|
||||
|
||||
def test_tall_matrix(self):
|
||||
a = np.zeros((10, 3), int)
|
||||
fill_diagonal(a, 5)
|
||||
assert_array_equal(
|
||||
a, np.array([[5, 0, 0],
|
||||
[0, 5, 0],
|
||||
[0, 0, 5],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0]])
|
||||
)
|
||||
|
||||
def test_tall_matrix_wrap(self):
|
||||
a = np.zeros((10, 3), int)
|
||||
fill_diagonal(a, 5, True)
|
||||
assert_array_equal(
|
||||
a, np.array([[5, 0, 0],
|
||||
[0, 5, 0],
|
||||
[0, 0, 5],
|
||||
[0, 0, 0],
|
||||
[5, 0, 0],
|
||||
[0, 5, 0],
|
||||
[0, 0, 5],
|
||||
[0, 0, 0],
|
||||
[5, 0, 0],
|
||||
[0, 5, 0]])
|
||||
)
|
||||
|
||||
def test_wide_matrix(self):
|
||||
a = np.zeros((3, 10), int)
|
||||
fill_diagonal(a, 5)
|
||||
assert_array_equal(
|
||||
a, np.array([[5, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[0, 5, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 5, 0, 0, 0, 0, 0, 0, 0]])
|
||||
)
|
||||
|
||||
def test_operate_4d_array(self):
|
||||
a = np.zeros((3, 3, 3, 3), int)
|
||||
fill_diagonal(a, 4)
|
||||
i = np.array([0, 1, 2])
|
||||
assert_equal(np.where(a != 0), (i, i, i, i))
|
||||
|
||||
def test_low_dim_handling(self):
|
||||
# raise error with low dimensionality
|
||||
a = np.zeros(3, int)
|
||||
with assert_raises_regex(ValueError, "at least 2-d"):
|
||||
fill_diagonal(a, 5)
|
||||
|
||||
def test_hetero_shape_handling(self):
|
||||
# raise error with high dimensionality and
|
||||
# shape mismatch
|
||||
a = np.zeros((3,3,7,3), int)
|
||||
with assert_raises_regex(ValueError, "equal length"):
|
||||
fill_diagonal(a, 2)
|
||||
|
||||
|
||||
def test_diag_indices():
|
||||
di = diag_indices(4)
|
||||
a = np.array([[1, 2, 3, 4],
|
||||
[5, 6, 7, 8],
|
||||
[9, 10, 11, 12],
|
||||
[13, 14, 15, 16]])
|
||||
a[di] = 100
|
||||
assert_array_equal(
|
||||
a, np.array([[100, 2, 3, 4],
|
||||
[5, 100, 7, 8],
|
||||
[9, 10, 100, 12],
|
||||
[13, 14, 15, 100]])
|
||||
)
|
||||
|
||||
# Now, we create indices to manipulate a 3-d array:
|
||||
d3 = diag_indices(2, 3)
|
||||
|
||||
# And use it to set the diagonal of a zeros array to 1:
|
||||
a = np.zeros((2, 2, 2), int)
|
||||
a[d3] = 1
|
||||
assert_array_equal(
|
||||
a, np.array([[[1, 0],
|
||||
[0, 0]],
|
||||
[[0, 0],
|
||||
[0, 1]]])
|
||||
)
|
||||
|
||||
|
||||
class TestDiagIndicesFrom:
|
||||
|
||||
def test_diag_indices_from(self):
|
||||
x = np.random.random((4, 4))
|
||||
r, c = diag_indices_from(x)
|
||||
assert_array_equal(r, np.arange(4))
|
||||
assert_array_equal(c, np.arange(4))
|
||||
|
||||
def test_error_small_input(self):
|
||||
x = np.ones(7)
|
||||
with assert_raises_regex(ValueError, "at least 2-d"):
|
||||
diag_indices_from(x)
|
||||
|
||||
def test_error_shape_mismatch(self):
|
||||
x = np.zeros((3, 3, 2, 3), int)
|
||||
with assert_raises_regex(ValueError, "equal length"):
|
||||
diag_indices_from(x)
|
||||
|
||||
|
||||
def test_ndindex():
|
||||
x = list(ndindex(1, 2, 3))
|
||||
expected = [ix for ix, e in ndenumerate(np.zeros((1, 2, 3)))]
|
||||
assert_array_equal(x, expected)
|
||||
|
||||
x = list(ndindex((1, 2, 3)))
|
||||
assert_array_equal(x, expected)
|
||||
|
||||
# Test use of scalars and tuples
|
||||
x = list(ndindex((3,)))
|
||||
assert_array_equal(x, list(ndindex(3)))
|
||||
|
||||
# Make sure size argument is optional
|
||||
x = list(ndindex())
|
||||
assert_equal(x, [()])
|
||||
|
||||
x = list(ndindex(()))
|
||||
assert_equal(x, [()])
|
||||
|
||||
# Make sure 0-sized ndindex works correctly
|
||||
x = list(ndindex(*[0]))
|
||||
assert_equal(x, [])
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,216 @@
|
||||
import numbers
|
||||
import operator
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_, assert_equal, assert_raises
|
||||
|
||||
|
||||
# NOTE: This class should be kept as an exact copy of the example from the
|
||||
# docstring for NDArrayOperatorsMixin.
|
||||
|
||||
class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
|
||||
def __init__(self, value):
|
||||
self.value = np.asarray(value)
|
||||
|
||||
# One might also consider adding the built-in list type to this
|
||||
# list, to support operations like np.add(array_like, list)
|
||||
_HANDLED_TYPES = (np.ndarray, numbers.Number)
|
||||
|
||||
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
|
||||
out = kwargs.get('out', ())
|
||||
for x in inputs + out:
|
||||
# Only support operations with instances of _HANDLED_TYPES.
|
||||
# Use ArrayLike instead of type(self) for isinstance to
|
||||
# allow subclasses that don't override __array_ufunc__ to
|
||||
# handle ArrayLike objects.
|
||||
if not isinstance(x, self._HANDLED_TYPES + (ArrayLike,)):
|
||||
return NotImplemented
|
||||
|
||||
# Defer to the implementation of the ufunc on unwrapped values.
|
||||
inputs = tuple(x.value if isinstance(x, ArrayLike) else x
|
||||
for x in inputs)
|
||||
if out:
|
||||
kwargs['out'] = tuple(
|
||||
x.value if isinstance(x, ArrayLike) else x
|
||||
for x in out)
|
||||
result = getattr(ufunc, method)(*inputs, **kwargs)
|
||||
|
||||
if type(result) is tuple:
|
||||
# multiple return values
|
||||
return tuple(type(self)(x) for x in result)
|
||||
elif method == 'at':
|
||||
# no return value
|
||||
return None
|
||||
else:
|
||||
# one return value
|
||||
return type(self)(result)
|
||||
|
||||
def __repr__(self):
|
||||
return '%s(%r)' % (type(self).__name__, self.value)
|
||||
|
||||
|
||||
def wrap_array_like(result):
|
||||
if type(result) is tuple:
|
||||
return tuple(ArrayLike(r) for r in result)
|
||||
else:
|
||||
return ArrayLike(result)
|
||||
|
||||
|
||||
def _assert_equal_type_and_value(result, expected, err_msg=None):
|
||||
assert_equal(type(result), type(expected), err_msg=err_msg)
|
||||
if isinstance(result, tuple):
|
||||
assert_equal(len(result), len(expected), err_msg=err_msg)
|
||||
for result_item, expected_item in zip(result, expected):
|
||||
_assert_equal_type_and_value(result_item, expected_item, err_msg)
|
||||
else:
|
||||
assert_equal(result.value, expected.value, err_msg=err_msg)
|
||||
assert_equal(getattr(result.value, 'dtype', None),
|
||||
getattr(expected.value, 'dtype', None), err_msg=err_msg)
|
||||
|
||||
|
||||
_ALL_BINARY_OPERATORS = [
|
||||
operator.lt,
|
||||
operator.le,
|
||||
operator.eq,
|
||||
operator.ne,
|
||||
operator.gt,
|
||||
operator.ge,
|
||||
operator.add,
|
||||
operator.sub,
|
||||
operator.mul,
|
||||
operator.truediv,
|
||||
operator.floordiv,
|
||||
operator.mod,
|
||||
divmod,
|
||||
pow,
|
||||
operator.lshift,
|
||||
operator.rshift,
|
||||
operator.and_,
|
||||
operator.xor,
|
||||
operator.or_,
|
||||
]
|
||||
|
||||
|
||||
class TestNDArrayOperatorsMixin:
|
||||
|
||||
def test_array_like_add(self):
|
||||
|
||||
def check(result):
|
||||
_assert_equal_type_and_value(result, ArrayLike(0))
|
||||
|
||||
check(ArrayLike(0) + 0)
|
||||
check(0 + ArrayLike(0))
|
||||
|
||||
check(ArrayLike(0) + np.array(0))
|
||||
check(np.array(0) + ArrayLike(0))
|
||||
|
||||
check(ArrayLike(np.array(0)) + 0)
|
||||
check(0 + ArrayLike(np.array(0)))
|
||||
|
||||
check(ArrayLike(np.array(0)) + np.array(0))
|
||||
check(np.array(0) + ArrayLike(np.array(0)))
|
||||
|
||||
def test_inplace(self):
|
||||
array_like = ArrayLike(np.array([0]))
|
||||
array_like += 1
|
||||
_assert_equal_type_and_value(array_like, ArrayLike(np.array([1])))
|
||||
|
||||
array = np.array([0])
|
||||
array += ArrayLike(1)
|
||||
_assert_equal_type_and_value(array, ArrayLike(np.array([1])))
|
||||
|
||||
def test_opt_out(self):
|
||||
|
||||
class OptOut:
|
||||
"""Object that opts out of __array_ufunc__."""
|
||||
__array_ufunc__ = None
|
||||
|
||||
def __add__(self, other):
|
||||
return self
|
||||
|
||||
def __radd__(self, other):
|
||||
return self
|
||||
|
||||
array_like = ArrayLike(1)
|
||||
opt_out = OptOut()
|
||||
|
||||
# supported operations
|
||||
assert_(array_like + opt_out is opt_out)
|
||||
assert_(opt_out + array_like is opt_out)
|
||||
|
||||
# not supported
|
||||
with assert_raises(TypeError):
|
||||
# don't use the Python default, array_like = array_like + opt_out
|
||||
array_like += opt_out
|
||||
with assert_raises(TypeError):
|
||||
array_like - opt_out
|
||||
with assert_raises(TypeError):
|
||||
opt_out - array_like
|
||||
|
||||
def test_subclass(self):
|
||||
|
||||
class SubArrayLike(ArrayLike):
|
||||
"""Should take precedence over ArrayLike."""
|
||||
|
||||
x = ArrayLike(0)
|
||||
y = SubArrayLike(1)
|
||||
_assert_equal_type_and_value(x + y, y)
|
||||
_assert_equal_type_and_value(y + x, y)
|
||||
|
||||
def test_object(self):
|
||||
x = ArrayLike(0)
|
||||
obj = object()
|
||||
with assert_raises(TypeError):
|
||||
x + obj
|
||||
with assert_raises(TypeError):
|
||||
obj + x
|
||||
with assert_raises(TypeError):
|
||||
x += obj
|
||||
|
||||
def test_unary_methods(self):
|
||||
array = np.array([-1, 0, 1, 2])
|
||||
array_like = ArrayLike(array)
|
||||
for op in [operator.neg,
|
||||
operator.pos,
|
||||
abs,
|
||||
operator.invert]:
|
||||
_assert_equal_type_and_value(op(array_like), ArrayLike(op(array)))
|
||||
|
||||
def test_forward_binary_methods(self):
|
||||
array = np.array([-1, 0, 1, 2])
|
||||
array_like = ArrayLike(array)
|
||||
for op in _ALL_BINARY_OPERATORS:
|
||||
expected = wrap_array_like(op(array, 1))
|
||||
actual = op(array_like, 1)
|
||||
err_msg = 'failed for operator {}'.format(op)
|
||||
_assert_equal_type_and_value(expected, actual, err_msg=err_msg)
|
||||
|
||||
def test_reflected_binary_methods(self):
|
||||
for op in _ALL_BINARY_OPERATORS:
|
||||
expected = wrap_array_like(op(2, 1))
|
||||
actual = op(2, ArrayLike(1))
|
||||
err_msg = 'failed for operator {}'.format(op)
|
||||
_assert_equal_type_and_value(expected, actual, err_msg=err_msg)
|
||||
|
||||
def test_matmul(self):
|
||||
array = np.array([1, 2], dtype=np.float64)
|
||||
array_like = ArrayLike(array)
|
||||
expected = ArrayLike(np.float64(5))
|
||||
_assert_equal_type_and_value(expected, np.matmul(array_like, array))
|
||||
_assert_equal_type_and_value(
|
||||
expected, operator.matmul(array_like, array))
|
||||
_assert_equal_type_and_value(
|
||||
expected, operator.matmul(array, array_like))
|
||||
|
||||
def test_ufunc_at(self):
|
||||
array = ArrayLike(np.array([1, 2, 3, 4]))
|
||||
assert_(np.negative.at(array, np.array([0, 1])) is None)
|
||||
_assert_equal_type_and_value(array, ArrayLike([-1, -2, 3, 4]))
|
||||
|
||||
def test_ufunc_two_outputs(self):
|
||||
mantissa, exponent = np.frexp(2 ** -3)
|
||||
expected = (ArrayLike(mantissa), ArrayLike(exponent))
|
||||
_assert_equal_type_and_value(
|
||||
np.frexp(ArrayLike(2 ** -3)), expected)
|
||||
_assert_equal_type_and_value(
|
||||
np.frexp(ArrayLike(np.array(2 ** -3))), expected)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,376 @@
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_equal, assert_equal, assert_raises
|
||||
import pytest
|
||||
from itertools import chain
|
||||
|
||||
def test_packbits():
|
||||
# Copied from the docstring.
|
||||
a = [[[1, 0, 1], [0, 1, 0]],
|
||||
[[1, 1, 0], [0, 0, 1]]]
|
||||
for dt in '?bBhHiIlLqQ':
|
||||
arr = np.array(a, dtype=dt)
|
||||
b = np.packbits(arr, axis=-1)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
|
||||
|
||||
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
|
||||
|
||||
|
||||
def test_packbits_empty():
|
||||
shapes = [
|
||||
(0,), (10, 20, 0), (10, 0, 20), (0, 10, 20), (20, 0, 0), (0, 20, 0),
|
||||
(0, 0, 20), (0, 0, 0),
|
||||
]
|
||||
for dt in '?bBhHiIlLqQ':
|
||||
for shape in shapes:
|
||||
a = np.empty(shape, dtype=dt)
|
||||
b = np.packbits(a)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_equal(b.shape, (0,))
|
||||
|
||||
|
||||
def test_packbits_empty_with_axis():
|
||||
# Original shapes and lists of packed shapes for different axes.
|
||||
shapes = [
|
||||
((0,), [(0,)]),
|
||||
((10, 20, 0), [(2, 20, 0), (10, 3, 0), (10, 20, 0)]),
|
||||
((10, 0, 20), [(2, 0, 20), (10, 0, 20), (10, 0, 3)]),
|
||||
((0, 10, 20), [(0, 10, 20), (0, 2, 20), (0, 10, 3)]),
|
||||
((20, 0, 0), [(3, 0, 0), (20, 0, 0), (20, 0, 0)]),
|
||||
((0, 20, 0), [(0, 20, 0), (0, 3, 0), (0, 20, 0)]),
|
||||
((0, 0, 20), [(0, 0, 20), (0, 0, 20), (0, 0, 3)]),
|
||||
((0, 0, 0), [(0, 0, 0), (0, 0, 0), (0, 0, 0)]),
|
||||
]
|
||||
for dt in '?bBhHiIlLqQ':
|
||||
for in_shape, out_shapes in shapes:
|
||||
for ax, out_shape in enumerate(out_shapes):
|
||||
a = np.empty(in_shape, dtype=dt)
|
||||
b = np.packbits(a, axis=ax)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_equal(b.shape, out_shape)
|
||||
|
||||
@pytest.mark.parametrize('bitorder', ('little', 'big'))
|
||||
def test_packbits_large(bitorder):
|
||||
# test data large enough for 16 byte vectorization
|
||||
a = np.array([1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0,
|
||||
0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1,
|
||||
1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,
|
||||
1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1,
|
||||
1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1,
|
||||
1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1,
|
||||
1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1,
|
||||
0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0,
|
||||
1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1,
|
||||
1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0,
|
||||
0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1,
|
||||
1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0,
|
||||
1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0,
|
||||
1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0])
|
||||
a = a.repeat(3)
|
||||
for dtype in '?bBhHiIlLqQ':
|
||||
arr = np.array(a, dtype=dtype)
|
||||
b = np.packbits(arr, axis=None, bitorder=bitorder)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
r = [252, 127, 192, 3, 254, 7, 252, 0, 7, 31, 240, 0, 28, 1, 255, 252,
|
||||
113, 248, 3, 255, 192, 28, 15, 192, 28, 126, 0, 224, 127, 255,
|
||||
227, 142, 7, 31, 142, 63, 28, 126, 56, 227, 240, 0, 227, 128, 63,
|
||||
224, 14, 56, 252, 112, 56, 255, 241, 248, 3, 240, 56, 224, 112,
|
||||
63, 255, 255, 199, 224, 14, 0, 31, 143, 192, 3, 255, 199, 0, 1,
|
||||
255, 224, 1, 255, 252, 126, 63, 0, 1, 192, 252, 14, 63, 0, 15,
|
||||
199, 252, 113, 255, 3, 128, 56, 252, 14, 7, 0, 113, 255, 255, 142, 56, 227,
|
||||
129, 248, 227, 129, 199, 31, 128]
|
||||
if bitorder == 'big':
|
||||
assert_array_equal(b, r)
|
||||
# equal for size being multiple of 8
|
||||
assert_array_equal(np.unpackbits(b, bitorder=bitorder)[:-4], a)
|
||||
|
||||
# check last byte of different remainders (16 byte vectorization)
|
||||
b = [np.packbits(arr[:-i], axis=None)[-1] for i in range(1, 16)]
|
||||
assert_array_equal(b, [128, 128, 128, 31, 30, 28, 24, 16, 0, 0, 0, 199,
|
||||
198, 196, 192])
|
||||
|
||||
|
||||
arr = arr.reshape(36, 25)
|
||||
b = np.packbits(arr, axis=0)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, [[190, 186, 178, 178, 150, 215, 87, 83, 83, 195,
|
||||
199, 206, 204, 204, 140, 140, 136, 136, 8, 40, 105,
|
||||
107, 75, 74, 88],
|
||||
[72, 216, 248, 241, 227, 195, 202, 90, 90, 83,
|
||||
83, 119, 127, 109, 73, 64, 208, 244, 189, 45,
|
||||
41, 104, 122, 90, 18],
|
||||
[113, 120, 248, 216, 152, 24, 60, 52, 182, 150,
|
||||
150, 150, 146, 210, 210, 246, 255, 255, 223,
|
||||
151, 21, 17, 17, 131, 163],
|
||||
[214, 210, 210, 64, 68, 5, 5, 1, 72, 88, 92,
|
||||
92, 78, 110, 39, 181, 149, 220, 222, 218, 218,
|
||||
202, 234, 170, 168],
|
||||
[0, 128, 128, 192, 80, 112, 48, 160, 160, 224,
|
||||
240, 208, 144, 128, 160, 224, 240, 208, 144,
|
||||
144, 176, 240, 224, 192, 128]])
|
||||
|
||||
b = np.packbits(arr, axis=1)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, [[252, 127, 192, 0],
|
||||
[ 7, 252, 15, 128],
|
||||
[240, 0, 28, 0],
|
||||
[255, 128, 0, 128],
|
||||
[192, 31, 255, 128],
|
||||
[142, 63, 0, 0],
|
||||
[255, 240, 7, 0],
|
||||
[ 7, 224, 14, 0],
|
||||
[126, 0, 224, 0],
|
||||
[255, 255, 199, 0],
|
||||
[ 56, 28, 126, 0],
|
||||
[113, 248, 227, 128],
|
||||
[227, 142, 63, 0],
|
||||
[ 0, 28, 112, 0],
|
||||
[ 15, 248, 3, 128],
|
||||
[ 28, 126, 56, 0],
|
||||
[ 56, 255, 241, 128],
|
||||
[240, 7, 224, 0],
|
||||
[227, 129, 192, 128],
|
||||
[255, 255, 254, 0],
|
||||
[126, 0, 224, 0],
|
||||
[ 3, 241, 248, 0],
|
||||
[ 0, 255, 241, 128],
|
||||
[128, 0, 255, 128],
|
||||
[224, 1, 255, 128],
|
||||
[248, 252, 126, 0],
|
||||
[ 0, 7, 3, 128],
|
||||
[224, 113, 248, 0],
|
||||
[ 0, 252, 127, 128],
|
||||
[142, 63, 224, 0],
|
||||
[224, 14, 63, 0],
|
||||
[ 7, 3, 128, 0],
|
||||
[113, 255, 255, 128],
|
||||
[ 28, 113, 199, 0],
|
||||
[ 7, 227, 142, 0],
|
||||
[ 14, 56, 252, 0]])
|
||||
|
||||
arr = arr.T.copy()
|
||||
b = np.packbits(arr, axis=0)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, [[252, 7, 240, 255, 192, 142, 255, 7, 126, 255,
|
||||
56, 113, 227, 0, 15, 28, 56, 240, 227, 255,
|
||||
126, 3, 0, 128, 224, 248, 0, 224, 0, 142, 224,
|
||||
7, 113, 28, 7, 14],
|
||||
[127, 252, 0, 128, 31, 63, 240, 224, 0, 255,
|
||||
28, 248, 142, 28, 248, 126, 255, 7, 129, 255,
|
||||
0, 241, 255, 0, 1, 252, 7, 113, 252, 63, 14,
|
||||
3, 255, 113, 227, 56],
|
||||
[192, 15, 28, 0, 255, 0, 7, 14, 224, 199, 126,
|
||||
227, 63, 112, 3, 56, 241, 224, 192, 254, 224,
|
||||
248, 241, 255, 255, 126, 3, 248, 127, 224, 63,
|
||||
128, 255, 199, 142, 252],
|
||||
[0, 128, 0, 128, 128, 0, 0, 0, 0, 0, 0, 128, 0,
|
||||
0, 128, 0, 128, 0, 128, 0, 0, 0, 128, 128,
|
||||
128, 0, 128, 0, 128, 0, 0, 0, 128, 0, 0, 0]])
|
||||
|
||||
b = np.packbits(arr, axis=1)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, [[190, 72, 113, 214, 0],
|
||||
[186, 216, 120, 210, 128],
|
||||
[178, 248, 248, 210, 128],
|
||||
[178, 241, 216, 64, 192],
|
||||
[150, 227, 152, 68, 80],
|
||||
[215, 195, 24, 5, 112],
|
||||
[ 87, 202, 60, 5, 48],
|
||||
[ 83, 90, 52, 1, 160],
|
||||
[ 83, 90, 182, 72, 160],
|
||||
[195, 83, 150, 88, 224],
|
||||
[199, 83, 150, 92, 240],
|
||||
[206, 119, 150, 92, 208],
|
||||
[204, 127, 146, 78, 144],
|
||||
[204, 109, 210, 110, 128],
|
||||
[140, 73, 210, 39, 160],
|
||||
[140, 64, 246, 181, 224],
|
||||
[136, 208, 255, 149, 240],
|
||||
[136, 244, 255, 220, 208],
|
||||
[ 8, 189, 223, 222, 144],
|
||||
[ 40, 45, 151, 218, 144],
|
||||
[105, 41, 21, 218, 176],
|
||||
[107, 104, 17, 202, 240],
|
||||
[ 75, 122, 17, 234, 224],
|
||||
[ 74, 90, 131, 170, 192],
|
||||
[ 88, 18, 163, 168, 128]])
|
||||
|
||||
|
||||
# result is the same if input is multiplied with a nonzero value
|
||||
for dtype in 'bBhHiIlLqQ':
|
||||
arr = np.array(a, dtype=dtype)
|
||||
rnd = np.random.randint(low=np.iinfo(dtype).min,
|
||||
high=np.iinfo(dtype).max, size=arr.size,
|
||||
dtype=dtype)
|
||||
rnd[rnd == 0] = 1
|
||||
arr *= rnd.astype(dtype)
|
||||
b = np.packbits(arr, axis=-1)
|
||||
assert_array_equal(np.unpackbits(b)[:-4], a)
|
||||
|
||||
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
|
||||
|
||||
|
||||
def test_packbits_very_large():
|
||||
# test some with a larger arrays gh-8637
|
||||
# code is covered earlier but larger array makes crash on bug more likely
|
||||
for s in range(950, 1050):
|
||||
for dt in '?bBhHiIlLqQ':
|
||||
x = np.ones((200, s), dtype=bool)
|
||||
np.packbits(x, axis=1)
|
||||
|
||||
|
||||
def test_unpackbits():
|
||||
# Copied from the docstring.
|
||||
a = np.array([[2], [7], [23]], dtype=np.uint8)
|
||||
b = np.unpackbits(a, axis=1)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
|
||||
[0, 0, 0, 0, 0, 1, 1, 1],
|
||||
[0, 0, 0, 1, 0, 1, 1, 1]]))
|
||||
|
||||
def test_pack_unpack_order():
|
||||
a = np.array([[2], [7], [23]], dtype=np.uint8)
|
||||
b = np.unpackbits(a, axis=1)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
b_little = np.unpackbits(a, axis=1, bitorder='little')
|
||||
b_big = np.unpackbits(a, axis=1, bitorder='big')
|
||||
assert_array_equal(b, b_big)
|
||||
assert_array_equal(a, np.packbits(b_little, axis=1, bitorder='little'))
|
||||
assert_array_equal(b[:,::-1], b_little)
|
||||
assert_array_equal(a, np.packbits(b_big, axis=1, bitorder='big'))
|
||||
assert_raises(ValueError, np.unpackbits, a, bitorder='r')
|
||||
assert_raises(TypeError, np.unpackbits, a, bitorder=10)
|
||||
|
||||
|
||||
|
||||
def test_unpackbits_empty():
|
||||
a = np.empty((0,), dtype=np.uint8)
|
||||
b = np.unpackbits(a)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_array_equal(b, np.empty((0,)))
|
||||
|
||||
|
||||
def test_unpackbits_empty_with_axis():
|
||||
# Lists of packed shapes for different axes and unpacked shapes.
|
||||
shapes = [
|
||||
([(0,)], (0,)),
|
||||
([(2, 24, 0), (16, 3, 0), (16, 24, 0)], (16, 24, 0)),
|
||||
([(2, 0, 24), (16, 0, 24), (16, 0, 3)], (16, 0, 24)),
|
||||
([(0, 16, 24), (0, 2, 24), (0, 16, 3)], (0, 16, 24)),
|
||||
([(3, 0, 0), (24, 0, 0), (24, 0, 0)], (24, 0, 0)),
|
||||
([(0, 24, 0), (0, 3, 0), (0, 24, 0)], (0, 24, 0)),
|
||||
([(0, 0, 24), (0, 0, 24), (0, 0, 3)], (0, 0, 24)),
|
||||
([(0, 0, 0), (0, 0, 0), (0, 0, 0)], (0, 0, 0)),
|
||||
]
|
||||
for in_shapes, out_shape in shapes:
|
||||
for ax, in_shape in enumerate(in_shapes):
|
||||
a = np.empty(in_shape, dtype=np.uint8)
|
||||
b = np.unpackbits(a, axis=ax)
|
||||
assert_equal(b.dtype, np.uint8)
|
||||
assert_equal(b.shape, out_shape)
|
||||
|
||||
|
||||
def test_unpackbits_large():
|
||||
# test all possible numbers via comparison to already tested packbits
|
||||
d = np.arange(277, dtype=np.uint8)
|
||||
assert_array_equal(np.packbits(np.unpackbits(d)), d)
|
||||
assert_array_equal(np.packbits(np.unpackbits(d[::2])), d[::2])
|
||||
d = np.tile(d, (3, 1))
|
||||
assert_array_equal(np.packbits(np.unpackbits(d, axis=1), axis=1), d)
|
||||
d = d.T.copy()
|
||||
assert_array_equal(np.packbits(np.unpackbits(d, axis=0), axis=0), d)
|
||||
|
||||
|
||||
class TestCount():
|
||||
x = np.array([
|
||||
[1, 0, 1, 0, 0, 1, 0],
|
||||
[0, 1, 1, 1, 0, 0, 0],
|
||||
[0, 0, 1, 0, 0, 1, 1],
|
||||
[1, 1, 0, 0, 0, 1, 1],
|
||||
[1, 0, 1, 0, 1, 0, 1],
|
||||
[0, 0, 1, 1, 1, 0, 0],
|
||||
[0, 1, 0, 1, 0, 1, 0],
|
||||
], dtype=np.uint8)
|
||||
padded1 = np.zeros(57, dtype=np.uint8)
|
||||
padded1[:49] = x.ravel()
|
||||
padded1b = np.zeros(57, dtype=np.uint8)
|
||||
padded1b[:49] = x[::-1].copy().ravel()
|
||||
padded2 = np.zeros((9, 9), dtype=np.uint8)
|
||||
padded2[:7, :7] = x
|
||||
|
||||
@pytest.mark.parametrize('bitorder', ('little', 'big'))
|
||||
@pytest.mark.parametrize('count', chain(range(58), range(-1, -57, -1)))
|
||||
def test_roundtrip(self, bitorder, count):
|
||||
if count < 0:
|
||||
# one extra zero of padding
|
||||
cutoff = count - 1
|
||||
else:
|
||||
cutoff = count
|
||||
# test complete invertibility of packbits and unpackbits with count
|
||||
packed = np.packbits(self.x, bitorder=bitorder)
|
||||
unpacked = np.unpackbits(packed, count=count, bitorder=bitorder)
|
||||
assert_equal(unpacked.dtype, np.uint8)
|
||||
assert_array_equal(unpacked, self.padded1[:cutoff])
|
||||
|
||||
@pytest.mark.parametrize('kwargs', [
|
||||
{}, {'count': None},
|
||||
])
|
||||
def test_count(self, kwargs):
|
||||
packed = np.packbits(self.x)
|
||||
unpacked = np.unpackbits(packed, **kwargs)
|
||||
assert_equal(unpacked.dtype, np.uint8)
|
||||
assert_array_equal(unpacked, self.padded1[:-1])
|
||||
|
||||
@pytest.mark.parametrize('bitorder', ('little', 'big'))
|
||||
# delta==-1 when count<0 because one extra zero of padding
|
||||
@pytest.mark.parametrize('count', chain(range(8), range(-1, -9, -1)))
|
||||
def test_roundtrip_axis(self, bitorder, count):
|
||||
if count < 0:
|
||||
# one extra zero of padding
|
||||
cutoff = count - 1
|
||||
else:
|
||||
cutoff = count
|
||||
packed0 = np.packbits(self.x, axis=0, bitorder=bitorder)
|
||||
unpacked0 = np.unpackbits(packed0, axis=0, count=count,
|
||||
bitorder=bitorder)
|
||||
assert_equal(unpacked0.dtype, np.uint8)
|
||||
assert_array_equal(unpacked0, self.padded2[:cutoff, :self.x.shape[1]])
|
||||
|
||||
packed1 = np.packbits(self.x, axis=1, bitorder=bitorder)
|
||||
unpacked1 = np.unpackbits(packed1, axis=1, count=count,
|
||||
bitorder=bitorder)
|
||||
assert_equal(unpacked1.dtype, np.uint8)
|
||||
assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :cutoff])
|
||||
|
||||
@pytest.mark.parametrize('kwargs', [
|
||||
{}, {'count': None},
|
||||
{'bitorder' : 'little'},
|
||||
{'bitorder': 'little', 'count': None},
|
||||
{'bitorder' : 'big'},
|
||||
{'bitorder': 'big', 'count': None},
|
||||
])
|
||||
def test_axis_count(self, kwargs):
|
||||
packed0 = np.packbits(self.x, axis=0)
|
||||
unpacked0 = np.unpackbits(packed0, axis=0, **kwargs)
|
||||
assert_equal(unpacked0.dtype, np.uint8)
|
||||
if kwargs.get('bitorder', 'big') == 'big':
|
||||
assert_array_equal(unpacked0, self.padded2[:-1, :self.x.shape[1]])
|
||||
else:
|
||||
assert_array_equal(unpacked0[::-1, :], self.padded2[:-1, :self.x.shape[1]])
|
||||
|
||||
packed1 = np.packbits(self.x, axis=1)
|
||||
unpacked1 = np.unpackbits(packed1, axis=1, **kwargs)
|
||||
assert_equal(unpacked1.dtype, np.uint8)
|
||||
if kwargs.get('bitorder', 'big') == 'big':
|
||||
assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :-1])
|
||||
else:
|
||||
assert_array_equal(unpacked1[:, ::-1], self.padded2[:self.x.shape[0], :-1])
|
||||
|
||||
def test_bad_count(self):
|
||||
packed0 = np.packbits(self.x, axis=0)
|
||||
assert_raises(ValueError, np.unpackbits, packed0, axis=0, count=-9)
|
||||
packed1 = np.packbits(self.x, axis=1)
|
||||
assert_raises(ValueError, np.unpackbits, packed1, axis=1, count=-9)
|
||||
packed = np.packbits(self.x)
|
||||
assert_raises(ValueError, np.unpackbits, packed, count=-57)
|
||||
@@ -0,0 +1,303 @@
|
||||
import numpy as np
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_almost_equal,
|
||||
assert_array_almost_equal, assert_raises, assert_allclose
|
||||
)
|
||||
|
||||
import pytest
|
||||
|
||||
# `poly1d` has some support for `bool_` and `timedelta64`,
|
||||
# but it is limited and they are therefore excluded here
|
||||
TYPE_CODES = np.typecodes["AllInteger"] + np.typecodes["AllFloat"] + "O"
|
||||
|
||||
|
||||
class TestPolynomial:
|
||||
def test_poly1d_str_and_repr(self):
|
||||
p = np.poly1d([1., 2, 3])
|
||||
assert_equal(repr(p), 'poly1d([1., 2., 3.])')
|
||||
assert_equal(str(p),
|
||||
' 2\n'
|
||||
'1 x + 2 x + 3')
|
||||
|
||||
q = np.poly1d([3., 2, 1])
|
||||
assert_equal(repr(q), 'poly1d([3., 2., 1.])')
|
||||
assert_equal(str(q),
|
||||
' 2\n'
|
||||
'3 x + 2 x + 1')
|
||||
|
||||
r = np.poly1d([1.89999 + 2j, -3j, -5.12345678, 2 + 1j])
|
||||
assert_equal(str(r),
|
||||
' 3 2\n'
|
||||
'(1.9 + 2j) x - 3j x - 5.123 x + (2 + 1j)')
|
||||
|
||||
assert_equal(str(np.poly1d([-3, -2, -1])),
|
||||
' 2\n'
|
||||
'-3 x - 2 x - 1')
|
||||
|
||||
def test_poly1d_resolution(self):
|
||||
p = np.poly1d([1., 2, 3])
|
||||
q = np.poly1d([3., 2, 1])
|
||||
assert_equal(p(0), 3.0)
|
||||
assert_equal(p(5), 38.0)
|
||||
assert_equal(q(0), 1.0)
|
||||
assert_equal(q(5), 86.0)
|
||||
|
||||
def test_poly1d_math(self):
|
||||
# here we use some simple coeffs to make calculations easier
|
||||
p = np.poly1d([1., 2, 4])
|
||||
q = np.poly1d([4., 2, 1])
|
||||
assert_equal(p/q, (np.poly1d([0.25]), np.poly1d([1.5, 3.75])))
|
||||
assert_equal(p.integ(), np.poly1d([1/3, 1., 4., 0.]))
|
||||
assert_equal(p.integ(1), np.poly1d([1/3, 1., 4., 0.]))
|
||||
|
||||
p = np.poly1d([1., 2, 3])
|
||||
q = np.poly1d([3., 2, 1])
|
||||
assert_equal(p * q, np.poly1d([3., 8., 14., 8., 3.]))
|
||||
assert_equal(p + q, np.poly1d([4., 4., 4.]))
|
||||
assert_equal(p - q, np.poly1d([-2., 0., 2.]))
|
||||
assert_equal(p ** 4, np.poly1d([1., 8., 36., 104., 214., 312., 324., 216., 81.]))
|
||||
assert_equal(p(q), np.poly1d([9., 12., 16., 8., 6.]))
|
||||
assert_equal(q(p), np.poly1d([3., 12., 32., 40., 34.]))
|
||||
assert_equal(p.deriv(), np.poly1d([2., 2.]))
|
||||
assert_equal(p.deriv(2), np.poly1d([2.]))
|
||||
assert_equal(np.polydiv(np.poly1d([1, 0, -1]), np.poly1d([1, 1])),
|
||||
(np.poly1d([1., -1.]), np.poly1d([0.])))
|
||||
|
||||
@pytest.mark.parametrize("type_code", TYPE_CODES)
|
||||
def test_poly1d_misc(self, type_code: str) -> None:
|
||||
dtype = np.dtype(type_code)
|
||||
ar = np.array([1, 2, 3], dtype=dtype)
|
||||
p = np.poly1d(ar)
|
||||
|
||||
# `__eq__`
|
||||
assert_equal(np.asarray(p), ar)
|
||||
assert_equal(np.asarray(p).dtype, dtype)
|
||||
assert_equal(len(p), 2)
|
||||
|
||||
# `__getitem__`
|
||||
comparison_dct = {-1: 0, 0: 3, 1: 2, 2: 1, 3: 0}
|
||||
for index, ref in comparison_dct.items():
|
||||
scalar = p[index]
|
||||
assert_equal(scalar, ref)
|
||||
if dtype == np.object_:
|
||||
assert isinstance(scalar, int)
|
||||
else:
|
||||
assert_equal(scalar.dtype, dtype)
|
||||
|
||||
def test_poly1d_variable_arg(self):
|
||||
q = np.poly1d([1., 2, 3], variable='y')
|
||||
assert_equal(str(q),
|
||||
' 2\n'
|
||||
'1 y + 2 y + 3')
|
||||
q = np.poly1d([1., 2, 3], variable='lambda')
|
||||
assert_equal(str(q),
|
||||
' 2\n'
|
||||
'1 lambda + 2 lambda + 3')
|
||||
|
||||
def test_poly(self):
|
||||
assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]),
|
||||
[1, -3, -2, 6])
|
||||
|
||||
# From matlab docs
|
||||
A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
|
||||
assert_array_almost_equal(np.poly(A), [1, -6, -72, -27])
|
||||
|
||||
# Should produce real output for perfect conjugates
|
||||
assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j])))
|
||||
assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j,
|
||||
1-2j, 1.+3.5j, 1-3.5j])))
|
||||
assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j])))
|
||||
assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j])))
|
||||
assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j])))
|
||||
assert_(np.isrealobj(np.poly([1j, -1j])))
|
||||
assert_(np.isrealobj(np.poly([1, -1])))
|
||||
|
||||
assert_(np.iscomplexobj(np.poly([1j, -1.0000001j])))
|
||||
|
||||
np.random.seed(42)
|
||||
a = np.random.randn(100) + 1j*np.random.randn(100)
|
||||
assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
|
||||
|
||||
def test_roots(self):
|
||||
assert_array_equal(np.roots([1, 0, 0]), [0, 0])
|
||||
|
||||
def test_str_leading_zeros(self):
|
||||
p = np.poly1d([4, 3, 2, 1])
|
||||
p[3] = 0
|
||||
assert_equal(str(p),
|
||||
" 2\n"
|
||||
"3 x + 2 x + 1")
|
||||
|
||||
p = np.poly1d([1, 2])
|
||||
p[0] = 0
|
||||
p[1] = 0
|
||||
assert_equal(str(p), " \n0")
|
||||
|
||||
def test_polyfit(self):
|
||||
c = np.array([3., 2., 1.])
|
||||
x = np.linspace(0, 2, 7)
|
||||
y = np.polyval(c, x)
|
||||
err = [1, -1, 1, -1, 1, -1, 1]
|
||||
weights = np.arange(8, 1, -1)**2/7.0
|
||||
|
||||
# Check exception when too few points for variance estimate. Note that
|
||||
# the estimate requires the number of data points to exceed
|
||||
# degree + 1
|
||||
assert_raises(ValueError, np.polyfit,
|
||||
[1], [1], deg=0, cov=True)
|
||||
|
||||
# check 1D case
|
||||
m, cov = np.polyfit(x, y+err, 2, cov=True)
|
||||
est = [3.8571, 0.2857, 1.619]
|
||||
assert_almost_equal(est, m, decimal=4)
|
||||
val0 = [[ 1.4694, -2.9388, 0.8163],
|
||||
[-2.9388, 6.3673, -2.1224],
|
||||
[ 0.8163, -2.1224, 1.161 ]]
|
||||
assert_almost_equal(val0, cov, decimal=4)
|
||||
|
||||
m2, cov2 = np.polyfit(x, y+err, 2, w=weights, cov=True)
|
||||
assert_almost_equal([4.8927, -1.0177, 1.7768], m2, decimal=4)
|
||||
val = [[ 4.3964, -5.0052, 0.4878],
|
||||
[-5.0052, 6.8067, -0.9089],
|
||||
[ 0.4878, -0.9089, 0.3337]]
|
||||
assert_almost_equal(val, cov2, decimal=4)
|
||||
|
||||
m3, cov3 = np.polyfit(x, y+err, 2, w=weights, cov="unscaled")
|
||||
assert_almost_equal([4.8927, -1.0177, 1.7768], m3, decimal=4)
|
||||
val = [[ 0.1473, -0.1677, 0.0163],
|
||||
[-0.1677, 0.228 , -0.0304],
|
||||
[ 0.0163, -0.0304, 0.0112]]
|
||||
assert_almost_equal(val, cov3, decimal=4)
|
||||
|
||||
# check 2D (n,1) case
|
||||
y = y[:, np.newaxis]
|
||||
c = c[:, np.newaxis]
|
||||
assert_almost_equal(c, np.polyfit(x, y, 2))
|
||||
# check 2D (n,2) case
|
||||
yy = np.concatenate((y, y), axis=1)
|
||||
cc = np.concatenate((c, c), axis=1)
|
||||
assert_almost_equal(cc, np.polyfit(x, yy, 2))
|
||||
|
||||
m, cov = np.polyfit(x, yy + np.array(err)[:, np.newaxis], 2, cov=True)
|
||||
assert_almost_equal(est, m[:, 0], decimal=4)
|
||||
assert_almost_equal(est, m[:, 1], decimal=4)
|
||||
assert_almost_equal(val0, cov[:, :, 0], decimal=4)
|
||||
assert_almost_equal(val0, cov[:, :, 1], decimal=4)
|
||||
|
||||
# check order 1 (deg=0) case, were the analytic results are simple
|
||||
np.random.seed(123)
|
||||
y = np.random.normal(size=(4, 10000))
|
||||
mean, cov = np.polyfit(np.zeros(y.shape[0]), y, deg=0, cov=True)
|
||||
# Should get sigma_mean = sigma/sqrt(N) = 1./sqrt(4) = 0.5.
|
||||
assert_allclose(mean.std(), 0.5, atol=0.01)
|
||||
assert_allclose(np.sqrt(cov.mean()), 0.5, atol=0.01)
|
||||
# Without scaling, since reduced chi2 is 1, the result should be the same.
|
||||
mean, cov = np.polyfit(np.zeros(y.shape[0]), y, w=np.ones(y.shape[0]),
|
||||
deg=0, cov="unscaled")
|
||||
assert_allclose(mean.std(), 0.5, atol=0.01)
|
||||
assert_almost_equal(np.sqrt(cov.mean()), 0.5)
|
||||
# If we estimate our errors wrong, no change with scaling:
|
||||
w = np.full(y.shape[0], 1./0.5)
|
||||
mean, cov = np.polyfit(np.zeros(y.shape[0]), y, w=w, deg=0, cov=True)
|
||||
assert_allclose(mean.std(), 0.5, atol=0.01)
|
||||
assert_allclose(np.sqrt(cov.mean()), 0.5, atol=0.01)
|
||||
# But if we do not scale, our estimate for the error in the mean will
|
||||
# differ.
|
||||
mean, cov = np.polyfit(np.zeros(y.shape[0]), y, w=w, deg=0, cov="unscaled")
|
||||
assert_allclose(mean.std(), 0.5, atol=0.01)
|
||||
assert_almost_equal(np.sqrt(cov.mean()), 0.25)
|
||||
|
||||
def test_objects(self):
|
||||
from decimal import Decimal
|
||||
p = np.poly1d([Decimal('4.0'), Decimal('3.0'), Decimal('2.0')])
|
||||
p2 = p * Decimal('1.333333333333333')
|
||||
assert_(p2[1] == Decimal("3.9999999999999990"))
|
||||
p2 = p.deriv()
|
||||
assert_(p2[1] == Decimal('8.0'))
|
||||
p2 = p.integ()
|
||||
assert_(p2[3] == Decimal("1.333333333333333333333333333"))
|
||||
assert_(p2[2] == Decimal('1.5'))
|
||||
assert_(np.issubdtype(p2.coeffs.dtype, np.object_))
|
||||
p = np.poly([Decimal(1), Decimal(2)])
|
||||
assert_equal(np.poly([Decimal(1), Decimal(2)]),
|
||||
[1, Decimal(-3), Decimal(2)])
|
||||
|
||||
def test_complex(self):
|
||||
p = np.poly1d([3j, 2j, 1j])
|
||||
p2 = p.integ()
|
||||
assert_((p2.coeffs == [1j, 1j, 1j, 0]).all())
|
||||
p2 = p.deriv()
|
||||
assert_((p2.coeffs == [6j, 2j]).all())
|
||||
|
||||
def test_integ_coeffs(self):
|
||||
p = np.poly1d([3, 2, 1])
|
||||
p2 = p.integ(3, k=[9, 7, 6])
|
||||
assert_(
|
||||
(p2.coeffs == [1/4./5., 1/3./4., 1/2./3., 9/1./2., 7, 6]).all())
|
||||
|
||||
def test_zero_dims(self):
|
||||
try:
|
||||
np.poly(np.zeros((0, 0)))
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def test_poly_int_overflow(self):
|
||||
"""
|
||||
Regression test for gh-5096.
|
||||
"""
|
||||
v = np.arange(1, 21)
|
||||
assert_almost_equal(np.poly(v), np.poly(np.diag(v)))
|
||||
|
||||
def test_zero_poly_dtype(self):
|
||||
"""
|
||||
Regression test for gh-16354.
|
||||
"""
|
||||
z = np.array([0, 0, 0])
|
||||
p = np.poly1d(z.astype(np.int64))
|
||||
assert_equal(p.coeffs.dtype, np.int64)
|
||||
|
||||
p = np.poly1d(z.astype(np.float32))
|
||||
assert_equal(p.coeffs.dtype, np.float32)
|
||||
|
||||
p = np.poly1d(z.astype(np.complex64))
|
||||
assert_equal(p.coeffs.dtype, np.complex64)
|
||||
|
||||
def test_poly_eq(self):
|
||||
p = np.poly1d([1, 2, 3])
|
||||
p2 = np.poly1d([1, 2, 4])
|
||||
assert_equal(p == None, False)
|
||||
assert_equal(p != None, True)
|
||||
assert_equal(p == p, True)
|
||||
assert_equal(p == p2, False)
|
||||
assert_equal(p != p2, True)
|
||||
|
||||
def test_polydiv(self):
|
||||
b = np.poly1d([2, 6, 6, 1])
|
||||
a = np.poly1d([-1j, (1+2j), -(2+1j), 1])
|
||||
q, r = np.polydiv(b, a)
|
||||
assert_equal(q.coeffs.dtype, np.complex128)
|
||||
assert_equal(r.coeffs.dtype, np.complex128)
|
||||
assert_equal(q*a + r, b)
|
||||
|
||||
c = [1, 2, 3]
|
||||
d = np.poly1d([1, 2, 3])
|
||||
s, t = np.polydiv(c, d)
|
||||
assert isinstance(s, np.poly1d)
|
||||
assert isinstance(t, np.poly1d)
|
||||
u, v = np.polydiv(d, c)
|
||||
assert isinstance(u, np.poly1d)
|
||||
assert isinstance(v, np.poly1d)
|
||||
|
||||
def test_poly_coeffs_mutable(self):
|
||||
""" Coefficients should be modifiable """
|
||||
p = np.poly1d([1, 2, 3])
|
||||
|
||||
p.coeffs += 1
|
||||
assert_equal(p.coeffs, [2, 3, 4])
|
||||
|
||||
p.coeffs[2] += 10
|
||||
assert_equal(p.coeffs, [2, 3, 14])
|
||||
|
||||
# this never used to be allowed - let's not add features to deprecated
|
||||
# APIs
|
||||
assert_raises(AttributeError, setattr, p, 'coeffs', np.array(1))
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,247 @@
|
||||
import os
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_array_almost_equal,
|
||||
assert_raises, _assert_valid_refcount,
|
||||
)
|
||||
|
||||
|
||||
class TestRegression:
|
||||
def test_poly1d(self):
|
||||
# Ticket #28
|
||||
assert_equal(np.poly1d([1]) - np.poly1d([1, 0]),
|
||||
np.poly1d([-1, 1]))
|
||||
|
||||
def test_cov_parameters(self):
|
||||
# Ticket #91
|
||||
x = np.random.random((3, 3))
|
||||
y = x.copy()
|
||||
np.cov(x, rowvar=True)
|
||||
np.cov(y, rowvar=False)
|
||||
assert_array_equal(x, y)
|
||||
|
||||
def test_mem_digitize(self):
|
||||
# Ticket #95
|
||||
for i in range(100):
|
||||
np.digitize([1, 2, 3, 4], [1, 3])
|
||||
np.digitize([0, 1, 2, 3, 4], [1, 3])
|
||||
|
||||
def test_unique_zero_sized(self):
|
||||
# Ticket #205
|
||||
assert_array_equal([], np.unique(np.array([])))
|
||||
|
||||
def test_mem_vectorise(self):
|
||||
# Ticket #325
|
||||
vt = np.vectorize(lambda *args: args)
|
||||
vt(np.zeros((1, 2, 1)), np.zeros((2, 1, 1)), np.zeros((1, 1, 2)))
|
||||
vt(np.zeros((1, 2, 1)), np.zeros((2, 1, 1)), np.zeros((1,
|
||||
1, 2)), np.zeros((2, 2)))
|
||||
|
||||
def test_mgrid_single_element(self):
|
||||
# Ticket #339
|
||||
assert_array_equal(np.mgrid[0:0:1j], [0])
|
||||
assert_array_equal(np.mgrid[0:0], [])
|
||||
|
||||
def test_refcount_vectorize(self):
|
||||
# Ticket #378
|
||||
def p(x, y):
|
||||
return 123
|
||||
v = np.vectorize(p)
|
||||
_assert_valid_refcount(v)
|
||||
|
||||
def test_poly1d_nan_roots(self):
|
||||
# Ticket #396
|
||||
p = np.poly1d([np.nan, np.nan, 1], r=False)
|
||||
assert_raises(np.linalg.LinAlgError, getattr, p, "r")
|
||||
|
||||
def test_mem_polymul(self):
|
||||
# Ticket #448
|
||||
np.polymul([], [1.])
|
||||
|
||||
def test_mem_string_concat(self):
|
||||
# Ticket #469
|
||||
x = np.array([])
|
||||
np.append(x, 'asdasd\tasdasd')
|
||||
|
||||
def test_poly_div(self):
|
||||
# Ticket #553
|
||||
u = np.poly1d([1, 2, 3])
|
||||
v = np.poly1d([1, 2, 3, 4, 5])
|
||||
q, r = np.polydiv(u, v)
|
||||
assert_equal(q*v + r, u)
|
||||
|
||||
def test_poly_eq(self):
|
||||
# Ticket #554
|
||||
x = np.poly1d([1, 2, 3])
|
||||
y = np.poly1d([3, 4])
|
||||
assert_(x != y)
|
||||
assert_(x == x)
|
||||
|
||||
def test_polyfit_build(self):
|
||||
# Ticket #628
|
||||
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
|
||||
9.95368241e+00, -3.14526520e+02]
|
||||
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
|
||||
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
|
||||
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
|
||||
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
|
||||
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
|
||||
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
|
||||
170, 171, 172, 173, 174, 175, 176]
|
||||
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
|
||||
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
|
||||
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
|
||||
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
|
||||
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
|
||||
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
|
||||
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
|
||||
tested = np.polyfit(x, y, 4)
|
||||
assert_array_almost_equal(ref, tested)
|
||||
|
||||
def test_polydiv_type(self):
|
||||
# Make polydiv work for complex types
|
||||
msg = "Wrong type, should be complex"
|
||||
x = np.ones(3, dtype=complex)
|
||||
q, r = np.polydiv(x, x)
|
||||
assert_(q.dtype == complex, msg)
|
||||
msg = "Wrong type, should be float"
|
||||
x = np.ones(3, dtype=int)
|
||||
q, r = np.polydiv(x, x)
|
||||
assert_(q.dtype == float, msg)
|
||||
|
||||
def test_histogramdd_too_many_bins(self):
|
||||
# Ticket 928.
|
||||
assert_raises(ValueError, np.histogramdd, np.ones((1, 10)), bins=2**10)
|
||||
|
||||
def test_polyint_type(self):
|
||||
# Ticket #944
|
||||
msg = "Wrong type, should be complex"
|
||||
x = np.ones(3, dtype=complex)
|
||||
assert_(np.polyint(x).dtype == complex, msg)
|
||||
msg = "Wrong type, should be float"
|
||||
x = np.ones(3, dtype=int)
|
||||
assert_(np.polyint(x).dtype == float, msg)
|
||||
|
||||
def test_ndenumerate_crash(self):
|
||||
# Ticket 1140
|
||||
# Shouldn't crash:
|
||||
list(np.ndenumerate(np.array([[]])))
|
||||
|
||||
def test_asfarray_none(self):
|
||||
# Test for changeset r5065
|
||||
assert_array_equal(np.array([np.nan]), np.asfarray([None]))
|
||||
|
||||
def test_large_fancy_indexing(self):
|
||||
# Large enough to fail on 64-bit.
|
||||
nbits = np.dtype(np.intp).itemsize * 8
|
||||
thesize = int((2**nbits)**(1.0/5.0)+1)
|
||||
|
||||
def dp():
|
||||
n = 3
|
||||
a = np.ones((n,)*5)
|
||||
i = np.random.randint(0, n, size=thesize)
|
||||
a[np.ix_(i, i, i, i, i)] = 0
|
||||
|
||||
def dp2():
|
||||
n = 3
|
||||
a = np.ones((n,)*5)
|
||||
i = np.random.randint(0, n, size=thesize)
|
||||
a[np.ix_(i, i, i, i, i)]
|
||||
|
||||
assert_raises(ValueError, dp)
|
||||
assert_raises(ValueError, dp2)
|
||||
|
||||
def test_void_coercion(self):
|
||||
dt = np.dtype([('a', 'f4'), ('b', 'i4')])
|
||||
x = np.zeros((1,), dt)
|
||||
assert_(np.r_[x, x].dtype == dt)
|
||||
|
||||
def test_who_with_0dim_array(self):
|
||||
# ticket #1243
|
||||
import os
|
||||
import sys
|
||||
|
||||
oldstdout = sys.stdout
|
||||
sys.stdout = open(os.devnull, 'w')
|
||||
try:
|
||||
try:
|
||||
np.who({'foo': np.array(1)})
|
||||
except Exception:
|
||||
raise AssertionError("ticket #1243")
|
||||
finally:
|
||||
sys.stdout.close()
|
||||
sys.stdout = oldstdout
|
||||
|
||||
def test_include_dirs(self):
|
||||
# As a sanity check, just test that get_include
|
||||
# includes something reasonable. Somewhat
|
||||
# related to ticket #1405.
|
||||
include_dirs = [np.get_include()]
|
||||
for path in include_dirs:
|
||||
assert_(isinstance(path, str))
|
||||
assert_(path != '')
|
||||
|
||||
def test_polyder_return_type(self):
|
||||
# Ticket #1249
|
||||
assert_(isinstance(np.polyder(np.poly1d([1]), 0), np.poly1d))
|
||||
assert_(isinstance(np.polyder([1], 0), np.ndarray))
|
||||
assert_(isinstance(np.polyder(np.poly1d([1]), 1), np.poly1d))
|
||||
assert_(isinstance(np.polyder([1], 1), np.ndarray))
|
||||
|
||||
def test_append_fields_dtype_list(self):
|
||||
# Ticket #1676
|
||||
from numpy.lib.recfunctions import append_fields
|
||||
|
||||
base = np.array([1, 2, 3], dtype=np.int32)
|
||||
names = ['a', 'b', 'c']
|
||||
data = np.eye(3).astype(np.int32)
|
||||
dlist = [np.float64, np.int32, np.int32]
|
||||
try:
|
||||
append_fields(base, names, data, dlist)
|
||||
except Exception:
|
||||
raise AssertionError()
|
||||
|
||||
def test_loadtxt_fields_subarrays(self):
|
||||
# For ticket #1936
|
||||
from io import StringIO
|
||||
|
||||
dt = [("a", 'u1', 2), ("b", 'u1', 2)]
|
||||
x = np.loadtxt(StringIO("0 1 2 3"), dtype=dt)
|
||||
assert_equal(x, np.array([((0, 1), (2, 3))], dtype=dt))
|
||||
|
||||
dt = [("a", [("a", 'u1', (1, 3)), ("b", 'u1')])]
|
||||
x = np.loadtxt(StringIO("0 1 2 3"), dtype=dt)
|
||||
assert_equal(x, np.array([(((0, 1, 2), 3),)], dtype=dt))
|
||||
|
||||
dt = [("a", 'u1', (2, 2))]
|
||||
x = np.loadtxt(StringIO("0 1 2 3"), dtype=dt)
|
||||
assert_equal(x, np.array([(((0, 1), (2, 3)),)], dtype=dt))
|
||||
|
||||
dt = [("a", 'u1', (2, 3, 2))]
|
||||
x = np.loadtxt(StringIO("0 1 2 3 4 5 6 7 8 9 10 11"), dtype=dt)
|
||||
data = [((((0, 1), (2, 3), (4, 5)), ((6, 7), (8, 9), (10, 11))),)]
|
||||
assert_equal(x, np.array(data, dtype=dt))
|
||||
|
||||
def test_nansum_with_boolean(self):
|
||||
# gh-2978
|
||||
a = np.zeros(2, dtype=bool)
|
||||
try:
|
||||
np.nansum(a)
|
||||
except Exception:
|
||||
raise AssertionError()
|
||||
|
||||
def test_py3_compat(self):
|
||||
# gh-2561
|
||||
# Test if the oldstyle class test is bypassed in python3
|
||||
class C():
|
||||
"""Old-style class in python2, normal class in python3"""
|
||||
pass
|
||||
|
||||
out = open(os.devnull, 'w')
|
||||
try:
|
||||
np.info(C(), output=out)
|
||||
except AttributeError:
|
||||
raise AssertionError()
|
||||
finally:
|
||||
out.close()
|
||||
@@ -0,0 +1,787 @@
|
||||
import numpy as np
|
||||
import functools
|
||||
import sys
|
||||
import pytest
|
||||
|
||||
from numpy.lib.shape_base import (
|
||||
apply_along_axis, apply_over_axes, array_split, split, hsplit, dsplit,
|
||||
vsplit, dstack, column_stack, kron, tile, expand_dims, take_along_axis,
|
||||
put_along_axis
|
||||
)
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_raises, assert_warns
|
||||
)
|
||||
|
||||
|
||||
IS_64BIT = sys.maxsize > 2**32
|
||||
|
||||
|
||||
def _add_keepdims(func):
|
||||
""" hack in keepdims behavior into a function taking an axis """
|
||||
@functools.wraps(func)
|
||||
def wrapped(a, axis, **kwargs):
|
||||
res = func(a, axis=axis, **kwargs)
|
||||
if axis is None:
|
||||
axis = 0 # res is now a scalar, so we can insert this anywhere
|
||||
return np.expand_dims(res, axis=axis)
|
||||
return wrapped
|
||||
|
||||
|
||||
class TestTakeAlongAxis:
|
||||
def test_argequivalent(self):
|
||||
""" Test it translates from arg<func> to <func> """
|
||||
from numpy.random import rand
|
||||
a = rand(3, 4, 5)
|
||||
|
||||
funcs = [
|
||||
(np.sort, np.argsort, dict()),
|
||||
(_add_keepdims(np.min), _add_keepdims(np.argmin), dict()),
|
||||
(_add_keepdims(np.max), _add_keepdims(np.argmax), dict()),
|
||||
(np.partition, np.argpartition, dict(kth=2)),
|
||||
]
|
||||
|
||||
for func, argfunc, kwargs in funcs:
|
||||
for axis in list(range(a.ndim)) + [None]:
|
||||
a_func = func(a, axis=axis, **kwargs)
|
||||
ai_func = argfunc(a, axis=axis, **kwargs)
|
||||
assert_equal(a_func, take_along_axis(a, ai_func, axis=axis))
|
||||
|
||||
def test_invalid(self):
|
||||
""" Test it errors when indices has too few dimensions """
|
||||
a = np.ones((10, 10))
|
||||
ai = np.ones((10, 2), dtype=np.intp)
|
||||
|
||||
# sanity check
|
||||
take_along_axis(a, ai, axis=1)
|
||||
|
||||
# not enough indices
|
||||
assert_raises(ValueError, take_along_axis, a, np.array(1), axis=1)
|
||||
# bool arrays not allowed
|
||||
assert_raises(IndexError, take_along_axis, a, ai.astype(bool), axis=1)
|
||||
# float arrays not allowed
|
||||
assert_raises(IndexError, take_along_axis, a, ai.astype(float), axis=1)
|
||||
# invalid axis
|
||||
assert_raises(np.AxisError, take_along_axis, a, ai, axis=10)
|
||||
|
||||
def test_empty(self):
|
||||
""" Test everything is ok with empty results, even with inserted dims """
|
||||
a = np.ones((3, 4, 5))
|
||||
ai = np.ones((3, 0, 5), dtype=np.intp)
|
||||
|
||||
actual = take_along_axis(a, ai, axis=1)
|
||||
assert_equal(actual.shape, ai.shape)
|
||||
|
||||
def test_broadcast(self):
|
||||
""" Test that non-indexing dimensions are broadcast in both directions """
|
||||
a = np.ones((3, 4, 1))
|
||||
ai = np.ones((1, 2, 5), dtype=np.intp)
|
||||
actual = take_along_axis(a, ai, axis=1)
|
||||
assert_equal(actual.shape, (3, 2, 5))
|
||||
|
||||
|
||||
class TestPutAlongAxis:
|
||||
def test_replace_max(self):
|
||||
a_base = np.array([[10, 30, 20], [60, 40, 50]])
|
||||
|
||||
for axis in list(range(a_base.ndim)) + [None]:
|
||||
# we mutate this in the loop
|
||||
a = a_base.copy()
|
||||
|
||||
# replace the max with a small value
|
||||
i_max = _add_keepdims(np.argmax)(a, axis=axis)
|
||||
put_along_axis(a, i_max, -99, axis=axis)
|
||||
|
||||
# find the new minimum, which should max
|
||||
i_min = _add_keepdims(np.argmin)(a, axis=axis)
|
||||
|
||||
assert_equal(i_min, i_max)
|
||||
|
||||
def test_broadcast(self):
|
||||
""" Test that non-indexing dimensions are broadcast in both directions """
|
||||
a = np.ones((3, 4, 1))
|
||||
ai = np.arange(10, dtype=np.intp).reshape((1, 2, 5)) % 4
|
||||
put_along_axis(a, ai, 20, axis=1)
|
||||
assert_equal(take_along_axis(a, ai, axis=1), 20)
|
||||
|
||||
|
||||
class TestApplyAlongAxis:
|
||||
def test_simple(self):
|
||||
a = np.ones((20, 10), 'd')
|
||||
assert_array_equal(
|
||||
apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
|
||||
|
||||
def test_simple101(self):
|
||||
a = np.ones((10, 101), 'd')
|
||||
assert_array_equal(
|
||||
apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
|
||||
|
||||
def test_3d(self):
|
||||
a = np.arange(27).reshape((3, 3, 3))
|
||||
assert_array_equal(apply_along_axis(np.sum, 0, a),
|
||||
[[27, 30, 33], [36, 39, 42], [45, 48, 51]])
|
||||
|
||||
def test_preserve_subclass(self):
|
||||
def double(row):
|
||||
return row * 2
|
||||
|
||||
class MyNDArray(np.ndarray):
|
||||
pass
|
||||
|
||||
m = np.array([[0, 1], [2, 3]]).view(MyNDArray)
|
||||
expected = np.array([[0, 2], [4, 6]]).view(MyNDArray)
|
||||
|
||||
result = apply_along_axis(double, 0, m)
|
||||
assert_(isinstance(result, MyNDArray))
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
result = apply_along_axis(double, 1, m)
|
||||
assert_(isinstance(result, MyNDArray))
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
def test_subclass(self):
|
||||
class MinimalSubclass(np.ndarray):
|
||||
data = 1
|
||||
|
||||
def minimal_function(array):
|
||||
return array.data
|
||||
|
||||
a = np.zeros((6, 3)).view(MinimalSubclass)
|
||||
|
||||
assert_array_equal(
|
||||
apply_along_axis(minimal_function, 0, a), np.array([1, 1, 1])
|
||||
)
|
||||
|
||||
def test_scalar_array(self, cls=np.ndarray):
|
||||
a = np.ones((6, 3)).view(cls)
|
||||
res = apply_along_axis(np.sum, 0, a)
|
||||
assert_(isinstance(res, cls))
|
||||
assert_array_equal(res, np.array([6, 6, 6]).view(cls))
|
||||
|
||||
def test_0d_array(self, cls=np.ndarray):
|
||||
def sum_to_0d(x):
|
||||
""" Sum x, returning a 0d array of the same class """
|
||||
assert_equal(x.ndim, 1)
|
||||
return np.squeeze(np.sum(x, keepdims=True))
|
||||
a = np.ones((6, 3)).view(cls)
|
||||
res = apply_along_axis(sum_to_0d, 0, a)
|
||||
assert_(isinstance(res, cls))
|
||||
assert_array_equal(res, np.array([6, 6, 6]).view(cls))
|
||||
|
||||
res = apply_along_axis(sum_to_0d, 1, a)
|
||||
assert_(isinstance(res, cls))
|
||||
assert_array_equal(res, np.array([3, 3, 3, 3, 3, 3]).view(cls))
|
||||
|
||||
def test_axis_insertion(self, cls=np.ndarray):
|
||||
def f1to2(x):
|
||||
"""produces an asymmetric non-square matrix from x"""
|
||||
assert_equal(x.ndim, 1)
|
||||
return (x[::-1] * x[1:,None]).view(cls)
|
||||
|
||||
a2d = np.arange(6*3).reshape((6, 3))
|
||||
|
||||
# 2d insertion along first axis
|
||||
actual = apply_along_axis(f1to2, 0, a2d)
|
||||
expected = np.stack([
|
||||
f1to2(a2d[:,i]) for i in range(a2d.shape[1])
|
||||
], axis=-1).view(cls)
|
||||
assert_equal(type(actual), type(expected))
|
||||
assert_equal(actual, expected)
|
||||
|
||||
# 2d insertion along last axis
|
||||
actual = apply_along_axis(f1to2, 1, a2d)
|
||||
expected = np.stack([
|
||||
f1to2(a2d[i,:]) for i in range(a2d.shape[0])
|
||||
], axis=0).view(cls)
|
||||
assert_equal(type(actual), type(expected))
|
||||
assert_equal(actual, expected)
|
||||
|
||||
# 3d insertion along middle axis
|
||||
a3d = np.arange(6*5*3).reshape((6, 5, 3))
|
||||
|
||||
actual = apply_along_axis(f1to2, 1, a3d)
|
||||
expected = np.stack([
|
||||
np.stack([
|
||||
f1to2(a3d[i,:,j]) for i in range(a3d.shape[0])
|
||||
], axis=0)
|
||||
for j in range(a3d.shape[2])
|
||||
], axis=-1).view(cls)
|
||||
assert_equal(type(actual), type(expected))
|
||||
assert_equal(actual, expected)
|
||||
|
||||
def test_subclass_preservation(self):
|
||||
class MinimalSubclass(np.ndarray):
|
||||
pass
|
||||
self.test_scalar_array(MinimalSubclass)
|
||||
self.test_0d_array(MinimalSubclass)
|
||||
self.test_axis_insertion(MinimalSubclass)
|
||||
|
||||
def test_axis_insertion_ma(self):
|
||||
def f1to2(x):
|
||||
"""produces an asymmetric non-square matrix from x"""
|
||||
assert_equal(x.ndim, 1)
|
||||
res = x[::-1] * x[1:,None]
|
||||
return np.ma.masked_where(res%5==0, res)
|
||||
a = np.arange(6*3).reshape((6, 3))
|
||||
res = apply_along_axis(f1to2, 0, a)
|
||||
assert_(isinstance(res, np.ma.masked_array))
|
||||
assert_equal(res.ndim, 3)
|
||||
assert_array_equal(res[:,:,0].mask, f1to2(a[:,0]).mask)
|
||||
assert_array_equal(res[:,:,1].mask, f1to2(a[:,1]).mask)
|
||||
assert_array_equal(res[:,:,2].mask, f1to2(a[:,2]).mask)
|
||||
|
||||
def test_tuple_func1d(self):
|
||||
def sample_1d(x):
|
||||
return x[1], x[0]
|
||||
res = np.apply_along_axis(sample_1d, 1, np.array([[1, 2], [3, 4]]))
|
||||
assert_array_equal(res, np.array([[2, 1], [4, 3]]))
|
||||
|
||||
def test_empty(self):
|
||||
# can't apply_along_axis when there's no chance to call the function
|
||||
def never_call(x):
|
||||
assert_(False) # should never be reached
|
||||
|
||||
a = np.empty((0, 0))
|
||||
assert_raises(ValueError, np.apply_along_axis, never_call, 0, a)
|
||||
assert_raises(ValueError, np.apply_along_axis, never_call, 1, a)
|
||||
|
||||
# but it's sometimes ok with some non-zero dimensions
|
||||
def empty_to_1(x):
|
||||
assert_(len(x) == 0)
|
||||
return 1
|
||||
|
||||
a = np.empty((10, 0))
|
||||
actual = np.apply_along_axis(empty_to_1, 1, a)
|
||||
assert_equal(actual, np.ones(10))
|
||||
assert_raises(ValueError, np.apply_along_axis, empty_to_1, 0, a)
|
||||
|
||||
def test_with_iterable_object(self):
|
||||
# from issue 5248
|
||||
d = np.array([
|
||||
[{1, 11}, {2, 22}, {3, 33}],
|
||||
[{4, 44}, {5, 55}, {6, 66}]
|
||||
])
|
||||
actual = np.apply_along_axis(lambda a: set.union(*a), 0, d)
|
||||
expected = np.array([{1, 11, 4, 44}, {2, 22, 5, 55}, {3, 33, 6, 66}])
|
||||
|
||||
assert_equal(actual, expected)
|
||||
|
||||
# issue 8642 - assert_equal doesn't detect this!
|
||||
for i in np.ndindex(actual.shape):
|
||||
assert_equal(type(actual[i]), type(expected[i]))
|
||||
|
||||
|
||||
class TestApplyOverAxes:
|
||||
def test_simple(self):
|
||||
a = np.arange(24).reshape(2, 3, 4)
|
||||
aoa_a = apply_over_axes(np.sum, a, [0, 2])
|
||||
assert_array_equal(aoa_a, np.array([[[60], [92], [124]]]))
|
||||
|
||||
|
||||
class TestExpandDims:
|
||||
def test_functionality(self):
|
||||
s = (2, 3, 4, 5)
|
||||
a = np.empty(s)
|
||||
for axis in range(-5, 4):
|
||||
b = expand_dims(a, axis)
|
||||
assert_(b.shape[axis] == 1)
|
||||
assert_(np.squeeze(b).shape == s)
|
||||
|
||||
def test_axis_tuple(self):
|
||||
a = np.empty((3, 3, 3))
|
||||
assert np.expand_dims(a, axis=(0, 1, 2)).shape == (1, 1, 1, 3, 3, 3)
|
||||
assert np.expand_dims(a, axis=(0, -1, -2)).shape == (1, 3, 3, 3, 1, 1)
|
||||
assert np.expand_dims(a, axis=(0, 3, 5)).shape == (1, 3, 3, 1, 3, 1)
|
||||
assert np.expand_dims(a, axis=(0, -3, -5)).shape == (1, 1, 3, 1, 3, 3)
|
||||
|
||||
def test_axis_out_of_range(self):
|
||||
s = (2, 3, 4, 5)
|
||||
a = np.empty(s)
|
||||
assert_raises(np.AxisError, expand_dims, a, -6)
|
||||
assert_raises(np.AxisError, expand_dims, a, 5)
|
||||
|
||||
a = np.empty((3, 3, 3))
|
||||
assert_raises(np.AxisError, expand_dims, a, (0, -6))
|
||||
assert_raises(np.AxisError, expand_dims, a, (0, 5))
|
||||
|
||||
def test_repeated_axis(self):
|
||||
a = np.empty((3, 3, 3))
|
||||
assert_raises(ValueError, expand_dims, a, axis=(1, 1))
|
||||
|
||||
def test_subclasses(self):
|
||||
a = np.arange(10).reshape((2, 5))
|
||||
a = np.ma.array(a, mask=a%3 == 0)
|
||||
|
||||
expanded = np.expand_dims(a, axis=1)
|
||||
assert_(isinstance(expanded, np.ma.MaskedArray))
|
||||
assert_equal(expanded.shape, (2, 1, 5))
|
||||
assert_equal(expanded.mask.shape, (2, 1, 5))
|
||||
|
||||
|
||||
class TestArraySplit:
|
||||
def test_integer_0_split(self):
|
||||
a = np.arange(10)
|
||||
assert_raises(ValueError, array_split, a, 0)
|
||||
|
||||
def test_integer_split(self):
|
||||
a = np.arange(10)
|
||||
res = array_split(a, 1)
|
||||
desired = [np.arange(10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 2)
|
||||
desired = [np.arange(5), np.arange(5, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 3)
|
||||
desired = [np.arange(4), np.arange(4, 7), np.arange(7, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 4)
|
||||
desired = [np.arange(3), np.arange(3, 6), np.arange(6, 8),
|
||||
np.arange(8, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 5)
|
||||
desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
|
||||
np.arange(6, 8), np.arange(8, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 6)
|
||||
desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
|
||||
np.arange(6, 8), np.arange(8, 9), np.arange(9, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 7)
|
||||
desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
|
||||
np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
|
||||
np.arange(9, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 8)
|
||||
desired = [np.arange(2), np.arange(2, 4), np.arange(4, 5),
|
||||
np.arange(5, 6), np.arange(6, 7), np.arange(7, 8),
|
||||
np.arange(8, 9), np.arange(9, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 9)
|
||||
desired = [np.arange(2), np.arange(2, 3), np.arange(3, 4),
|
||||
np.arange(4, 5), np.arange(5, 6), np.arange(6, 7),
|
||||
np.arange(7, 8), np.arange(8, 9), np.arange(9, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 10)
|
||||
desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
|
||||
np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
|
||||
np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
|
||||
np.arange(9, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
res = array_split(a, 11)
|
||||
desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
|
||||
np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
|
||||
np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
|
||||
np.arange(9, 10), np.array([])]
|
||||
compare_results(res, desired)
|
||||
|
||||
def test_integer_split_2D_rows(self):
|
||||
a = np.array([np.arange(10), np.arange(10)])
|
||||
res = array_split(a, 3, axis=0)
|
||||
tgt = [np.array([np.arange(10)]), np.array([np.arange(10)]),
|
||||
np.zeros((0, 10))]
|
||||
compare_results(res, tgt)
|
||||
assert_(a.dtype.type is res[-1].dtype.type)
|
||||
|
||||
# Same thing for manual splits:
|
||||
res = array_split(a, [0, 1], axis=0)
|
||||
tgt = [np.zeros((0, 10)), np.array([np.arange(10)]),
|
||||
np.array([np.arange(10)])]
|
||||
compare_results(res, tgt)
|
||||
assert_(a.dtype.type is res[-1].dtype.type)
|
||||
|
||||
def test_integer_split_2D_cols(self):
|
||||
a = np.array([np.arange(10), np.arange(10)])
|
||||
res = array_split(a, 3, axis=-1)
|
||||
desired = [np.array([np.arange(4), np.arange(4)]),
|
||||
np.array([np.arange(4, 7), np.arange(4, 7)]),
|
||||
np.array([np.arange(7, 10), np.arange(7, 10)])]
|
||||
compare_results(res, desired)
|
||||
|
||||
def test_integer_split_2D_default(self):
|
||||
""" This will fail if we change default axis
|
||||
"""
|
||||
a = np.array([np.arange(10), np.arange(10)])
|
||||
res = array_split(a, 3)
|
||||
tgt = [np.array([np.arange(10)]), np.array([np.arange(10)]),
|
||||
np.zeros((0, 10))]
|
||||
compare_results(res, tgt)
|
||||
assert_(a.dtype.type is res[-1].dtype.type)
|
||||
# perhaps should check higher dimensions
|
||||
|
||||
@pytest.mark.skipif(not IS_64BIT, reason="Needs 64bit platform")
|
||||
def test_integer_split_2D_rows_greater_max_int32(self):
|
||||
a = np.broadcast_to([0], (1 << 32, 2))
|
||||
res = array_split(a, 4)
|
||||
chunk = np.broadcast_to([0], (1 << 30, 2))
|
||||
tgt = [chunk] * 4
|
||||
for i in range(len(tgt)):
|
||||
assert_equal(res[i].shape, tgt[i].shape)
|
||||
|
||||
def test_index_split_simple(self):
|
||||
a = np.arange(10)
|
||||
indices = [1, 5, 7]
|
||||
res = array_split(a, indices, axis=-1)
|
||||
desired = [np.arange(0, 1), np.arange(1, 5), np.arange(5, 7),
|
||||
np.arange(7, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
def test_index_split_low_bound(self):
|
||||
a = np.arange(10)
|
||||
indices = [0, 5, 7]
|
||||
res = array_split(a, indices, axis=-1)
|
||||
desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
|
||||
np.arange(7, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
def test_index_split_high_bound(self):
|
||||
a = np.arange(10)
|
||||
indices = [0, 5, 7, 10, 12]
|
||||
res = array_split(a, indices, axis=-1)
|
||||
desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
|
||||
np.arange(7, 10), np.array([]), np.array([])]
|
||||
compare_results(res, desired)
|
||||
|
||||
|
||||
class TestSplit:
|
||||
# The split function is essentially the same as array_split,
|
||||
# except that it test if splitting will result in an
|
||||
# equal split. Only test for this case.
|
||||
|
||||
def test_equal_split(self):
|
||||
a = np.arange(10)
|
||||
res = split(a, 2)
|
||||
desired = [np.arange(5), np.arange(5, 10)]
|
||||
compare_results(res, desired)
|
||||
|
||||
def test_unequal_split(self):
|
||||
a = np.arange(10)
|
||||
assert_raises(ValueError, split, a, 3)
|
||||
|
||||
|
||||
class TestColumnStack:
|
||||
def test_non_iterable(self):
|
||||
assert_raises(TypeError, column_stack, 1)
|
||||
|
||||
def test_1D_arrays(self):
|
||||
# example from docstring
|
||||
a = np.array((1, 2, 3))
|
||||
b = np.array((2, 3, 4))
|
||||
expected = np.array([[1, 2],
|
||||
[2, 3],
|
||||
[3, 4]])
|
||||
actual = np.column_stack((a, b))
|
||||
assert_equal(actual, expected)
|
||||
|
||||
def test_2D_arrays(self):
|
||||
# same as hstack 2D docstring example
|
||||
a = np.array([[1], [2], [3]])
|
||||
b = np.array([[2], [3], [4]])
|
||||
expected = np.array([[1, 2],
|
||||
[2, 3],
|
||||
[3, 4]])
|
||||
actual = np.column_stack((a, b))
|
||||
assert_equal(actual, expected)
|
||||
|
||||
def test_generator(self):
|
||||
with pytest.raises(TypeError, match="arrays to stack must be"):
|
||||
column_stack((np.arange(3) for _ in range(2)))
|
||||
|
||||
|
||||
class TestDstack:
|
||||
def test_non_iterable(self):
|
||||
assert_raises(TypeError, dstack, 1)
|
||||
|
||||
def test_0D_array(self):
|
||||
a = np.array(1)
|
||||
b = np.array(2)
|
||||
res = dstack([a, b])
|
||||
desired = np.array([[[1, 2]]])
|
||||
assert_array_equal(res, desired)
|
||||
|
||||
def test_1D_array(self):
|
||||
a = np.array([1])
|
||||
b = np.array([2])
|
||||
res = dstack([a, b])
|
||||
desired = np.array([[[1, 2]]])
|
||||
assert_array_equal(res, desired)
|
||||
|
||||
def test_2D_array(self):
|
||||
a = np.array([[1], [2]])
|
||||
b = np.array([[1], [2]])
|
||||
res = dstack([a, b])
|
||||
desired = np.array([[[1, 1]], [[2, 2, ]]])
|
||||
assert_array_equal(res, desired)
|
||||
|
||||
def test_2D_array2(self):
|
||||
a = np.array([1, 2])
|
||||
b = np.array([1, 2])
|
||||
res = dstack([a, b])
|
||||
desired = np.array([[[1, 1], [2, 2]]])
|
||||
assert_array_equal(res, desired)
|
||||
|
||||
def test_generator(self):
|
||||
with pytest.raises(TypeError, match="arrays to stack must be"):
|
||||
dstack((np.arange(3) for _ in range(2)))
|
||||
|
||||
|
||||
# array_split has more comprehensive test of splitting.
|
||||
# only do simple test on hsplit, vsplit, and dsplit
|
||||
class TestHsplit:
|
||||
"""Only testing for integer splits.
|
||||
|
||||
"""
|
||||
def test_non_iterable(self):
|
||||
assert_raises(ValueError, hsplit, 1, 1)
|
||||
|
||||
def test_0D_array(self):
|
||||
a = np.array(1)
|
||||
try:
|
||||
hsplit(a, 2)
|
||||
assert_(0)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def test_1D_array(self):
|
||||
a = np.array([1, 2, 3, 4])
|
||||
res = hsplit(a, 2)
|
||||
desired = [np.array([1, 2]), np.array([3, 4])]
|
||||
compare_results(res, desired)
|
||||
|
||||
def test_2D_array(self):
|
||||
a = np.array([[1, 2, 3, 4],
|
||||
[1, 2, 3, 4]])
|
||||
res = hsplit(a, 2)
|
||||
desired = [np.array([[1, 2], [1, 2]]), np.array([[3, 4], [3, 4]])]
|
||||
compare_results(res, desired)
|
||||
|
||||
|
||||
class TestVsplit:
|
||||
"""Only testing for integer splits.
|
||||
|
||||
"""
|
||||
def test_non_iterable(self):
|
||||
assert_raises(ValueError, vsplit, 1, 1)
|
||||
|
||||
def test_0D_array(self):
|
||||
a = np.array(1)
|
||||
assert_raises(ValueError, vsplit, a, 2)
|
||||
|
||||
def test_1D_array(self):
|
||||
a = np.array([1, 2, 3, 4])
|
||||
try:
|
||||
vsplit(a, 2)
|
||||
assert_(0)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def test_2D_array(self):
|
||||
a = np.array([[1, 2, 3, 4],
|
||||
[1, 2, 3, 4]])
|
||||
res = vsplit(a, 2)
|
||||
desired = [np.array([[1, 2, 3, 4]]), np.array([[1, 2, 3, 4]])]
|
||||
compare_results(res, desired)
|
||||
|
||||
|
||||
class TestDsplit:
|
||||
# Only testing for integer splits.
|
||||
def test_non_iterable(self):
|
||||
assert_raises(ValueError, dsplit, 1, 1)
|
||||
|
||||
def test_0D_array(self):
|
||||
a = np.array(1)
|
||||
assert_raises(ValueError, dsplit, a, 2)
|
||||
|
||||
def test_1D_array(self):
|
||||
a = np.array([1, 2, 3, 4])
|
||||
assert_raises(ValueError, dsplit, a, 2)
|
||||
|
||||
def test_2D_array(self):
|
||||
a = np.array([[1, 2, 3, 4],
|
||||
[1, 2, 3, 4]])
|
||||
try:
|
||||
dsplit(a, 2)
|
||||
assert_(0)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def test_3D_array(self):
|
||||
a = np.array([[[1, 2, 3, 4],
|
||||
[1, 2, 3, 4]],
|
||||
[[1, 2, 3, 4],
|
||||
[1, 2, 3, 4]]])
|
||||
res = dsplit(a, 2)
|
||||
desired = [np.array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]),
|
||||
np.array([[[3, 4], [3, 4]], [[3, 4], [3, 4]]])]
|
||||
compare_results(res, desired)
|
||||
|
||||
|
||||
class TestSqueeze:
|
||||
def test_basic(self):
|
||||
from numpy.random import rand
|
||||
|
||||
a = rand(20, 10, 10, 1, 1)
|
||||
b = rand(20, 1, 10, 1, 20)
|
||||
c = rand(1, 1, 20, 10)
|
||||
assert_array_equal(np.squeeze(a), np.reshape(a, (20, 10, 10)))
|
||||
assert_array_equal(np.squeeze(b), np.reshape(b, (20, 10, 20)))
|
||||
assert_array_equal(np.squeeze(c), np.reshape(c, (20, 10)))
|
||||
|
||||
# Squeezing to 0-dim should still give an ndarray
|
||||
a = [[[1.5]]]
|
||||
res = np.squeeze(a)
|
||||
assert_equal(res, 1.5)
|
||||
assert_equal(res.ndim, 0)
|
||||
assert_equal(type(res), np.ndarray)
|
||||
|
||||
|
||||
class TestKron:
|
||||
def test_basic(self):
|
||||
# Using 0-dimensional ndarray
|
||||
a = np.array(1)
|
||||
b = np.array([[1, 2], [3, 4]])
|
||||
k = np.array([[1, 2], [3, 4]])
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
a = np.array([[1, 2], [3, 4]])
|
||||
b = np.array(1)
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
|
||||
# Using 1-dimensional ndarray
|
||||
a = np.array([3])
|
||||
b = np.array([[1, 2], [3, 4]])
|
||||
k = np.array([[3, 6], [9, 12]])
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
a = np.array([[1, 2], [3, 4]])
|
||||
b = np.array([3])
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
|
||||
# Using 3-dimensional ndarray
|
||||
a = np.array([[[1]], [[2]]])
|
||||
b = np.array([[1, 2], [3, 4]])
|
||||
k = np.array([[[1, 2], [3, 4]], [[2, 4], [6, 8]]])
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
a = np.array([[1, 2], [3, 4]])
|
||||
b = np.array([[[1]], [[2]]])
|
||||
k = np.array([[[1, 2], [3, 4]], [[2, 4], [6, 8]]])
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
|
||||
def test_return_type(self):
|
||||
class myarray(np.ndarray):
|
||||
__array_priority__ = 1.0
|
||||
|
||||
a = np.ones([2, 2])
|
||||
ma = myarray(a.shape, a.dtype, a.data)
|
||||
assert_equal(type(kron(a, a)), np.ndarray)
|
||||
assert_equal(type(kron(ma, ma)), myarray)
|
||||
assert_equal(type(kron(a, ma)), myarray)
|
||||
assert_equal(type(kron(ma, a)), myarray)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"array_class", [np.asarray, np.mat]
|
||||
)
|
||||
def test_kron_smoke(self, array_class):
|
||||
a = array_class(np.ones([3, 3]))
|
||||
b = array_class(np.ones([3, 3]))
|
||||
k = array_class(np.ones([9, 9]))
|
||||
|
||||
assert_array_equal(np.kron(a, b), k)
|
||||
|
||||
def test_kron_ma(self):
|
||||
x = np.ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
|
||||
k = np.ma.array(np.diag([1, 4, 4, 16]),
|
||||
mask=~np.array(np.identity(4), dtype=bool))
|
||||
|
||||
assert_array_equal(k, np.kron(x, x))
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"shape_a,shape_b", [
|
||||
((1, 1), (1, 1)),
|
||||
((1, 2, 3), (4, 5, 6)),
|
||||
((2, 2), (2, 2, 2)),
|
||||
((1, 0), (1, 1)),
|
||||
((2, 0, 2), (2, 2)),
|
||||
((2, 0, 0, 2), (2, 0, 2)),
|
||||
])
|
||||
def test_kron_shape(self, shape_a, shape_b):
|
||||
a = np.ones(shape_a)
|
||||
b = np.ones(shape_b)
|
||||
normalised_shape_a = (1,) * max(0, len(shape_b)-len(shape_a)) + shape_a
|
||||
normalised_shape_b = (1,) * max(0, len(shape_a)-len(shape_b)) + shape_b
|
||||
expected_shape = np.multiply(normalised_shape_a, normalised_shape_b)
|
||||
|
||||
k = np.kron(a, b)
|
||||
assert np.array_equal(
|
||||
k.shape, expected_shape), "Unexpected shape from kron"
|
||||
|
||||
|
||||
class TestTile:
|
||||
def test_basic(self):
|
||||
a = np.array([0, 1, 2])
|
||||
b = [[1, 2], [3, 4]]
|
||||
assert_equal(tile(a, 2), [0, 1, 2, 0, 1, 2])
|
||||
assert_equal(tile(a, (2, 2)), [[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]])
|
||||
assert_equal(tile(a, (1, 2)), [[0, 1, 2, 0, 1, 2]])
|
||||
assert_equal(tile(b, 2), [[1, 2, 1, 2], [3, 4, 3, 4]])
|
||||
assert_equal(tile(b, (2, 1)), [[1, 2], [3, 4], [1, 2], [3, 4]])
|
||||
assert_equal(tile(b, (2, 2)), [[1, 2, 1, 2], [3, 4, 3, 4],
|
||||
[1, 2, 1, 2], [3, 4, 3, 4]])
|
||||
|
||||
def test_tile_one_repetition_on_array_gh4679(self):
|
||||
a = np.arange(5)
|
||||
b = tile(a, 1)
|
||||
b += 2
|
||||
assert_equal(a, np.arange(5))
|
||||
|
||||
def test_empty(self):
|
||||
a = np.array([[[]]])
|
||||
b = np.array([[], []])
|
||||
c = tile(b, 2).shape
|
||||
d = tile(a, (3, 2, 5)).shape
|
||||
assert_equal(c, (2, 0))
|
||||
assert_equal(d, (3, 2, 0))
|
||||
|
||||
def test_kroncompare(self):
|
||||
from numpy.random import randint
|
||||
|
||||
reps = [(2,), (1, 2), (2, 1), (2, 2), (2, 3, 2), (3, 2)]
|
||||
shape = [(3,), (2, 3), (3, 4, 3), (3, 2, 3), (4, 3, 2, 4), (2, 2)]
|
||||
for s in shape:
|
||||
b = randint(0, 10, size=s)
|
||||
for r in reps:
|
||||
a = np.ones(r, b.dtype)
|
||||
large = tile(b, r)
|
||||
klarge = kron(a, b)
|
||||
assert_equal(large, klarge)
|
||||
|
||||
|
||||
class TestMayShareMemory:
|
||||
def test_basic(self):
|
||||
d = np.ones((50, 60))
|
||||
d2 = np.ones((30, 60, 6))
|
||||
assert_(np.may_share_memory(d, d))
|
||||
assert_(np.may_share_memory(d, d[::-1]))
|
||||
assert_(np.may_share_memory(d, d[::2]))
|
||||
assert_(np.may_share_memory(d, d[1:, ::-1]))
|
||||
|
||||
assert_(not np.may_share_memory(d[::-1], d2))
|
||||
assert_(not np.may_share_memory(d[::2], d2))
|
||||
assert_(not np.may_share_memory(d[1:, ::-1], d2))
|
||||
assert_(np.may_share_memory(d2[1:, ::-1], d2))
|
||||
|
||||
|
||||
# Utility
|
||||
def compare_results(res, desired):
|
||||
"""Compare lists of arrays."""
|
||||
if len(res) != len(desired):
|
||||
raise ValueError("Iterables have different lengths")
|
||||
# See also PEP 618 for Python 3.10
|
||||
for x, y in zip(res, desired):
|
||||
assert_array_equal(x, y)
|
||||
@@ -0,0 +1,645 @@
|
||||
import numpy as np
|
||||
from numpy.core._rational_tests import rational
|
||||
from numpy.testing import (
|
||||
assert_equal, assert_array_equal, assert_raises, assert_,
|
||||
assert_raises_regex, assert_warns,
|
||||
)
|
||||
from numpy.lib.stride_tricks import (
|
||||
as_strided, broadcast_arrays, _broadcast_shape, broadcast_to,
|
||||
broadcast_shapes, sliding_window_view,
|
||||
)
|
||||
import pytest
|
||||
|
||||
|
||||
def assert_shapes_correct(input_shapes, expected_shape):
|
||||
# Broadcast a list of arrays with the given input shapes and check the
|
||||
# common output shape.
|
||||
|
||||
inarrays = [np.zeros(s) for s in input_shapes]
|
||||
outarrays = broadcast_arrays(*inarrays)
|
||||
outshapes = [a.shape for a in outarrays]
|
||||
expected = [expected_shape] * len(inarrays)
|
||||
assert_equal(outshapes, expected)
|
||||
|
||||
|
||||
def assert_incompatible_shapes_raise(input_shapes):
|
||||
# Broadcast a list of arrays with the given (incompatible) input shapes
|
||||
# and check that they raise a ValueError.
|
||||
|
||||
inarrays = [np.zeros(s) for s in input_shapes]
|
||||
assert_raises(ValueError, broadcast_arrays, *inarrays)
|
||||
|
||||
|
||||
def assert_same_as_ufunc(shape0, shape1, transposed=False, flipped=False):
|
||||
# Broadcast two shapes against each other and check that the data layout
|
||||
# is the same as if a ufunc did the broadcasting.
|
||||
|
||||
x0 = np.zeros(shape0, dtype=int)
|
||||
# Note that multiply.reduce's identity element is 1.0, so when shape1==(),
|
||||
# this gives the desired n==1.
|
||||
n = int(np.multiply.reduce(shape1))
|
||||
x1 = np.arange(n).reshape(shape1)
|
||||
if transposed:
|
||||
x0 = x0.T
|
||||
x1 = x1.T
|
||||
if flipped:
|
||||
x0 = x0[::-1]
|
||||
x1 = x1[::-1]
|
||||
# Use the add ufunc to do the broadcasting. Since we're adding 0s to x1, the
|
||||
# result should be exactly the same as the broadcasted view of x1.
|
||||
y = x0 + x1
|
||||
b0, b1 = broadcast_arrays(x0, x1)
|
||||
assert_array_equal(y, b1)
|
||||
|
||||
|
||||
def test_same():
|
||||
x = np.arange(10)
|
||||
y = np.arange(10)
|
||||
bx, by = broadcast_arrays(x, y)
|
||||
assert_array_equal(x, bx)
|
||||
assert_array_equal(y, by)
|
||||
|
||||
def test_broadcast_kwargs():
|
||||
# ensure that a TypeError is appropriately raised when
|
||||
# np.broadcast_arrays() is called with any keyword
|
||||
# argument other than 'subok'
|
||||
x = np.arange(10)
|
||||
y = np.arange(10)
|
||||
|
||||
with assert_raises_regex(TypeError, 'got an unexpected keyword'):
|
||||
broadcast_arrays(x, y, dtype='float64')
|
||||
|
||||
|
||||
def test_one_off():
|
||||
x = np.array([[1, 2, 3]])
|
||||
y = np.array([[1], [2], [3]])
|
||||
bx, by = broadcast_arrays(x, y)
|
||||
bx0 = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
|
||||
by0 = bx0.T
|
||||
assert_array_equal(bx0, bx)
|
||||
assert_array_equal(by0, by)
|
||||
|
||||
|
||||
def test_same_input_shapes():
|
||||
# Check that the final shape is just the input shape.
|
||||
|
||||
data = [
|
||||
(),
|
||||
(1,),
|
||||
(3,),
|
||||
(0, 1),
|
||||
(0, 3),
|
||||
(1, 0),
|
||||
(3, 0),
|
||||
(1, 3),
|
||||
(3, 1),
|
||||
(3, 3),
|
||||
]
|
||||
for shape in data:
|
||||
input_shapes = [shape]
|
||||
# Single input.
|
||||
assert_shapes_correct(input_shapes, shape)
|
||||
# Double input.
|
||||
input_shapes2 = [shape, shape]
|
||||
assert_shapes_correct(input_shapes2, shape)
|
||||
# Triple input.
|
||||
input_shapes3 = [shape, shape, shape]
|
||||
assert_shapes_correct(input_shapes3, shape)
|
||||
|
||||
|
||||
def test_two_compatible_by_ones_input_shapes():
|
||||
# Check that two different input shapes of the same length, but some have
|
||||
# ones, broadcast to the correct shape.
|
||||
|
||||
data = [
|
||||
[[(1,), (3,)], (3,)],
|
||||
[[(1, 3), (3, 3)], (3, 3)],
|
||||
[[(3, 1), (3, 3)], (3, 3)],
|
||||
[[(1, 3), (3, 1)], (3, 3)],
|
||||
[[(1, 1), (3, 3)], (3, 3)],
|
||||
[[(1, 1), (1, 3)], (1, 3)],
|
||||
[[(1, 1), (3, 1)], (3, 1)],
|
||||
[[(1, 0), (0, 0)], (0, 0)],
|
||||
[[(0, 1), (0, 0)], (0, 0)],
|
||||
[[(1, 0), (0, 1)], (0, 0)],
|
||||
[[(1, 1), (0, 0)], (0, 0)],
|
||||
[[(1, 1), (1, 0)], (1, 0)],
|
||||
[[(1, 1), (0, 1)], (0, 1)],
|
||||
]
|
||||
for input_shapes, expected_shape in data:
|
||||
assert_shapes_correct(input_shapes, expected_shape)
|
||||
# Reverse the input shapes since broadcasting should be symmetric.
|
||||
assert_shapes_correct(input_shapes[::-1], expected_shape)
|
||||
|
||||
|
||||
def test_two_compatible_by_prepending_ones_input_shapes():
|
||||
# Check that two different input shapes (of different lengths) broadcast
|
||||
# to the correct shape.
|
||||
|
||||
data = [
|
||||
[[(), (3,)], (3,)],
|
||||
[[(3,), (3, 3)], (3, 3)],
|
||||
[[(3,), (3, 1)], (3, 3)],
|
||||
[[(1,), (3, 3)], (3, 3)],
|
||||
[[(), (3, 3)], (3, 3)],
|
||||
[[(1, 1), (3,)], (1, 3)],
|
||||
[[(1,), (3, 1)], (3, 1)],
|
||||
[[(1,), (1, 3)], (1, 3)],
|
||||
[[(), (1, 3)], (1, 3)],
|
||||
[[(), (3, 1)], (3, 1)],
|
||||
[[(), (0,)], (0,)],
|
||||
[[(0,), (0, 0)], (0, 0)],
|
||||
[[(0,), (0, 1)], (0, 0)],
|
||||
[[(1,), (0, 0)], (0, 0)],
|
||||
[[(), (0, 0)], (0, 0)],
|
||||
[[(1, 1), (0,)], (1, 0)],
|
||||
[[(1,), (0, 1)], (0, 1)],
|
||||
[[(1,), (1, 0)], (1, 0)],
|
||||
[[(), (1, 0)], (1, 0)],
|
||||
[[(), (0, 1)], (0, 1)],
|
||||
]
|
||||
for input_shapes, expected_shape in data:
|
||||
assert_shapes_correct(input_shapes, expected_shape)
|
||||
# Reverse the input shapes since broadcasting should be symmetric.
|
||||
assert_shapes_correct(input_shapes[::-1], expected_shape)
|
||||
|
||||
|
||||
def test_incompatible_shapes_raise_valueerror():
|
||||
# Check that a ValueError is raised for incompatible shapes.
|
||||
|
||||
data = [
|
||||
[(3,), (4,)],
|
||||
[(2, 3), (2,)],
|
||||
[(3,), (3,), (4,)],
|
||||
[(1, 3, 4), (2, 3, 3)],
|
||||
]
|
||||
for input_shapes in data:
|
||||
assert_incompatible_shapes_raise(input_shapes)
|
||||
# Reverse the input shapes since broadcasting should be symmetric.
|
||||
assert_incompatible_shapes_raise(input_shapes[::-1])
|
||||
|
||||
|
||||
def test_same_as_ufunc():
|
||||
# Check that the data layout is the same as if a ufunc did the operation.
|
||||
|
||||
data = [
|
||||
[[(1,), (3,)], (3,)],
|
||||
[[(1, 3), (3, 3)], (3, 3)],
|
||||
[[(3, 1), (3, 3)], (3, 3)],
|
||||
[[(1, 3), (3, 1)], (3, 3)],
|
||||
[[(1, 1), (3, 3)], (3, 3)],
|
||||
[[(1, 1), (1, 3)], (1, 3)],
|
||||
[[(1, 1), (3, 1)], (3, 1)],
|
||||
[[(1, 0), (0, 0)], (0, 0)],
|
||||
[[(0, 1), (0, 0)], (0, 0)],
|
||||
[[(1, 0), (0, 1)], (0, 0)],
|
||||
[[(1, 1), (0, 0)], (0, 0)],
|
||||
[[(1, 1), (1, 0)], (1, 0)],
|
||||
[[(1, 1), (0, 1)], (0, 1)],
|
||||
[[(), (3,)], (3,)],
|
||||
[[(3,), (3, 3)], (3, 3)],
|
||||
[[(3,), (3, 1)], (3, 3)],
|
||||
[[(1,), (3, 3)], (3, 3)],
|
||||
[[(), (3, 3)], (3, 3)],
|
||||
[[(1, 1), (3,)], (1, 3)],
|
||||
[[(1,), (3, 1)], (3, 1)],
|
||||
[[(1,), (1, 3)], (1, 3)],
|
||||
[[(), (1, 3)], (1, 3)],
|
||||
[[(), (3, 1)], (3, 1)],
|
||||
[[(), (0,)], (0,)],
|
||||
[[(0,), (0, 0)], (0, 0)],
|
||||
[[(0,), (0, 1)], (0, 0)],
|
||||
[[(1,), (0, 0)], (0, 0)],
|
||||
[[(), (0, 0)], (0, 0)],
|
||||
[[(1, 1), (0,)], (1, 0)],
|
||||
[[(1,), (0, 1)], (0, 1)],
|
||||
[[(1,), (1, 0)], (1, 0)],
|
||||
[[(), (1, 0)], (1, 0)],
|
||||
[[(), (0, 1)], (0, 1)],
|
||||
]
|
||||
for input_shapes, expected_shape in data:
|
||||
assert_same_as_ufunc(input_shapes[0], input_shapes[1],
|
||||
"Shapes: %s %s" % (input_shapes[0], input_shapes[1]))
|
||||
# Reverse the input shapes since broadcasting should be symmetric.
|
||||
assert_same_as_ufunc(input_shapes[1], input_shapes[0])
|
||||
# Try them transposed, too.
|
||||
assert_same_as_ufunc(input_shapes[0], input_shapes[1], True)
|
||||
# ... and flipped for non-rank-0 inputs in order to test negative
|
||||
# strides.
|
||||
if () not in input_shapes:
|
||||
assert_same_as_ufunc(input_shapes[0], input_shapes[1], False, True)
|
||||
assert_same_as_ufunc(input_shapes[0], input_shapes[1], True, True)
|
||||
|
||||
|
||||
def test_broadcast_to_succeeds():
|
||||
data = [
|
||||
[np.array(0), (0,), np.array(0)],
|
||||
[np.array(0), (1,), np.zeros(1)],
|
||||
[np.array(0), (3,), np.zeros(3)],
|
||||
[np.ones(1), (1,), np.ones(1)],
|
||||
[np.ones(1), (2,), np.ones(2)],
|
||||
[np.ones(1), (1, 2, 3), np.ones((1, 2, 3))],
|
||||
[np.arange(3), (3,), np.arange(3)],
|
||||
[np.arange(3), (1, 3), np.arange(3).reshape(1, -1)],
|
||||
[np.arange(3), (2, 3), np.array([[0, 1, 2], [0, 1, 2]])],
|
||||
# test if shape is not a tuple
|
||||
[np.ones(0), 0, np.ones(0)],
|
||||
[np.ones(1), 1, np.ones(1)],
|
||||
[np.ones(1), 2, np.ones(2)],
|
||||
# these cases with size 0 are strange, but they reproduce the behavior
|
||||
# of broadcasting with ufuncs (see test_same_as_ufunc above)
|
||||
[np.ones(1), (0,), np.ones(0)],
|
||||
[np.ones((1, 2)), (0, 2), np.ones((0, 2))],
|
||||
[np.ones((2, 1)), (2, 0), np.ones((2, 0))],
|
||||
]
|
||||
for input_array, shape, expected in data:
|
||||
actual = broadcast_to(input_array, shape)
|
||||
assert_array_equal(expected, actual)
|
||||
|
||||
|
||||
def test_broadcast_to_raises():
|
||||
data = [
|
||||
[(0,), ()],
|
||||
[(1,), ()],
|
||||
[(3,), ()],
|
||||
[(3,), (1,)],
|
||||
[(3,), (2,)],
|
||||
[(3,), (4,)],
|
||||
[(1, 2), (2, 1)],
|
||||
[(1, 1), (1,)],
|
||||
[(1,), -1],
|
||||
[(1,), (-1,)],
|
||||
[(1, 2), (-1, 2)],
|
||||
]
|
||||
for orig_shape, target_shape in data:
|
||||
arr = np.zeros(orig_shape)
|
||||
assert_raises(ValueError, lambda: broadcast_to(arr, target_shape))
|
||||
|
||||
|
||||
def test_broadcast_shape():
|
||||
# tests internal _broadcast_shape
|
||||
# _broadcast_shape is already exercised indirectly by broadcast_arrays
|
||||
# _broadcast_shape is also exercised by the public broadcast_shapes function
|
||||
assert_equal(_broadcast_shape(), ())
|
||||
assert_equal(_broadcast_shape([1, 2]), (2,))
|
||||
assert_equal(_broadcast_shape(np.ones((1, 1))), (1, 1))
|
||||
assert_equal(_broadcast_shape(np.ones((1, 1)), np.ones((3, 4))), (3, 4))
|
||||
assert_equal(_broadcast_shape(*([np.ones((1, 2))] * 32)), (1, 2))
|
||||
assert_equal(_broadcast_shape(*([np.ones((1, 2))] * 100)), (1, 2))
|
||||
|
||||
# regression tests for gh-5862
|
||||
assert_equal(_broadcast_shape(*([np.ones(2)] * 32 + [1])), (2,))
|
||||
bad_args = [np.ones(2)] * 32 + [np.ones(3)] * 32
|
||||
assert_raises(ValueError, lambda: _broadcast_shape(*bad_args))
|
||||
|
||||
|
||||
def test_broadcast_shapes_succeeds():
|
||||
# tests public broadcast_shapes
|
||||
data = [
|
||||
[[], ()],
|
||||
[[()], ()],
|
||||
[[(7,)], (7,)],
|
||||
[[(1, 2), (2,)], (1, 2)],
|
||||
[[(1, 1)], (1, 1)],
|
||||
[[(1, 1), (3, 4)], (3, 4)],
|
||||
[[(6, 7), (5, 6, 1), (7,), (5, 1, 7)], (5, 6, 7)],
|
||||
[[(5, 6, 1)], (5, 6, 1)],
|
||||
[[(1, 3), (3, 1)], (3, 3)],
|
||||
[[(1, 0), (0, 0)], (0, 0)],
|
||||
[[(0, 1), (0, 0)], (0, 0)],
|
||||
[[(1, 0), (0, 1)], (0, 0)],
|
||||
[[(1, 1), (0, 0)], (0, 0)],
|
||||
[[(1, 1), (1, 0)], (1, 0)],
|
||||
[[(1, 1), (0, 1)], (0, 1)],
|
||||
[[(), (0,)], (0,)],
|
||||
[[(0,), (0, 0)], (0, 0)],
|
||||
[[(0,), (0, 1)], (0, 0)],
|
||||
[[(1,), (0, 0)], (0, 0)],
|
||||
[[(), (0, 0)], (0, 0)],
|
||||
[[(1, 1), (0,)], (1, 0)],
|
||||
[[(1,), (0, 1)], (0, 1)],
|
||||
[[(1,), (1, 0)], (1, 0)],
|
||||
[[(), (1, 0)], (1, 0)],
|
||||
[[(), (0, 1)], (0, 1)],
|
||||
[[(1,), (3,)], (3,)],
|
||||
[[2, (3, 2)], (3, 2)],
|
||||
]
|
||||
for input_shapes, target_shape in data:
|
||||
assert_equal(broadcast_shapes(*input_shapes), target_shape)
|
||||
|
||||
assert_equal(broadcast_shapes(*([(1, 2)] * 32)), (1, 2))
|
||||
assert_equal(broadcast_shapes(*([(1, 2)] * 100)), (1, 2))
|
||||
|
||||
# regression tests for gh-5862
|
||||
assert_equal(broadcast_shapes(*([(2,)] * 32)), (2,))
|
||||
|
||||
|
||||
def test_broadcast_shapes_raises():
|
||||
# tests public broadcast_shapes
|
||||
data = [
|
||||
[(3,), (4,)],
|
||||
[(2, 3), (2,)],
|
||||
[(3,), (3,), (4,)],
|
||||
[(1, 3, 4), (2, 3, 3)],
|
||||
[(1, 2), (3,1), (3,2), (10, 5)],
|
||||
[2, (2, 3)],
|
||||
]
|
||||
for input_shapes in data:
|
||||
assert_raises(ValueError, lambda: broadcast_shapes(*input_shapes))
|
||||
|
||||
bad_args = [(2,)] * 32 + [(3,)] * 32
|
||||
assert_raises(ValueError, lambda: broadcast_shapes(*bad_args))
|
||||
|
||||
|
||||
def test_as_strided():
|
||||
a = np.array([None])
|
||||
a_view = as_strided(a)
|
||||
expected = np.array([None])
|
||||
assert_array_equal(a_view, np.array([None]))
|
||||
|
||||
a = np.array([1, 2, 3, 4])
|
||||
a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,))
|
||||
expected = np.array([1, 3])
|
||||
assert_array_equal(a_view, expected)
|
||||
|
||||
a = np.array([1, 2, 3, 4])
|
||||
a_view = as_strided(a, shape=(3, 4), strides=(0, 1 * a.itemsize))
|
||||
expected = np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]])
|
||||
assert_array_equal(a_view, expected)
|
||||
|
||||
# Regression test for gh-5081
|
||||
dt = np.dtype([('num', 'i4'), ('obj', 'O')])
|
||||
a = np.empty((4,), dtype=dt)
|
||||
a['num'] = np.arange(1, 5)
|
||||
a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
|
||||
expected_num = [[1, 2, 3, 4]] * 3
|
||||
expected_obj = [[None]*4]*3
|
||||
assert_equal(a_view.dtype, dt)
|
||||
assert_array_equal(expected_num, a_view['num'])
|
||||
assert_array_equal(expected_obj, a_view['obj'])
|
||||
|
||||
# Make sure that void types without fields are kept unchanged
|
||||
a = np.empty((4,), dtype='V4')
|
||||
a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
|
||||
assert_equal(a.dtype, a_view.dtype)
|
||||
|
||||
# Make sure that the only type that could fail is properly handled
|
||||
dt = np.dtype({'names': [''], 'formats': ['V4']})
|
||||
a = np.empty((4,), dtype=dt)
|
||||
a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
|
||||
assert_equal(a.dtype, a_view.dtype)
|
||||
|
||||
# Custom dtypes should not be lost (gh-9161)
|
||||
r = [rational(i) for i in range(4)]
|
||||
a = np.array(r, dtype=rational)
|
||||
a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
|
||||
assert_equal(a.dtype, a_view.dtype)
|
||||
assert_array_equal([r] * 3, a_view)
|
||||
|
||||
|
||||
class TestSlidingWindowView:
|
||||
def test_1d(self):
|
||||
arr = np.arange(5)
|
||||
arr_view = sliding_window_view(arr, 2)
|
||||
expected = np.array([[0, 1],
|
||||
[1, 2],
|
||||
[2, 3],
|
||||
[3, 4]])
|
||||
assert_array_equal(arr_view, expected)
|
||||
|
||||
def test_2d(self):
|
||||
i, j = np.ogrid[:3, :4]
|
||||
arr = 10*i + j
|
||||
shape = (2, 2)
|
||||
arr_view = sliding_window_view(arr, shape)
|
||||
expected = np.array([[[[0, 1], [10, 11]],
|
||||
[[1, 2], [11, 12]],
|
||||
[[2, 3], [12, 13]]],
|
||||
[[[10, 11], [20, 21]],
|
||||
[[11, 12], [21, 22]],
|
||||
[[12, 13], [22, 23]]]])
|
||||
assert_array_equal(arr_view, expected)
|
||||
|
||||
def test_2d_with_axis(self):
|
||||
i, j = np.ogrid[:3, :4]
|
||||
arr = 10*i + j
|
||||
arr_view = sliding_window_view(arr, 3, 0)
|
||||
expected = np.array([[[0, 10, 20],
|
||||
[1, 11, 21],
|
||||
[2, 12, 22],
|
||||
[3, 13, 23]]])
|
||||
assert_array_equal(arr_view, expected)
|
||||
|
||||
def test_2d_repeated_axis(self):
|
||||
i, j = np.ogrid[:3, :4]
|
||||
arr = 10*i + j
|
||||
arr_view = sliding_window_view(arr, (2, 3), (1, 1))
|
||||
expected = np.array([[[[0, 1, 2],
|
||||
[1, 2, 3]]],
|
||||
[[[10, 11, 12],
|
||||
[11, 12, 13]]],
|
||||
[[[20, 21, 22],
|
||||
[21, 22, 23]]]])
|
||||
assert_array_equal(arr_view, expected)
|
||||
|
||||
def test_2d_without_axis(self):
|
||||
i, j = np.ogrid[:4, :4]
|
||||
arr = 10*i + j
|
||||
shape = (2, 3)
|
||||
arr_view = sliding_window_view(arr, shape)
|
||||
expected = np.array([[[[0, 1, 2], [10, 11, 12]],
|
||||
[[1, 2, 3], [11, 12, 13]]],
|
||||
[[[10, 11, 12], [20, 21, 22]],
|
||||
[[11, 12, 13], [21, 22, 23]]],
|
||||
[[[20, 21, 22], [30, 31, 32]],
|
||||
[[21, 22, 23], [31, 32, 33]]]])
|
||||
assert_array_equal(arr_view, expected)
|
||||
|
||||
def test_errors(self):
|
||||
i, j = np.ogrid[:4, :4]
|
||||
arr = 10*i + j
|
||||
with pytest.raises(ValueError, match='cannot contain negative values'):
|
||||
sliding_window_view(arr, (-1, 3))
|
||||
with pytest.raises(
|
||||
ValueError,
|
||||
match='must provide window_shape for all dimensions of `x`'):
|
||||
sliding_window_view(arr, (1,))
|
||||
with pytest.raises(
|
||||
ValueError,
|
||||
match='Must provide matching length window_shape and axis'):
|
||||
sliding_window_view(arr, (1, 3, 4), axis=(0, 1))
|
||||
with pytest.raises(
|
||||
ValueError,
|
||||
match='window shape cannot be larger than input array'):
|
||||
sliding_window_view(arr, (5, 5))
|
||||
|
||||
def test_writeable(self):
|
||||
arr = np.arange(5)
|
||||
view = sliding_window_view(arr, 2, writeable=False)
|
||||
assert_(not view.flags.writeable)
|
||||
with pytest.raises(
|
||||
ValueError,
|
||||
match='assignment destination is read-only'):
|
||||
view[0, 0] = 3
|
||||
view = sliding_window_view(arr, 2, writeable=True)
|
||||
assert_(view.flags.writeable)
|
||||
view[0, 1] = 3
|
||||
assert_array_equal(arr, np.array([0, 3, 2, 3, 4]))
|
||||
|
||||
def test_subok(self):
|
||||
class MyArray(np.ndarray):
|
||||
pass
|
||||
|
||||
arr = np.arange(5).view(MyArray)
|
||||
assert_(not isinstance(sliding_window_view(arr, 2,
|
||||
subok=False),
|
||||
MyArray))
|
||||
assert_(isinstance(sliding_window_view(arr, 2, subok=True), MyArray))
|
||||
# Default behavior
|
||||
assert_(not isinstance(sliding_window_view(arr, 2), MyArray))
|
||||
|
||||
|
||||
def as_strided_writeable():
|
||||
arr = np.ones(10)
|
||||
view = as_strided(arr, writeable=False)
|
||||
assert_(not view.flags.writeable)
|
||||
|
||||
# Check that writeable also is fine:
|
||||
view = as_strided(arr, writeable=True)
|
||||
assert_(view.flags.writeable)
|
||||
view[...] = 3
|
||||
assert_array_equal(arr, np.full_like(arr, 3))
|
||||
|
||||
# Test that things do not break down for readonly:
|
||||
arr.flags.writeable = False
|
||||
view = as_strided(arr, writeable=False)
|
||||
view = as_strided(arr, writeable=True)
|
||||
assert_(not view.flags.writeable)
|
||||
|
||||
|
||||
class VerySimpleSubClass(np.ndarray):
|
||||
def __new__(cls, *args, **kwargs):
|
||||
return np.array(*args, subok=True, **kwargs).view(cls)
|
||||
|
||||
|
||||
class SimpleSubClass(VerySimpleSubClass):
|
||||
def __new__(cls, *args, **kwargs):
|
||||
self = np.array(*args, subok=True, **kwargs).view(cls)
|
||||
self.info = 'simple'
|
||||
return self
|
||||
|
||||
def __array_finalize__(self, obj):
|
||||
self.info = getattr(obj, 'info', '') + ' finalized'
|
||||
|
||||
|
||||
def test_subclasses():
|
||||
# test that subclass is preserved only if subok=True
|
||||
a = VerySimpleSubClass([1, 2, 3, 4])
|
||||
assert_(type(a) is VerySimpleSubClass)
|
||||
a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,))
|
||||
assert_(type(a_view) is np.ndarray)
|
||||
a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,), subok=True)
|
||||
assert_(type(a_view) is VerySimpleSubClass)
|
||||
# test that if a subclass has __array_finalize__, it is used
|
||||
a = SimpleSubClass([1, 2, 3, 4])
|
||||
a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,), subok=True)
|
||||
assert_(type(a_view) is SimpleSubClass)
|
||||
assert_(a_view.info == 'simple finalized')
|
||||
|
||||
# similar tests for broadcast_arrays
|
||||
b = np.arange(len(a)).reshape(-1, 1)
|
||||
a_view, b_view = broadcast_arrays(a, b)
|
||||
assert_(type(a_view) is np.ndarray)
|
||||
assert_(type(b_view) is np.ndarray)
|
||||
assert_(a_view.shape == b_view.shape)
|
||||
a_view, b_view = broadcast_arrays(a, b, subok=True)
|
||||
assert_(type(a_view) is SimpleSubClass)
|
||||
assert_(a_view.info == 'simple finalized')
|
||||
assert_(type(b_view) is np.ndarray)
|
||||
assert_(a_view.shape == b_view.shape)
|
||||
|
||||
# and for broadcast_to
|
||||
shape = (2, 4)
|
||||
a_view = broadcast_to(a, shape)
|
||||
assert_(type(a_view) is np.ndarray)
|
||||
assert_(a_view.shape == shape)
|
||||
a_view = broadcast_to(a, shape, subok=True)
|
||||
assert_(type(a_view) is SimpleSubClass)
|
||||
assert_(a_view.info == 'simple finalized')
|
||||
assert_(a_view.shape == shape)
|
||||
|
||||
|
||||
def test_writeable():
|
||||
# broadcast_to should return a readonly array
|
||||
original = np.array([1, 2, 3])
|
||||
result = broadcast_to(original, (2, 3))
|
||||
assert_equal(result.flags.writeable, False)
|
||||
assert_raises(ValueError, result.__setitem__, slice(None), 0)
|
||||
|
||||
# but the result of broadcast_arrays needs to be writeable, to
|
||||
# preserve backwards compatibility
|
||||
for is_broadcast, results in [(False, broadcast_arrays(original,)),
|
||||
(True, broadcast_arrays(0, original))]:
|
||||
for result in results:
|
||||
# This will change to False in a future version
|
||||
if is_broadcast:
|
||||
with assert_warns(FutureWarning):
|
||||
assert_equal(result.flags.writeable, True)
|
||||
with assert_warns(DeprecationWarning):
|
||||
result[:] = 0
|
||||
# Warning not emitted, writing to the array resets it
|
||||
assert_equal(result.flags.writeable, True)
|
||||
else:
|
||||
# No warning:
|
||||
assert_equal(result.flags.writeable, True)
|
||||
|
||||
for results in [broadcast_arrays(original),
|
||||
broadcast_arrays(0, original)]:
|
||||
for result in results:
|
||||
# resets the warn_on_write DeprecationWarning
|
||||
result.flags.writeable = True
|
||||
# check: no warning emitted
|
||||
assert_equal(result.flags.writeable, True)
|
||||
result[:] = 0
|
||||
|
||||
# keep readonly input readonly
|
||||
original.flags.writeable = False
|
||||
_, result = broadcast_arrays(0, original)
|
||||
assert_equal(result.flags.writeable, False)
|
||||
|
||||
# regression test for GH6491
|
||||
shape = (2,)
|
||||
strides = [0]
|
||||
tricky_array = as_strided(np.array(0), shape, strides)
|
||||
other = np.zeros((1,))
|
||||
first, second = broadcast_arrays(tricky_array, other)
|
||||
assert_(first.shape == second.shape)
|
||||
|
||||
|
||||
def test_writeable_memoryview():
|
||||
# The result of broadcast_arrays exports as a non-writeable memoryview
|
||||
# because otherwise there is no good way to opt in to the new behaviour
|
||||
# (i.e. you would need to set writeable to False explicitly).
|
||||
# See gh-13929.
|
||||
original = np.array([1, 2, 3])
|
||||
|
||||
for is_broadcast, results in [(False, broadcast_arrays(original,)),
|
||||
(True, broadcast_arrays(0, original))]:
|
||||
for result in results:
|
||||
# This will change to False in a future version
|
||||
if is_broadcast:
|
||||
# memoryview(result, writable=True) will give warning but cannot
|
||||
# be tested using the python API.
|
||||
assert memoryview(result).readonly
|
||||
else:
|
||||
assert not memoryview(result).readonly
|
||||
|
||||
|
||||
def test_reference_types():
|
||||
input_array = np.array('a', dtype=object)
|
||||
expected = np.array(['a'] * 3, dtype=object)
|
||||
actual = broadcast_to(input_array, (3,))
|
||||
assert_array_equal(expected, actual)
|
||||
|
||||
actual, _ = broadcast_arrays(input_array, np.ones(3))
|
||||
assert_array_equal(expected, actual)
|
||||
@@ -0,0 +1,541 @@
|
||||
"""Test functions for matrix module
|
||||
|
||||
"""
|
||||
from numpy.testing import (
|
||||
assert_equal, assert_array_equal, assert_array_max_ulp,
|
||||
assert_array_almost_equal, assert_raises, assert_
|
||||
)
|
||||
from numpy import (
|
||||
arange, add, fliplr, flipud, zeros, ones, eye, array, diag, histogram2d,
|
||||
tri, mask_indices, triu_indices, triu_indices_from, tril_indices,
|
||||
tril_indices_from, vander,
|
||||
)
|
||||
import numpy as np
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
def get_mat(n):
|
||||
data = arange(n)
|
||||
data = add.outer(data, data)
|
||||
return data
|
||||
|
||||
|
||||
class TestEye:
|
||||
def test_basic(self):
|
||||
assert_equal(eye(4),
|
||||
array([[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[0, 0, 0, 1]]))
|
||||
|
||||
assert_equal(eye(4, dtype='f'),
|
||||
array([[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[0, 0, 0, 1]], 'f'))
|
||||
|
||||
assert_equal(eye(3) == 1,
|
||||
eye(3, dtype=bool))
|
||||
|
||||
def test_uint64(self):
|
||||
# Regression test for gh-9982
|
||||
assert_equal(eye(np.uint64(2), dtype=int), array([[1, 0], [0, 1]]))
|
||||
assert_equal(eye(np.uint64(2), M=np.uint64(4), k=np.uint64(1)),
|
||||
array([[0, 1, 0, 0], [0, 0, 1, 0]]))
|
||||
|
||||
def test_diag(self):
|
||||
assert_equal(eye(4, k=1),
|
||||
array([[0, 1, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[0, 0, 0, 1],
|
||||
[0, 0, 0, 0]]))
|
||||
|
||||
assert_equal(eye(4, k=-1),
|
||||
array([[0, 0, 0, 0],
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, 0]]))
|
||||
|
||||
def test_2d(self):
|
||||
assert_equal(eye(4, 3),
|
||||
array([[1, 0, 0],
|
||||
[0, 1, 0],
|
||||
[0, 0, 1],
|
||||
[0, 0, 0]]))
|
||||
|
||||
assert_equal(eye(3, 4),
|
||||
array([[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, 0]]))
|
||||
|
||||
def test_diag2d(self):
|
||||
assert_equal(eye(3, 4, k=2),
|
||||
array([[0, 0, 1, 0],
|
||||
[0, 0, 0, 1],
|
||||
[0, 0, 0, 0]]))
|
||||
|
||||
assert_equal(eye(4, 3, k=-2),
|
||||
array([[0, 0, 0],
|
||||
[0, 0, 0],
|
||||
[1, 0, 0],
|
||||
[0, 1, 0]]))
|
||||
|
||||
def test_eye_bounds(self):
|
||||
assert_equal(eye(2, 2, 1), [[0, 1], [0, 0]])
|
||||
assert_equal(eye(2, 2, -1), [[0, 0], [1, 0]])
|
||||
assert_equal(eye(2, 2, 2), [[0, 0], [0, 0]])
|
||||
assert_equal(eye(2, 2, -2), [[0, 0], [0, 0]])
|
||||
assert_equal(eye(3, 2, 2), [[0, 0], [0, 0], [0, 0]])
|
||||
assert_equal(eye(3, 2, 1), [[0, 1], [0, 0], [0, 0]])
|
||||
assert_equal(eye(3, 2, -1), [[0, 0], [1, 0], [0, 1]])
|
||||
assert_equal(eye(3, 2, -2), [[0, 0], [0, 0], [1, 0]])
|
||||
assert_equal(eye(3, 2, -3), [[0, 0], [0, 0], [0, 0]])
|
||||
|
||||
def test_strings(self):
|
||||
assert_equal(eye(2, 2, dtype='S3'),
|
||||
[[b'1', b''], [b'', b'1']])
|
||||
|
||||
def test_bool(self):
|
||||
assert_equal(eye(2, 2, dtype=bool), [[True, False], [False, True]])
|
||||
|
||||
def test_order(self):
|
||||
mat_c = eye(4, 3, k=-1)
|
||||
mat_f = eye(4, 3, k=-1, order='F')
|
||||
assert_equal(mat_c, mat_f)
|
||||
assert mat_c.flags.c_contiguous
|
||||
assert not mat_c.flags.f_contiguous
|
||||
assert not mat_f.flags.c_contiguous
|
||||
assert mat_f.flags.f_contiguous
|
||||
|
||||
|
||||
class TestDiag:
|
||||
def test_vector(self):
|
||||
vals = (100 * arange(5)).astype('l')
|
||||
b = zeros((5, 5))
|
||||
for k in range(5):
|
||||
b[k, k] = vals[k]
|
||||
assert_equal(diag(vals), b)
|
||||
b = zeros((7, 7))
|
||||
c = b.copy()
|
||||
for k in range(5):
|
||||
b[k, k + 2] = vals[k]
|
||||
c[k + 2, k] = vals[k]
|
||||
assert_equal(diag(vals, k=2), b)
|
||||
assert_equal(diag(vals, k=-2), c)
|
||||
|
||||
def test_matrix(self, vals=None):
|
||||
if vals is None:
|
||||
vals = (100 * get_mat(5) + 1).astype('l')
|
||||
b = zeros((5,))
|
||||
for k in range(5):
|
||||
b[k] = vals[k, k]
|
||||
assert_equal(diag(vals), b)
|
||||
b = b * 0
|
||||
for k in range(3):
|
||||
b[k] = vals[k, k + 2]
|
||||
assert_equal(diag(vals, 2), b[:3])
|
||||
for k in range(3):
|
||||
b[k] = vals[k + 2, k]
|
||||
assert_equal(diag(vals, -2), b[:3])
|
||||
|
||||
def test_fortran_order(self):
|
||||
vals = array((100 * get_mat(5) + 1), order='F', dtype='l')
|
||||
self.test_matrix(vals)
|
||||
|
||||
def test_diag_bounds(self):
|
||||
A = [[1, 2], [3, 4], [5, 6]]
|
||||
assert_equal(diag(A, k=2), [])
|
||||
assert_equal(diag(A, k=1), [2])
|
||||
assert_equal(diag(A, k=0), [1, 4])
|
||||
assert_equal(diag(A, k=-1), [3, 6])
|
||||
assert_equal(diag(A, k=-2), [5])
|
||||
assert_equal(diag(A, k=-3), [])
|
||||
|
||||
def test_failure(self):
|
||||
assert_raises(ValueError, diag, [[[1]]])
|
||||
|
||||
|
||||
class TestFliplr:
|
||||
def test_basic(self):
|
||||
assert_raises(ValueError, fliplr, ones(4))
|
||||
a = get_mat(4)
|
||||
b = a[:, ::-1]
|
||||
assert_equal(fliplr(a), b)
|
||||
a = [[0, 1, 2],
|
||||
[3, 4, 5]]
|
||||
b = [[2, 1, 0],
|
||||
[5, 4, 3]]
|
||||
assert_equal(fliplr(a), b)
|
||||
|
||||
|
||||
class TestFlipud:
|
||||
def test_basic(self):
|
||||
a = get_mat(4)
|
||||
b = a[::-1, :]
|
||||
assert_equal(flipud(a), b)
|
||||
a = [[0, 1, 2],
|
||||
[3, 4, 5]]
|
||||
b = [[3, 4, 5],
|
||||
[0, 1, 2]]
|
||||
assert_equal(flipud(a), b)
|
||||
|
||||
|
||||
class TestHistogram2d:
|
||||
def test_simple(self):
|
||||
x = array(
|
||||
[0.41702200, 0.72032449, 1.1437481e-4, 0.302332573, 0.146755891])
|
||||
y = array(
|
||||
[0.09233859, 0.18626021, 0.34556073, 0.39676747, 0.53881673])
|
||||
xedges = np.linspace(0, 1, 10)
|
||||
yedges = np.linspace(0, 1, 10)
|
||||
H = histogram2d(x, y, (xedges, yedges))[0]
|
||||
answer = array(
|
||||
[[0, 0, 0, 1, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 1, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[1, 0, 1, 0, 0, 0, 0, 0, 0],
|
||||
[0, 1, 0, 0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0]])
|
||||
assert_array_equal(H.T, answer)
|
||||
H = histogram2d(x, y, xedges)[0]
|
||||
assert_array_equal(H.T, answer)
|
||||
H, xedges, yedges = histogram2d(list(range(10)), list(range(10)))
|
||||
assert_array_equal(H, eye(10, 10))
|
||||
assert_array_equal(xedges, np.linspace(0, 9, 11))
|
||||
assert_array_equal(yedges, np.linspace(0, 9, 11))
|
||||
|
||||
def test_asym(self):
|
||||
x = array([1, 1, 2, 3, 4, 4, 4, 5])
|
||||
y = array([1, 3, 2, 0, 1, 2, 3, 4])
|
||||
H, xed, yed = histogram2d(
|
||||
x, y, (6, 5), range=[[0, 6], [0, 5]], density=True)
|
||||
answer = array(
|
||||
[[0., 0, 0, 0, 0],
|
||||
[0, 1, 0, 1, 0],
|
||||
[0, 0, 1, 0, 0],
|
||||
[1, 0, 0, 0, 0],
|
||||
[0, 1, 1, 1, 0],
|
||||
[0, 0, 0, 0, 1]])
|
||||
assert_array_almost_equal(H, answer/8., 3)
|
||||
assert_array_equal(xed, np.linspace(0, 6, 7))
|
||||
assert_array_equal(yed, np.linspace(0, 5, 6))
|
||||
|
||||
def test_density(self):
|
||||
x = array([1, 2, 3, 1, 2, 3, 1, 2, 3])
|
||||
y = array([1, 1, 1, 2, 2, 2, 3, 3, 3])
|
||||
H, xed, yed = histogram2d(
|
||||
x, y, [[1, 2, 3, 5], [1, 2, 3, 5]], density=True)
|
||||
answer = array([[1, 1, .5],
|
||||
[1, 1, .5],
|
||||
[.5, .5, .25]])/9.
|
||||
assert_array_almost_equal(H, answer, 3)
|
||||
|
||||
def test_all_outliers(self):
|
||||
r = np.random.rand(100) + 1. + 1e6 # histogramdd rounds by decimal=6
|
||||
H, xed, yed = histogram2d(r, r, (4, 5), range=([0, 1], [0, 1]))
|
||||
assert_array_equal(H, 0)
|
||||
|
||||
def test_empty(self):
|
||||
a, edge1, edge2 = histogram2d([], [], bins=([0, 1], [0, 1]))
|
||||
assert_array_max_ulp(a, array([[0.]]))
|
||||
|
||||
a, edge1, edge2 = histogram2d([], [], bins=4)
|
||||
assert_array_max_ulp(a, np.zeros((4, 4)))
|
||||
|
||||
def test_binparameter_combination(self):
|
||||
x = array(
|
||||
[0, 0.09207008, 0.64575234, 0.12875982, 0.47390599,
|
||||
0.59944483, 1])
|
||||
y = array(
|
||||
[0, 0.14344267, 0.48988575, 0.30558665, 0.44700682,
|
||||
0.15886423, 1])
|
||||
edges = (0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1)
|
||||
H, xe, ye = histogram2d(x, y, (edges, 4))
|
||||
answer = array(
|
||||
[[2., 0., 0., 0.],
|
||||
[0., 1., 0., 0.],
|
||||
[0., 0., 0., 0.],
|
||||
[0., 0., 0., 0.],
|
||||
[0., 1., 0., 0.],
|
||||
[1., 0., 0., 0.],
|
||||
[0., 1., 0., 0.],
|
||||
[0., 0., 0., 0.],
|
||||
[0., 0., 0., 0.],
|
||||
[0., 0., 0., 1.]])
|
||||
assert_array_equal(H, answer)
|
||||
assert_array_equal(ye, array([0., 0.25, 0.5, 0.75, 1]))
|
||||
H, xe, ye = histogram2d(x, y, (4, edges))
|
||||
answer = array(
|
||||
[[1., 1., 0., 1., 0., 0., 0., 0., 0., 0.],
|
||||
[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
|
||||
[0., 1., 0., 0., 1., 0., 0., 0., 0., 0.],
|
||||
[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])
|
||||
assert_array_equal(H, answer)
|
||||
assert_array_equal(xe, array([0., 0.25, 0.5, 0.75, 1]))
|
||||
|
||||
def test_dispatch(self):
|
||||
class ShouldDispatch:
|
||||
def __array_function__(self, function, types, args, kwargs):
|
||||
return types, args, kwargs
|
||||
|
||||
xy = [1, 2]
|
||||
s_d = ShouldDispatch()
|
||||
r = histogram2d(s_d, xy)
|
||||
# Cannot use assert_equal since that dispatches...
|
||||
assert_(r == ((ShouldDispatch,), (s_d, xy), {}))
|
||||
r = histogram2d(xy, s_d)
|
||||
assert_(r == ((ShouldDispatch,), (xy, s_d), {}))
|
||||
r = histogram2d(xy, xy, bins=s_d)
|
||||
assert_(r, ((ShouldDispatch,), (xy, xy), dict(bins=s_d)))
|
||||
r = histogram2d(xy, xy, bins=[s_d, 5])
|
||||
assert_(r, ((ShouldDispatch,), (xy, xy), dict(bins=[s_d, 5])))
|
||||
assert_raises(Exception, histogram2d, xy, xy, bins=[s_d])
|
||||
r = histogram2d(xy, xy, weights=s_d)
|
||||
assert_(r, ((ShouldDispatch,), (xy, xy), dict(weights=s_d)))
|
||||
|
||||
@pytest.mark.parametrize(("x_len", "y_len"), [(10, 11), (20, 19)])
|
||||
def test_bad_length(self, x_len, y_len):
|
||||
x, y = np.ones(x_len), np.ones(y_len)
|
||||
with pytest.raises(ValueError,
|
||||
match='x and y must have the same length.'):
|
||||
histogram2d(x, y)
|
||||
|
||||
|
||||
class TestTri:
|
||||
def test_dtype(self):
|
||||
out = array([[1, 0, 0],
|
||||
[1, 1, 0],
|
||||
[1, 1, 1]])
|
||||
assert_array_equal(tri(3), out)
|
||||
assert_array_equal(tri(3, dtype=bool), out.astype(bool))
|
||||
|
||||
|
||||
def test_tril_triu_ndim2():
|
||||
for dtype in np.typecodes['AllFloat'] + np.typecodes['AllInteger']:
|
||||
a = np.ones((2, 2), dtype=dtype)
|
||||
b = np.tril(a)
|
||||
c = np.triu(a)
|
||||
assert_array_equal(b, [[1, 0], [1, 1]])
|
||||
assert_array_equal(c, b.T)
|
||||
# should return the same dtype as the original array
|
||||
assert_equal(b.dtype, a.dtype)
|
||||
assert_equal(c.dtype, a.dtype)
|
||||
|
||||
|
||||
def test_tril_triu_ndim3():
|
||||
for dtype in np.typecodes['AllFloat'] + np.typecodes['AllInteger']:
|
||||
a = np.array([
|
||||
[[1, 1], [1, 1]],
|
||||
[[1, 1], [1, 0]],
|
||||
[[1, 1], [0, 0]],
|
||||
], dtype=dtype)
|
||||
a_tril_desired = np.array([
|
||||
[[1, 0], [1, 1]],
|
||||
[[1, 0], [1, 0]],
|
||||
[[1, 0], [0, 0]],
|
||||
], dtype=dtype)
|
||||
a_triu_desired = np.array([
|
||||
[[1, 1], [0, 1]],
|
||||
[[1, 1], [0, 0]],
|
||||
[[1, 1], [0, 0]],
|
||||
], dtype=dtype)
|
||||
a_triu_observed = np.triu(a)
|
||||
a_tril_observed = np.tril(a)
|
||||
assert_array_equal(a_triu_observed, a_triu_desired)
|
||||
assert_array_equal(a_tril_observed, a_tril_desired)
|
||||
assert_equal(a_triu_observed.dtype, a.dtype)
|
||||
assert_equal(a_tril_observed.dtype, a.dtype)
|
||||
|
||||
|
||||
def test_tril_triu_with_inf():
|
||||
# Issue 4859
|
||||
arr = np.array([[1, 1, np.inf],
|
||||
[1, 1, 1],
|
||||
[np.inf, 1, 1]])
|
||||
out_tril = np.array([[1, 0, 0],
|
||||
[1, 1, 0],
|
||||
[np.inf, 1, 1]])
|
||||
out_triu = out_tril.T
|
||||
assert_array_equal(np.triu(arr), out_triu)
|
||||
assert_array_equal(np.tril(arr), out_tril)
|
||||
|
||||
|
||||
def test_tril_triu_dtype():
|
||||
# Issue 4916
|
||||
# tril and triu should return the same dtype as input
|
||||
for c in np.typecodes['All']:
|
||||
if c == 'V':
|
||||
continue
|
||||
arr = np.zeros((3, 3), dtype=c)
|
||||
assert_equal(np.triu(arr).dtype, arr.dtype)
|
||||
assert_equal(np.tril(arr).dtype, arr.dtype)
|
||||
|
||||
# check special cases
|
||||
arr = np.array([['2001-01-01T12:00', '2002-02-03T13:56'],
|
||||
['2004-01-01T12:00', '2003-01-03T13:45']],
|
||||
dtype='datetime64')
|
||||
assert_equal(np.triu(arr).dtype, arr.dtype)
|
||||
assert_equal(np.tril(arr).dtype, arr.dtype)
|
||||
|
||||
arr = np.zeros((3, 3), dtype='f4,f4')
|
||||
assert_equal(np.triu(arr).dtype, arr.dtype)
|
||||
assert_equal(np.tril(arr).dtype, arr.dtype)
|
||||
|
||||
|
||||
def test_mask_indices():
|
||||
# simple test without offset
|
||||
iu = mask_indices(3, np.triu)
|
||||
a = np.arange(9).reshape(3, 3)
|
||||
assert_array_equal(a[iu], array([0, 1, 2, 4, 5, 8]))
|
||||
# Now with an offset
|
||||
iu1 = mask_indices(3, np.triu, 1)
|
||||
assert_array_equal(a[iu1], array([1, 2, 5]))
|
||||
|
||||
|
||||
def test_tril_indices():
|
||||
# indices without and with offset
|
||||
il1 = tril_indices(4)
|
||||
il2 = tril_indices(4, k=2)
|
||||
il3 = tril_indices(4, m=5)
|
||||
il4 = tril_indices(4, k=2, m=5)
|
||||
|
||||
a = np.array([[1, 2, 3, 4],
|
||||
[5, 6, 7, 8],
|
||||
[9, 10, 11, 12],
|
||||
[13, 14, 15, 16]])
|
||||
b = np.arange(1, 21).reshape(4, 5)
|
||||
|
||||
# indexing:
|
||||
assert_array_equal(a[il1],
|
||||
array([1, 5, 6, 9, 10, 11, 13, 14, 15, 16]))
|
||||
assert_array_equal(b[il3],
|
||||
array([1, 6, 7, 11, 12, 13, 16, 17, 18, 19]))
|
||||
|
||||
# And for assigning values:
|
||||
a[il1] = -1
|
||||
assert_array_equal(a,
|
||||
array([[-1, 2, 3, 4],
|
||||
[-1, -1, 7, 8],
|
||||
[-1, -1, -1, 12],
|
||||
[-1, -1, -1, -1]]))
|
||||
b[il3] = -1
|
||||
assert_array_equal(b,
|
||||
array([[-1, 2, 3, 4, 5],
|
||||
[-1, -1, 8, 9, 10],
|
||||
[-1, -1, -1, 14, 15],
|
||||
[-1, -1, -1, -1, 20]]))
|
||||
# These cover almost the whole array (two diagonals right of the main one):
|
||||
a[il2] = -10
|
||||
assert_array_equal(a,
|
||||
array([[-10, -10, -10, 4],
|
||||
[-10, -10, -10, -10],
|
||||
[-10, -10, -10, -10],
|
||||
[-10, -10, -10, -10]]))
|
||||
b[il4] = -10
|
||||
assert_array_equal(b,
|
||||
array([[-10, -10, -10, 4, 5],
|
||||
[-10, -10, -10, -10, 10],
|
||||
[-10, -10, -10, -10, -10],
|
||||
[-10, -10, -10, -10, -10]]))
|
||||
|
||||
|
||||
class TestTriuIndices:
|
||||
def test_triu_indices(self):
|
||||
iu1 = triu_indices(4)
|
||||
iu2 = triu_indices(4, k=2)
|
||||
iu3 = triu_indices(4, m=5)
|
||||
iu4 = triu_indices(4, k=2, m=5)
|
||||
|
||||
a = np.array([[1, 2, 3, 4],
|
||||
[5, 6, 7, 8],
|
||||
[9, 10, 11, 12],
|
||||
[13, 14, 15, 16]])
|
||||
b = np.arange(1, 21).reshape(4, 5)
|
||||
|
||||
# Both for indexing:
|
||||
assert_array_equal(a[iu1],
|
||||
array([1, 2, 3, 4, 6, 7, 8, 11, 12, 16]))
|
||||
assert_array_equal(b[iu3],
|
||||
array([1, 2, 3, 4, 5, 7, 8, 9,
|
||||
10, 13, 14, 15, 19, 20]))
|
||||
|
||||
# And for assigning values:
|
||||
a[iu1] = -1
|
||||
assert_array_equal(a,
|
||||
array([[-1, -1, -1, -1],
|
||||
[5, -1, -1, -1],
|
||||
[9, 10, -1, -1],
|
||||
[13, 14, 15, -1]]))
|
||||
b[iu3] = -1
|
||||
assert_array_equal(b,
|
||||
array([[-1, -1, -1, -1, -1],
|
||||
[6, -1, -1, -1, -1],
|
||||
[11, 12, -1, -1, -1],
|
||||
[16, 17, 18, -1, -1]]))
|
||||
|
||||
# These cover almost the whole array (two diagonals right of the
|
||||
# main one):
|
||||
a[iu2] = -10
|
||||
assert_array_equal(a,
|
||||
array([[-1, -1, -10, -10],
|
||||
[5, -1, -1, -10],
|
||||
[9, 10, -1, -1],
|
||||
[13, 14, 15, -1]]))
|
||||
b[iu4] = -10
|
||||
assert_array_equal(b,
|
||||
array([[-1, -1, -10, -10, -10],
|
||||
[6, -1, -1, -10, -10],
|
||||
[11, 12, -1, -1, -10],
|
||||
[16, 17, 18, -1, -1]]))
|
||||
|
||||
|
||||
class TestTrilIndicesFrom:
|
||||
def test_exceptions(self):
|
||||
assert_raises(ValueError, tril_indices_from, np.ones((2,)))
|
||||
assert_raises(ValueError, tril_indices_from, np.ones((2, 2, 2)))
|
||||
# assert_raises(ValueError, tril_indices_from, np.ones((2, 3)))
|
||||
|
||||
|
||||
class TestTriuIndicesFrom:
|
||||
def test_exceptions(self):
|
||||
assert_raises(ValueError, triu_indices_from, np.ones((2,)))
|
||||
assert_raises(ValueError, triu_indices_from, np.ones((2, 2, 2)))
|
||||
# assert_raises(ValueError, triu_indices_from, np.ones((2, 3)))
|
||||
|
||||
|
||||
class TestVander:
|
||||
def test_basic(self):
|
||||
c = np.array([0, 1, -2, 3])
|
||||
v = vander(c)
|
||||
powers = np.array([[0, 0, 0, 0, 1],
|
||||
[1, 1, 1, 1, 1],
|
||||
[16, -8, 4, -2, 1],
|
||||
[81, 27, 9, 3, 1]])
|
||||
# Check default value of N:
|
||||
assert_array_equal(v, powers[:, 1:])
|
||||
# Check a range of N values, including 0 and 5 (greater than default)
|
||||
m = powers.shape[1]
|
||||
for n in range(6):
|
||||
v = vander(c, N=n)
|
||||
assert_array_equal(v, powers[:, m-n:m])
|
||||
|
||||
def test_dtypes(self):
|
||||
c = array([11, -12, 13], dtype=np.int8)
|
||||
v = vander(c)
|
||||
expected = np.array([[121, 11, 1],
|
||||
[144, -12, 1],
|
||||
[169, 13, 1]])
|
||||
assert_array_equal(v, expected)
|
||||
|
||||
c = array([1.0+1j, 1.0-1j])
|
||||
v = vander(c, N=3)
|
||||
expected = np.array([[2j, 1+1j, 1],
|
||||
[-2j, 1-1j, 1]])
|
||||
# The data is floating point, but the values are small integers,
|
||||
# so assert_array_equal *should* be safe here (rather than, say,
|
||||
# assert_array_almost_equal).
|
||||
assert_array_equal(v, expected)
|
||||
@@ -0,0 +1,478 @@
|
||||
import numpy as np
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_raises
|
||||
)
|
||||
from numpy.lib.type_check import (
|
||||
common_type, mintypecode, isreal, iscomplex, isposinf, isneginf,
|
||||
nan_to_num, isrealobj, iscomplexobj, asfarray, real_if_close
|
||||
)
|
||||
|
||||
|
||||
def assert_all(x):
|
||||
assert_(np.all(x), x)
|
||||
|
||||
|
||||
class TestCommonType:
|
||||
def test_basic(self):
|
||||
ai32 = np.array([[1, 2], [3, 4]], dtype=np.int32)
|
||||
af16 = np.array([[1, 2], [3, 4]], dtype=np.float16)
|
||||
af32 = np.array([[1, 2], [3, 4]], dtype=np.float32)
|
||||
af64 = np.array([[1, 2], [3, 4]], dtype=np.float64)
|
||||
acs = np.array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=np.csingle)
|
||||
acd = np.array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=np.cdouble)
|
||||
assert_(common_type(ai32) == np.float64)
|
||||
assert_(common_type(af16) == np.float16)
|
||||
assert_(common_type(af32) == np.float32)
|
||||
assert_(common_type(af64) == np.float64)
|
||||
assert_(common_type(acs) == np.csingle)
|
||||
assert_(common_type(acd) == np.cdouble)
|
||||
|
||||
|
||||
class TestMintypecode:
|
||||
|
||||
def test_default_1(self):
|
||||
for itype in '1bcsuwil':
|
||||
assert_equal(mintypecode(itype), 'd')
|
||||
assert_equal(mintypecode('f'), 'f')
|
||||
assert_equal(mintypecode('d'), 'd')
|
||||
assert_equal(mintypecode('F'), 'F')
|
||||
assert_equal(mintypecode('D'), 'D')
|
||||
|
||||
def test_default_2(self):
|
||||
for itype in '1bcsuwil':
|
||||
assert_equal(mintypecode(itype+'f'), 'f')
|
||||
assert_equal(mintypecode(itype+'d'), 'd')
|
||||
assert_equal(mintypecode(itype+'F'), 'F')
|
||||
assert_equal(mintypecode(itype+'D'), 'D')
|
||||
assert_equal(mintypecode('ff'), 'f')
|
||||
assert_equal(mintypecode('fd'), 'd')
|
||||
assert_equal(mintypecode('fF'), 'F')
|
||||
assert_equal(mintypecode('fD'), 'D')
|
||||
assert_equal(mintypecode('df'), 'd')
|
||||
assert_equal(mintypecode('dd'), 'd')
|
||||
#assert_equal(mintypecode('dF',savespace=1),'F')
|
||||
assert_equal(mintypecode('dF'), 'D')
|
||||
assert_equal(mintypecode('dD'), 'D')
|
||||
assert_equal(mintypecode('Ff'), 'F')
|
||||
#assert_equal(mintypecode('Fd',savespace=1),'F')
|
||||
assert_equal(mintypecode('Fd'), 'D')
|
||||
assert_equal(mintypecode('FF'), 'F')
|
||||
assert_equal(mintypecode('FD'), 'D')
|
||||
assert_equal(mintypecode('Df'), 'D')
|
||||
assert_equal(mintypecode('Dd'), 'D')
|
||||
assert_equal(mintypecode('DF'), 'D')
|
||||
assert_equal(mintypecode('DD'), 'D')
|
||||
|
||||
def test_default_3(self):
|
||||
assert_equal(mintypecode('fdF'), 'D')
|
||||
#assert_equal(mintypecode('fdF',savespace=1),'F')
|
||||
assert_equal(mintypecode('fdD'), 'D')
|
||||
assert_equal(mintypecode('fFD'), 'D')
|
||||
assert_equal(mintypecode('dFD'), 'D')
|
||||
|
||||
assert_equal(mintypecode('ifd'), 'd')
|
||||
assert_equal(mintypecode('ifF'), 'F')
|
||||
assert_equal(mintypecode('ifD'), 'D')
|
||||
assert_equal(mintypecode('idF'), 'D')
|
||||
#assert_equal(mintypecode('idF',savespace=1),'F')
|
||||
assert_equal(mintypecode('idD'), 'D')
|
||||
|
||||
|
||||
class TestIsscalar:
|
||||
|
||||
def test_basic(self):
|
||||
assert_(np.isscalar(3))
|
||||
assert_(not np.isscalar([3]))
|
||||
assert_(not np.isscalar((3,)))
|
||||
assert_(np.isscalar(3j))
|
||||
assert_(np.isscalar(4.0))
|
||||
|
||||
|
||||
class TestReal:
|
||||
|
||||
def test_real(self):
|
||||
y = np.random.rand(10,)
|
||||
assert_array_equal(y, np.real(y))
|
||||
|
||||
y = np.array(1)
|
||||
out = np.real(y)
|
||||
assert_array_equal(y, out)
|
||||
assert_(isinstance(out, np.ndarray))
|
||||
|
||||
y = 1
|
||||
out = np.real(y)
|
||||
assert_equal(y, out)
|
||||
assert_(not isinstance(out, np.ndarray))
|
||||
|
||||
def test_cmplx(self):
|
||||
y = np.random.rand(10,)+1j*np.random.rand(10,)
|
||||
assert_array_equal(y.real, np.real(y))
|
||||
|
||||
y = np.array(1 + 1j)
|
||||
out = np.real(y)
|
||||
assert_array_equal(y.real, out)
|
||||
assert_(isinstance(out, np.ndarray))
|
||||
|
||||
y = 1 + 1j
|
||||
out = np.real(y)
|
||||
assert_equal(1.0, out)
|
||||
assert_(not isinstance(out, np.ndarray))
|
||||
|
||||
|
||||
class TestImag:
|
||||
|
||||
def test_real(self):
|
||||
y = np.random.rand(10,)
|
||||
assert_array_equal(0, np.imag(y))
|
||||
|
||||
y = np.array(1)
|
||||
out = np.imag(y)
|
||||
assert_array_equal(0, out)
|
||||
assert_(isinstance(out, np.ndarray))
|
||||
|
||||
y = 1
|
||||
out = np.imag(y)
|
||||
assert_equal(0, out)
|
||||
assert_(not isinstance(out, np.ndarray))
|
||||
|
||||
def test_cmplx(self):
|
||||
y = np.random.rand(10,)+1j*np.random.rand(10,)
|
||||
assert_array_equal(y.imag, np.imag(y))
|
||||
|
||||
y = np.array(1 + 1j)
|
||||
out = np.imag(y)
|
||||
assert_array_equal(y.imag, out)
|
||||
assert_(isinstance(out, np.ndarray))
|
||||
|
||||
y = 1 + 1j
|
||||
out = np.imag(y)
|
||||
assert_equal(1.0, out)
|
||||
assert_(not isinstance(out, np.ndarray))
|
||||
|
||||
|
||||
class TestIscomplex:
|
||||
|
||||
def test_fail(self):
|
||||
z = np.array([-1, 0, 1])
|
||||
res = iscomplex(z)
|
||||
assert_(not np.any(res, axis=0))
|
||||
|
||||
def test_pass(self):
|
||||
z = np.array([-1j, 1, 0])
|
||||
res = iscomplex(z)
|
||||
assert_array_equal(res, [1, 0, 0])
|
||||
|
||||
|
||||
class TestIsreal:
|
||||
|
||||
def test_pass(self):
|
||||
z = np.array([-1, 0, 1j])
|
||||
res = isreal(z)
|
||||
assert_array_equal(res, [1, 1, 0])
|
||||
|
||||
def test_fail(self):
|
||||
z = np.array([-1j, 1, 0])
|
||||
res = isreal(z)
|
||||
assert_array_equal(res, [0, 1, 1])
|
||||
|
||||
|
||||
class TestIscomplexobj:
|
||||
|
||||
def test_basic(self):
|
||||
z = np.array([-1, 0, 1])
|
||||
assert_(not iscomplexobj(z))
|
||||
z = np.array([-1j, 0, -1])
|
||||
assert_(iscomplexobj(z))
|
||||
|
||||
def test_scalar(self):
|
||||
assert_(not iscomplexobj(1.0))
|
||||
assert_(iscomplexobj(1+0j))
|
||||
|
||||
def test_list(self):
|
||||
assert_(iscomplexobj([3, 1+0j, True]))
|
||||
assert_(not iscomplexobj([3, 1, True]))
|
||||
|
||||
def test_duck(self):
|
||||
class DummyComplexArray:
|
||||
@property
|
||||
def dtype(self):
|
||||
return np.dtype(complex)
|
||||
dummy = DummyComplexArray()
|
||||
assert_(iscomplexobj(dummy))
|
||||
|
||||
def test_pandas_duck(self):
|
||||
# This tests a custom np.dtype duck-typed class, such as used by pandas
|
||||
# (pandas.core.dtypes)
|
||||
class PdComplex(np.complex128):
|
||||
pass
|
||||
class PdDtype:
|
||||
name = 'category'
|
||||
names = None
|
||||
type = PdComplex
|
||||
kind = 'c'
|
||||
str = '<c16'
|
||||
base = np.dtype('complex128')
|
||||
class DummyPd:
|
||||
@property
|
||||
def dtype(self):
|
||||
return PdDtype
|
||||
dummy = DummyPd()
|
||||
assert_(iscomplexobj(dummy))
|
||||
|
||||
def test_custom_dtype_duck(self):
|
||||
class MyArray(list):
|
||||
@property
|
||||
def dtype(self):
|
||||
return complex
|
||||
|
||||
a = MyArray([1+0j, 2+0j, 3+0j])
|
||||
assert_(iscomplexobj(a))
|
||||
|
||||
|
||||
class TestIsrealobj:
|
||||
def test_basic(self):
|
||||
z = np.array([-1, 0, 1])
|
||||
assert_(isrealobj(z))
|
||||
z = np.array([-1j, 0, -1])
|
||||
assert_(not isrealobj(z))
|
||||
|
||||
|
||||
class TestIsnan:
|
||||
|
||||
def test_goodvalues(self):
|
||||
z = np.array((-1., 0., 1.))
|
||||
res = np.isnan(z) == 0
|
||||
assert_all(np.all(res, axis=0))
|
||||
|
||||
def test_posinf(self):
|
||||
with np.errstate(divide='ignore'):
|
||||
assert_all(np.isnan(np.array((1.,))/0.) == 0)
|
||||
|
||||
def test_neginf(self):
|
||||
with np.errstate(divide='ignore'):
|
||||
assert_all(np.isnan(np.array((-1.,))/0.) == 0)
|
||||
|
||||
def test_ind(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isnan(np.array((0.,))/0.) == 1)
|
||||
|
||||
def test_integer(self):
|
||||
assert_all(np.isnan(1) == 0)
|
||||
|
||||
def test_complex(self):
|
||||
assert_all(np.isnan(1+1j) == 0)
|
||||
|
||||
def test_complex1(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isnan(np.array(0+0j)/0.) == 1)
|
||||
|
||||
|
||||
class TestIsfinite:
|
||||
# Fixme, wrong place, isfinite now ufunc
|
||||
|
||||
def test_goodvalues(self):
|
||||
z = np.array((-1., 0., 1.))
|
||||
res = np.isfinite(z) == 1
|
||||
assert_all(np.all(res, axis=0))
|
||||
|
||||
def test_posinf(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isfinite(np.array((1.,))/0.) == 0)
|
||||
|
||||
def test_neginf(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isfinite(np.array((-1.,))/0.) == 0)
|
||||
|
||||
def test_ind(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isfinite(np.array((0.,))/0.) == 0)
|
||||
|
||||
def test_integer(self):
|
||||
assert_all(np.isfinite(1) == 1)
|
||||
|
||||
def test_complex(self):
|
||||
assert_all(np.isfinite(1+1j) == 1)
|
||||
|
||||
def test_complex1(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isfinite(np.array(1+1j)/0.) == 0)
|
||||
|
||||
|
||||
class TestIsinf:
|
||||
# Fixme, wrong place, isinf now ufunc
|
||||
|
||||
def test_goodvalues(self):
|
||||
z = np.array((-1., 0., 1.))
|
||||
res = np.isinf(z) == 0
|
||||
assert_all(np.all(res, axis=0))
|
||||
|
||||
def test_posinf(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isinf(np.array((1.,))/0.) == 1)
|
||||
|
||||
def test_posinf_scalar(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isinf(np.array(1.,)/0.) == 1)
|
||||
|
||||
def test_neginf(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isinf(np.array((-1.,))/0.) == 1)
|
||||
|
||||
def test_neginf_scalar(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isinf(np.array(-1.)/0.) == 1)
|
||||
|
||||
def test_ind(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
assert_all(np.isinf(np.array((0.,))/0.) == 0)
|
||||
|
||||
|
||||
class TestIsposinf:
|
||||
|
||||
def test_generic(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = isposinf(np.array((-1., 0, 1))/0.)
|
||||
assert_(vals[0] == 0)
|
||||
assert_(vals[1] == 0)
|
||||
assert_(vals[2] == 1)
|
||||
|
||||
|
||||
class TestIsneginf:
|
||||
|
||||
def test_generic(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = isneginf(np.array((-1., 0, 1))/0.)
|
||||
assert_(vals[0] == 1)
|
||||
assert_(vals[1] == 0)
|
||||
assert_(vals[2] == 0)
|
||||
|
||||
|
||||
class TestNanToNum:
|
||||
|
||||
def test_generic(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = nan_to_num(np.array((-1., 0, 1))/0.)
|
||||
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
|
||||
assert_(vals[1] == 0)
|
||||
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
|
||||
# perform the same tests but with nan, posinf and neginf keywords
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = nan_to_num(np.array((-1., 0, 1))/0.,
|
||||
nan=10, posinf=20, neginf=30)
|
||||
assert_equal(vals, [30, 10, 20])
|
||||
assert_all(np.isfinite(vals[[0, 2]]))
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
|
||||
# perform the same test but in-place
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = np.array((-1., 0, 1))/0.
|
||||
result = nan_to_num(vals, copy=False)
|
||||
|
||||
assert_(result is vals)
|
||||
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
|
||||
assert_(vals[1] == 0)
|
||||
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
|
||||
# perform the same test but in-place
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = np.array((-1., 0, 1))/0.
|
||||
result = nan_to_num(vals, copy=False, nan=10, posinf=20, neginf=30)
|
||||
|
||||
assert_(result is vals)
|
||||
assert_equal(vals, [30, 10, 20])
|
||||
assert_all(np.isfinite(vals[[0, 2]]))
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
|
||||
def test_array(self):
|
||||
vals = nan_to_num([1])
|
||||
assert_array_equal(vals, np.array([1], int))
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
vals = nan_to_num([1], nan=10, posinf=20, neginf=30)
|
||||
assert_array_equal(vals, np.array([1], int))
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
|
||||
def test_integer(self):
|
||||
vals = nan_to_num(1)
|
||||
assert_all(vals == 1)
|
||||
assert_equal(type(vals), np.int_)
|
||||
vals = nan_to_num(1, nan=10, posinf=20, neginf=30)
|
||||
assert_all(vals == 1)
|
||||
assert_equal(type(vals), np.int_)
|
||||
|
||||
def test_float(self):
|
||||
vals = nan_to_num(1.0)
|
||||
assert_all(vals == 1.0)
|
||||
assert_equal(type(vals), np.float_)
|
||||
vals = nan_to_num(1.1, nan=10, posinf=20, neginf=30)
|
||||
assert_all(vals == 1.1)
|
||||
assert_equal(type(vals), np.float_)
|
||||
|
||||
def test_complex_good(self):
|
||||
vals = nan_to_num(1+1j)
|
||||
assert_all(vals == 1+1j)
|
||||
assert_equal(type(vals), np.complex_)
|
||||
vals = nan_to_num(1+1j, nan=10, posinf=20, neginf=30)
|
||||
assert_all(vals == 1+1j)
|
||||
assert_equal(type(vals), np.complex_)
|
||||
|
||||
def test_complex_bad(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
v = 1 + 1j
|
||||
v += np.array(0+1.j)/0.
|
||||
vals = nan_to_num(v)
|
||||
# !! This is actually (unexpectedly) zero
|
||||
assert_all(np.isfinite(vals))
|
||||
assert_equal(type(vals), np.complex_)
|
||||
|
||||
def test_complex_bad2(self):
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
v = 1 + 1j
|
||||
v += np.array(-1+1.j)/0.
|
||||
vals = nan_to_num(v)
|
||||
assert_all(np.isfinite(vals))
|
||||
assert_equal(type(vals), np.complex_)
|
||||
# Fixme
|
||||
#assert_all(vals.imag > 1e10) and assert_all(np.isfinite(vals))
|
||||
# !! This is actually (unexpectedly) positive
|
||||
# !! inf. Comment out for now, and see if it
|
||||
# !! changes
|
||||
#assert_all(vals.real < -1e10) and assert_all(np.isfinite(vals))
|
||||
|
||||
def test_do_not_rewrite_previous_keyword(self):
|
||||
# This is done to test that when, for instance, nan=np.inf then these
|
||||
# values are not rewritten by posinf keyword to the posinf value.
|
||||
with np.errstate(divide='ignore', invalid='ignore'):
|
||||
vals = nan_to_num(np.array((-1., 0, 1))/0., nan=np.inf, posinf=999)
|
||||
assert_all(np.isfinite(vals[[0, 2]]))
|
||||
assert_all(vals[0] < -1e10)
|
||||
assert_equal(vals[[1, 2]], [np.inf, 999])
|
||||
assert_equal(type(vals), np.ndarray)
|
||||
|
||||
|
||||
class TestRealIfClose:
|
||||
|
||||
def test_basic(self):
|
||||
a = np.random.rand(10)
|
||||
b = real_if_close(a+1e-15j)
|
||||
assert_all(isrealobj(b))
|
||||
assert_array_equal(a, b)
|
||||
b = real_if_close(a+1e-7j)
|
||||
assert_all(iscomplexobj(b))
|
||||
b = real_if_close(a+1e-7j, tol=1e-6)
|
||||
assert_all(isrealobj(b))
|
||||
|
||||
|
||||
class TestArrayConversion:
|
||||
|
||||
def test_asfarray(self):
|
||||
a = asfarray(np.array([1, 2, 3]))
|
||||
assert_equal(a.__class__, np.ndarray)
|
||||
assert_(np.issubdtype(a.dtype, np.floating))
|
||||
|
||||
# previously this would infer dtypes from arrays, unlike every single
|
||||
# other numpy function
|
||||
assert_raises(TypeError,
|
||||
asfarray, np.array([1, 2, 3]), dtype=np.array(1.0))
|
||||
@@ -0,0 +1,98 @@
|
||||
import numpy as np
|
||||
import numpy.core as nx
|
||||
import numpy.lib.ufunclike as ufl
|
||||
from numpy.testing import (
|
||||
assert_, assert_equal, assert_array_equal, assert_warns, assert_raises
|
||||
)
|
||||
|
||||
|
||||
class TestUfunclike:
|
||||
|
||||
def test_isposinf(self):
|
||||
a = nx.array([nx.inf, -nx.inf, nx.nan, 0.0, 3.0, -3.0])
|
||||
out = nx.zeros(a.shape, bool)
|
||||
tgt = nx.array([True, False, False, False, False, False])
|
||||
|
||||
res = ufl.isposinf(a)
|
||||
assert_equal(res, tgt)
|
||||
res = ufl.isposinf(a, out)
|
||||
assert_equal(res, tgt)
|
||||
assert_equal(out, tgt)
|
||||
|
||||
a = a.astype(np.complex_)
|
||||
with assert_raises(TypeError):
|
||||
ufl.isposinf(a)
|
||||
|
||||
def test_isneginf(self):
|
||||
a = nx.array([nx.inf, -nx.inf, nx.nan, 0.0, 3.0, -3.0])
|
||||
out = nx.zeros(a.shape, bool)
|
||||
tgt = nx.array([False, True, False, False, False, False])
|
||||
|
||||
res = ufl.isneginf(a)
|
||||
assert_equal(res, tgt)
|
||||
res = ufl.isneginf(a, out)
|
||||
assert_equal(res, tgt)
|
||||
assert_equal(out, tgt)
|
||||
|
||||
a = a.astype(np.complex_)
|
||||
with assert_raises(TypeError):
|
||||
ufl.isneginf(a)
|
||||
|
||||
def test_fix(self):
|
||||
a = nx.array([[1.0, 1.1, 1.5, 1.8], [-1.0, -1.1, -1.5, -1.8]])
|
||||
out = nx.zeros(a.shape, float)
|
||||
tgt = nx.array([[1., 1., 1., 1.], [-1., -1., -1., -1.]])
|
||||
|
||||
res = ufl.fix(a)
|
||||
assert_equal(res, tgt)
|
||||
res = ufl.fix(a, out)
|
||||
assert_equal(res, tgt)
|
||||
assert_equal(out, tgt)
|
||||
assert_equal(ufl.fix(3.14), 3)
|
||||
|
||||
def test_fix_with_subclass(self):
|
||||
class MyArray(nx.ndarray):
|
||||
def __new__(cls, data, metadata=None):
|
||||
res = nx.array(data, copy=True).view(cls)
|
||||
res.metadata = metadata
|
||||
return res
|
||||
|
||||
def __array_wrap__(self, obj, context=None):
|
||||
if isinstance(obj, MyArray):
|
||||
obj.metadata = self.metadata
|
||||
return obj
|
||||
|
||||
def __array_finalize__(self, obj):
|
||||
self.metadata = getattr(obj, 'metadata', None)
|
||||
return self
|
||||
|
||||
a = nx.array([1.1, -1.1])
|
||||
m = MyArray(a, metadata='foo')
|
||||
f = ufl.fix(m)
|
||||
assert_array_equal(f, nx.array([1, -1]))
|
||||
assert_(isinstance(f, MyArray))
|
||||
assert_equal(f.metadata, 'foo')
|
||||
|
||||
# check 0d arrays don't decay to scalars
|
||||
m0d = m[0,...]
|
||||
m0d.metadata = 'bar'
|
||||
f0d = ufl.fix(m0d)
|
||||
assert_(isinstance(f0d, MyArray))
|
||||
assert_equal(f0d.metadata, 'bar')
|
||||
|
||||
def test_scalar(self):
|
||||
x = np.inf
|
||||
actual = np.isposinf(x)
|
||||
expected = np.True_
|
||||
assert_equal(actual, expected)
|
||||
assert_equal(type(actual), type(expected))
|
||||
|
||||
x = -3.4
|
||||
actual = np.fix(x)
|
||||
expected = np.float64(-3.0)
|
||||
assert_equal(actual, expected)
|
||||
assert_equal(type(actual), type(expected))
|
||||
|
||||
out = np.array(0.0)
|
||||
actual = np.fix(x, out=out)
|
||||
assert_(actual is out)
|
||||
@@ -0,0 +1,228 @@
|
||||
import inspect
|
||||
import sys
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
from numpy.core import arange
|
||||
from numpy.testing import assert_, assert_equal, assert_raises_regex
|
||||
from numpy.lib import deprecate, deprecate_with_doc
|
||||
import numpy.lib.utils as utils
|
||||
|
||||
from io import StringIO
|
||||
|
||||
|
||||
@pytest.mark.skipif(sys.flags.optimize == 2, reason="Python running -OO")
|
||||
@pytest.mark.skipif(
|
||||
sys.version_info == (3, 10, 0, "candidate", 1),
|
||||
reason="Broken as of bpo-44524",
|
||||
)
|
||||
def test_lookfor():
|
||||
out = StringIO()
|
||||
utils.lookfor('eigenvalue', module='numpy', output=out,
|
||||
import_modules=False)
|
||||
out = out.getvalue()
|
||||
assert_('numpy.linalg.eig' in out)
|
||||
|
||||
|
||||
@deprecate
|
||||
def old_func(self, x):
|
||||
return x
|
||||
|
||||
|
||||
@deprecate(message="Rather use new_func2")
|
||||
def old_func2(self, x):
|
||||
return x
|
||||
|
||||
|
||||
def old_func3(self, x):
|
||||
return x
|
||||
new_func3 = deprecate(old_func3, old_name="old_func3", new_name="new_func3")
|
||||
|
||||
|
||||
def old_func4(self, x):
|
||||
"""Summary.
|
||||
|
||||
Further info.
|
||||
"""
|
||||
return x
|
||||
new_func4 = deprecate(old_func4)
|
||||
|
||||
|
||||
def old_func5(self, x):
|
||||
"""Summary.
|
||||
|
||||
Bizarre indentation.
|
||||
"""
|
||||
return x
|
||||
new_func5 = deprecate(old_func5, message="This function is\ndeprecated.")
|
||||
|
||||
|
||||
def old_func6(self, x):
|
||||
"""
|
||||
Also in PEP-257.
|
||||
"""
|
||||
return x
|
||||
new_func6 = deprecate(old_func6)
|
||||
|
||||
|
||||
@deprecate_with_doc(msg="Rather use new_func7")
|
||||
def old_func7(self,x):
|
||||
return x
|
||||
|
||||
|
||||
def test_deprecate_decorator():
|
||||
assert_('deprecated' in old_func.__doc__)
|
||||
|
||||
|
||||
def test_deprecate_decorator_message():
|
||||
assert_('Rather use new_func2' in old_func2.__doc__)
|
||||
|
||||
|
||||
def test_deprecate_fn():
|
||||
assert_('old_func3' in new_func3.__doc__)
|
||||
assert_('new_func3' in new_func3.__doc__)
|
||||
|
||||
|
||||
def test_deprecate_with_doc_decorator_message():
|
||||
assert_('Rather use new_func7' in old_func7.__doc__)
|
||||
|
||||
|
||||
@pytest.mark.skipif(sys.flags.optimize == 2, reason="-OO discards docstrings")
|
||||
@pytest.mark.parametrize('old_func, new_func', [
|
||||
(old_func4, new_func4),
|
||||
(old_func5, new_func5),
|
||||
(old_func6, new_func6),
|
||||
])
|
||||
def test_deprecate_help_indentation(old_func, new_func):
|
||||
_compare_docs(old_func, new_func)
|
||||
# Ensure we don't mess up the indentation
|
||||
for knd, func in (('old', old_func), ('new', new_func)):
|
||||
for li, line in enumerate(func.__doc__.split('\n')):
|
||||
if li == 0:
|
||||
assert line.startswith(' ') or not line.startswith(' '), knd
|
||||
elif line:
|
||||
assert line.startswith(' '), knd
|
||||
|
||||
|
||||
def _compare_docs(old_func, new_func):
|
||||
old_doc = inspect.getdoc(old_func)
|
||||
new_doc = inspect.getdoc(new_func)
|
||||
index = new_doc.index('\n\n') + 2
|
||||
assert_equal(new_doc[index:], old_doc)
|
||||
|
||||
|
||||
@pytest.mark.skipif(sys.flags.optimize == 2, reason="-OO discards docstrings")
|
||||
def test_deprecate_preserve_whitespace():
|
||||
assert_('\n Bizarre' in new_func5.__doc__)
|
||||
|
||||
|
||||
def test_deprecate_module():
|
||||
assert_(old_func.__module__ == __name__)
|
||||
|
||||
|
||||
def test_safe_eval_nameconstant():
|
||||
# Test if safe_eval supports Python 3.4 _ast.NameConstant
|
||||
utils.safe_eval('None')
|
||||
|
||||
|
||||
class TestByteBounds:
|
||||
|
||||
def test_byte_bounds(self):
|
||||
# pointer difference matches size * itemsize
|
||||
# due to contiguity
|
||||
a = arange(12).reshape(3, 4)
|
||||
low, high = utils.byte_bounds(a)
|
||||
assert_equal(high - low, a.size * a.itemsize)
|
||||
|
||||
def test_unusual_order_positive_stride(self):
|
||||
a = arange(12).reshape(3, 4)
|
||||
b = a.T
|
||||
low, high = utils.byte_bounds(b)
|
||||
assert_equal(high - low, b.size * b.itemsize)
|
||||
|
||||
def test_unusual_order_negative_stride(self):
|
||||
a = arange(12).reshape(3, 4)
|
||||
b = a.T[::-1]
|
||||
low, high = utils.byte_bounds(b)
|
||||
assert_equal(high - low, b.size * b.itemsize)
|
||||
|
||||
def test_strided(self):
|
||||
a = arange(12)
|
||||
b = a[::2]
|
||||
low, high = utils.byte_bounds(b)
|
||||
# the largest pointer address is lost (even numbers only in the
|
||||
# stride), and compensate addresses for striding by 2
|
||||
assert_equal(high - low, b.size * 2 * b.itemsize - b.itemsize)
|
||||
|
||||
|
||||
def test_assert_raises_regex_context_manager():
|
||||
with assert_raises_regex(ValueError, 'no deprecation warning'):
|
||||
raise ValueError('no deprecation warning')
|
||||
|
||||
|
||||
def test_info_method_heading():
|
||||
# info(class) should only print "Methods:" heading if methods exist
|
||||
|
||||
class NoPublicMethods:
|
||||
pass
|
||||
|
||||
class WithPublicMethods:
|
||||
def first_method():
|
||||
pass
|
||||
|
||||
def _has_method_heading(cls):
|
||||
out = StringIO()
|
||||
utils.info(cls, output=out)
|
||||
return 'Methods:' in out.getvalue()
|
||||
|
||||
assert _has_method_heading(WithPublicMethods)
|
||||
assert not _has_method_heading(NoPublicMethods)
|
||||
|
||||
|
||||
def test_drop_metadata():
|
||||
def _compare_dtypes(dt1, dt2):
|
||||
return np.can_cast(dt1, dt2, casting='no')
|
||||
|
||||
# structured dtype
|
||||
dt = np.dtype([('l1', [('l2', np.dtype('S8', metadata={'msg': 'toto'}))])],
|
||||
metadata={'msg': 'titi'})
|
||||
dt_m = utils.drop_metadata(dt)
|
||||
assert _compare_dtypes(dt, dt_m) is True
|
||||
assert dt_m.metadata is None
|
||||
assert dt_m['l1'].metadata is None
|
||||
assert dt_m['l1']['l2'].metadata is None
|
||||
|
||||
# alignement
|
||||
dt = np.dtype([('x', '<f8'), ('y', '<i4')],
|
||||
align=True,
|
||||
metadata={'msg': 'toto'})
|
||||
dt_m = utils.drop_metadata(dt)
|
||||
assert _compare_dtypes(dt, dt_m) is True
|
||||
assert dt_m.metadata is None
|
||||
|
||||
# subdtype
|
||||
dt = np.dtype('8f',
|
||||
metadata={'msg': 'toto'})
|
||||
dt_m = utils.drop_metadata(dt)
|
||||
assert _compare_dtypes(dt, dt_m) is True
|
||||
assert dt_m.metadata is None
|
||||
|
||||
# scalar
|
||||
dt = np.dtype('uint32',
|
||||
metadata={'msg': 'toto'})
|
||||
dt_m = utils.drop_metadata(dt)
|
||||
assert _compare_dtypes(dt, dt_m) is True
|
||||
assert dt_m.metadata is None
|
||||
|
||||
|
||||
@pytest.mark.parametrize("dtype",
|
||||
[np.dtype("i,i,i,i")[["f1", "f3"]],
|
||||
np.dtype("f8"),
|
||||
np.dtype("10i")])
|
||||
def test_drop_metadata_identity_and_copy(dtype):
|
||||
# If there is no metadata, the identity is preserved:
|
||||
assert utils.drop_metadata(dtype) is dtype
|
||||
|
||||
# If there is any, it is dropped (subforms are checked above)
|
||||
dtype = np.dtype(dtype, metadata={1: 2})
|
||||
assert utils.drop_metadata(dtype).metadata is None
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,239 @@
|
||||
from collections.abc import Callable, Sequence
|
||||
from typing import (
|
||||
Any,
|
||||
overload,
|
||||
TypeVar,
|
||||
Union,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
generic,
|
||||
number,
|
||||
bool_,
|
||||
timedelta64,
|
||||
datetime64,
|
||||
int_,
|
||||
intp,
|
||||
float64,
|
||||
signedinteger,
|
||||
floating,
|
||||
complexfloating,
|
||||
object_,
|
||||
_OrderCF,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
DTypeLike,
|
||||
_DTypeLike,
|
||||
ArrayLike,
|
||||
_ArrayLike,
|
||||
NDArray,
|
||||
_SupportsArrayFunc,
|
||||
_ArrayLikeInt_co,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeComplex_co,
|
||||
_ArrayLikeObject_co,
|
||||
)
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
|
||||
# The returned arrays dtype must be compatible with `np.equal`
|
||||
_MaskFunc = Callable[
|
||||
[NDArray[int_], _T],
|
||||
NDArray[Union[number[Any], bool_, timedelta64, datetime64, object_]],
|
||||
]
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
@overload
|
||||
def fliplr(m: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def fliplr(m: ArrayLike) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def flipud(m: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def flipud(m: ArrayLike) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def eye(
|
||||
N: int,
|
||||
M: None | int = ...,
|
||||
k: int = ...,
|
||||
dtype: None = ...,
|
||||
order: _OrderCF = ...,
|
||||
*,
|
||||
like: None | _SupportsArrayFunc = ...,
|
||||
) -> NDArray[float64]: ...
|
||||
@overload
|
||||
def eye(
|
||||
N: int,
|
||||
M: None | int = ...,
|
||||
k: int = ...,
|
||||
dtype: _DTypeLike[_SCT] = ...,
|
||||
order: _OrderCF = ...,
|
||||
*,
|
||||
like: None | _SupportsArrayFunc = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def eye(
|
||||
N: int,
|
||||
M: None | int = ...,
|
||||
k: int = ...,
|
||||
dtype: DTypeLike = ...,
|
||||
order: _OrderCF = ...,
|
||||
*,
|
||||
like: None | _SupportsArrayFunc = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def diag(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def diag(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def diagflat(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def diagflat(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def tri(
|
||||
N: int,
|
||||
M: None | int = ...,
|
||||
k: int = ...,
|
||||
dtype: None = ...,
|
||||
*,
|
||||
like: None | _SupportsArrayFunc = ...
|
||||
) -> NDArray[float64]: ...
|
||||
@overload
|
||||
def tri(
|
||||
N: int,
|
||||
M: None | int = ...,
|
||||
k: int = ...,
|
||||
dtype: _DTypeLike[_SCT] = ...,
|
||||
*,
|
||||
like: None | _SupportsArrayFunc = ...
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def tri(
|
||||
N: int,
|
||||
M: None | int = ...,
|
||||
k: int = ...,
|
||||
dtype: DTypeLike = ...,
|
||||
*,
|
||||
like: None | _SupportsArrayFunc = ...
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def tril(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def tril(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def triu(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def triu(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def vander( # type: ignore[misc]
|
||||
x: _ArrayLikeInt_co,
|
||||
N: None | int = ...,
|
||||
increasing: bool = ...,
|
||||
) -> NDArray[signedinteger[Any]]: ...
|
||||
@overload
|
||||
def vander( # type: ignore[misc]
|
||||
x: _ArrayLikeFloat_co,
|
||||
N: None | int = ...,
|
||||
increasing: bool = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def vander(
|
||||
x: _ArrayLikeComplex_co,
|
||||
N: None | int = ...,
|
||||
increasing: bool = ...,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def vander(
|
||||
x: _ArrayLikeObject_co,
|
||||
N: None | int = ...,
|
||||
increasing: bool = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
|
||||
@overload
|
||||
def histogram2d( # type: ignore[misc]
|
||||
x: _ArrayLikeFloat_co,
|
||||
y: _ArrayLikeFloat_co,
|
||||
bins: int | Sequence[int] = ...,
|
||||
range: None | _ArrayLikeFloat_co = ...,
|
||||
density: None | bool = ...,
|
||||
weights: None | _ArrayLikeFloat_co = ...,
|
||||
) -> tuple[
|
||||
NDArray[float64],
|
||||
NDArray[floating[Any]],
|
||||
NDArray[floating[Any]],
|
||||
]: ...
|
||||
@overload
|
||||
def histogram2d(
|
||||
x: _ArrayLikeComplex_co,
|
||||
y: _ArrayLikeComplex_co,
|
||||
bins: int | Sequence[int] = ...,
|
||||
range: None | _ArrayLikeFloat_co = ...,
|
||||
density: None | bool = ...,
|
||||
weights: None | _ArrayLikeFloat_co = ...,
|
||||
) -> tuple[
|
||||
NDArray[float64],
|
||||
NDArray[complexfloating[Any, Any]],
|
||||
NDArray[complexfloating[Any, Any]],
|
||||
]: ...
|
||||
@overload # TODO: Sort out `bins`
|
||||
def histogram2d(
|
||||
x: _ArrayLikeComplex_co,
|
||||
y: _ArrayLikeComplex_co,
|
||||
bins: Sequence[_ArrayLikeInt_co],
|
||||
range: None | _ArrayLikeFloat_co = ...,
|
||||
density: None | bool = ...,
|
||||
weights: None | _ArrayLikeFloat_co = ...,
|
||||
) -> tuple[
|
||||
NDArray[float64],
|
||||
NDArray[Any],
|
||||
NDArray[Any],
|
||||
]: ...
|
||||
|
||||
# NOTE: we're assuming/demanding here the `mask_func` returns
|
||||
# an ndarray of shape `(n, n)`; otherwise there is the possibility
|
||||
# of the output tuple having more or less than 2 elements
|
||||
@overload
|
||||
def mask_indices(
|
||||
n: int,
|
||||
mask_func: _MaskFunc[int],
|
||||
k: int = ...,
|
||||
) -> tuple[NDArray[intp], NDArray[intp]]: ...
|
||||
@overload
|
||||
def mask_indices(
|
||||
n: int,
|
||||
mask_func: _MaskFunc[_T],
|
||||
k: _T,
|
||||
) -> tuple[NDArray[intp], NDArray[intp]]: ...
|
||||
|
||||
def tril_indices(
|
||||
n: int,
|
||||
k: int = ...,
|
||||
m: None | int = ...,
|
||||
) -> tuple[NDArray[int_], NDArray[int_]]: ...
|
||||
|
||||
def tril_indices_from(
|
||||
arr: NDArray[Any],
|
||||
k: int = ...,
|
||||
) -> tuple[NDArray[int_], NDArray[int_]]: ...
|
||||
|
||||
def triu_indices(
|
||||
n: int,
|
||||
k: int = ...,
|
||||
m: None | int = ...,
|
||||
) -> tuple[NDArray[int_], NDArray[int_]]: ...
|
||||
|
||||
def triu_indices_from(
|
||||
arr: NDArray[Any],
|
||||
k: int = ...,
|
||||
) -> tuple[NDArray[int_], NDArray[int_]]: ...
|
||||
@@ -0,0 +1,735 @@
|
||||
"""Automatically adapted for numpy Sep 19, 2005 by convertcode.py
|
||||
|
||||
"""
|
||||
import functools
|
||||
|
||||
__all__ = ['iscomplexobj', 'isrealobj', 'imag', 'iscomplex',
|
||||
'isreal', 'nan_to_num', 'real', 'real_if_close',
|
||||
'typename', 'asfarray', 'mintypecode',
|
||||
'common_type']
|
||||
|
||||
from .._utils import set_module
|
||||
import numpy.core.numeric as _nx
|
||||
from numpy.core.numeric import asarray, asanyarray, isnan, zeros
|
||||
from numpy.core import overrides, getlimits
|
||||
from .ufunclike import isneginf, isposinf
|
||||
|
||||
|
||||
array_function_dispatch = functools.partial(
|
||||
overrides.array_function_dispatch, module='numpy')
|
||||
|
||||
|
||||
_typecodes_by_elsize = 'GDFgdfQqLlIiHhBb?'
|
||||
|
||||
|
||||
@set_module('numpy')
|
||||
def mintypecode(typechars, typeset='GDFgdf', default='d'):
|
||||
"""
|
||||
Return the character for the minimum-size type to which given types can
|
||||
be safely cast.
|
||||
|
||||
The returned type character must represent the smallest size dtype such
|
||||
that an array of the returned type can handle the data from an array of
|
||||
all types in `typechars` (or if `typechars` is an array, then its
|
||||
dtype.char).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
typechars : list of str or array_like
|
||||
If a list of strings, each string should represent a dtype.
|
||||
If array_like, the character representation of the array dtype is used.
|
||||
typeset : str or list of str, optional
|
||||
The set of characters that the returned character is chosen from.
|
||||
The default set is 'GDFgdf'.
|
||||
default : str, optional
|
||||
The default character, this is returned if none of the characters in
|
||||
`typechars` matches a character in `typeset`.
|
||||
|
||||
Returns
|
||||
-------
|
||||
typechar : str
|
||||
The character representing the minimum-size type that was found.
|
||||
|
||||
See Also
|
||||
--------
|
||||
dtype, sctype2char, maximum_sctype
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.mintypecode(['d', 'f', 'S'])
|
||||
'd'
|
||||
>>> x = np.array([1.1, 2-3.j])
|
||||
>>> np.mintypecode(x)
|
||||
'D'
|
||||
|
||||
>>> np.mintypecode('abceh', default='G')
|
||||
'G'
|
||||
|
||||
"""
|
||||
typecodes = ((isinstance(t, str) and t) or asarray(t).dtype.char
|
||||
for t in typechars)
|
||||
intersection = set(t for t in typecodes if t in typeset)
|
||||
if not intersection:
|
||||
return default
|
||||
if 'F' in intersection and 'd' in intersection:
|
||||
return 'D'
|
||||
return min(intersection, key=_typecodes_by_elsize.index)
|
||||
|
||||
|
||||
def _asfarray_dispatcher(a, dtype=None):
|
||||
return (a,)
|
||||
|
||||
|
||||
@array_function_dispatch(_asfarray_dispatcher)
|
||||
def asfarray(a, dtype=_nx.float_):
|
||||
"""
|
||||
Return an array converted to a float type.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
a : array_like
|
||||
The input array.
|
||||
dtype : str or dtype object, optional
|
||||
Float type code to coerce input array `a`. If `dtype` is one of the
|
||||
'int' dtypes, it is replaced with float64.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray
|
||||
The input `a` as a float ndarray.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.asfarray([2, 3])
|
||||
array([2., 3.])
|
||||
>>> np.asfarray([2, 3], dtype='float')
|
||||
array([2., 3.])
|
||||
>>> np.asfarray([2, 3], dtype='int8')
|
||||
array([2., 3.])
|
||||
|
||||
"""
|
||||
if not _nx.issubdtype(dtype, _nx.inexact):
|
||||
dtype = _nx.float_
|
||||
return asarray(a, dtype=dtype)
|
||||
|
||||
|
||||
def _real_dispatcher(val):
|
||||
return (val,)
|
||||
|
||||
|
||||
@array_function_dispatch(_real_dispatcher)
|
||||
def real(val):
|
||||
"""
|
||||
Return the real part of the complex argument.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
val : array_like
|
||||
Input array.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The real component of the complex argument. If `val` is real, the type
|
||||
of `val` is used for the output. If `val` has complex elements, the
|
||||
returned type is float.
|
||||
|
||||
See Also
|
||||
--------
|
||||
real_if_close, imag, angle
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.array([1+2j, 3+4j, 5+6j])
|
||||
>>> a.real
|
||||
array([1., 3., 5.])
|
||||
>>> a.real = 9
|
||||
>>> a
|
||||
array([9.+2.j, 9.+4.j, 9.+6.j])
|
||||
>>> a.real = np.array([9, 8, 7])
|
||||
>>> a
|
||||
array([9.+2.j, 8.+4.j, 7.+6.j])
|
||||
>>> np.real(1 + 1j)
|
||||
1.0
|
||||
|
||||
"""
|
||||
try:
|
||||
return val.real
|
||||
except AttributeError:
|
||||
return asanyarray(val).real
|
||||
|
||||
|
||||
def _imag_dispatcher(val):
|
||||
return (val,)
|
||||
|
||||
|
||||
@array_function_dispatch(_imag_dispatcher)
|
||||
def imag(val):
|
||||
"""
|
||||
Return the imaginary part of the complex argument.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
val : array_like
|
||||
Input array.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray or scalar
|
||||
The imaginary component of the complex argument. If `val` is real,
|
||||
the type of `val` is used for the output. If `val` has complex
|
||||
elements, the returned type is float.
|
||||
|
||||
See Also
|
||||
--------
|
||||
real, angle, real_if_close
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.array([1+2j, 3+4j, 5+6j])
|
||||
>>> a.imag
|
||||
array([2., 4., 6.])
|
||||
>>> a.imag = np.array([8, 10, 12])
|
||||
>>> a
|
||||
array([1. +8.j, 3.+10.j, 5.+12.j])
|
||||
>>> np.imag(1 + 1j)
|
||||
1.0
|
||||
|
||||
"""
|
||||
try:
|
||||
return val.imag
|
||||
except AttributeError:
|
||||
return asanyarray(val).imag
|
||||
|
||||
|
||||
def _is_type_dispatcher(x):
|
||||
return (x,)
|
||||
|
||||
|
||||
@array_function_dispatch(_is_type_dispatcher)
|
||||
def iscomplex(x):
|
||||
"""
|
||||
Returns a bool array, where True if input element is complex.
|
||||
|
||||
What is tested is whether the input has a non-zero imaginary part, not if
|
||||
the input type is complex.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
Input array.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray of bools
|
||||
Output array.
|
||||
|
||||
See Also
|
||||
--------
|
||||
isreal
|
||||
iscomplexobj : Return True if x is a complex type or an array of complex
|
||||
numbers.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
|
||||
array([ True, False, False, False, False, True])
|
||||
|
||||
"""
|
||||
ax = asanyarray(x)
|
||||
if issubclass(ax.dtype.type, _nx.complexfloating):
|
||||
return ax.imag != 0
|
||||
res = zeros(ax.shape, bool)
|
||||
return res[()] # convert to scalar if needed
|
||||
|
||||
|
||||
@array_function_dispatch(_is_type_dispatcher)
|
||||
def isreal(x):
|
||||
"""
|
||||
Returns a bool array, where True if input element is real.
|
||||
|
||||
If element has complex type with zero complex part, the return value
|
||||
for that element is True.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
Input array.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray, bool
|
||||
Boolean array of same shape as `x`.
|
||||
|
||||
Notes
|
||||
-----
|
||||
`isreal` may behave unexpectedly for string or object arrays (see examples)
|
||||
|
||||
See Also
|
||||
--------
|
||||
iscomplex
|
||||
isrealobj : Return True if x is not a complex type.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
|
||||
>>> np.isreal(a)
|
||||
array([False, True, True, True, True, False])
|
||||
|
||||
The function does not work on string arrays.
|
||||
|
||||
>>> a = np.array([2j, "a"], dtype="U")
|
||||
>>> np.isreal(a) # Warns about non-elementwise comparison
|
||||
False
|
||||
|
||||
Returns True for all elements in input array of ``dtype=object`` even if
|
||||
any of the elements is complex.
|
||||
|
||||
>>> a = np.array([1, "2", 3+4j], dtype=object)
|
||||
>>> np.isreal(a)
|
||||
array([ True, True, True])
|
||||
|
||||
isreal should not be used with object arrays
|
||||
|
||||
>>> a = np.array([1+2j, 2+1j], dtype=object)
|
||||
>>> np.isreal(a)
|
||||
array([ True, True])
|
||||
|
||||
"""
|
||||
return imag(x) == 0
|
||||
|
||||
|
||||
@array_function_dispatch(_is_type_dispatcher)
|
||||
def iscomplexobj(x):
|
||||
"""
|
||||
Check for a complex type or an array of complex numbers.
|
||||
|
||||
The type of the input is checked, not the value. Even if the input
|
||||
has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : any
|
||||
The input can be of any type and shape.
|
||||
|
||||
Returns
|
||||
-------
|
||||
iscomplexobj : bool
|
||||
The return value, True if `x` is of a complex type or has at least
|
||||
one complex element.
|
||||
|
||||
See Also
|
||||
--------
|
||||
isrealobj, iscomplex
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.iscomplexobj(1)
|
||||
False
|
||||
>>> np.iscomplexobj(1+0j)
|
||||
True
|
||||
>>> np.iscomplexobj([3, 1+0j, True])
|
||||
True
|
||||
|
||||
"""
|
||||
try:
|
||||
dtype = x.dtype
|
||||
type_ = dtype.type
|
||||
except AttributeError:
|
||||
type_ = asarray(x).dtype.type
|
||||
return issubclass(type_, _nx.complexfloating)
|
||||
|
||||
|
||||
@array_function_dispatch(_is_type_dispatcher)
|
||||
def isrealobj(x):
|
||||
"""
|
||||
Return True if x is a not complex type or an array of complex numbers.
|
||||
|
||||
The type of the input is checked, not the value. So even if the input
|
||||
has an imaginary part equal to zero, `isrealobj` evaluates to False
|
||||
if the data type is complex.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : any
|
||||
The input can be of any type and shape.
|
||||
|
||||
Returns
|
||||
-------
|
||||
y : bool
|
||||
The return value, False if `x` is of a complex type.
|
||||
|
||||
See Also
|
||||
--------
|
||||
iscomplexobj, isreal
|
||||
|
||||
Notes
|
||||
-----
|
||||
The function is only meant for arrays with numerical values but it
|
||||
accepts all other objects. Since it assumes array input, the return
|
||||
value of other objects may be True.
|
||||
|
||||
>>> np.isrealobj('A string')
|
||||
True
|
||||
>>> np.isrealobj(False)
|
||||
True
|
||||
>>> np.isrealobj(None)
|
||||
True
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.isrealobj(1)
|
||||
True
|
||||
>>> np.isrealobj(1+0j)
|
||||
False
|
||||
>>> np.isrealobj([3, 1+0j, True])
|
||||
False
|
||||
|
||||
"""
|
||||
return not iscomplexobj(x)
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
|
||||
def _getmaxmin(t):
|
||||
from numpy.core import getlimits
|
||||
f = getlimits.finfo(t)
|
||||
return f.max, f.min
|
||||
|
||||
|
||||
def _nan_to_num_dispatcher(x, copy=None, nan=None, posinf=None, neginf=None):
|
||||
return (x,)
|
||||
|
||||
|
||||
@array_function_dispatch(_nan_to_num_dispatcher)
|
||||
def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None):
|
||||
"""
|
||||
Replace NaN with zero and infinity with large finite numbers (default
|
||||
behaviour) or with the numbers defined by the user using the `nan`,
|
||||
`posinf` and/or `neginf` keywords.
|
||||
|
||||
If `x` is inexact, NaN is replaced by zero or by the user defined value in
|
||||
`nan` keyword, infinity is replaced by the largest finite floating point
|
||||
values representable by ``x.dtype`` or by the user defined value in
|
||||
`posinf` keyword and -infinity is replaced by the most negative finite
|
||||
floating point values representable by ``x.dtype`` or by the user defined
|
||||
value in `neginf` keyword.
|
||||
|
||||
For complex dtypes, the above is applied to each of the real and
|
||||
imaginary components of `x` separately.
|
||||
|
||||
If `x` is not inexact, then no replacements are made.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : scalar or array_like
|
||||
Input data.
|
||||
copy : bool, optional
|
||||
Whether to create a copy of `x` (True) or to replace values
|
||||
in-place (False). The in-place operation only occurs if
|
||||
casting to an array does not require a copy.
|
||||
Default is True.
|
||||
|
||||
.. versionadded:: 1.13
|
||||
nan : int, float, optional
|
||||
Value to be used to fill NaN values. If no value is passed
|
||||
then NaN values will be replaced with 0.0.
|
||||
|
||||
.. versionadded:: 1.17
|
||||
posinf : int, float, optional
|
||||
Value to be used to fill positive infinity values. If no value is
|
||||
passed then positive infinity values will be replaced with a very
|
||||
large number.
|
||||
|
||||
.. versionadded:: 1.17
|
||||
neginf : int, float, optional
|
||||
Value to be used to fill negative infinity values. If no value is
|
||||
passed then negative infinity values will be replaced with a very
|
||||
small (or negative) number.
|
||||
|
||||
.. versionadded:: 1.17
|
||||
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray
|
||||
`x`, with the non-finite values replaced. If `copy` is False, this may
|
||||
be `x` itself.
|
||||
|
||||
See Also
|
||||
--------
|
||||
isinf : Shows which elements are positive or negative infinity.
|
||||
isneginf : Shows which elements are negative infinity.
|
||||
isposinf : Shows which elements are positive infinity.
|
||||
isnan : Shows which elements are Not a Number (NaN).
|
||||
isfinite : Shows which elements are finite (not NaN, not infinity)
|
||||
|
||||
Notes
|
||||
-----
|
||||
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
|
||||
(IEEE 754). This means that Not a Number is not equivalent to infinity.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.nan_to_num(np.inf)
|
||||
1.7976931348623157e+308
|
||||
>>> np.nan_to_num(-np.inf)
|
||||
-1.7976931348623157e+308
|
||||
>>> np.nan_to_num(np.nan)
|
||||
0.0
|
||||
>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
|
||||
>>> np.nan_to_num(x)
|
||||
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
|
||||
-1.28000000e+002, 1.28000000e+002])
|
||||
>>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
|
||||
array([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,
|
||||
-1.2800000e+02, 1.2800000e+02])
|
||||
>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
|
||||
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
|
||||
-1.28000000e+002, 1.28000000e+002])
|
||||
>>> np.nan_to_num(y)
|
||||
array([ 1.79769313e+308 +0.00000000e+000j, # may vary
|
||||
0.00000000e+000 +0.00000000e+000j,
|
||||
0.00000000e+000 +1.79769313e+308j])
|
||||
>>> np.nan_to_num(y, nan=111111, posinf=222222)
|
||||
array([222222.+111111.j, 111111. +0.j, 111111.+222222.j])
|
||||
"""
|
||||
x = _nx.array(x, subok=True, copy=copy)
|
||||
xtype = x.dtype.type
|
||||
|
||||
isscalar = (x.ndim == 0)
|
||||
|
||||
if not issubclass(xtype, _nx.inexact):
|
||||
return x[()] if isscalar else x
|
||||
|
||||
iscomplex = issubclass(xtype, _nx.complexfloating)
|
||||
|
||||
dest = (x.real, x.imag) if iscomplex else (x,)
|
||||
maxf, minf = _getmaxmin(x.real.dtype)
|
||||
if posinf is not None:
|
||||
maxf = posinf
|
||||
if neginf is not None:
|
||||
minf = neginf
|
||||
for d in dest:
|
||||
idx_nan = isnan(d)
|
||||
idx_posinf = isposinf(d)
|
||||
idx_neginf = isneginf(d)
|
||||
_nx.copyto(d, nan, where=idx_nan)
|
||||
_nx.copyto(d, maxf, where=idx_posinf)
|
||||
_nx.copyto(d, minf, where=idx_neginf)
|
||||
return x[()] if isscalar else x
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
|
||||
def _real_if_close_dispatcher(a, tol=None):
|
||||
return (a,)
|
||||
|
||||
|
||||
@array_function_dispatch(_real_if_close_dispatcher)
|
||||
def real_if_close(a, tol=100):
|
||||
"""
|
||||
If input is complex with all imaginary parts close to zero, return
|
||||
real parts.
|
||||
|
||||
"Close to zero" is defined as `tol` * (machine epsilon of the type for
|
||||
`a`).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
a : array_like
|
||||
Input array.
|
||||
tol : float
|
||||
Tolerance in machine epsilons for the complex part of the elements
|
||||
in the array. If the tolerance is <=1, then the absolute tolerance
|
||||
is used.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray
|
||||
If `a` is real, the type of `a` is used for the output. If `a`
|
||||
has complex elements, the returned type is float.
|
||||
|
||||
See Also
|
||||
--------
|
||||
real, imag, angle
|
||||
|
||||
Notes
|
||||
-----
|
||||
Machine epsilon varies from machine to machine and between data types
|
||||
but Python floats on most platforms have a machine epsilon equal to
|
||||
2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print
|
||||
out the machine epsilon for floats.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.finfo(float).eps
|
||||
2.2204460492503131e-16 # may vary
|
||||
|
||||
>>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)
|
||||
array([2.1, 5.2])
|
||||
>>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
|
||||
array([2.1+4.e-13j, 5.2 + 3e-15j])
|
||||
|
||||
"""
|
||||
a = asanyarray(a)
|
||||
type_ = a.dtype.type
|
||||
if not issubclass(type_, _nx.complexfloating):
|
||||
return a
|
||||
if tol > 1:
|
||||
f = getlimits.finfo(type_)
|
||||
tol = f.eps * tol
|
||||
if _nx.all(_nx.absolute(a.imag) < tol):
|
||||
a = a.real
|
||||
return a
|
||||
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
|
||||
_namefromtype = {'S1': 'character',
|
||||
'?': 'bool',
|
||||
'b': 'signed char',
|
||||
'B': 'unsigned char',
|
||||
'h': 'short',
|
||||
'H': 'unsigned short',
|
||||
'i': 'integer',
|
||||
'I': 'unsigned integer',
|
||||
'l': 'long integer',
|
||||
'L': 'unsigned long integer',
|
||||
'q': 'long long integer',
|
||||
'Q': 'unsigned long long integer',
|
||||
'f': 'single precision',
|
||||
'd': 'double precision',
|
||||
'g': 'long precision',
|
||||
'F': 'complex single precision',
|
||||
'D': 'complex double precision',
|
||||
'G': 'complex long double precision',
|
||||
'S': 'string',
|
||||
'U': 'unicode',
|
||||
'V': 'void',
|
||||
'O': 'object'
|
||||
}
|
||||
|
||||
@set_module('numpy')
|
||||
def typename(char):
|
||||
"""
|
||||
Return a description for the given data type code.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
char : str
|
||||
Data type code.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : str
|
||||
Description of the input data type code.
|
||||
|
||||
See Also
|
||||
--------
|
||||
dtype, typecodes
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
|
||||
... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
|
||||
>>> for typechar in typechars:
|
||||
... print(typechar, ' : ', np.typename(typechar))
|
||||
...
|
||||
S1 : character
|
||||
? : bool
|
||||
B : unsigned char
|
||||
D : complex double precision
|
||||
G : complex long double precision
|
||||
F : complex single precision
|
||||
I : unsigned integer
|
||||
H : unsigned short
|
||||
L : unsigned long integer
|
||||
O : object
|
||||
Q : unsigned long long integer
|
||||
S : string
|
||||
U : unicode
|
||||
V : void
|
||||
b : signed char
|
||||
d : double precision
|
||||
g : long precision
|
||||
f : single precision
|
||||
i : integer
|
||||
h : short
|
||||
l : long integer
|
||||
q : long long integer
|
||||
|
||||
"""
|
||||
return _namefromtype[char]
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
|
||||
#determine the "minimum common type" for a group of arrays.
|
||||
array_type = [[_nx.half, _nx.single, _nx.double, _nx.longdouble],
|
||||
[None, _nx.csingle, _nx.cdouble, _nx.clongdouble]]
|
||||
array_precision = {_nx.half: 0,
|
||||
_nx.single: 1,
|
||||
_nx.double: 2,
|
||||
_nx.longdouble: 3,
|
||||
_nx.csingle: 1,
|
||||
_nx.cdouble: 2,
|
||||
_nx.clongdouble: 3}
|
||||
|
||||
|
||||
def _common_type_dispatcher(*arrays):
|
||||
return arrays
|
||||
|
||||
|
||||
@array_function_dispatch(_common_type_dispatcher)
|
||||
def common_type(*arrays):
|
||||
"""
|
||||
Return a scalar type which is common to the input arrays.
|
||||
|
||||
The return type will always be an inexact (i.e. floating point) scalar
|
||||
type, even if all the arrays are integer arrays. If one of the inputs is
|
||||
an integer array, the minimum precision type that is returned is a
|
||||
64-bit floating point dtype.
|
||||
|
||||
All input arrays except int64 and uint64 can be safely cast to the
|
||||
returned dtype without loss of information.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
array1, array2, ... : ndarrays
|
||||
Input arrays.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : data type code
|
||||
Data type code.
|
||||
|
||||
See Also
|
||||
--------
|
||||
dtype, mintypecode
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.common_type(np.arange(2, dtype=np.float32))
|
||||
<class 'numpy.float32'>
|
||||
>>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
|
||||
<class 'numpy.float64'>
|
||||
>>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
|
||||
<class 'numpy.complex128'>
|
||||
|
||||
"""
|
||||
is_complex = False
|
||||
precision = 0
|
||||
for a in arrays:
|
||||
t = a.dtype.type
|
||||
if iscomplexobj(a):
|
||||
is_complex = True
|
||||
if issubclass(t, _nx.integer):
|
||||
p = 2 # array_precision[_nx.double]
|
||||
else:
|
||||
p = array_precision.get(t, None)
|
||||
if p is None:
|
||||
raise TypeError("can't get common type for non-numeric array")
|
||||
precision = max(precision, p)
|
||||
if is_complex:
|
||||
return array_type[1][precision]
|
||||
else:
|
||||
return array_type[0][precision]
|
||||
@@ -0,0 +1,222 @@
|
||||
from collections.abc import Container, Iterable
|
||||
from typing import (
|
||||
Literal as L,
|
||||
Any,
|
||||
overload,
|
||||
TypeVar,
|
||||
Protocol,
|
||||
)
|
||||
|
||||
from numpy import (
|
||||
dtype,
|
||||
generic,
|
||||
bool_,
|
||||
floating,
|
||||
float64,
|
||||
complexfloating,
|
||||
integer,
|
||||
)
|
||||
|
||||
from numpy._typing import (
|
||||
ArrayLike,
|
||||
DTypeLike,
|
||||
NBitBase,
|
||||
NDArray,
|
||||
_64Bit,
|
||||
_SupportsDType,
|
||||
_ScalarLike_co,
|
||||
_ArrayLike,
|
||||
_DTypeLikeComplex,
|
||||
)
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_T_co = TypeVar("_T_co", covariant=True)
|
||||
_SCT = TypeVar("_SCT", bound=generic)
|
||||
_NBit1 = TypeVar("_NBit1", bound=NBitBase)
|
||||
_NBit2 = TypeVar("_NBit2", bound=NBitBase)
|
||||
|
||||
class _SupportsReal(Protocol[_T_co]):
|
||||
@property
|
||||
def real(self) -> _T_co: ...
|
||||
|
||||
class _SupportsImag(Protocol[_T_co]):
|
||||
@property
|
||||
def imag(self) -> _T_co: ...
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
def mintypecode(
|
||||
typechars: Iterable[str | ArrayLike],
|
||||
typeset: Container[str] = ...,
|
||||
default: str = ...,
|
||||
) -> str: ...
|
||||
|
||||
# `asfarray` ignores dtypes if they're not inexact
|
||||
|
||||
@overload
|
||||
def asfarray(
|
||||
a: object,
|
||||
dtype: None | type[float] = ...,
|
||||
) -> NDArray[float64]: ...
|
||||
@overload
|
||||
def asfarray( # type: ignore[misc]
|
||||
a: Any,
|
||||
dtype: _DTypeLikeComplex,
|
||||
) -> NDArray[complexfloating[Any, Any]]: ...
|
||||
@overload
|
||||
def asfarray(
|
||||
a: Any,
|
||||
dtype: DTypeLike,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
|
||||
@overload
|
||||
def real(val: _SupportsReal[_T]) -> _T: ...
|
||||
@overload
|
||||
def real(val: ArrayLike) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def imag(val: _SupportsImag[_T]) -> _T: ...
|
||||
@overload
|
||||
def imag(val: ArrayLike) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def iscomplex(x: _ScalarLike_co) -> bool_: ... # type: ignore[misc]
|
||||
@overload
|
||||
def iscomplex(x: ArrayLike) -> NDArray[bool_]: ...
|
||||
|
||||
@overload
|
||||
def isreal(x: _ScalarLike_co) -> bool_: ... # type: ignore[misc]
|
||||
@overload
|
||||
def isreal(x: ArrayLike) -> NDArray[bool_]: ...
|
||||
|
||||
def iscomplexobj(x: _SupportsDType[dtype[Any]] | ArrayLike) -> bool: ...
|
||||
|
||||
def isrealobj(x: _SupportsDType[dtype[Any]] | ArrayLike) -> bool: ...
|
||||
|
||||
@overload
|
||||
def nan_to_num( # type: ignore[misc]
|
||||
x: _SCT,
|
||||
copy: bool = ...,
|
||||
nan: float = ...,
|
||||
posinf: None | float = ...,
|
||||
neginf: None | float = ...,
|
||||
) -> _SCT: ...
|
||||
@overload
|
||||
def nan_to_num(
|
||||
x: _ScalarLike_co,
|
||||
copy: bool = ...,
|
||||
nan: float = ...,
|
||||
posinf: None | float = ...,
|
||||
neginf: None | float = ...,
|
||||
) -> Any: ...
|
||||
@overload
|
||||
def nan_to_num(
|
||||
x: _ArrayLike[_SCT],
|
||||
copy: bool = ...,
|
||||
nan: float = ...,
|
||||
posinf: None | float = ...,
|
||||
neginf: None | float = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def nan_to_num(
|
||||
x: ArrayLike,
|
||||
copy: bool = ...,
|
||||
nan: float = ...,
|
||||
posinf: None | float = ...,
|
||||
neginf: None | float = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
# If one passes a complex array to `real_if_close`, then one is reasonably
|
||||
# expected to verify the output dtype (so we can return an unsafe union here)
|
||||
|
||||
@overload
|
||||
def real_if_close( # type: ignore[misc]
|
||||
a: _ArrayLike[complexfloating[_NBit1, _NBit1]],
|
||||
tol: float = ...,
|
||||
) -> NDArray[floating[_NBit1]] | NDArray[complexfloating[_NBit1, _NBit1]]: ...
|
||||
@overload
|
||||
def real_if_close(
|
||||
a: _ArrayLike[_SCT],
|
||||
tol: float = ...,
|
||||
) -> NDArray[_SCT]: ...
|
||||
@overload
|
||||
def real_if_close(
|
||||
a: ArrayLike,
|
||||
tol: float = ...,
|
||||
) -> NDArray[Any]: ...
|
||||
|
||||
@overload
|
||||
def typename(char: L['S1']) -> L['character']: ...
|
||||
@overload
|
||||
def typename(char: L['?']) -> L['bool']: ...
|
||||
@overload
|
||||
def typename(char: L['b']) -> L['signed char']: ...
|
||||
@overload
|
||||
def typename(char: L['B']) -> L['unsigned char']: ...
|
||||
@overload
|
||||
def typename(char: L['h']) -> L['short']: ...
|
||||
@overload
|
||||
def typename(char: L['H']) -> L['unsigned short']: ...
|
||||
@overload
|
||||
def typename(char: L['i']) -> L['integer']: ...
|
||||
@overload
|
||||
def typename(char: L['I']) -> L['unsigned integer']: ...
|
||||
@overload
|
||||
def typename(char: L['l']) -> L['long integer']: ...
|
||||
@overload
|
||||
def typename(char: L['L']) -> L['unsigned long integer']: ...
|
||||
@overload
|
||||
def typename(char: L['q']) -> L['long long integer']: ...
|
||||
@overload
|
||||
def typename(char: L['Q']) -> L['unsigned long long integer']: ...
|
||||
@overload
|
||||
def typename(char: L['f']) -> L['single precision']: ...
|
||||
@overload
|
||||
def typename(char: L['d']) -> L['double precision']: ...
|
||||
@overload
|
||||
def typename(char: L['g']) -> L['long precision']: ...
|
||||
@overload
|
||||
def typename(char: L['F']) -> L['complex single precision']: ...
|
||||
@overload
|
||||
def typename(char: L['D']) -> L['complex double precision']: ...
|
||||
@overload
|
||||
def typename(char: L['G']) -> L['complex long double precision']: ...
|
||||
@overload
|
||||
def typename(char: L['S']) -> L['string']: ...
|
||||
@overload
|
||||
def typename(char: L['U']) -> L['unicode']: ...
|
||||
@overload
|
||||
def typename(char: L['V']) -> L['void']: ...
|
||||
@overload
|
||||
def typename(char: L['O']) -> L['object']: ...
|
||||
|
||||
@overload
|
||||
def common_type( # type: ignore[misc]
|
||||
*arrays: _SupportsDType[dtype[
|
||||
integer[Any]
|
||||
]]
|
||||
) -> type[floating[_64Bit]]: ...
|
||||
@overload
|
||||
def common_type( # type: ignore[misc]
|
||||
*arrays: _SupportsDType[dtype[
|
||||
floating[_NBit1]
|
||||
]]
|
||||
) -> type[floating[_NBit1]]: ...
|
||||
@overload
|
||||
def common_type( # type: ignore[misc]
|
||||
*arrays: _SupportsDType[dtype[
|
||||
integer[Any] | floating[_NBit1]
|
||||
]]
|
||||
) -> type[floating[_NBit1 | _64Bit]]: ...
|
||||
@overload
|
||||
def common_type( # type: ignore[misc]
|
||||
*arrays: _SupportsDType[dtype[
|
||||
floating[_NBit1] | complexfloating[_NBit2, _NBit2]
|
||||
]]
|
||||
) -> type[complexfloating[_NBit1 | _NBit2, _NBit1 | _NBit2]]: ...
|
||||
@overload
|
||||
def common_type(
|
||||
*arrays: _SupportsDType[dtype[
|
||||
integer[Any] | floating[_NBit1] | complexfloating[_NBit2, _NBit2]
|
||||
]]
|
||||
) -> type[complexfloating[_64Bit | _NBit1 | _NBit2, _64Bit | _NBit1 | _NBit2]]: ...
|
||||
@@ -0,0 +1,210 @@
|
||||
"""
|
||||
Module of functions that are like ufuncs in acting on arrays and optionally
|
||||
storing results in an output array.
|
||||
|
||||
"""
|
||||
__all__ = ['fix', 'isneginf', 'isposinf']
|
||||
|
||||
import numpy.core.numeric as nx
|
||||
from numpy.core.overrides import array_function_dispatch
|
||||
import warnings
|
||||
import functools
|
||||
|
||||
|
||||
def _dispatcher(x, out=None):
|
||||
return (x, out)
|
||||
|
||||
|
||||
@array_function_dispatch(_dispatcher, verify=False, module='numpy')
|
||||
def fix(x, out=None):
|
||||
"""
|
||||
Round to nearest integer towards zero.
|
||||
|
||||
Round an array of floats element-wise to nearest integer towards zero.
|
||||
The rounded values are returned as floats.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
An array of floats to be rounded
|
||||
out : ndarray, optional
|
||||
A location into which the result is stored. If provided, it must have
|
||||
a shape that the input broadcasts to. If not provided or None, a
|
||||
freshly-allocated array is returned.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray of floats
|
||||
A float array with the same dimensions as the input.
|
||||
If second argument is not supplied then a float array is returned
|
||||
with the rounded values.
|
||||
|
||||
If a second argument is supplied the result is stored there.
|
||||
The return value `out` is then a reference to that array.
|
||||
|
||||
See Also
|
||||
--------
|
||||
rint, trunc, floor, ceil
|
||||
around : Round to given number of decimals
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.fix(3.14)
|
||||
3.0
|
||||
>>> np.fix(3)
|
||||
3.0
|
||||
>>> np.fix([2.1, 2.9, -2.1, -2.9])
|
||||
array([ 2., 2., -2., -2.])
|
||||
|
||||
"""
|
||||
# promote back to an array if flattened
|
||||
res = nx.asanyarray(nx.ceil(x, out=out))
|
||||
res = nx.floor(x, out=res, where=nx.greater_equal(x, 0))
|
||||
|
||||
# when no out argument is passed and no subclasses are involved, flatten
|
||||
# scalars
|
||||
if out is None and type(res) is nx.ndarray:
|
||||
res = res[()]
|
||||
return res
|
||||
|
||||
|
||||
@array_function_dispatch(_dispatcher, verify=False, module='numpy')
|
||||
def isposinf(x, out=None):
|
||||
"""
|
||||
Test element-wise for positive infinity, return result as bool array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The input array.
|
||||
out : array_like, optional
|
||||
A location into which the result is stored. If provided, it must have a
|
||||
shape that the input broadcasts to. If not provided or None, a
|
||||
freshly-allocated boolean array is returned.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray
|
||||
A boolean array with the same dimensions as the input.
|
||||
If second argument is not supplied then a boolean array is returned
|
||||
with values True where the corresponding element of the input is
|
||||
positive infinity and values False where the element of the input is
|
||||
not positive infinity.
|
||||
|
||||
If a second argument is supplied the result is stored there. If the
|
||||
type of that array is a numeric type the result is represented as zeros
|
||||
and ones, if the type is boolean then as False and True.
|
||||
The return value `out` is then a reference to that array.
|
||||
|
||||
See Also
|
||||
--------
|
||||
isinf, isneginf, isfinite, isnan
|
||||
|
||||
Notes
|
||||
-----
|
||||
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
|
||||
(IEEE 754).
|
||||
|
||||
Errors result if the second argument is also supplied when x is a scalar
|
||||
input, if first and second arguments have different shapes, or if the
|
||||
first argument has complex values
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.isposinf(np.PINF)
|
||||
True
|
||||
>>> np.isposinf(np.inf)
|
||||
True
|
||||
>>> np.isposinf(np.NINF)
|
||||
False
|
||||
>>> np.isposinf([-np.inf, 0., np.inf])
|
||||
array([False, False, True])
|
||||
|
||||
>>> x = np.array([-np.inf, 0., np.inf])
|
||||
>>> y = np.array([2, 2, 2])
|
||||
>>> np.isposinf(x, y)
|
||||
array([0, 0, 1])
|
||||
>>> y
|
||||
array([0, 0, 1])
|
||||
|
||||
"""
|
||||
is_inf = nx.isinf(x)
|
||||
try:
|
||||
signbit = ~nx.signbit(x)
|
||||
except TypeError as e:
|
||||
dtype = nx.asanyarray(x).dtype
|
||||
raise TypeError(f'This operation is not supported for {dtype} values '
|
||||
'because it would be ambiguous.') from e
|
||||
else:
|
||||
return nx.logical_and(is_inf, signbit, out)
|
||||
|
||||
|
||||
@array_function_dispatch(_dispatcher, verify=False, module='numpy')
|
||||
def isneginf(x, out=None):
|
||||
"""
|
||||
Test element-wise for negative infinity, return result as bool array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : array_like
|
||||
The input array.
|
||||
out : array_like, optional
|
||||
A location into which the result is stored. If provided, it must have a
|
||||
shape that the input broadcasts to. If not provided or None, a
|
||||
freshly-allocated boolean array is returned.
|
||||
|
||||
Returns
|
||||
-------
|
||||
out : ndarray
|
||||
A boolean array with the same dimensions as the input.
|
||||
If second argument is not supplied then a numpy boolean array is
|
||||
returned with values True where the corresponding element of the
|
||||
input is negative infinity and values False where the element of
|
||||
the input is not negative infinity.
|
||||
|
||||
If a second argument is supplied the result is stored there. If the
|
||||
type of that array is a numeric type the result is represented as
|
||||
zeros and ones, if the type is boolean then as False and True. The
|
||||
return value `out` is then a reference to that array.
|
||||
|
||||
See Also
|
||||
--------
|
||||
isinf, isposinf, isnan, isfinite
|
||||
|
||||
Notes
|
||||
-----
|
||||
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
|
||||
(IEEE 754).
|
||||
|
||||
Errors result if the second argument is also supplied when x is a scalar
|
||||
input, if first and second arguments have different shapes, or if the
|
||||
first argument has complex values.
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> np.isneginf(np.NINF)
|
||||
True
|
||||
>>> np.isneginf(np.inf)
|
||||
False
|
||||
>>> np.isneginf(np.PINF)
|
||||
False
|
||||
>>> np.isneginf([-np.inf, 0., np.inf])
|
||||
array([ True, False, False])
|
||||
|
||||
>>> x = np.array([-np.inf, 0., np.inf])
|
||||
>>> y = np.array([2, 2, 2])
|
||||
>>> np.isneginf(x, y)
|
||||
array([1, 0, 0])
|
||||
>>> y
|
||||
array([1, 0, 0])
|
||||
|
||||
"""
|
||||
is_inf = nx.isinf(x)
|
||||
try:
|
||||
signbit = nx.signbit(x)
|
||||
except TypeError as e:
|
||||
dtype = nx.asanyarray(x).dtype
|
||||
raise TypeError(f'This operation is not supported for {dtype} values '
|
||||
'because it would be ambiguous.') from e
|
||||
else:
|
||||
return nx.logical_and(is_inf, signbit, out)
|
||||
@@ -0,0 +1,66 @@
|
||||
from typing import Any, overload, TypeVar
|
||||
|
||||
from numpy import floating, bool_, object_, ndarray
|
||||
from numpy._typing import (
|
||||
NDArray,
|
||||
_FloatLike_co,
|
||||
_ArrayLikeFloat_co,
|
||||
_ArrayLikeObject_co,
|
||||
)
|
||||
|
||||
_ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
@overload
|
||||
def fix( # type: ignore[misc]
|
||||
x: _FloatLike_co,
|
||||
out: None = ...,
|
||||
) -> floating[Any]: ...
|
||||
@overload
|
||||
def fix(
|
||||
x: _ArrayLikeFloat_co,
|
||||
out: None = ...,
|
||||
) -> NDArray[floating[Any]]: ...
|
||||
@overload
|
||||
def fix(
|
||||
x: _ArrayLikeObject_co,
|
||||
out: None = ...,
|
||||
) -> NDArray[object_]: ...
|
||||
@overload
|
||||
def fix(
|
||||
x: _ArrayLikeFloat_co | _ArrayLikeObject_co,
|
||||
out: _ArrayType,
|
||||
) -> _ArrayType: ...
|
||||
|
||||
@overload
|
||||
def isposinf( # type: ignore[misc]
|
||||
x: _FloatLike_co,
|
||||
out: None = ...,
|
||||
) -> bool_: ...
|
||||
@overload
|
||||
def isposinf(
|
||||
x: _ArrayLikeFloat_co,
|
||||
out: None = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def isposinf(
|
||||
x: _ArrayLikeFloat_co,
|
||||
out: _ArrayType,
|
||||
) -> _ArrayType: ...
|
||||
|
||||
@overload
|
||||
def isneginf( # type: ignore[misc]
|
||||
x: _FloatLike_co,
|
||||
out: None = ...,
|
||||
) -> bool_: ...
|
||||
@overload
|
||||
def isneginf(
|
||||
x: _ArrayLikeFloat_co,
|
||||
out: None = ...,
|
||||
) -> NDArray[bool_]: ...
|
||||
@overload
|
||||
def isneginf(
|
||||
x: _ArrayLikeFloat_co,
|
||||
out: _ArrayType,
|
||||
) -> _ArrayType: ...
|
||||
@@ -0,0 +1,286 @@
|
||||
"""
|
||||
Standard container-class for easy multiple-inheritance.
|
||||
|
||||
Try to inherit from the ndarray instead of using this class as this is not
|
||||
complete.
|
||||
|
||||
"""
|
||||
from numpy.core import (
|
||||
array, asarray, absolute, add, subtract, multiply, divide,
|
||||
remainder, power, left_shift, right_shift, bitwise_and, bitwise_or,
|
||||
bitwise_xor, invert, less, less_equal, not_equal, equal, greater,
|
||||
greater_equal, shape, reshape, arange, sin, sqrt, transpose
|
||||
)
|
||||
|
||||
|
||||
class container:
|
||||
"""
|
||||
container(data, dtype=None, copy=True)
|
||||
|
||||
Standard container-class for easy multiple-inheritance.
|
||||
|
||||
Methods
|
||||
-------
|
||||
copy
|
||||
tostring
|
||||
byteswap
|
||||
astype
|
||||
|
||||
"""
|
||||
def __init__(self, data, dtype=None, copy=True):
|
||||
self.array = array(data, dtype, copy=copy)
|
||||
|
||||
def __repr__(self):
|
||||
if self.ndim > 0:
|
||||
return self.__class__.__name__ + repr(self.array)[len("array"):]
|
||||
else:
|
||||
return self.__class__.__name__ + "(" + repr(self.array) + ")"
|
||||
|
||||
def __array__(self, t=None):
|
||||
if t:
|
||||
return self.array.astype(t)
|
||||
return self.array
|
||||
|
||||
# Array as sequence
|
||||
def __len__(self):
|
||||
return len(self.array)
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self._rc(self.array[index])
|
||||
|
||||
def __setitem__(self, index, value):
|
||||
self.array[index] = asarray(value, self.dtype)
|
||||
|
||||
def __abs__(self):
|
||||
return self._rc(absolute(self.array))
|
||||
|
||||
def __neg__(self):
|
||||
return self._rc(-self.array)
|
||||
|
||||
def __add__(self, other):
|
||||
return self._rc(self.array + asarray(other))
|
||||
|
||||
__radd__ = __add__
|
||||
|
||||
def __iadd__(self, other):
|
||||
add(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __sub__(self, other):
|
||||
return self._rc(self.array - asarray(other))
|
||||
|
||||
def __rsub__(self, other):
|
||||
return self._rc(asarray(other) - self.array)
|
||||
|
||||
def __isub__(self, other):
|
||||
subtract(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __mul__(self, other):
|
||||
return self._rc(multiply(self.array, asarray(other)))
|
||||
|
||||
__rmul__ = __mul__
|
||||
|
||||
def __imul__(self, other):
|
||||
multiply(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __div__(self, other):
|
||||
return self._rc(divide(self.array, asarray(other)))
|
||||
|
||||
def __rdiv__(self, other):
|
||||
return self._rc(divide(asarray(other), self.array))
|
||||
|
||||
def __idiv__(self, other):
|
||||
divide(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __mod__(self, other):
|
||||
return self._rc(remainder(self.array, other))
|
||||
|
||||
def __rmod__(self, other):
|
||||
return self._rc(remainder(other, self.array))
|
||||
|
||||
def __imod__(self, other):
|
||||
remainder(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __divmod__(self, other):
|
||||
return (self._rc(divide(self.array, other)),
|
||||
self._rc(remainder(self.array, other)))
|
||||
|
||||
def __rdivmod__(self, other):
|
||||
return (self._rc(divide(other, self.array)),
|
||||
self._rc(remainder(other, self.array)))
|
||||
|
||||
def __pow__(self, other):
|
||||
return self._rc(power(self.array, asarray(other)))
|
||||
|
||||
def __rpow__(self, other):
|
||||
return self._rc(power(asarray(other), self.array))
|
||||
|
||||
def __ipow__(self, other):
|
||||
power(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __lshift__(self, other):
|
||||
return self._rc(left_shift(self.array, other))
|
||||
|
||||
def __rshift__(self, other):
|
||||
return self._rc(right_shift(self.array, other))
|
||||
|
||||
def __rlshift__(self, other):
|
||||
return self._rc(left_shift(other, self.array))
|
||||
|
||||
def __rrshift__(self, other):
|
||||
return self._rc(right_shift(other, self.array))
|
||||
|
||||
def __ilshift__(self, other):
|
||||
left_shift(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __irshift__(self, other):
|
||||
right_shift(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __and__(self, other):
|
||||
return self._rc(bitwise_and(self.array, other))
|
||||
|
||||
def __rand__(self, other):
|
||||
return self._rc(bitwise_and(other, self.array))
|
||||
|
||||
def __iand__(self, other):
|
||||
bitwise_and(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __xor__(self, other):
|
||||
return self._rc(bitwise_xor(self.array, other))
|
||||
|
||||
def __rxor__(self, other):
|
||||
return self._rc(bitwise_xor(other, self.array))
|
||||
|
||||
def __ixor__(self, other):
|
||||
bitwise_xor(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __or__(self, other):
|
||||
return self._rc(bitwise_or(self.array, other))
|
||||
|
||||
def __ror__(self, other):
|
||||
return self._rc(bitwise_or(other, self.array))
|
||||
|
||||
def __ior__(self, other):
|
||||
bitwise_or(self.array, other, self.array)
|
||||
return self
|
||||
|
||||
def __pos__(self):
|
||||
return self._rc(self.array)
|
||||
|
||||
def __invert__(self):
|
||||
return self._rc(invert(self.array))
|
||||
|
||||
def _scalarfunc(self, func):
|
||||
if self.ndim == 0:
|
||||
return func(self[0])
|
||||
else:
|
||||
raise TypeError(
|
||||
"only rank-0 arrays can be converted to Python scalars.")
|
||||
|
||||
def __complex__(self):
|
||||
return self._scalarfunc(complex)
|
||||
|
||||
def __float__(self):
|
||||
return self._scalarfunc(float)
|
||||
|
||||
def __int__(self):
|
||||
return self._scalarfunc(int)
|
||||
|
||||
def __hex__(self):
|
||||
return self._scalarfunc(hex)
|
||||
|
||||
def __oct__(self):
|
||||
return self._scalarfunc(oct)
|
||||
|
||||
def __lt__(self, other):
|
||||
return self._rc(less(self.array, other))
|
||||
|
||||
def __le__(self, other):
|
||||
return self._rc(less_equal(self.array, other))
|
||||
|
||||
def __eq__(self, other):
|
||||
return self._rc(equal(self.array, other))
|
||||
|
||||
def __ne__(self, other):
|
||||
return self._rc(not_equal(self.array, other))
|
||||
|
||||
def __gt__(self, other):
|
||||
return self._rc(greater(self.array, other))
|
||||
|
||||
def __ge__(self, other):
|
||||
return self._rc(greater_equal(self.array, other))
|
||||
|
||||
def copy(self):
|
||||
""
|
||||
return self._rc(self.array.copy())
|
||||
|
||||
def tostring(self):
|
||||
""
|
||||
return self.array.tostring()
|
||||
|
||||
def tobytes(self):
|
||||
""
|
||||
return self.array.tobytes()
|
||||
|
||||
def byteswap(self):
|
||||
""
|
||||
return self._rc(self.array.byteswap())
|
||||
|
||||
def astype(self, typecode):
|
||||
""
|
||||
return self._rc(self.array.astype(typecode))
|
||||
|
||||
def _rc(self, a):
|
||||
if len(shape(a)) == 0:
|
||||
return a
|
||||
else:
|
||||
return self.__class__(a)
|
||||
|
||||
def __array_wrap__(self, *args):
|
||||
return self.__class__(args[0])
|
||||
|
||||
def __setattr__(self, attr, value):
|
||||
if attr == 'array':
|
||||
object.__setattr__(self, attr, value)
|
||||
return
|
||||
try:
|
||||
self.array.__setattr__(attr, value)
|
||||
except AttributeError:
|
||||
object.__setattr__(self, attr, value)
|
||||
|
||||
# Only called after other approaches fail.
|
||||
def __getattr__(self, attr):
|
||||
if (attr == 'array'):
|
||||
return object.__getattribute__(self, attr)
|
||||
return self.array.__getattribute__(attr)
|
||||
|
||||
#############################################################
|
||||
# Test of class container
|
||||
#############################################################
|
||||
if __name__ == '__main__':
|
||||
temp = reshape(arange(10000), (100, 100))
|
||||
|
||||
ua = container(temp)
|
||||
# new object created begin test
|
||||
print(dir(ua))
|
||||
print(shape(ua), ua.shape) # I have changed Numeric.py
|
||||
|
||||
ua_small = ua[:3, :5]
|
||||
print(ua_small)
|
||||
# this did not change ua[0,0], which is not normal behavior
|
||||
ua_small[0, 0] = 10
|
||||
print(ua_small[0, 0], ua[0, 0])
|
||||
print(sin(ua_small) / 3. * 6. + sqrt(ua_small ** 2))
|
||||
print(less(ua_small, 103), type(less(ua_small, 103)))
|
||||
print(type(ua_small * reshape(arange(15), shape(ua_small))))
|
||||
print(reshape(ua_small, (5, 3)))
|
||||
print(transpose(ua_small))
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,91 @@
|
||||
from ast import AST
|
||||
from collections.abc import Callable, Mapping, Sequence
|
||||
from typing import (
|
||||
Any,
|
||||
overload,
|
||||
TypeVar,
|
||||
Protocol,
|
||||
)
|
||||
|
||||
from numpy import ndarray, generic
|
||||
|
||||
from numpy.core.numerictypes import (
|
||||
issubclass_ as issubclass_,
|
||||
issubdtype as issubdtype,
|
||||
issubsctype as issubsctype,
|
||||
)
|
||||
|
||||
_T_contra = TypeVar("_T_contra", contravariant=True)
|
||||
_FuncType = TypeVar("_FuncType", bound=Callable[..., Any])
|
||||
|
||||
# A file-like object opened in `w` mode
|
||||
class _SupportsWrite(Protocol[_T_contra]):
|
||||
def write(self, s: _T_contra, /) -> Any: ...
|
||||
|
||||
__all__: list[str]
|
||||
|
||||
class _Deprecate:
|
||||
old_name: None | str
|
||||
new_name: None | str
|
||||
message: None | str
|
||||
def __init__(
|
||||
self,
|
||||
old_name: None | str = ...,
|
||||
new_name: None | str = ...,
|
||||
message: None | str = ...,
|
||||
) -> None: ...
|
||||
# NOTE: `__call__` can in principle take arbitrary `*args` and `**kwargs`,
|
||||
# even though they aren't used for anything
|
||||
def __call__(self, func: _FuncType) -> _FuncType: ...
|
||||
|
||||
def get_include() -> str: ...
|
||||
|
||||
@overload
|
||||
def deprecate(
|
||||
*,
|
||||
old_name: None | str = ...,
|
||||
new_name: None | str = ...,
|
||||
message: None | str = ...,
|
||||
) -> _Deprecate: ...
|
||||
@overload
|
||||
def deprecate(
|
||||
func: _FuncType,
|
||||
/,
|
||||
old_name: None | str = ...,
|
||||
new_name: None | str = ...,
|
||||
message: None | str = ...,
|
||||
) -> _FuncType: ...
|
||||
|
||||
def deprecate_with_doc(msg: None | str) -> _Deprecate: ...
|
||||
|
||||
# NOTE: In practice `byte_bounds` can (potentially) take any object
|
||||
# implementing the `__array_interface__` protocol. The caveat is
|
||||
# that certain keys, marked as optional in the spec, must be present for
|
||||
# `byte_bounds`. This concerns `"strides"` and `"data"`.
|
||||
def byte_bounds(a: generic | ndarray[Any, Any]) -> tuple[int, int]: ...
|
||||
|
||||
def who(vardict: None | Mapping[str, ndarray[Any, Any]] = ...) -> None: ...
|
||||
|
||||
def info(
|
||||
object: object = ...,
|
||||
maxwidth: int = ...,
|
||||
output: None | _SupportsWrite[str] = ...,
|
||||
toplevel: str = ...,
|
||||
) -> None: ...
|
||||
|
||||
def source(
|
||||
object: object,
|
||||
output: None | _SupportsWrite[str] = ...,
|
||||
) -> None: ...
|
||||
|
||||
def lookfor(
|
||||
what: str,
|
||||
module: None | str | Sequence[str] = ...,
|
||||
import_modules: bool = ...,
|
||||
regenerate: bool = ...,
|
||||
output: None | _SupportsWrite[str] =...,
|
||||
) -> None: ...
|
||||
|
||||
def safe_eval(source: str | AST) -> Any: ...
|
||||
|
||||
def show_runtime() -> None: ...
|
||||
Reference in New Issue
Block a user