Highlights:
- Groupby aggregation with relabeling
- Better repr for MultiIndex
- Better truncated repr for Series and DataFrame
- Series.explode to split list-like values to rows
Highlights:
- New plotting API
- Stacking Classifier and Regressor
- Permutation-based feature importance
- Native support for missing values for gradient boosting
- Precomputed sparse nearest neighbors graph
- KNN Based Imputation
- Tree pruning
- Retrieve dataframes from OpenML
- Checking scikit-learn compatibility of an estimator
- ROC AUC now supports multiclass classification
Implements an approximate string matching version of R's native
'match' function. Can calculate various string distances based on
edits (Damerau-Levenshtein, Hamming, Levenshtein, optimal sting
alignment), qgrams (q- gram, cosine, jaccard distance) or heuristic
metrics (Jaro, Jaro-Winkler). An implementation of soundex is provided
as well. Distances can be computed between character vectors while
taking proper care of encoding or between integer vectors representing
generic sequences. This package is built for speed and runs in
parallel by using 'openMP'. An API for C or C++ is exposed as well.
# ellipsis 0.3.0
* `check_dots_used()`, `check_dots_unnamed()`, and `check_dots_empty()` gain an
`action` argument, to specify if they should error, warn, message or signal
when the dots meet the condition.
Changelog:
ixion 0.15.0
* fill_down_cells() method has been added to model_context, to fill duplicate
values downward from an arbitrary cell position. For now, it always
duplicate the value of the source cell; cell value enumerations are not
supported. Also, filling down of formula cells is not yet supported.
* cell iterator has been aded to model_context, for efficient horizontal and
vertical iterations of cell values in an arbitrary range within a sheet.
* improved the cmake-based build, with all test cases integrated.
* switched to spdlog for compile-time debug log outputs.
* improved performance by removing repeated fetching of each formula
cell prior to interpretation.
* reworked topological sorting of formula cells to avoid having to
unnecessarily build dependency relations twice; once during the
dirty cell determination and twice prior to interpretation of
formula cells. The new code performs topological sorting during the
dirty cell determination phase.
* reworked the cell reference tracker to use R-tree. This allows more
accurate tracking of references involving grouped formulas.
* fixed a resource leak with dynamic loading of compute engine modules.
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
Changes:
- Fix a regression in 1.5 that allowed expressions to compare equal to
strings, and caused == to call str() on the other object.
- Avoid using scipy versions of numpy functions, which are deprecated,
in lambdify.
Take MAINTAINERship.
Changes:
- The np.testing.utils functions have been updated from
1.19.0-dev0. This improves the function documentation and error
messages as well extending the assert_array_compare function to
additional types.
- Allow matmul (@) to work with object arrays.
- Fix regression in matmul (@) for boolean types.
- Array comparison assertions include maximum differences.
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.
Breaking changes:
- Deprecate is_EmptySet in favor of is_empty.
- Lambda now requires a tuple rather than a list for the signature
argument (non-tuple iterables are deprecated)
- Eq(expr) now raises ValueError. Eq(expr, 0) should be used
instead.
- Refactory of the units module. Scale factors and dimensions are now
both global and relative to single unit systems.
- get_dixon_matrix() now computes only the necessary monomials for the
Dixon matrix.
- The ProductSet of no sets is no longer the empty set. Instead is the
set consisting of the empty tuple.
- Deprecated tensorhead() and tensorsymmetry() static methods.
- Rational, irrational, transcendental and algebraic now imply finite
in the assumptions system. This means that all symbols declared as
rational, integer, odd etc are now automatically assumed finite.
- In the (old) assumptions, complex=True now implies finite=True. Note
that the default assumption for Symbol is complex=None, which allows
for the possibility for it to be infinite.
- The assumptions system is changed so that only finite numbers can be
considered real, positive, negative, nonnegative, nonpositive or
nonzero (since nonzero implies real). This means that any symbol
declared with e.g. real=True is now automatically considered
finite. It also means that infinities can not be considered positive
or negative since they are not real (e.g. oo.is_positive is now
False).
- New assumptions extended_real, extended_positive etc are added that
allow for positive and negative infinity. The equivalent of
Symbol('x', real=True) in version 1.4 is now Symbol('x',
extended_real=True). The equivalent of Symbol('x', negative=False)
is now Symbol('x', extended_negative=False) although it is usually
better to use Symbol('x', nonnegative=True) (which implies both
real=True and finite=True as well). Code that previously checked if
x.is_positive should now be written as if x.is_extended_positive if
it is intended that infinities should be allowed.
- Numbers still compare the same as they do in Python (Float(1) == 1)
except when they appear in an Expression, e.g. x**2.0 != x**2
Changes:
- Add project URLs to setup.py
- fix tests and ctypes code for PyPy
- use npy_intp instead of int for indexing array
- Ignore DeprecationWarning during nose imports
- Fix use-after-free in boolean indexing
- Fix errors in _add_newdocs
- fix byte order reversal for datetime64[ns]
- Use nbytes to also catch empty descr during allocation
- np.array cleared errors occured in PyMemoryView_FromObject
- Fixes for Undefined Behavior Sanitizer (UBSan) errors.
- ensure that casting to/from structured is properly checked.
- fix histogram*d dispatchers
- further fixup to histogram2d dispatcher.
- Replace contextlib.suppress for Python 2.7
- fix compilation of 3rd party modules with Py_LIMITED_API...
- Fix memory leak in dtype from dict contructor
- Document array_function at a higher level.
- add new recfunctions to __all__
- Remove stray print that causes a SystemError on python 3.7
- Pin pytest version to 5.0.1.
- Enable huge pages in all Linux builds
- fix behavior of structured_to_unstructured
Partially based on diff sent by Kai-Uwe Eckhardt in private mail.
v1.2.0
-- A huge refactoring of the library happened - renaming,
deprecating and replacing existing functions by improved API's.
All deprecated functions, macros and symbols are only marked as such
so this version is still API and ABI compatible to v1.x.
-- Daniel Mendler was pushing for those changes and contributing a load of patches,
refactorings, code reviews and whatnotelse.
-- Christoph Zurnieden re-worked internals of the library, improved the performance,
did code reviews and wrote documentation.
-- Francois Perrad did some refactoring and took again care of linting the sources and
provided all fixes.
-- Jan Nijtmans, Karel Miko and Joachim Breitner contributed various patches.
-- Private symbols can now be hidden for the shared library builds, disabled by default.
-- All API's follow a single code style, are prefixed the same etc.
-- Unified, safer and improved API's
-- Less magic numbers - return values (where appropriate) and most flags are now enums,
this was implemented in a backwards compatible way where return values were int.
-- API's with return values are now by default marked as "warn on unsused result", this
can be disabled if required (which will most likely hide bugs), c.f. MP_WUR in tommath.h
-- Provide a whole set of setters&getters for different primitive types (long, uint32_t, etc.)
-- All those primitive setters are now optimized.
-- It's possible to automatically tune the cutoff values for Karatsuba&Toom-Cook
-- The custom allocators which were formerly known as XMALLOC(), XFREE() etc. are now available
as MP_MALLOC(), MP_REALLOC(), MP_CALLOC() and MP_FREE(). MP_REALLOC() and MP_FREE() now also
provide the allocated size to ease the usage of simple allocators without tracking.
-- Building is now also possible with MSVC 2015, 2017 and 2019 (use makefile.msvc)
-- Added mp_decr() and mp_incr()
-- Added mp_log_u32()
-- Improved prime-checking
-- Improved Toom-Cook multiplication
-- Removed the LTM book (`make docs` now builds the user manual)
Utilities for dealing with IEEE floating point numbers, ported from
the Tango math library; approximate and exact equality comparisons for
general types.
pkglint --only "https instead of http" -r -F
With manual adjustments afterwards since pkglint 19.4.4 fixed a few
indentations in unrelated lines.
This mainly affects projects hosted at SourceForce, as well as
freedesktop.org, CTAN and GNU.
Highlights:
* Logic expressions with relations can now be simplifed in a better
way which has impact on e.g. simplification of piecewise
expressions.
* The MathML Presentation printer has seen a major improvement with
support configuration and about a hundred new functions.
* Union and Intersection have been improved to, among other
improvements, support Python sets.
* The test procedure has been changed to include code coverage and
code quality checks leading to a number of issues being identified
and removed.
* Unicode support, especially for Python 2.7, has been improved.
* subs and Subs have been improved in a number of ways.
* SymPy objects now renders as LaTeX automatically in Jupyter
notebooks. init_printing is still required to LaTeX render non-SymPy
objects such as lists of expressions or Python ints.
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
This is a major release from 0.9.0 and includes a number new
statistical models and many bug fixes.
Highlights include:
* Generalized Additive Models. This major feature is experimental and
may change.
* Conditional Models such as ConditionalLogit, which are known as
fixed effect models in Econometrics.
* Dimension Reduction Methods include Sliced Inverse Regression,
Principal Hessian Directions and Sliced Avg. Variance Estimation
* Regression using Quadratic Inference Functions (QIF)
* Gaussian Process Regression
Update xylib to version 1.5.
change from release notes:
improved CNF reading
changes to reading SpecsLab2 xy
support text files with lines terminated by CR only
more robust reading of CSV files
fixes for big-endian platforms
included xyConvert (GUI converter)
support filenames with non-ascii characters
added SpecsLab2 xy format
Provides a wide array of (semi)groupoids and operations for working with them.
A Semigroupoid is a Category without the requirement of identity arrows
for every object in the category.
A Category is any Semigroupoid for which the Yoneda lemma holds.
When working with comonads you often have the <*> portion of an Applicative,
but not the pure. This was captured in Uustalu and Vene's
"Essence of Dataflow Programming" in the form of the ComonadZip class
in the days before Applicative. Apply provides a weaker invariant,
but for the comonads used for data flow programming
(found in the streams package), this invariant is preserved.
Applicative function composition forms a semigroupoid.
Similarly many structures are nearly a comonad, but not quite,
for instance lists provide a reasonable extend operation in the form of tails,
but do not always contain a value.
Formally, the class Profunctor represents a profunctor from Hask ->
Hask.
Intuitively it is a bifunctor where the first argument is
contravariant and the second argument is covariant.
A bifunctor is a type constructor that takes two type arguments and is
a functor in both arguments. That is, unlike with Functor, a type
constructor such as Either does not need to be partially applied for a
Bifunctor instance, and the methods in this class permit mapping
functions over the Left value or the Right value, or both at the same
time.
Formally, the class Bifunctor represents a bifunctor from Hask ->
Hask.
Intuitively it is a bifunctor where both the first and second
arguments are covariant.
You can define a Bifunctor by either defining bimap or by defining
both first and second.
