numpy 2.4.1__pp311-pypy311_pp73-macosx_14_0_arm64.whl

numpy/distutils/unixccompiler.py

@@ -0,0 +1,141 @@
+"""
+unixccompiler - can handle very long argument lists for ar.
+
+"""
+import os
+import sys
+import subprocess
+import shlex
+
+from distutils.errors import CompileError, DistutilsExecError, LibError
+from distutils.unixccompiler import UnixCCompiler
+from numpy.distutils.ccompiler import replace_method
+from numpy.distutils.misc_util import _commandline_dep_string
+from numpy.distutils import log
+
+# Note that UnixCCompiler._compile appeared in Python 2.3
+def UnixCCompiler__compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+    """Compile a single source files with a Unix-style compiler."""
+    # HP ad-hoc fix, see ticket 1383
+    ccomp = self.compiler_so
+    if ccomp[0] == 'aCC':
+        # remove flags that will trigger ANSI-C mode for aCC
+        if '-Ae' in ccomp:
+            ccomp.remove('-Ae')
+        if '-Aa' in ccomp:
+            ccomp.remove('-Aa')
+        # add flags for (almost) sane C++ handling
+        ccomp += ['-AA']
+        self.compiler_so = ccomp
+    # ensure OPT environment variable is read
+    if 'OPT' in os.environ:
+        # XXX who uses this?
+        from sysconfig import get_config_vars
+        opt = shlex.join(shlex.split(os.environ['OPT']))
+        gcv_opt = shlex.join(shlex.split(get_config_vars('OPT')[0]))
+        ccomp_s = shlex.join(self.compiler_so)
+        if opt not in ccomp_s:
+            ccomp_s = ccomp_s.replace(gcv_opt, opt)
+            self.compiler_so = shlex.split(ccomp_s)
+        llink_s = shlex.join(self.linker_so)
+        if opt not in llink_s:
+            self.linker_so = self.linker_so + shlex.split(opt)
+
+    display = '%s: %s' % (os.path.basename(self.compiler_so[0]), src)
+
+    # gcc style automatic dependencies, outputs a makefile (-MF) that lists
+    # all headers needed by a c file as a side effect of compilation (-MMD)
+    if getattr(self, '_auto_depends', False):
+        deps = ['-MMD', '-MF', obj + '.d']
+    else:
+        deps = []
+
+    try:
+        self.spawn(self.compiler_so + cc_args + [src, '-o', obj] + deps +
+                   extra_postargs, display = display)
+    except DistutilsExecError as e:
+        msg = str(e)
+        raise CompileError(msg) from None
+
+    # add commandline flags to dependency file
+    if deps:
+        # After running the compiler, the file created will be in EBCDIC
+        # but will not be tagged as such. This tags it so the file does not
+        # have multiple different encodings being written to it
+        if sys.platform == 'zos':
+            subprocess.check_output(['chtag', '-tc', 'IBM1047', obj + '.d'])
+        with open(obj + '.d', 'a') as f:
+            f.write(_commandline_dep_string(cc_args, extra_postargs, pp_opts))
+
+replace_method(UnixCCompiler, '_compile', UnixCCompiler__compile)
+
+
+def UnixCCompiler_create_static_lib(self, objects, output_libname,
+                                    output_dir=None, debug=0, target_lang=None):
+    """
+    Build a static library in a separate sub-process.
+
+    Parameters
+    ----------
+    objects : list or tuple of str
+        List of paths to object files used to build the static library.
+    output_libname : str
+        The library name as an absolute or relative (if `output_dir` is used)
+        path.
+    output_dir : str, optional
+        The path to the output directory. Default is None, in which case
+        the ``output_dir`` attribute of the UnixCCompiler instance.
+    debug : bool, optional
+        This parameter is not used.
+    target_lang : str, optional
+        This parameter is not used.
+
+    Returns
+    -------
+    None
+
+    """
+    objects, output_dir = self._fix_object_args(objects, output_dir)
+
+    output_filename = \
+                    self.library_filename(output_libname, output_dir=output_dir)
+
+    if self._need_link(objects, output_filename):
+        try:
+            # previous .a may be screwed up; best to remove it first
+            # and recreate.
+            # Also, ar on OS X doesn't handle updating universal archives
+            os.unlink(output_filename)
+        except OSError:
+            pass
+        self.mkpath(os.path.dirname(output_filename))
+        tmp_objects = objects + self.objects
+        while tmp_objects:
+            objects = tmp_objects[:50]
+            tmp_objects = tmp_objects[50:]
+            display = '%s: adding %d object files to %s' % (
+                           os.path.basename(self.archiver[0]),
+                           len(objects), output_filename)
+            self.spawn(self.archiver + [output_filename] + objects,
+                       display = display)
+
+        # Not many Unices required ranlib anymore -- SunOS 4.x is, I
+        # think the only major Unix that does.  Maybe we need some
+        # platform intelligence here to skip ranlib if it's not
+        # needed -- or maybe Python's configure script took care of
+        # it for us, hence the check for leading colon.
+        if self.ranlib:
+            display = '%s:@ %s' % (os.path.basename(self.ranlib[0]),
+                                   output_filename)
+            try:
+                self.spawn(self.ranlib + [output_filename],
+                           display = display)
+            except DistutilsExecError as e:
+                msg = str(e)
+                raise LibError(msg) from None
+    else:
+        log.debug("skipping %s (up-to-date)", output_filename)
+    return
+
+replace_method(UnixCCompiler, 'create_static_lib',
+               UnixCCompiler_create_static_lib)

