numexpr 2.13.1__tar.gz → 2.14.0__tar.gz

{numexpr-2.13.1 → numexpr-2.14.0}/ANNOUNCE.rst

@@ -1,31 +1,27 @@
 =========================
-Announcing NumExpr 2.13.
+Announcing NumExpr 2.14.
 =========================
 
 Hi everyone,
 
-NumExpr 2.13.1 introduces a couple of patches for maximum/minimum and
-multiplication/addition for booleans to match NumPy behaviour.
-Thanks to Luke Shaw for these contributions.
+NumExpr 2.14.0 introduces a couple of patches for tan/tanh and
+adds static typing support.
+Thanks to Luke Shaw and Joren Hammudoglu (@jorenham) for these contributions.
 
 Project documentation is available at:
 
 https://numexpr.readthedocs.io/
 
-Changes from 2.12.1 to 2.13.0
+Changes from 2.13.1 to 2.14.0
 -----------------------------
 
-* New functionality has been added:
-  * Bitwise operators (and, or, not, xor): `&, |, ~, ^`
-  * New binary arithmetic operator for floor division: `//`
-  * New functions: `signbit`, `hypot`, `copysign`, `nextafter`, `maximum`,
-    `minimum`, `log2`, `trunc`, `round` and `sign`.
-  * Also enables integer outputs for integer inputs for
-    `abs`, `fmod`, `copy`, `ones_like`, `sign` and `round`.
+* Numerical stability for overflow has been improved for ``tan`` and ``tanh`` 
+  to handle possible overflows for complex numbers.
 
-  Thanks to Luke Shaw for the contributions.
+* Static typing support has been added, making NumExpr compatible with
+  static type checkers like `mypy` and `pyright`.
+  Thanks to Joren Hammudoglu (@jorenham) for the work.
 
-* New wheels for Python 3.14 and 3.14t are provided.
 
 What's Numexpr?
 ---------------

{numexpr-2.13.1 → numexpr-2.14.0}/MANIFEST.in

@@ -2,7 +2,7 @@ include MANIFEST.in VERSION
 
 include *.rst *.txt *.cfg site.cfg.example
 
-recursive-include numexpr *.cpp *.hpp *.py
+recursive-include numexpr *.cpp *.hpp *.py *.pyi py.typed
 recursive-include numexpr/win32 *.c *.h
 exclude numexpr/__config__.py RELEASING.txt site.cfg
 

