2 views

Skip to first unread message

Dec 27, 2009, 8:34:38 PM12/27/09

to Discussion of Numerical Python, SciPy Users List, python-ann...@python.org

Hi,

I am pleased to announce the release of numpy 1.4.0. The highlights of

this release are:

- Faster import time

- Extended array wrapping mechanism for ufuncs

- New Neighborhood iterator (C-level only)

- C99-like complex functions in npymath, and a lot of portability

fixes for basic floating point math functions

The full release notes are at the end of the email. The sources are

uploaded on Pypi, and the binary installers will soon come on the

sourceforge page:

https://sourceforge.net/projects/numpy/

Thank you to everyone involved in this release, developers, users who

reported bugs, fix documentation, etc...

enjoy,

the numpy developers.

=========================

NumPy 1.4.0 Release Notes

=========================

This minor includes numerous bug fixes, as well as a few new features. It

is backward compatible with 1.3.0 release.

Highlights

==========

* Faster import time

* Extended array wrapping mechanism for ufuncs

* New Neighborhood iterator (C-level only)

* C99-like complex functions in npymath

New features

============

Extended array wrapping mechanism for ufuncs

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

An __array_prepare__ method has been added to ndarray to provide subclasses

greater flexibility to interact with ufuncs and ufunc-like functions. ndarray

already provided __array_wrap__, which allowed subclasses to set the array type

for the result and populate metadata on the way out of the ufunc (as seen in

the implementation of MaskedArray). For some applications it is necessary to

provide checks and populate metadata *on the way in*. __array_prepare__ is

therefore called just after the ufunc has initialized the output array but

before computing the results and populating it. This way, checks can be made

and errors raised before operations which may modify data in place.

Automatic detection of forward incompatibilities

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Previously, if an extension was built against a version N of NumPy, and used on

a system with NumPy M < N, the import_array was successfull, which could cause

crashes because the version M does not have a function in N. Starting from

NumPy 1.4.0, this will cause a failure in import_array, so the error will be

catched early on.

New iterators

~~~~~~~~~~~~~

A new neighborhood iterator has been added to the C API. It can be used to

iterate over the items in a neighborhood of an array, and can handle boundaries

conditions automatically. Zero and one padding are available, as well as

arbitrary constant value, mirror and circular padding.

New polynomial support

~~~~~~~~~~~~~~~~~~~~~~

New modules chebyshev and polynomial have been added. The new polynomial module

is not compatible with the current polynomial support in numpy, but is much

like the new chebyshev module. The most noticeable difference to most will

be that coefficients are specified from low to high power, that the low

level functions do *not* work with the Chebyshev and Polynomial classes as

arguements, and that the Chebyshev and Polynomial classes include a domain.

Mapping between domains is a linear substitution and the two classes can be

converted one to the other, allowing, for instance, a Chebyshev series in

one domain to be expanded as a polynomial in another domain. The new classes

should generally be used instead of the low level functions, the latter are

provided for those who wish to build their own classes.

The new modules are not automatically imported into the numpy namespace,

they must be explicitly brought in with an "import numpy.polynomial"

statement.

New C API

~~~~~~~~~

The following C functions have been added to the C API:

#. PyArray_GetNDArrayCFeatureVersion: return the *API* version of the

loaded numpy.

#. PyArray_Correlate2 - like PyArray_Correlate, but implements the usual

definition of correlation. Inputs are not swapped, and conjugate is

taken for complex arrays.

#. PyArray_NeighborhoodIterNew - a new iterator to iterate over a

neighborhood of a point, with automatic boundaries handling. It is

documented in the iterators section of the C-API reference, and you can

find some examples in the multiarray_test.c.src file in numpy.core.

New ufuncs

~~~~~~~~~~

The following ufuncs have been added to the C API:

#. copysign - return the value of the first argument with the sign copied

from the second argument.

#. nextafter - return the next representable floating point value of the

first argument toward the second argument.

New defines

~~~~~~~~~~~

The alpha processor is now defined and available in numpy/npy_cpu.h. The

failed detection of the PARISC processor has been fixed. The defines are:

#. NPY_CPU_HPPA: PARISC

#. NPY_CPU_ALPHA: Alpha

Testing

~~~~~~~

#. deprecated decorator: this decorator may be used to avoid cluttering

