Version 0.50.0:
This is a more usual release in comparison to the others that have been made in the last six months. It comprises the result of a number of maintenance tasks along with some new features and a lot of bug fixes.
Highlights of core feature changes include:
The compilation chain is now based on LLVM 9.
The error handling and reporting system has been improved to reduce the size of error messages, and also improve quality and specificity.
The CUDA target has more stream constructors available and a new function for compiling to PTX without linking and loading the code to a device. Further, the macro-based system for describing CUDA threads and blocks has been replaced with standard typing and lowering implementations, for improved debugging and extensibility.
Version 0.49.1:
This is a bugfix release for 0.49.0, it fixes some residual issues with SSA form, a critical bug in the branch pruning logic and a number of other smaller issues:
* Fixed Threading Implementation Typos
* Fixes Remove references to cffi_support from docs and examples
* Fix invalid type in resolve for comparison expr in parfors.
* Fix erroneous rewrite of predicate to bit const on prune.
* Fixes SSA local def scan based on invalid equality assumption.
* Fixes naming error in array_exprs
* Fix. Incorrect race variable detection due to SSA naming.
* Make literal_unroll function work as a freevar.
* Unset the memory manager after EMM Plugin tests
* Fix some SSA issues
* Pin to sphinx=2.4.4 to avoid problem with C declaration
* Fix unifying undefined first class function types issue
* Update example in 5m guide WRT SSA type stability.
* Restore numba.types as public API
Version 0.49.0:
This release is very large in terms of code changes. Large scale removal of unsupported Python and NumPy versions has taken place along with a significant amount of refactoring to simplify the Numba code base to make it easier for contributors. Numba’s intermediate representation has also undergone some important changes to solve a number of long standing issues. In addition some new features have been added and a large number of bugs have been fixed!
IMPORTANT: In this release Numba’s internals have moved about a lot. A backwards compatibility “shim” is provided for this release so as to not immediately break projects using Numba’s internals. If a module is imported from a moved location the shim will issue a deprecation warning and suggest how to update the import statement for the new location. The shim will be removed in 0.50.0!
Highlights of core feature changes include:
Removal of all Python 2 related code and also updating the minimum supported Python version to 3.6, the minimum supported NumPy version to 1.15 and the minimum supported SciPy version to 1.0.
Refactoring of the Numba code base. The code is now organised into submodules by functionality. This cleans up Numba’s top level namespace.
Introduction of an ir.Del free static single assignment form for Numba’s intermediate representation
An OpenMP-like thread masking API has been added for use with code using the parallel CPU backends
For the CUDA target, all kernel launches now require a configuration, this preventing accidental launches of kernels with the old default of a single thread in a single block. The hard-coded autotuner is also now removed, such tuning is deferred to CUDA API calls that provide the same functionality
The CUDA target also gained an External Memory Management plugin interface to allow Numba to use another CUDA-aware library for all memory allocations and deallocations
The Numba Typed List container gained support for construction from iterables
Experimental support was added for first-class function types
Version 0.48.0
This release is particularly small as it was present to catch anything that missed the 0.47.0 deadline (the deadline deliberately coincided with the end of support for Python 2.7). The next release will be considerably larger.
The core changes in this release are dominated by the start of the clean up needed for the end of Python 2.7 support, improvements to the CUDA target and support for numerous additional unicode string methods.
Enhancements from user contributed PRs (with thanks!):
Brian Wignall fixed more spelling typos in.
Denis Smirnov added support for string methods capitalize, casefold, swapcase , rsplit , partition and splitlines .
Elena Totmenina extended support for string methods startswith and added endswith .
Eric Wieser made type_callable return the decorated function itself in
Ethan Pronovost added support for np.argwhere in
Graham Markall contributed a large number of CUDA enhancements and fixes, namely:
* Remove Python 3.4 backports from utils
* Make device_array_like create contiguous arrays
* Don’t launch ForAll kernels with 0 elements
* Fix various issues in CUDA library search
* Enable use of records and bools for shared memory, remove ddt, add additional transpose tests
* Fix: Add more appropriate typing for CUDA device arrays
* test_consuming_strides: Keep dev array alive
* State that CUDA Toolkit 8.0 required in docs
James Bourbeau added the Python 3.8 classifier to setup.py in.
John Kirkham added a clarification to the __cuda_array_interface__ documentation in.
Leo Fang Fixed an indexing problem in dummyarray in.
Marcel Bargull fixed a build and test issue for Python 3.8 in.
Maria Rubtsov added support for string methods isdecimal , isdigit , isnumeric and replace .
General Enhancements:
* Make type_callable return the decorated function
* merge string prs
This merge PR included the following:
* Implement str.capitalize() based on CPython
* Implement str.casefold() based on CPython
* Implement str.swapcase() based on CPython
* Implement str.rsplit() based on CPython
* Implement str.isdecimal
* Implement str.isdigit
* Implement str.isnumeric
* Implement str.partition() based on CPython
* Implement str.splitlines() based on CPython
* Implement str.replace
* Functionality extension str.startswith() based on CPython
* Add functionality for str.endswith()
* Disable help messages.
* Add coverage for np.argwhere
Fixes:
* Only use lives (and not aliases) to create post parfor live set.
* Fix more spelling typos
* Propagate semantic constants ahead of static rewrites.
* Add Python 3.8 classifier to setup.py
* Update setup.py and buildscripts for dependency requirements
* Convert from arrays to names in define() and don’t invalidate for multiple consistent defines.
* Permit mixed int types in wrap_index
* Catch the use of global typed-list in JITed functions
* Fix, bug in bytecode analysis.
CUDA Enhancements/Fixes:
* Fix: Add more appropriate typing for CUDA device arrays
* Make device_array_like create contiguous arrays
* State that CUDA Toolkit 8.0 required in docs
* test_consuming_strides: Keep dev array alive
* Fix IndexError when accessing the “-1” element of dummyarray
* Enable use of records and bools for shared memory, remove ddt, add additional transpose tests
* Fix various issues in CUDA library search
* Don’t launch ForAll kernels with 0 elements
* Remove Python 3.4 backports from utils
Documentation Updates:
* Clarify what dictionary means
* Update docs for updated version requirements
* Update deprecation notices for 0.48.0
CI updates:
* Install optional dependencies for Python 3.8 tests
* Drop Py2.7 and Py3.5 from public CI
* Fix CI py38
pkglint -r --network --only "migrate"
As a side-effect of migrating the homepages, pkglint also fixed a few
indentations in unrelated lines. These and the new homepages have been
checked manually.
Version 0.47.0
--------------
This release expands the capability of Numba in a number of important areas and
is also significant as it is the last major point release with support for
Python 2 and Python 3.5 included. The next release (0.48.0) will be for Python
3.6+ only! (This follows NumPy's deprecation schedule as specified in
`NEP 29 <https://numpy.org/neps/nep-0029-deprecation_policy.html>`_.)
Highlights of core feature changes include:
* Full support for Python 3.8 (Siu Kwan Lam)
* Opt-in bounds checking (Aaron Meurer)
* Support for ``map``, ``filter`` and ``reduce`` (Stuart Archibald)
Intel also kindly sponsored research and development that lead to some exciting
new features:
* Initial support for basic ``try``/``except`` use (Siu Kwan Lam)
* The ability to pass functions created from closures/lambdas as arguments
(Stuart Archibald)
* ``sorted`` and ``list.sort()`` now accept the ``key`` argument (Stuart
Archibald and Siu Kwan Lam)
* A new compiler pass triggered through the use of the function
``numba.literal_unroll`` which permits iteration over heterogeneous tuples
and constant lists of constants. (Stuart Archibald)
Enhancements from user contributed PRs (with thanks!):
* Ankit Mahato added a reference to a new talk on Numba at PyCon India 2019
* Brian Wignall kindly fixed some spelling mistakes and typos
* Denis Smirnov wrote numerous methods to considerable enhance string support
including:
* ``str.rindex()``
* ``str.isprintable()``
* ``str.index()``
* ``start/end`` parameters for ``str.find()``
* ``str.isspace()``
* ``str.isidentifier()``
* ``str.rpartition()``
* ``str.lower()`` and ``str.islower()``
* Elena Totmenina implemented both ``str.isalnum()``, ``str.isalpha()`` and
``str.isascii``
* Eric Larson fixed a bug in literal comparison
* Ethan Pronovost updated the ``np.arange`` implementation to allow
the use of the ``dtype`` key word argument and also added ``bool``
implementations for several types.
* Graham Markall fixed some issues with the CUDA target, namely:
* Added physical limits for CC 7.0 / 7.5 to CUDA autotune
* Fixed bugs in TestCudaWarpOperations
* Improved errors / warnings for the CUDA vectorize decorator
* Guilherme Leobas fixed a typo in the ``urem`` implementation
* Isaac Virshup contributed a number of patches that fixed bugs, added support
for more NumPy functions and enhanced Python feature support. These
contributions included:
* Allow array construction with mixed type shape tuples
* Implementing ``np.lcm``
* Implement np.gcd and math.gcd
* Make slice constructor more similar to python.
* Added support for slice.indices
* Clarify numba ufunc supported features
* James Bourbeau fixed some issues with tooling, add ``setuptools`` as a
dependency and add pre-commit hooks for ``flake8`` compliance.
* Leo Fang made ``numba.dummyarray.Array`` iterable
* Marc Garcia fixed the ``numba.jit`` parameter name signature_or_function
* Marcelo Duarte Trevisani patched the llvmlite requirement to ``>=0.30.0``
* Matt Cooper fixed a long standing CI problem by remove maxParallel
* Matti Picus fixed an issue with ``collections.abc``
from Azure Pipelines.
* Rob Ennis patched a bug in ``np.interp`` ``float32`` handling
* VDimir fixed a bug in array transposition layouts and re-enabled and
fixed some idle tests.
* Vyacheslav Smirnov Enable support for `str.istitle()``
General Enhancements:
* Bounds checking
* Add pre-commit hooks
* Handle kw args in inliner when callee is a function
* Permits closures to become functions, enables map(), filter()
* Implement method title() for unicode based on Cpython
* Enable support for istitle() method for unicode string
* Implement str.lower() and str.islower()
* Implement str.rfind()
* Refactor `overload*` and support `jit_options` and `inline`
* Added support for slice.indices
* Add `bool` overload for several types
* Allow array construction with mixed type shape tuples
* Python3.8 support
* Add parfor support for ndarray.fill.
* Update typeconv error message to ask for sys.executable.
* Update `np.arange` implementation with `@overload`
* Make slice constructor more similar to python.
* Implement np.gcd and math.gcd
* Add setuptools as a dependency
* put git hash into build string
* Better compiler error messages for improperly used reduction
variables.
* Typed list implement and expose allocation
* Typed list faster copy
* Implement str.isspace() based on CPython
* Implement str.isprintable() based on CPython
* Implement str.isidentifier() based on CPython
* Implement str.isalnum() based on CPython
* Implement str.isalpha() based on CPython
* Implement str.rpartition() based on CPython
* Implement str.isascii() based on CPython
* Add graphviz output for FunctionIR
* Python3.8 looplifting
* Implement str.expandtabs() based on CPython
* Implement str.index() based on CPython
* Implement str.rindex() based on CPython
* Support params start/end for str.find()
* Bump to llvmlite 0.31
* Specialise arange dtype on arch + python version.
* basic support for try except
* Implement np.lcm
* loop canonicalisation and type aware tuple unroller/loop body
versioning passes
* Update hash(tuple) for Python 3.8.
* Implement sort/sorted with key.
* Add `is_internal` property to all Type classes.
Fixes:
* Update to LLVM8 memset/memcpy intrinsic
* Convert sub to add and div to mul when doing the reduction across
the per-thread reduction array.
* Handle 0 correctly as slice parameter.
* Remove multiply defined variables from all blocks' equivalence sets.
* Fix pickling of dufunc
* BUG: Comparison for literal
* Change get_call_table to support intermediate Vars.
* Requires llvmlite >=0.30.0
* prefer to import from collections.abc
* fix flake8 errors
* Fix and enable idle tests from test_array_manipulation
* Fix transpose output array layout
* Fix issue with SVML (and knock-on function resolution effects).
* Treat 0d arrays like scalars.
* fix missing incref on flags
* fix typos in numba/targets/base.py
* fix typos
* fix spelling in now-failing tests
* windowing test should check equality only up to double precision
errors
* fix refining list by using extend on an iterator
* Fix return type in arange and zero step size handling.
* suppress spurious RuntimeWarning about ufunc sizes
* skip the xfail test for now. Py3.8 CFG refactor seems to have
changed the test case
* regex needs to accept singular form of "argument"
* fix typed list equals
* Fix some spelling typos
* np.interp bugfix for float32 handling
* fix creating list with JIT disabled
* fix creating dict with JIT disabled
* Better handling of prange with multiple reductions on the same
variable.
* Improve the error message for `raise <string>`.
* Move overload of literal_unroll to avoid circular dependency that
breaks Python 2.7
* Fix test error on windows
* Fixes a bug in the relabelling logic in literal_unroll.
* Fix overload_method problem with stararg
* Add ind_to_const to enable fewer equivalence classes.
* Remove xfail for test which has since had underlying issue fixed.
* skip pycc test on Python 3.8 + macOS because of distutils issue
Version 0.46.0
This release significantly reworked one of the main parts of Numba, the compiler
pipeline, to make it more extensible and easier to use. The purpose of this was
to continue enhancing Numba's ability for use as a compiler toolkit. In a
similar vein, Numba now has an extension registration mechanism to allow other
Numba-using projects to automatically have their Numba JIT compilable functions
discovered. There were also a number of other related compiler toolkit
enhancement added along with some more NumPy features and a lot of bug fixes.
This release has updated the CUDA Array Interface specification to version 2,
which clarifies the `strides` attribute for C-contiguous arrays and specifies
the treatment for zero-size arrays. The implementation in Numba has been
changed and may affect downstream packages relying on the old behavior
General Enhancements:
* Add rewrite for semantic constants.
* Add np.cross support
* Make IR comparable and legalize it.
* R&D inlining, jitted and overloaded.
* Automatic JIT of called functions
* Inspection tool to check what numba supports
* Implement np.count_nonzero
* Unicode array support
* Entrypoints for numba extensions
* Literal dispatch
* Allow dtype input argument in np.sum
* New compiler.
* add support for np.append
* Refactor NRT C-API
* 0.46 scheduled deprecations
* Add env var to disable performance warnings.
* add np.array_equal support
* Implement numba.cross2d
* Add triangular indices functions
* Enable support for count() method for unicode string
Fixes:
* Fix inplace operator error for arrays
* Detect and raise unsupported on generator expressions
* Don't allow the allocation of mutable objects written into a
container to be hoisted.
* Avoid deprecated use of inspect.getargspec
* Replace GC macro with function call
* Loosen up typed container casting checks
* Fix some coding lines at the top of some files (utf8 -> utf-8)
* Replace "import \*" with explicit imports in numba/types
* Fix incorrect alg in isupper for ascii strings.
* test using jitclass in typed-list
* Add allocation hoisting info to LICM section at diagnostic L4
* Offset search box to avoid wrapping on some pages with Safari.
* Replace all "except BaseException" with "except Exception".
* Restore the "free" conda channel for NumPy 1.10 support.
* Add lowering for constant bytes.
* Add exception chaining for better error context
* Name of type should not contain user facing description for debug.
* Limit the number of return types for recursive functions
* Fixed two module teardown races in py2.
* Fix and test numpy.random.random_sample(n) for np117
* NamedTuple - Raises an error on non-iterable elements
* Add a newline in patched errors
* Fix liveness for remove dead of parfors (and other IR extensions)
* Make List.__getitem__ accept unsigned parameters
* Raise specific error at typing time for iteration on >1D array.
* Fix static_getitem with Literal type as index
* Update to inliner cost model information.
* Use specific random number seed when generating arbitrary test data
* Adjust test timeouts
* Skip unicode array tests on ppc64le that trigger an LLVM bug
* Fix packaging issue due to missing numba/cext
* Fix issue 4520 due to storage model mismatch
* Updates for llvmlite 0.30.0
CUDA Enhancements/Fixes:
* cudasim mishandling recarray
* Replace use of `np.prod` with `functools.reduce` for computing size
from shape
* Prevent taking the GIL in ForAll
* Just pass NULL for b2d_func for constant dynamic
sharedmem
* Update CUDA Array Interface & Enforce Numba compliance
* Implement math.{degrees, radians} for the CUDA target.
* Bump cuda array interface to version 2
Documentation Updates:
* Add docs for ARMv8/AArch64
* Add supported platforms to the docs.
* Add docstrings to inspect methods
* Update Python 2.7 EOL statement
* Add note about np.sum
* Minor parallel performance tips edits
* Clarify docs for typed dict with regard to arrays
* Fix example in guvectorize docstring.
* fix two typos in architecture.rst
* Document numba.extending.intrinsic and inlining.
* Fix typo in jit-compilation docs
* add dependency list to docs
* Add documentation for implementing new compiler passes.
Version 0.45.1
This patch release addresses some regressions reported in the 0.45.0 release and adds support for NumPy 1.17:
* accept scalar/0d-arrays
* Fix. Parfors reduction vars not deleted.
* Use process level locks for fork() only.
* Try to fix.
* Fix np1.17 isnan, isinf, isfinite ufuncs
* Fix np.interp for np1.17 nan handling
* Fix nump1.17 random function non-aliasing
Version 0.45.0
In this release, Numba gained an experimental numba.typed.List container as a future replacement of the reflected list. In addition, functions decorated with parallel=True can now be cached to reduce compilation overhead associated with the auto-parallelization.
Enhancements from user contributed PRs (with thanks!):
James Bourbeau added the Numba version to reportable error messages, added the signature parameter to inspect_types, improved the docstring of normalize_signatur, and fixed by adding reference counting to register_dispatcher
Guilherme Leobas implemented the dominator tree and dominance frontier algorithms
Nick White fixed the issue with round in the CUDA target.
Joshua Adelman added support for determining if a value is in a range (i.e. x in range(...)), and added windowing functions (np.bartlett, np.hamming, np.blackman, np.hanning, np.kaiser) from NumPy.
Lucio Fernandez-Arjona added support for np.select
Rob Ennis added support for np.flatnonzero
Keith Kraus extended the __cuda_array_interface__ with an optional mask attribute.
Gregory R. Lee replaced deprecated use of inspect.getargspec
Version 0.44.1
This patch release addresses some regressions reported in the 0.44.0 release:
- Fix 4164 issue with NUMBAPRO_NVVM.
- Abandon branch pruning if an arg name is redefined.
- Fix 4156. Problem with defining in-loop variables.
Version 0.44.0
IMPORTANT: In this release a few significant deprecations (and some less
significant ones) are being made, users are encouraged to read the related
documentation.
General enhancements in this release include:
- Numba is backed by LLVM 8 on all platforms apart from ppc64le, which, due to
bugs, remains on the LLVM 7.x series.
- Numba's dictionary support now includes type inference for keys and values.
- The .view() method now works for NumPy scalar types.
- Newly supported NumPy functions added: np.delete, np.nanquantile, np.quantile,
np.repeat, np.shape.
In addition considerable effort has been made to fix some long standing bugs and
a large number of other bugs, the "Fixes" section is very large this time!
Enhancements from user contributed PRs (with thanks!):
- Max Bolingbroke added support for the selective use of fastmath flags in
3847.
- Rob Ennis made min() and max() work on iterables in 3820 and added
np.quantile and np.nanquantile in 3899.
- Sergey Shalnov added numerous unicode string related features, zfill in 3978,
ljust in 4001, rjust and center in 4044 and strip, lstrip and rstrip in
4048.
- Guilherme Leobas added support for np.delete in 3890
- Christoph Deil exposed the Numba CLI via python -m numba in 4066 and made
numerous documentation fixes.
- Leo Schwarz wrote the bulk of the code for jitclass default constructor
arguments in 3852.
- Nick White enhanced the CUDA backend to use min/max PTX instructions where
possible in 4054.
- Lucio Fernandez-Arjona implemented the unicode string __mul__ function in
3952.
- Dimitri Vorona wrote the bulk of the code to implement getitem and setitem for
jitclass in 3861.
General Enhancements:
* Min max on iterables
* Unicode type iteration
* Allow fine-grained control of fastmath flags to partially address 2923
* Add support for np.delete
* Support for np.quantile and np.nanquantile
* Fix 3457 :: Implements np.repeat
* Add .view() method for NumPy scalars
* Update icc_rt clone recipe.
* __mul__ for strings, initial implementation and tests
* Type-inferred dictionary
* Create a view for string slicing to avoid extra allocations
* zfill operation implementation
* ljust operation implementation
* Support dict() and {}
* Support for llvm 8
* Make type.Optional str more representative
* Deprecation warnings
* rjust and center operations implementation
* strip, lstrip and rstrip operations implementation
* Expose numba CLI via python -m numba
* Impl np.shape and support function for asarray.
* Deprecate the use of iternext_impl without RefType
CUDA Enhancements/Fixes:
* Adds .nbytes property to CUDA device array objects.
* Add .inspect_ptx() to cuda device function
* CUDA: Use min/max PTX Instructions
* Update env-vars for CUDA libraries lookup
Documentation Updates:
* Code repository map
* adding Joris' Fosdem 2019 presentation
* order talks on applications of Numba by date
* fix two small typos in vectorize docs
* Fixup jitclass docs
* mention preprint repo in FAQ. Fixes 3981
* Correct runtests command in contributing.rst
* fix typo
* Ambiguous Documentation fix for guvectorize.
* Remove remaining mentions of autojit in docs
* Fix annotate example in docstring
* Add FAQ entry explaining Numba project name
* Add Documentation for atomicity of typed.Dict
* Remove info about CUDA ENVVAR potential replacement
Fixes:
* Resolves issue 3528. Adds support for slices when not using parallel=True.
* Remove dels for known dead vars.
* Fix mutable flag transmission in .astype
* Fix some minor issues in the C source.
* Correct boolean reinterpretation of data
* Comments out the appveyor badge
* fixes flake8 after merge
* Add assert to ir.py to help enforce correct structuring
* fix preparfor dtype transform for datetime64
* Prevent mutation of objmode fallback IR.
* Updates for llvmlite 0.29
* Use safe_load from pyyaml.
* Add tolerance to network errors by permitting conda to retry
* Fix casting in namedtuple ctor.
* Fix array inliner for multiple array definition.
* Cherrypick 3903 to main
* Raise better error if unsupported jump opcode found.
* Apply flake8 to the numpy related files
* Silence DeprecationWarning
* Better error message for unknown opcode
* Fix typing of ufuncs in parfor conversion
* Return variable renaming dict from inline_closurecall
* Fix bug in alignment computation of Record.make_c_struct
* Fix error with pickling unicode
* Unicode split algo versioning
* Add handler for unknown locale to numba -s
* Permit Optionals in ufunc machinery
* Remove assert in type inference causing poor error message.
* add is_ascii flag to UnicodeType
* Prevent zero division error in np.linalg.cond
* Resolves 4007.
* Add a more specific error message for invalid write to a global.
* Fix handling of titles in record dtype
* Do a check if a call is const before saying that an object is multiply defined.
* Fix issue 4020. Turn off no_cpython_wrapper flag when compiling for…
* [WIP] Fixing wrong dtype of array inside reflected list 4028
* Change IPython cache dir name to numba_cache
* Delete examples/notebooks/LinearRegr.py
* Catch writes to global typed.Dict and raise.
* Check tuple length
* Fix missing incref on optional return None
* Make the warnings fixer flush work for warning comparing on type.
* Fix function definition finding logic for commented def
* Fix alignment check on 32-bit.
* Use PEP 508 compliant env markers for install deps
Version 0.43.1
This is a bugfix release that provides minor changes to fix: a bug in branch
pruning, bugs in `np.interp` functionality, and also fully accommodate the
NumPy 1.16 release series.
* NumPy 1.16 support
* Refactor np.interp
* Rewrite pruned conditionals as their evaluated constants.
Version 0.43.0
In this release, the major new features are:
* Initial support for statically typed dictionaries
* Improvements to hash() to match Python 3 behavior
* Support for the heapq module
* Ability to pass C structs to Numba
* More NumPy functions: asarray, trapz, roll, ptp, extract
Version 0.42.0
In this release the major features are:
* The capability to launch and attach the GDB debugger from within a jitted function.
* The upgrading of LLVM to version 7.0.0.
Version 0.41.0
This release adds the following major features:
* Diagnostics showing the optimizations done by ParallelAccelerator
* Support for profiling Numba-compiled functions in Intel VTune
* Additional NumPy functions: partition, nancumsum, nancumprod, ediff1d, cov,
conj, conjugate, tri, tril, triu
* Initial support for Python 3 Unicode strings
General Enhancements:
* armv7 support
* invert mapping b/w binop operators and the operator module
* First attempt at parallel diagnostics
* Adding NUMBA_ENABLE_PROFILING envvar, enabling jit event
* Support for np.partition
* Support for np.nancumsum and np.nancumprod
* Add location information to exceptions.
* Support for np.ediff1d
* Support for np.cov
* Support user pipeline class in with lifting
* string support
* Improve error message for empty imprecise lists.
* Enable overload(operator.getitem)
* Support negative indexing in tuple.
* Refactor Const type
* Optimized usage of alloca out of the loop
* Updates for llvmlite 0.26
* Add support for `np.conj/np.conjugate`.
* np.tri, np.tril, np.triu - default optional args
* Permit dtype argument as sole kwarg in np.eye
CUDA Enhancements:
* Add max_registers Option to cuda.jit
Continuous Integration / Testing:
* CI with Azure Pipelines
* Workaround race condition with apt
* Fix issues with Azure Pipelines
* Fix `RuntimeWarning: 'numba.runtests' found in sys.modules`
* Disable openmp in wheel building
* Azure Pipelines templates
* Fix cuda tests and error reporting in test discovery
* Prevent faulthandler installation on armv7l
* Fix CUDA test that used negative indexing behaviour that's fixed.
* Start Flake8 checking of Numba source
Fixes:
* Fix dispatcher to only consider contiguous-ness.
* Fix 3119, raise for 0d arrays in reductions
* Reduce redundant module linking
* Fix AOT on windows.
* Fix memory management of __cuda_array_interface__ views.
* Fix typo in error name.
* Fix the default unboxing logic
* Allow non-global reference to objmode() context-manager
* Fix global reference in objmode for dynamically created function
* CUDA_ERROR_MISALIGNED_ADDRESS Using Multiple Const Arrays
* Correctly handle very old versions of colorama
* Add 32bit package guard for non-32bit installs
* Fix with-objmode warning
* Fix label offset in call inline after parfor pass
* Fixes raising of user defined exceptions for exec(<string>).
* Fix error due to function naming in CI in py2.7
* Fixed TBB's single thread execution and test added for
* Allow matching non-array objects in find_callname()
* Change getiter and iternext to not be pure.
* Make ir.UndefinedType singleton class.
* Fix np.random.shuffle sideeffect
* Raise unsupported for kwargs given to `print()`
* Remove dead script.
* Fix stencil support for boolean as return type
* Fix handling make_function literals
* Add missing unicode != unicode
* Fix complex math sqrt implementation for large -ve values
* This adds arg an check for the pattern supplied to Parfors.
* Sets list dtor linkage to `linkonce_odr` to fix visibility in AOT
Documentation Updates:
* Update 0.40 changelog with additional PRs
* Tweak spacing to avoid search box wrapping onto second line
* Add note about memory leaks with exceptions to docs.
* Add FAQ on CUDA + fork issue.
* Update docs for argsort, kind kwarg partially supported.
* Added mention of njit in 5minguide.rst
* Fix parallel reduction example in docs.
* Fix broken link and mark up problem.
* Size Numba logo in docs in em units.
* just two typos
* Document string support
* Documentation for parallel diagnostics.
Version 0.39.0
Here are the highlights for the Numba 0.39.0 release.
This is the first version that supports Python 3.7.
With help from Intel, we have fixed the issues with SVML support.
List has gained support for containing reference-counted types like NumPy arrays and list. Note, list still cannot hold heterogeneous types.
We have made a significant change to the internal calling-convention, which should be transparent to most users, to allow for a future feature that will permitting jumping back into python-mode from a nopython-mode function. This also fixes a limitation to print that disabled its use from nopython functions that were deep in the call-stack.
For CUDA GPU support, we added a __cuda_array_interface__ following the NumPy array interface specification to allow Numba to consume externally defined device arrays. We have opened a corresponding pull request to CuPy to test out the concept and be able to use a CuPy GPU array.
The Numba dispatcher inspect_types() method now supports the kwarg pretty which if set to True will produce ANSI/HTML output, showing the annotated types, when invoked from ipython/jupyter-notebook respectively.
The NumPy functions ndarray.dot, np.percentile and np.nanpercentile, and np.unique are now supported.
Numba now supports the use of a per-project configuration file to permanently set behaviours typically set via NUMBA_* family environment variables.
Support for the ppc64le architecture has been added.
Numba is an Open Source NumPy-aware optimizing compiler for Python
sponsored by Continuum Analytics, Inc. It uses the
remarkable LLVM compiler infrastructure to compile Python syntax to
machine code.
It is aware of NumPy arrays as typed memory regions and so can speed-up
code using NumPy arrays. Other, less well-typed code will be translated
to Python C-API calls effectively removing the "interpreter" but not removing
the dynamic indirection.
Numba is also not a tracing JIT. It *compiles* your code before it gets
run either using run-time type information or type information you provide
in the decorator.
Numba is a mechanism for producing machine code from Python syntax and typed
data structures such as those that exist in NumPy.
Packaged by Kamil Rytarowski for pkgsrc-wip and updated by me.