{numexpr-2.13.1 → numexpr-2.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numexpr
-Version: 2.13.1
+Version: 2.14.0
 Summary: Fast numerical expression evaluator for NumPy
 Author-email: "David M. Cooke, Francesc Alted, and others" <blosc@blosc.org>
 Maintainer-email: Blosc Development Team <blosc@blosc.org>
@@ -14,6 +14,7 @@ Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3

{numexpr-2.13.1 → numexpr-2.14.0}/RELEASE_NOTES.rst

@@ -1,13 +1,25 @@
 =====================================
-Release notes for NumExpr 2.13 series
+Release notes for NumExpr 2.14 series
 =====================================
 
+Changes from 2.13.1 to 2.14.0
+-----------------------------
+
+* Numerical stability for overflow has been improved for ``tan`` and ``tanh`` 
+  to handle possible overflows for complex numbers.
+
+* Static typing support has been added, making NumExpr compatible with
+  static type checkers like `mypy` and `pyright`.
+  Thanks to Joren Hammudoglu (@jorenham) for the work.
+
+
 Changes from 2.13.0 to 2.13.1
 -----------------------------
 
 * Patch to maximum/minimum functions in order to match NumPy NaN handling
 * Patch to convert '+'->'|' and '*'->'&' for booleans
 
+
 Changes from 2.12.1 to 2.13.0
 -----------------------------
 

numexpr-2.14.0/VERSION

@@ -0,0 +1 @@
+2.14.0

numexpr-2.14.0/numexpr/__init__.py

@@ -0,0 +1,82 @@
+###################################################################
+#  Numexpr - Fast numerical array expression evaluator for NumPy.
+#
+#      License: MIT
+#      Author:  See AUTHORS.txt
+#
+#  See LICENSE.txt and LICENSES/*.txt for details about copyright and
+#  rights to use.
+####################################################################
+
+"""
+Numexpr is a fast numerical expression evaluator for NumPy.  With it,
+expressions that operate on arrays (like "3*a+4*b") are accelerated
+and use less memory than doing the same calculation in Python.
+
+See:
+
+https://github.com/pydata/numexpr
+
+for more info about it.
+
+"""
+
+from typing import TYPE_CHECKING, Final
+
+if TYPE_CHECKING:
+    import unittest
+
+# the `import _ as _` are needed for mypy to understand these are re-exports
+
+from numexpr.interpreter import __BLOCK_SIZE1__ as __BLOCK_SIZE1__
+from numexpr.interpreter import MAX_THREADS as MAX_THREADS
+from numexpr.interpreter import use_vml as use_vml
+
+is_cpu_amd_intel: Final = False # DEPRECATION WARNING: WILL BE REMOVED IN FUTURE RELEASE
+
+# cpuinfo imports were moved into the test submodule function that calls them
+# to improve import times.
+
+from numexpr.expressions import E as E
+from numexpr.necompiler import NumExpr as NumExpr
+from numexpr.necompiler import disassemble as disassemble
+from numexpr.necompiler import evaluate as evaluate
+from numexpr.necompiler import re_evaluate as re_evaluate
+from numexpr.necompiler import validate as validate
+from numexpr.utils import _init_num_threads
+from numexpr.utils import detect_number_of_cores as detect_number_of_cores
+from numexpr.utils import detect_number_of_threads as detect_number_of_threads
+from numexpr.utils import get_num_threads as get_num_threads
+from numexpr.utils import get_vml_version as get_vml_version
+from numexpr.utils import set_num_threads as set_num_threads
+from numexpr.utils import set_vml_accuracy_mode as set_vml_accuracy_mode
+from numexpr.utils import set_vml_num_threads as set_vml_num_threads
+
+# Detect the number of cores
+ncores: Final = detect_number_of_cores()
+# Initialize the number of threads to be used
+nthreads: Final = _init_num_threads()
+# The default for VML is 1 thread (see #39)
+# set_vml_num_threads(1)
+
+from . import version as version
+
+__version__: Final = version.version
+
+def print_versions() -> None:
+    """Print the versions of software that numexpr relies on."""
+    try:
+        import numexpr.tests
+        return numexpr.tests.print_versions()  # type: ignore[no-untyped-call]
+    except ImportError:
+        # To maintain Python 2.6 compatibility we have simple error handling
+        raise ImportError('`numexpr.tests` could not be imported, likely it was excluded from the distribution.')
+
+def test(verbosity: int = 1) -> "unittest.result.TestResult":
+    """Run all the tests in the test suite."""
+    try:
+        import numexpr.tests
+        return numexpr.tests.test(verbosity=verbosity)  # type: ignore[no-untyped-call]
+    except ImportError:
+        # To maintain Python 2.6 compatibility we have simple error handling
+        raise ImportError('`numexpr.tests` could not be imported, likely it was excluded from the distribution.')

{numexpr-2.13.1 → numexpr-2.14.0}/numexpr/complex_functions.hpp

@@ -390,42 +390,45 @@ nc_sinh(std::complex<double> *x, std::complex<double> *r)
 static void
 nc_tan(std::complex<double> *x, std::complex<double> *r)
 {
-    double sr,cr,shi,chi;
-    double rs,is,rc,ic;
-    double d;
-    double xr=x->real(), xi=x->imag();
-    sr = sin(xr);
-    cr = cos(xr);
-    shi = sinh(xi);
-    chi = cosh(xi);
-    rs = sr*chi;
-    is = cr*shi;
-    rc = cr*chi;
-    ic = -sr*shi;
-    d = rc*rc + ic*ic;
-    r->real((rs*rc+is*ic)/d);
-    r->imag((is*rc-rs*ic)/d);
+    double xr = x->real();
+    double xi = x->imag();
+    double imag_part;
+
+    double denom = cos(2*xr) + cosh(2*xi);
+    // handle overflows
+    if (xi > 20) {
+        imag_part = 1.0 / (1.0 + exp(-4*xi));
+    } else if (xi < -20) {
+        imag_part = -1.0 / (1.0 + exp(4*xi));
+    } else {
+        imag_part = sinh(2*xi) / denom;
+    }
+    double real_part = sin(2*xr) / denom;
+
+    r->real(real_part);
+    r->imag(imag_part);
     return;
 }
 
 static void
 nc_tanh(std::complex<double> *x, std::complex<double> *r)
 {
-    double si,ci,shr,chr;
-    double rs,is,rc,ic;
-    double d;
-    double xr=x->real(), xi=x->imag();
-    si = sin(xi);
-    ci = cos(xi);
-    shr = sinh(xr);
-    chr = cosh(xr);
-    rs = ci*shr;
-    is = si*chr;
-    rc = ci*chr;
-    ic = si*shr;
-    d = rc*rc + ic*ic;
-    r->real((rs*rc+is*ic)/d);
-    r->imag((is*rc-rs*ic)/d);
+    double xr = x->real();
+    double xi = x->imag();
+    double real_part;
+    double denom = cosh(2*xr) + cos(2*xi);
+    // handle overflows
+    if (xr > 20) {
+        real_part = 1.0 / (1.0 + exp(-4*xr));
+    } else if (xr < -20) {
+        real_part = -1.0 / (1.0 + exp(4*xr));
+    } else {
+        real_part = sinh(2*xr) / denom;
+    }
+    double imag_part = sin(2*xi) / denom;
+
+    r->real(real_part);
+    r->imag(imag_part);
     return;
 }