3
���h�" � @ st d Z ddlZyddlmZmZmZ W nJ ek
rn dd� Zdd� Zdd d
�Zdd d �Zd
d� Z ddd�ZY nX dS )zfFunctions copied from unreleased versions of numpy.
See the NumPy license in the licenses directory.
� N)� broadcast_to�stack�nanprodc C s4 t | �t |�k r0|jt | �d�}|jr0|j| � |S )N)�type)r �viewZ__array_finalize__)Zoriginal_arrayZ new_array� r �4/tmp/pip-build-5_djhm0z/xray/xarray/core/npcompat.py�_maybe_view_as_subclass s
r c C s� t j|�rt|�n|f}t j| d|d�} | r<| jr<td��tdd� |D ��rVtd��t j| fddd gd
g|d d �jd
}t | |�}| r�| j
j r�d|j
_ |S )NF)�copy�subokz/cannot broadcast a non-scalar to a scalar arrayc s s | ]}|d k V qdS )r Nr )�.0�sizer r r � <genexpr> s z _broadcast_to.<locals>.<genexpr>z4all elements of broadcast shape must be non-negativeZ multi_indexZ zerosize_okZrefs_ok�readonly�C)�flagsZop_flagsZ itershape�orderr T) �np�iterable�tuple�array�shape�
ValueError�anyZnditerZitviewsr r Z writeable)r r r r � broadcast�resultr r r �
_broadcast_to s
r Fc C s t | ||dd�S )a
Broadcast an array to a new shape.
Parameters
----------
array : array_like
The array to broadcast.
shape : tuple
The shape of the desired array.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array (default).
Returns
-------
broadcast : array
A readonly view on the original array with the given shape. It is
typically not contiguous. Furthermore, more than one element of a
broadcasted array may refer to a single memory location.
Raises
------
ValueError
If the array is not compatible with the new shape according to NumPy's
broadcasting rules.
Examples
--------
>>> x = np.array([1, 2, 3])
>>> np.broadcast_to(x, (3, 3))
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
T)r r )r )r r r r r r r * s "r c s� dd� | D �} | st d��tdd� | D ��}t|�dkr@t d��| d jd }| | kob|k n s|d j||�}t|��|dk r�||7 }td
�f| tjf � � fd d�| D �}tj ||d �S )
a�
Join a sequence of arrays along a new axis.
.. versionadded:: 1.10.0
Parameters
----------
arrays : sequence of ndarrays
Each array must have the same shape.
axis : int, optional
The axis along which the arrays will be stacked.
Returns
-------
stacked : ndarray
The stacked array has one more dimension than the input arrays.
See Also
--------
concatenate : Join a sequence of arrays along an existing axis.
split : Split array into a list of multiple sub-arrays of equal size.
Examples
--------
>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)
>>> np.stack(arrays, axis=1).shape
(3, 10, 4)
>>> np.stack(arrays, axis=2).shape
(3, 4, 10)
>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> np.stack((a, b))
array([[1, 2, 3],
[2, 3, 4]])
>>> np.stack((a, b), axis=-1)
array([[1, 2],
[2, 3],
[3, 4]])
c S s g | ]}t j|��qS r )r Z
asanyarray)r �arrr r r �
<listcomp>| s zstack.<locals>.<listcomp>z need at least one array to stackc s s | ] }|j V qd S )N)r )r r r r r r � s zstack.<locals>.<genexpr>� z)all input arrays must have the same shaper z"axis {0} out of bounds [-{1}, {1})Nc s g | ] }|� �qS r r )r r )�slr r r � s )�axis)
r �set�len�ndim�format�
IndexError�slicer ZnewaxisZ concatenate)Zarraysr! ZshapesZ result_ndim�msgZexpanded_arraysr )r r r O s - r c C sh t | tj� }|r tj| �} t| jjtj�s4| dfS |sFtj| dd�} tj| �}tj | ||d� | |fS )a�
If `a` is of inexact type, make a copy of `a`, replace NaNs with
the `val` value, and return the copy together with a boolean mask
marking the locations where NaNs were present. If `a` is not of
inexact type, do nothing and return `a` together with a mask of None.
Note that scalars will end up as array scalars, which is important
for using the result as the value of the out argument in some
operations.
Parameters
----------
a : array-like
Input array.
val : float
NaN values are set to val before doing the operation.
Returns
-------
y : ndarray
If `a` is of inexact type, return a copy of `a` with the NaNs
replaced by the fill value, otherwise return `a`.
mask: {bool, None}
If `a` is of inexact type, return a boolean mask marking locations of
NaNs, otherwise return None.
NT)r )�where)
�
isinstancer Zndarrayr �
issubclass�dtyper Zinexact�isnanZcopyto)�a�valZis_new�maskr r r � _replace_nan� s
r1 c C s" t | d�\} }tj| ||||d�S )a�
Return the product of array elements over a given axis treating Not a
Numbers (NaNs) as zero.
One is returned for slices that are all-NaN or empty.
.. versionadded:: 1.10.0
Parameters
----------
a : array_like
Array containing numbers whose sum is desired. If `a` is not an
array, a conversion is attempted.
axis : int, optional
Axis along which the product is computed. The default is to compute
the product of the flattened array.
dtype : data-type, optional
The type of the returned array and of the accumulator in which the
elements are summed. By default, the dtype of `a` is used. An
exception is when `a` has an integer type with less precision than
the platform (u)intp. In that case, the default will be either
(u)int32 or (u)int64 depending on whether the platform is 32 or 64
bits. For inexact inputs, dtype must be inexact.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``. If provided, it must have the same shape as the
expected output, but the type will be cast if necessary. See
`doc.ufuncs` for details. The casting of NaN to integer can yield
unexpected results.
keepdims : bool, optional
If True, the axes which are reduced are left in the result as
dimensions with size one. With this option, the result will
broadcast correctly against the original `arr`.
Returns
-------
y : ndarray or numpy scalar
See Also
--------
numpy.prod : Product across array propagating NaNs.
isnan : Show which elements are NaN.
Notes
-----
Numpy integer arithmetic is modular. If the size of a product exceeds
the size of an integer accumulator, its value will wrap around and the
result will be incorrect. Specifying ``dtype=double`` can alleviate
that problem.
Examples
--------
>>> np.nanprod(1)
1
>>> np.nanprod([1])
1
>>> np.nanprod([1, np.nan])
1.0
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanprod(a)
6.0
>>> np.nanprod(a, axis=0)
array([ 3., 2.])
r )r! r, �out�keepdims)r1 r �prod)r. r! r, r2 r3 r0 r r r r � s Br )F)r )NNNr )
�__doc__Znumpyr r r r � ImportErrorr r r1 r r r r �<module> s
%
A* |