testing output while testing DeprecationWarning is effectively raised by

the decorated test.

#. assert_array_almost_equal_nulps: new method to compare two arrays of

floating point values. With this function, two values are considered

close if there are not many representable floating point values in

between, thus being more robust than assert_array_almost_equal when the

values fluctuate a lot.

#. assert_array_max_ulp: raise an assertion if there are more than N

representable numbers between two floating point values.

#. assert_warns: raise an AssertionError if a callable does not generate a

warning of the appropriate class, without altering the warning state.

Reusing npymath

~~~~~~~~~~~~~~~

In 1.3.0, we started putting portable C math routines in npymath library, so

that people can use those to write portable extensions. Unfortunately, it was

not possible to easily link against this library: in 1.4.0, support has been

added to numpy.distutils so that 3rd party can reuse this library. See coremath

documentation for more information.

Improved set operations

~~~~~~~~~~~~~~~~~~~~~~~

In previous versions of NumPy some set functions (intersect1d,

setxor1d, setdiff1d and setmember1d) could return incorrect results if

the input arrays contained duplicate items. These now work correctly

for input arrays with duplicates. setmember1d has been renamed to

in1d, as with the change to accept arrays with duplicates it is

no longer a set operation, and is conceptually similar to an

elementwise version of the Python operator 'in'. All of these

functions now accept the boolean keyword assume_unique. This is False

by default, but can be set True if the input arrays are known not

to contain duplicates, which can increase the functions' execution

speed.

Improvements

============

#. numpy import is noticeably faster (from 20 to 30 % depending on the

platform and computer)

#. The sort functions now sort nans to the end.

* Real sort order is [R, nan]

* Complex sort order is [R + Rj, R + nanj, nan + Rj, nan + nanj]

Complex numbers with the same nan placements are sorted according to

the non-nan part if it exists.

#. The type comparison functions have been made consistent with the new

sort order of nans. Searchsorted now works with sorted arrays

containing nan values.

#. Complex division has been made more resistent to overflow.

#. Complex floor division has been made more resistent to overflow.

Deprecations

============

The following functions are deprecated:

#. correlate: it takes a new keyword argument old_behavior. When True (the

default), it returns the same result as before. When False, compute the

conventional correlation, and take the conjugate for complex arrays. The

old behavior will be removed in NumPy 1.5, and raises a

DeprecationWarning in 1.4.

#. unique1d: use unique instead. unique1d raises a deprecation

warning in 1.4, and will be removed in 1.5.

#. intersect1d_nu: use intersect1d instead. intersect1d_nu raises

a deprecation warning in 1.4, and will be removed in 1.5.

#. setmember1d: use in1d instead. setmember1d raises a deprecation

warning in 1.4, and will be removed in 1.5.

The following raise errors:

#. When operating on 0-d arrays, ``numpy.max`` and other functions accept

only ``axis=0``, ``axis=-1`` and ``axis=None``. Using an out-of-bounds

axes is an indication of a bug, so Numpy raises an error for these cases

now.

#. Specifying ``axis > MAX_DIMS`` is no longer allowed; Numpy raises now an

error instead of behaving similarly as for ``axis=None``.

Internal changes

================

Use C99 complex functions when available

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The numpy complex types are now guaranteed to be ABI compatible with C99

complex type, if availble on the platform. Moreoever, the complex ufunc now use

the platform C99 functions intead of our own.

split multiarray and umath source code

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The source code of multiarray and umath has been split into separate logic

compilation units. This should make the source code more amenable for

newcomers.

Separate compilation

~~~~~~~~~~~~~~~~~~~~

By default, every file of multiarray (and umath) is merged into one for

compilation as was the case before, but if NPY_SEPARATE_COMPILATION env

variable is set to a non-negative value, experimental individual compilation of

each file is enabled. This makes the compile/debug cycle much faster when

working on core numpy.

Separate core math library

~~~~~~~~~~~~~~~~~~~~~~~~~~

New functions which have been added:

* npy_copysign

* npy_nextafter

* npy_cpack

* npy_creal

* npy_cimag

* npy_cabs

* npy_cexp

* npy_clog

* npy_cpow

* npy_csqr

* npy_ccos

* npy_csin

Reply all

Reply to author

Forward

0 new messages

Search

Clear search

Close search

Google apps

Main menu