numpy/doc/ufuncs.py

@@ -0,0 +1,138 @@
+"""
+===================
+Universal Functions
+===================
+
+Ufuncs are, generally speaking, mathematical functions or operations that are
+applied element-by-element to the contents of an array. That is, the result
+in each output array element only depends on the value in the corresponding
+input array (or arrays) and on no other array elements. NumPy comes with a
+large suite of ufuncs, and scipy extends that suite substantially. The simplest
+example is the addition operator: ::
+
+ >>> np.array([0,2,3,4]) + np.array([1,1,-1,2])
+ array([1, 3, 2, 6])
+
+The ufunc module lists all the available ufuncs in numpy. Documentation on
+the specific ufuncs may be found in those modules. This documentation is
+intended to address the more general aspects of ufuncs common to most of
+them. All of the ufuncs that make use of Python operators (e.g., +, -, etc.)
+have equivalent functions defined (e.g. add() for +)
+
+Type coercion
+=============
+
+What happens when a binary operator (e.g., +,-,\\*,/, etc) deals with arrays of
+two different types? What is the type of the result? Typically, the result is
+the higher of the two types. For example: ::
+
+ float32 + float64 -> float64
+ int8 + int32 -> int32
+ int16 + float32 -> float32
+ float32 + complex64 -> complex64
+
+There are some less obvious cases generally involving mixes of types
+(e.g. uints, ints and floats) where equal bit sizes for each are not
+capable of saving all the information in a different type of equivalent
+bit size. Some examples are int32 vs float32 or uint32 vs int32.
+Generally, the result is the higher type of larger size than both
+(if available). So: ::
+
+ int32 + float32 -> float64
+ uint32 + int32 -> int64
+
+Finally, the type coercion behavior when expressions involve Python
+scalars is different than that seen for arrays. Since Python has a
+limited number of types, combining a Python int with a dtype=np.int8
+array does not coerce to the higher type but instead, the type of the
+array prevails. So the rules for Python scalars combined with arrays is
+that the result will be that of the array equivalent the Python scalar
+if the Python scalar is of a higher 'kind' than the array (e.g., float
+vs. int), otherwise the resultant type will be that of the array.
+For example: ::
+
+  Python int + int8 -> int8
+  Python float + int8 -> float64
+
+ufunc methods
+=============
+
+Binary ufuncs support 4 methods.
+
+**.reduce(arr)** applies the binary operator to elements of the array in
+  sequence. For example: ::
+
+ >>> np.add.reduce(np.arange(10))  # adds all elements of array
+ 45
+
+For multidimensional arrays, the first dimension is reduced by default: ::
+
+ >>> np.add.reduce(np.arange(10).reshape(2,5))
+     array([ 5,  7,  9, 11, 13])
+
+The axis keyword can be used to specify different axes to reduce: ::
+
+ >>> np.add.reduce(np.arange(10).reshape(2,5),axis=1)
+ array([10, 35])
+
+**.accumulate(arr)** applies the binary operator and generates an
+equivalently shaped array that includes the accumulated amount for each
+element of the array. A couple examples: ::
+
+ >>> np.add.accumulate(np.arange(10))
+ array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])
+ >>> np.multiply.accumulate(np.arange(1,9))
+ array([    1,     2,     6,    24,   120,   720,  5040, 40320])
+
+The behavior for multidimensional arrays is the same as for .reduce(),
+as is the use of the axis keyword).
+
+**.reduceat(arr,indices)** allows one to apply reduce to selected parts
+  of an array. It is a difficult method to understand. See the documentation
+  at:
+
+**.outer(arr1,arr2)** generates an outer operation on the two arrays arr1 and
+  arr2. It will work on multidimensional arrays (the shape of the result is
+  the concatenation of the two input shapes.: ::
+
+ >>> np.multiply.outer(np.arange(3),np.arange(4))
+ array([[0, 0, 0, 0],
+        [0, 1, 2, 3],
+        [0, 2, 4, 6]])
+
+Output arguments
+================
+
+All ufuncs accept an optional output array. The array must be of the expected
+output shape. Beware that if the type of the output array is of a different
+(and lower) type than the output result, the results may be silently truncated
+or otherwise corrupted in the downcast to the lower type. This usage is useful
+when one wants to avoid creating large temporary arrays and instead allows one
+to reuse the same array memory repeatedly (at the expense of not being able to
+use more convenient operator notation in expressions). Note that when the
+output argument is used, the ufunc still returns a reference to the result.
+
+ >>> x = np.arange(2)
+ >>> np.add(np.arange(2, dtype=float), np.arange(2, dtype=float), x,
+ ...        casting='unsafe')
+ array([0, 2])
+ >>> x
+ array([0, 2])
+
+and & or as ufuncs
+==================
+
+Invariably people try to use the python 'and' and 'or' as logical operators
+(and quite understandably). But these operators do not behave as normal
+operators since Python treats these quite differently. They cannot be
+overloaded with array equivalents. Thus using 'and' or 'or' with an array
+results in an error. There are two alternatives:
+
+ 1) use the ufunc functions logical_and() and logical_or().
+ 2) use the bitwise operators & and \\|. The drawback of these is that if
+    the arguments to these operators are not boolean arrays, the result is
+    likely incorrect. On the other hand, most usages of logical_and and
+    logical_or are with boolean arrays. As long as one is careful, this is
+    a convenient way to apply these operators.
+
+"""

