This function allows you to apply any arbitrary broadcasting function to any number of arguments
where the arguments can be SparseArray objects or scipy.sparse.spmatrix objects.
For example, the following will add two arrays:

sparse.elemwise(np.add,x,y)

Warning

Previously, elemwise was a method of the COO class. Now,
it has been moved to the sparse module.

We also support operations with a nonzero fill value. These are operations
that map zero values to nonzero values, such as x+1 or ~x.
In these cases, they will produce an output with a fill value of 1 or True,
assuming the original array has a fill value of 0 or False respectively.

If densification is needed, it must be explicit. In other words, you must call
COO.todense on the COO object. If both operands are COO,
both must be densified.

All binary operators support broadcasting.
This means that (under certain conditions) you can perform binary operations
on arrays with unequal shape. Namely, when the shape is missing a dimension,
or when a dimension is 1. For example, performing a binary operation
on two COO arrays with shapes (4,) and (5,1) yields
an object of shape (5,4). The same happens with arrays of shape
(1,4) and (5,1). However, (4,1) and (5,1)
will raise a ValueError.

As above, in the last three cases, an array with a nonzero fill value will be produced.

Notice that you can apply any unary or binary numpy.ufunc to COO
arrays, and numpy.ndarray objects and scalars and it will work so
long as the result is not dense. When applying to numpy.ndarray objects,
we check that operating on the array with zero would always produce a zero.

This method can take an arbitrary numpy.ufunc and performs a
reduction using that method. For example, the following will perform
a sum:

x.reduce(np.add,axis=1)

Note

This library currently performs reductions by grouping together all
coordinates along the supplied axes and reducing those. Then, if the
number in a group is deficient, it reduces an extra time with zero.
As a result, if reductions can change by adding multiple zeros to
it, this method won’t be accurate. However, it works in most cases.

COO arrays can be indexed just like regular
numpy.ndarray objects. They support integer, slice and boolean indexing.
However, currently, numpy advanced indexing is not properly supported. This
means that all of the following work like in Numpy, except that they will produce
COO arrays rather than numpy.ndarray objects, and will produce
scalars where expected. Assume that z.shape is (5,6,7)

z[0]z[1,3]z[1,4,3]z[:3,:2,3]z[::-1,1,3]z[-1]

All of the following will raise an IndexError, like in Numpy 1.13 and later.

Advanced indexing (indexing arrays with other arrays) is supported, but only for indexing
with a single array. Indexing a single array with multiple arrays is not supported at
this time. As above, if z.shape is (5,6,7), all of the following will
work like NumPy:

By default, when performing something like np.array(COO), we allow the array
to be converted into a dense one. To prevent this and raise a RuntimeError
instead, set the environment variable SPARSE_AUTO_DENSIFY to 0.

If it is desired to raise a warning if creating a sparse array that takes no less
memory than an equivalent desne array, set the environment variable
SPARSE_WARN_ON_TOO_DENSE to 1.