numpy/dtypes.py

@@ -0,0 +1,41 @@
+"""
+This module is home to specific dtypes related functionality and their classes.
+For more general information about dtypes, also see `numpy.dtype` and
+:ref:`arrays.dtypes`.
+
+Similar to the builtin ``types`` module, this submodule defines types (classes)
+that are not widely used directly.
+
+.. versionadded:: NumPy 1.25
+
+    The dtypes module is new in NumPy 1.25.  Previously DType classes were
+    only accessible indirectly.
+
+
+DType classes
+-------------
+
+The following are the classes of the corresponding NumPy dtype instances and
+NumPy scalar types.  The classes can be used in ``isinstance`` checks and can
+also be instantiated or used directly.  Direct use of these classes is not
+typical, since their scalar counterparts (e.g. ``np.float64``) or strings
+like ``"float64"`` can be used.
+"""
+
+# See doc/source/reference/routines.dtypes.rst for module-level docs
+
+__all__ = []
+
+
+def _add_dtype_helper(DType, alias):
+    # Function to add DTypes a bit more conveniently without channeling them
+    # through `numpy._core._multiarray_umath` namespace or similar.
+    from numpy import dtypes
+
+    setattr(dtypes, DType.__name__, DType)
+    __all__.append(DType.__name__)
+
+    if alias:
+        alias = alias.removeprefix("numpy.dtypes.")
+        setattr(dtypes, alias, DType)
+        __all__.append(alias)