| Current File : //proc/self/root/proc/self/root/lib64/python2.7/site-packages/numpy/core/numeric.pyc |
�
E�`Qc a @ s8 d d d d d d d d d d d
d d d
d d d d d d d d d d d d d d d d d d d d! d" d# d$ d% d& d' d( d) d* d+ d, d- d. d/ d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` ga Z da db l Z da db l Z da db l Z da db l Z da dc l Tda db l Z da dc l Te j dd de k r�e j df dg g � n d` e f dh � � YZ e
Z e j Z e j
Z
e j Z e j Z e j Z e j Z e j Z e j Z e j Z e j Z e j Z e j Z e j Z e e � Z db di e dj � Z db dk dl � Z db di e dm � Z dn � Z! e! e � e! e � db Z" e j# Z# e j$ Z$ e j% Z% e j& Z& e j' Z' e j( Z( e j) Z) e j* Z* e j+ Z+ e j, Z, e j dd de k re j- Z- e j. Z. n e j/ Z/ e j0 Z0 e j1 Z1 e j2 Z3 e j4 Z4 e j5 Z5 e j6 Z6 e j7 Z7 e j8 Z8 e j9 Z9 e j: Z: e j; Z; e j< Z< db db do � Z= db db dp � Z> db dq � Z? db dr � Z@ db db ds � ZA dt � ZB du � ZC dv � ZD i dd dw 6dx dy 6dz d{ 6ZE d| � ZF d} eG d~ � ZH d d� � ZI d� � ZJ y, da d� lK mL ZL mM ZM mN ZN mO ZO mP ZP Wn> eQ k
r�e jN ZN e jL ZL d� � ZM d� � ZO d� � ZP n Xdz d� � ZR db d� � ZS dd d� � ZT d� � ZU da da da db d� � ZV da d� lW mX ZX mY ZY mZ ZZ e[ e\ e] g Z^ e_ e` ea � r-e^ jb e` � n e_ ec ea � rLe^ jb ec � n db db db d� � Zd db db db d� � Ze e d� � Zf ef ee dd � ef ed dx � e jg d� k Zh ea d� � Zi d� � Zj d� � Zk i d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d{ 6d� d� 6d� d� 6d� dk 6d� d� 6d� d� 6d� d� 6d� d� 6Zl db d� � Zm dz dd d� � Zn da d� lo mp Zp mq Zq ep Zr es Zt d� � Zp d� � Zu db d� � Zv d� d� d� � Zw d� d� eG d� � Zx d� � Zy d� � Zz i e{ d� 6e| d� 6e} d� 6e~ d� 6e d� 6e� d� 6Z� i Z� x" e� j� � D] Z� e� e� e� e� <q;W[� db db db db db d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� e� f d� � � YZ� e� � Z� dO e� f d� � � YZ� d� � Z� e� � e� Z� Z� Z� Z� e� Z� Z� e� eG � Z� e� e � Z� da db l� Z� da dc l� Te! e� � db S(� t newaxist ndarrayt flatitert nditert nested_iterst ufunct aranget arrayt zerost
count_nonzerot emptyt broadcastt dtypet
fromstringt fromfilet
frombuffert int_asbuffert wheret argwheret copytot concatenatet fastCopyAndTransposet lexsortt set_numeric_opst can_castt
promote_typest min_scalar_typet result_typet asarrayt
asanyarrayt ascontiguousarrayt asfortranarrayt isfortrant
empty_liket
zeros_liket ones_liket correlatet convolvet innert dott einsumt outert vdott alterdott
restoredott rollt rollaxist crosst tensordott array2stringt get_printoptionst set_printoptionst
array_reprt array_strt set_string_functiont
little_endiant requiret fromitert array_equalt array_equivt indicest fromfunctiont iscloset loadt loadst isscalart binary_reprt base_reprt onest identityt allcloset compare_chararrayst putmaskt seterrt geterrt
setbufsizet
getbufsizet
seterrcallt
geterrcallt errstatet flatnonzerot Inft inft inftyt Infinityt nant NaNt False_t True_t bitwise_nott CLIPt RAISEt WRAPt MAXDIMSt BUFSIZEt
ALLOW_THREADSt ComplexWarningi����N( t *i i t getbuffert newbufferc B s e Z d Z RS( s�
The warning raised when casting a complex dtype to a real dtype.
As implemented, casting a complex number to a real discards its imaginary
part, but this behavior may not be what the user actually wants.
( t __name__t
__module__t __doc__( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR` % s t Kc C s8 t | d | d | d | �} t j | d d d �| S( s�
Return an array of zeros with the same shape and type as a given array.
With default parameters, is equivalent to ``a.copy().fill(0)``.
Parameters
----------
a : array_like
The shape and data-type of `a` define these same attributes of
the returned array.
dtype : data-type, optional
Overrides the data type of the result.
order : {'C', 'F', 'A', or 'K'}, optional
Overrides the memory layout of the result. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
'C' otherwise. 'K' means match the layout of `a` as closely
as possible.
Returns
-------
out : ndarray
Array of zeros with the same shape and type as `a`.
See Also
--------
ones_like : Return an array of ones with shape and type of input.
empty_like : Return an empty array with shape and type of input.
zeros : Return a new array setting values to zero.
ones : Return a new array setting values to one.
empty : Return a new uninitialized array.
Examples
--------
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> np.zeros_like(x)
array([[0, 0, 0],
[0, 0, 0]])
>>> y = np.arange(3, dtype=np.float)
>>> y
array([ 0., 1., 2.])
>>> np.zeros_like(y)
array([ 0., 0., 0.])
R t ordert suboki t castingt unsafe( R! t
multiarrayR ( t aR Rh Ri t res( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR" B s 2 t Cc C s, t | | | � } t j | d d d �| S( s�
Return a new array of given shape and type, filled with ones.
Please refer to the documentation for `zeros` for further details.
See Also
--------
zeros, ones_like
Examples
--------
>>> np.ones(5)
array([ 1., 1., 1., 1., 1.])
>>> np.ones((5,), dtype=np.int)
array([1, 1, 1, 1, 1])
>>> np.ones((2, 1))
array([[ 1.],
[ 1.]])
>>> s = (2,2)
>>> np.ones(s)
array([[ 1., 1.],
[ 1., 1.]])
i Rj Rk ( R
Rl R ( t shapeR Rh Rm ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRD x s c C s8 t | d | d | d | �} t j | d d d �| S( s�
Return an array of ones with the same shape and type as a given array.
With default parameters, is equivalent to ``a.copy().fill(1)``.
Parameters
----------
a : array_like
The shape and data-type of `a` define these same attributes of
the returned array.
dtype : data-type, optional
Overrides the data type of the result.
order : {'C', 'F', 'A', or 'K'}, optional
Overrides the memory layout of the result. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
'C' otherwise. 'K' means match the layout of `a` as closely
as possible.
Returns
-------
out : ndarray
Array of ones with the same shape and type as `a`.
See Also
--------
zeros_like : Return an array of zeros with shape and type of input.
empty_like : Return an empty array with shape and type of input.
zeros : Return a new array setting values to zero.
ones : Return a new array setting values to one.
empty : Return a new uninitialized array.
Examples
--------
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> np.ones_like(x)
array([[1, 1, 1],
[1, 1, 1]])
>>> y = np.arange(3, dtype=np.float)
>>> y
array([ 0., 1., 2.])
>>> np.ones_like(y)
array([ 1., 1., 1.])
R Rh Ri i Rj Rk ( R! Rl R ( Rm R Rh Ri Rn ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR# � s 2 c C s� i } x t D] } d | | <q
Wy t | d � } WnB t k
rx g | j j � D] } | j d � sT | ^ qT } n Xx* | D]" } | | k r� t j | � q� q� Wd S( Ni t __all__t _( Rq t getattrt AttributeErrort __dict__t keyst
startswitht append( t modulet adictRm t mallt k( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt
extend_all� s
5
c C s t | | d t d | �S( s�
Convert the input to an array.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major ('C') or column-major ('F' for FORTRAN)
memory representation. Defaults to 'C'.
Returns
-------
out : ndarray
Array interpretation of `a`. No copy is performed if the input
is already an ndarray. If `a` is a subclass of ndarray, a base
class ndarray is returned.
See Also
--------
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.
Examples
--------
Convert a list into an array:
>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])
Existing arrays are not copied:
>>> a = np.array([1, 2])
>>> np.asarray(a) is a
True
If `dtype` is set, array is copied only if dtype does not match:
>>> a = np.array([1, 2], dtype=np.float32)
>>> np.asarray(a, dtype=np.float32) is a
True
>>> np.asarray(a, dtype=np.float64) is a
False
Contrary to `asanyarray`, ndarray subclasses are not passed through:
>>> issubclass(np.matrix, np.ndarray)
True
>>> a = np.matrix([[1, 2]])
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True
t copyRh ( R t False( Rm R Rh ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR � s Dc C s t | | d t d | d t �S( s3
Convert the input to an ndarray, but pass ndarray subclasses through.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes scalars, lists, lists of tuples, tuples, tuples of tuples,
tuples of lists, and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major ('C') or column-major ('F') memory
representation. Defaults to 'C'.
Returns
-------
out : ndarray or an ndarray subclass
Array interpretation of `a`. If `a` is an ndarray or a subclass
of ndarray, it is returned as-is and no copy is performed.
See Also
--------
asarray : Similar function which always returns ndarrays.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and
Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.
Examples
--------
Convert a list into an array:
>>> a = [1, 2]
>>> np.asanyarray(a)
array([1, 2])
Instances of `ndarray` subclasses are passed through as-is:
>>> a = np.matrix([1, 2])
>>> np.asanyarray(a) is a
True
R~ Rh Ri ( R R t True( Rm R Rh ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR B s 2c C s t | | d t d d d d �S( sE
Return a contiguous array in memory (C order).
Parameters
----------
a : array_like
Input array.
dtype : str or dtype object, optional
Data-type of returned array.
Returns
-------
out : ndarray
Contiguous array of same shape and content as `a`, with type `dtype`
if specified.
See Also
--------
asfortranarray : Convert input to an ndarray with column-major
memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.
Examples
--------
>>> x = np.arange(6).reshape(2,3)
>>> np.ascontiguousarray(x, dtype=np.float32)
array([[ 0., 1., 2.],
[ 3., 4., 5.]], dtype=float32)
>>> x.flags['C_CONTIGUOUS']
True
R~ Rh Ro t ndmini ( R R ( Rm R ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR v s "c C s t | | d t d d d d �S( sU
Return an array laid out in Fortran order in memory.
Parameters
----------
a : array_like
Input array.
dtype : str or dtype object, optional
By default, the data-type is inferred from the input data.
Returns
-------
out : ndarray
The input `a` in Fortran, or column-major, order.
See Also
--------
ascontiguousarray : Convert input to a contiguous (C order) array.
asanyarray : Convert input to an ndarray with either row or
column-major memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.
Examples
--------
>>> x = np.arange(6).reshape(2,3)
>>> y = np.asfortranarray(x)
>>> x.flags['F_CONTIGUOUS']
False
>>> y.flags['F_CONTIGUOUS']
True
R~ Rh t FR� i ( R R ( Rm R ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR � s "c C s$ | d
k r g } n g | D] } | j � ^ q } | sJ t | d | �Sd | k sb d | k rk t } n t } t | d | d t d | �} d } d | k s� d | k s� d | k r� d } n- d
| k s� d | k s� d | k r� d } n x. | D]& } | j | s� | j | � } Pq� q� W| S( s'
Return an ndarray of the provided type that satisfies requirements.
This function is useful to be sure that an array with the correct flags
is returned for passing to compiled code (perhaps through ctypes).
Parameters
----------
a : array_like
The object to be converted to a type-and-requirement-satisfying array.
dtype : data-type
The required data-type, the default data-type is float64).
requirements : str or list of str
The requirements list can be any of the following
* 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
* 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
* 'ALIGNED' ('A') - ensure a data-type aligned array
* 'WRITEABLE' ('W') - ensure a writable array
* 'OWNDATA' ('O') - ensure an array that owns its own data
See Also
--------
asarray : Convert input to an ndarray.
asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfortranarray : Convert input to an ndarray with column-major
memory order.
ndarray.flags : Information about the memory layout of the array.
Notes
-----
The returned array will be guaranteed to have the listed requirements
by making a copy if needed.
Examples
--------
>>> x = np.arange(6).reshape(2,3)
>>> x.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : False
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
>>> y.flags
C_CONTIGUOUS : False
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
R t ENSUREARRAYt ER~ Ri t At FORTRANt F_CONTIGUOUSR� t
CONTIGUOUSt C_CONTIGUOUSRo N( t Nonet upperR R R� R t flagsR~ ( Rm R t requirementst xRi t arrt copychart prop( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR8 � s. 9
c C s
| j j S( sd
Returns True if array is arranged in Fortran-order in memory
and dimension > 1.
Parameters
----------
a : ndarray
Input array.
Examples
--------
np.array allows to specify whether the array is written in C-contiguous
order (last index varies the fastest), or FORTRAN-contiguous order in
memory (first index varies the fastest).
>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> np.isfortran(a)
False
>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='FORTRAN')
>>> b
array([[1, 2, 3],
[4, 5, 6]])
>>> np.isfortran(b)
True
The transpose of a C-ordered array is a FORTRAN-ordered array.
>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> np.isfortran(a)
False
>>> b = a.T
>>> b
array([[1, 4],
[2, 5],
[3, 6]])
>>> np.isfortran(b)
True
1-D arrays always evaluate as False.
>>> np.isfortran(np.array([1, 2], order='FORTRAN'))
False
( R� t fnc( Rm ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR s 7c C s t t | � j � � S( s�
Find the indices of array elements that are non-zero, grouped by element.
Parameters
----------
a : array_like
Input data.
Returns
-------
index_array : ndarray
Indices of elements that are non-zero. Indices are grouped by element.
See Also
--------
where, nonzero
Notes
-----
``np.argwhere(a)`` is the same as ``np.transpose(np.nonzero(a))``.
The output of ``argwhere`` is not suitable for indexing arrays.
For this purpose use ``where(a)`` instead.
Examples
--------
>>> x = np.arange(6).reshape(2,3)
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> np.argwhere(x>1)
array([[0, 2],
[1, 0],
[1, 1],
[1, 2]])
( t transposeR t nonzero( Rm ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR O s &c C s | j � j � d S( s<
Return indices that are non-zero in the flattened version of a.
This is equivalent to a.ravel().nonzero()[0].
Parameters
----------
a : ndarray
Input array.
Returns
-------
res : ndarray
Output array, containing the indices of the elements of `a.ravel()`
that are non-zero.
See Also
--------
nonzero : Return the indices of the non-zero elements of the input array.
ravel : Return a 1-D array containing the elements of the input array.
Examples
--------
>>> x = np.arange(-2, 3)
>>> x
array([-2, -1, 0, 1, 2])
>>> np.flatnonzero(x)
array([0, 1, 3, 4])
Use the indices of the non-zero elements as an index array to extract
these elements:
>>> x.ravel()[np.flatnonzero(x)]
array([-2, -1, 1, 2])
i ( t ravelR� ( Rm ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRP w s %t vi t si t fc C s% t | t � r! t | j � d S| S( Ni ( t
isinstancet
basestringt _mode_from_name_dictt lower( t mode( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt _mode_from_name� s t validc C sL t | � } | r5 t j d t � t j | | | � St j | | | � Sd S( s�
Cross-correlation of two 1-dimensional sequences.
This function computes the correlation as generally defined in signal
processing texts::
z[k] = sum_n a[n] * conj(v[n+k])
with a and v sequences being zero-padded where necessary and conj being
the conjugate.
Parameters
----------
a, v : array_like
Input sequences.
mode : {'valid', 'same', 'full'}, optional
Refer to the `convolve` docstring. Note that the default
is `valid`, unlike `convolve`, which uses `full`.
old_behavior : bool
If True, uses the old behavior from Numeric,
(correlate(a,v) == correlate(v,a), and the conjugate is not taken
for complex arrays). If False, uses the conventional signal
processing definition.
See Also
--------
convolve : Discrete, linear convolution of two one-dimensional sequences.
Examples
--------
>>> np.correlate([1, 2, 3], [0, 1, 0.5])
array([ 3.5])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
array([ 2. , 3.5, 3. ])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
array([ 0.5, 2. , 3.5, 3. , 0. ])
s�
The old behavior of correlate was deprecated for 1.4.0, and will be completely removed
for NumPy 2.0.
The new behavior fits the conventional definition of correlation: inputs are
never swapped, and the second argument is conjugated for complex arrays.N( R� t warningst warnt DeprecationWarningRl R$ t
correlate2( Rm R� R� t old_behavior( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR$ � s ' t fullc C s� t | d d �t | d d �} } t | � t | � k rM | | } } n t | � d k rn t d � � n t | � d k r� t d � � n t | � } t j | | d d d � | � S( s?
Returns the discrete, linear convolution of two one-dimensional sequences.
The convolution operator is often seen in signal processing, where it
models the effect of a linear time-invariant system on a signal [1]_. In
probability theory, the sum of two independent random variables is
distributed according to the convolution of their individual
distributions.
Parameters
----------
a : (N,) array_like
First one-dimensional input array.
v : (M,) array_like
Second one-dimensional input array.
mode : {'full', 'valid', 'same'}, optional
'full':
By default, mode is 'full'. This returns the convolution
at each point of overlap, with an output shape of (N+M-1,). At
the end-points of the convolution, the signals do not overlap
completely, and boundary effects may be seen.
'same':
Mode `same` returns output of length ``max(M, N)``. Boundary
effects are still visible.
'valid':
Mode `valid` returns output of length
``max(M, N) - min(M, N) + 1``. The convolution product is only given
for points where the signals overlap completely. Values outside
the signal boundary have no effect.
Returns
-------
out : ndarray
Discrete, linear convolution of `a` and `v`.
See Also
--------
scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
Transform.
scipy.linalg.toeplitz : Used to construct the convolution operator.
Notes
-----
The discrete convolution operation is defined as
.. math:: (f * g)[n] = \sum_{m = -\infty}^{\infty} f[m] g[n - m]
It can be shown that a convolution :math:`x(t) * y(t)` in time/space
is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
domain, after appropriate padding (padding is necessary to prevent
circular convolution). Since multiplication is more efficient (faster)
than convolution, the function `scipy.signal.fftconvolve` exploits the
FFT to calculate the convolution of large data-sets.
References
----------
.. [1] Wikipedia, "Convolution", http://en.wikipedia.org/wiki/Convolution.
Examples
--------
Note how the convolution operator flips the second array
before "sliding" the two across one another:
>>> np.convolve([1, 2, 3], [0, 1, 0.5])
array([ 0. , 1. , 2.5, 4. , 1.5])
Only return the middle values of the convolution.
Contains boundary effects, where zeros are taken
into account:
>>> np.convolve([1,2,3],[0,1,0.5], 'same')
array([ 1. , 2.5, 4. ])
The two arrays are of the same length, so there
is only one position where they completely overlap:
>>> np.convolve([1,2,3],[0,1,0.5], 'valid')
array([ 2.5])
R� i i s a cannot be emptys v cannot be emptyNi����( R t lent
ValueErrorR� Rl R$ ( Rm R� R� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR% � s S% c C sL t | � } t | � } | j � d d � t f | j � t d d � f S( s
Compute the outer product of two vectors.
Given two vectors, ``a = [a0, a1, ..., aM]`` and
``b = [b0, b1, ..., bN]``,
the outer product [1]_ is::
[[a0*b0 a0*b1 ... a0*bN ]
[a1*b0 .
[ ... .
[aM*b0 aM*bN ]]
Parameters
----------
a, b : array_like, shape (M,), (N,)
First and second input vectors. Inputs are flattened if they
are not already 1-dimensional.
Returns
-------
out : ndarray, shape (M, N)
``out[i, j] = a[i] * b[j]``
See also
--------
inner, einsum
References
----------
.. [1] : G. H. Golub and C. F. van Loan, *Matrix Computations*, 3rd
ed., Baltimore, MD, Johns Hopkins University Press, 1996,
pg. 8.
Examples
--------
Make a (*very* coarse) grid for computing a Mandelbrot set:
>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
>>> rl
array([[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.]])
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
>>> im
array([[ 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
[ 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
[ 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
[ 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
[ 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
>>> grid = rl + im
>>> grid
array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],
[-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],
[-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],
[-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],
[-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])
An example using a "vector" of letters:
>>> x = np.array(['a', 'b', 'c'], dtype=object)
>>> np.outer(x, [1, 2, 3])
array([[a, aa, aaa],
[b, bb, bbb],
[c, cc, ccc]], dtype=object)
N( R R� R ( Rm t b( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR) : s E ( R' R* R& R+ R, c C s+ t t | � j � j � t | � j � � S( N( R' R R� t conj( Rm R� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR* � s c C s d S( N( ( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR+ � s c C s d S( N( ( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR, � s c C s y t | � Wn& t | d � } t d | � } n
X| \ } } y t | � } t | � } Wn t k
r� | g } d } n Xy t | � } t | � } Wn t k
r� | g } d } n Xt | � t | � } } | j } t | j � } | j } t | j � }
t } | | k r%t } n� x� t | � D]r } | | | | | | k r^t } Pn | | d k r�| | c | 7<n | | d k r2| | c |
7<q2q2W| s�t
d � � n g t | � D] } | | k r�| ^ q�}
|
| } d } x | D] } | | | 9} q�Wd | f } g |
D] } | | ^ q*} g t |
� D] } | | k rM| ^ qM}
| |
} d } x | D] } | | | 9} q�W| d f } g |
D] } | | ^ q�} | j | � j | � } | j | � j | � } t
| | � } | j | | � S( s�
Compute tensor dot product along specified axes for arrays >= 1-D.
Given two tensors (arrays of dimension greater than or equal to one),
``a`` and ``b``, and an array_like object containing two array_like
objects, ``(a_axes, b_axes)``, sum the products of ``a``'s and ``b``'s
elements (components) over the axes specified by ``a_axes`` and
``b_axes``. The third argument can be a single non-negative
integer_like scalar, ``N``; if it is such, then the last ``N``
dimensions of ``a`` and the first ``N`` dimensions of ``b`` are summed
over.
Parameters
----------
a, b : array_like, len(shape) >= 1
Tensors to "dot".
axes : variable type
* integer_like scalar
Number of axes to sum over (applies to both arrays); or
* array_like, shape = (2,), both elements array_like
Axes to be summed over, first sequence applying to ``a``, second
to ``b``.
See Also
--------
dot, einsum
Notes
-----
When there is more than one axis to sum over - and they are not the last
(first) axes of ``a`` (``b``) - the argument ``axes`` should consist of
two sequences of the same length, with the first axis to sum over given
first in both sequences, the second axis second, and so forth.
Examples
--------
A "traditional" example:
>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
>>> c.shape
(5, 2)
>>> c
array([[ 4400., 4730.],
[ 4532., 4874.],
[ 4664., 5018.],
[ 4796., 5162.],
[ 4928., 5306.]])
>>> # A slower but equivalent way of computing the same...
>>> d = np.zeros((5,2))
>>> for i in range(5):
... for j in range(2):
... for k in range(3):
... for n in range(4):
... d[i,j] += a[k,n,i] * b[n,k,j]
>>> c == d
array([[ True, True],
[ True, True],
[ True, True],
[ True, True],
[ True, True]], dtype=bool)
An extended example taking advantage of the overloading of + and \*:
>>> a = np.array(range(1, 9))
>>> a.shape = (2, 2, 2)
>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
>>> A.shape = (2, 2)
>>> a; A
array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
array([[a, b],
[c, d]], dtype=object)
>>> np.tensordot(a, A) # third argument default is 2
array([abbcccdddd, aaaaabbbbbbcccccccdddddddd], dtype=object)
>>> np.tensordot(a, A, 1)
array([[[acc, bdd],
[aaacccc, bbbdddd]],
[[aaaaacccccc, bbbbbdddddd],
[aaaaaaacccccccc, bbbbbbbdddddddd]]], dtype=object)
>>> np.tensordot(a, A, 0) # "Left for reader" (result too long to incl.)
array([[[[[a, b],
[c, d]],
...
>>> np.tensordot(a, A, (0, 1))
array([[[abbbbb, cddddd],
[aabbbbbb, ccdddddd]],
[[aaabbbbbbb, cccddddddd],
[aaaabbbbbbbb, ccccdddddddd]]], dtype=object)
>>> np.tensordot(a, A, (2, 1))
array([[[abb, cdd],
[aaabbbb, cccdddd]],
[[aaaaabbbbbb, cccccdddddd],
[aaaaaaabbbbbbbb, cccccccdddddddd]]], dtype=object)
>>> np.tensordot(a, A, ((0, 1), (0, 1)))
array([abbbcccccddddddd, aabbbbccccccdddddddd], dtype=object)
>>> np.tensordot(a, A, ((2, 1), (1, 0)))
array([acccbbdddd, aaaaacccccccbbbbbbdddddddd], dtype=object)
i i s shape-mismatch for sumi����( t itert rangeR� t listt TypeErrorR Rp R� R t xrangeR� R� t reshapeR' ( Rm R� t axest axes_at axes_bt nat nbt as_t ndat bst ndbt equalR| t notint newaxes_at N2t axist
newshape_at oldat newaxes_bt
newshape_bt oldbt att btRn ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR0 � sl r
+
+
c C s� t | � } | d k r* | j } t } n | j | } t } | | ;} t t | | | � t | | � f � } | j | | � } | r� | j | j � S| Sd S( s�
Roll array elements along a given axis.
Elements that roll beyond the last position are re-introduced at
the first.
Parameters
----------
a : array_like
Input array.
shift : int
The number of places by which elements are shifted.
axis : int, optional
The axis along which elements are shifted. By default, the array
is flattened before shifting, after which the original
shape is restored.
Returns
-------
res : ndarray
Output array, with the same shape as `a`.
See Also
--------
rollaxis : Roll the specified axis backwards, until it lies in a
given position.
Examples
--------
>>> x = np.arange(10)
>>> np.roll(x, 2)
array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
>>> x2 = np.reshape(x, (2,5))
>>> x2
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> np.roll(x2, 1)
array([[9, 0, 1, 2, 3],
[4, 5, 6, 7, 8]])
>>> np.roll(x2, 1, axis=0)
array([[5, 6, 7, 8, 9],
[0, 1, 2, 3, 4]])
>>> np.roll(x2, 1, axis=1)
array([[4, 0, 1, 2, 3],
[9, 5, 6, 7, 8]])
N(
R R� t sizeR� Rp R R R t takeR� ( Rm t shiftR� t nR� t indexesRn ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR- C s 1
)c C s | j } | d k r" | | 7} n | d k r; | | 7} n d } d | k oX | k n sy t | d | | f � � n d | k o� | d k n s� t | d | | d f � � n | | k r� | d 8} n | | k r� | St d | � } | j | � | j | | � | j | � S( s4
Roll the specified axis backwards, until it lies in a given position.
Parameters
----------
a : ndarray
Input array.
axis : int
The axis to roll backwards. The positions of the other axes do not
change relative to one another.
start : int, optional
The axis is rolled until it lies before this position. The default,
0, results in a "complete" roll.
Returns
-------
res : ndarray
Output array.
See Also
--------
roll : Roll the elements of an array by a number of positions along a
given axis.
Examples
--------
>>> a = np.ones((3,4,5,6))
>>> np.rollaxis(a, 3, 1).shape
(3, 6, 4, 5)
>>> np.rollaxis(a, 2).shape
(5, 3, 4, 6)
>>> np.rollaxis(a, 1, 4).shape
(3, 5, 6, 4)
i s& rollaxis: %s (%d) must be >=0 and < %dR� i t start( t ndimR� R� t removet insertR� ( Rm R� R� R� t msgR� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR. � s$ $
c C s t | | d � S( Ni ( R. ( Rm R� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt _move_axis_to_0� s c C s] | d k r% | f d \ } } } n t | � j | d � } t | � j | d � } d } | j d d k s� | j d d k r� t | � � n | j d d k rH| j d d k r� | d | d | d | d } | j d k r� | S| j d | � Sq!| d | d } | d | d } | d | d | d | d }
n� | j d d k r!| j d d k r�| d | d | d | d } | d | d | d | d } | d | d | d | d }
q!| d | d } | d | d } | d | d | d | d }
n t | | |
g � } | j d k rI| S| j d | � Sd S( sh
Return the cross product of two (arrays of) vectors.
The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors
are defined by the last axis of `a` and `b` by default, and these axes
can have dimensions 2 or 3. Where the dimension of either `a` or `b` is
2, the third component of the input vector is assumed to be zero and the
cross product calculated accordingly. In cases where both input vectors
have dimension 2, the z-component of the cross product is returned.
Parameters
----------
a : array_like
Components of the first vector(s).
b : array_like
Components of the second vector(s).
axisa : int, optional
Axis of `a` that defines the vector(s). By default, the last axis.
axisb : int, optional
Axis of `b` that defines the vector(s). By default, the last axis.
axisc : int, optional
Axis of `c` containing the cross product vector(s). By default, the
last axis.
axis : int, optional
If defined, the axis of `a`, `b` and `c` that defines the vector(s)
and cross product(s). Overrides `axisa`, `axisb` and `axisc`.
Returns
-------
c : ndarray
Vector cross product(s).
Raises
------
ValueError
When the dimension of the vector(s) in `a` and/or `b` does not
equal 2 or 3.
See Also
--------
inner : Inner product
outer : Outer product.
ix_ : Construct index arrays.
Examples
--------
Vector cross-product.
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([-3, 6, -3])
One vector with dimension 2.
>>> x = [1, 2]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([12, -6, -3])
Equivalently:
>>> x = [1, 2, 0]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([12, -6, -3])
Both vectors with dimension 2.
>>> x = [1,2]
>>> y = [4,5]
>>> np.cross(x, y)
-3
Multiple vector cross-products. Note that the direction of the cross
product vector is defined by the `right-hand rule`.
>>> x = np.array([[1,2,3], [4,5,6]])
>>> y = np.array([[4,5,6], [1,2,3]])
>>> np.cross(x, y)
array([[-3, 6, -3],
[ 3, -6, 3]])
The orientation of `c` can be changed using the `axisc` keyword.
>>> np.cross(x, y, axisc=0)
array([[-3, 3],
[ 6, -6],
[-3, 3]])
Change the vector definition of `x` and `y` using `axisa` and `axisb`.
>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
>>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
>>> np.cross(x, y)
array([[ -6, 12, -6],
[ 0, 0, 0],
[ 6, -12, 6]])
>>> np.cross(x, y, axisa=0, axisb=0)
array([[-24, 48, -24],
[-30, 60, -30],
[-36, 72, -36]])
i i sD incompatible dimensions for cross product
(dimension must be 2 or 3)i i N( i i ( i i ( R� R t swapaxesRp R� R� R ( Rm R� t axisat axisbt axiscR� R� t cpR� t yt z( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR/ � s8 j &"%""%%( R1 R2 R3 c C sg | j d k s | j d k r< t | | | | d d � } n d t | j � f } | j t k rp | j j } n d } | j j t k o� | j d k } | r� d | | f S| j j
} | r� | d j � o� | j � r� d | } n d } t
| j j t � rN| j j r$d t | j � } n d t | j � } d
d t d � } n | d | | | f Sd
S( s�
Return the string representation of an array.
Parameters
----------
arr : ndarray
Input array.
max_line_width : int, optional
The maximum number of columns the string should span. Newline
characters split the string appropriately after array elements.
precision : int, optional
Floating point precision. Default is the current printing precision
(usually 8), which can be altered using `set_printoptions`.
suppress_small : bool, optional
Represent very small numbers as zero, default is False. Very small
is defined by `precision`, if the precision is 8 then
numbers smaller than 5e-9 are represented as zero.
Returns
-------
string : str
The string representation of an array.
See Also
--------
array_str, array2string, set_printoptions
Examples
--------
>>> np.array_repr(np.array([1,2]))
'array([1, 2])'
>>> np.array_repr(np.ma.array([0.]))
'MaskedArray([ 0.])'
>>> np.array_repr(np.array([], np.int32))
'array([], dtype=int32)'
>>> x = np.array([1e-6, 4e-7, 2, 3])
>>> np.array_repr(x, precision=6, suppress_small=True)
'array([ 0.000001, 0. , 2. , 3. ])'
i s , s array(s [], shape=%sR s %s(%s)s '%s't s %ss
t s (%s, %sdtype=%s)N( i ( R� Rp R1 t reprt __class__R Rd R t typet
_typelessdatat namet isalphat isalnumt
issubclasst flexiblet namest strR� ( R� t max_line_widtht precisiont suppress_smallt lstt cNamet skipdtypet typenamet lf( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR4 U s( * ! #
c C s t | | | | d d t � S( s=
Return a string representation of the data in an array.
The data in the array is returned as a single string. This function is
similar to `array_repr`, the difference being that `array_repr` also
returns information on the kind of array and its data type.
Parameters
----------
a : ndarray
Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`. The
default is, indirectly, 75.
precision : int, optional
Floating point precision. Default is the current printing precision
(usually 8), which can be altered using `set_printoptions`.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
See Also
--------
array2string, array_repr, set_printoptions
Examples
--------
>>> np.array_str(np.arange(3))
'[0 1 2]'
R� R� ( R1 R� ( Rm R� R� R� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR5 � s "c C sI | d k r5 | r" t j t d � St j t d � Sn t j | | � Sd S( s
Set a Python function to be used when pretty printing arrays.
Parameters
----------
f : function or None
Function to be used to pretty print arrays. The function should expect
a single array argument and return a string of the representation of
the array. If None, the function is reset to the default NumPy function
to print arrays.
repr : bool, optional
If True (default), the function for pretty printing (``__repr__``)
is set, if False the function that returns the default string
representation (``__str__``) is set.
See Also
--------
set_printoptions, get_printoptions
Examples
--------
>>> def pprint(arr):
... return 'HA! - What are you going to do now?'
...
>>> np.set_string_function(pprint)
>>> a = np.arange(10)
>>> a
HA! - What are you going to do now?
>>> print a
[0 1 2 3 4 5 6 7 8 9]
We can reset the function to the default:
>>> np.set_string_function(None)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
`repr` affects either pretty printing or normal string representation.
Note that ``__repr__`` is still affected by setting ``__str__``
because the width of each array element in the returned string becomes
equal to the length of the result of ``__str__()``.
>>> x = np.arange(4)
>>> np.set_string_function(lambda x:'random', repr=False)
>>> x.__str__()
'random'
>>> x.__repr__()
'array([ 0, 1, 2, 3])'
i i N( R� Rl R6 R4 R5 ( R� R� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR6 � s
3 t littlec C s� t | � } t | � } | d k r4 t g d | �St | f | d | �} x� t | � D] \ } } t | d | �} d | | f d | | d | _ | | d | | d } t | | � } t | | | | � qZ W| S( s�
Return an array representing the indices of a grid.
Compute an array where the subarrays contain index values 0,1,...
varying only along the corresponding axis.
Parameters
----------
dimensions : sequence of ints
The shape of the grid.
dtype : dtype, optional
Data type of the result.
Returns
-------
grid : ndarray
The array of grid indices,
``grid.shape = (len(dimensions),) + tuple(dimensions)``.
See Also
--------
mgrid, meshgrid
Notes
-----
The output shape is obtained by prepending the number of dimensions
in front of the tuple of dimensions, i.e. if `dimensions` is a tuple
``(r0, ..., rN-1)`` of length ``N``, the output shape is
``(N,r0,...,rN-1)``.
The subarrays ``grid[k]`` contains the N-D array of indices along the
``k-th`` axis. Explicitly::
grid[k,i0,i1,...,iN-1] = ik
Examples
--------
>>> grid = np.indices((2, 3))
>>> grid.shape
(2, 2, 3)
>>> grid[0] # row indices
array([[0, 0, 0],
[1, 1, 1]])
>>> grid[1] # column indices
array([[0, 1, 2],
[0, 1, 2]])
The indices can be used as an index into an array.
>>> x = np.arange(20).reshape(5, 4)
>>> row, col = np.indices((2, 3))
>>> x[row, col]
array([[0, 1, 2],
[4, 5, 6]])
Note that it would be more straightforward in the above example to
extract the required elements directly with ``x[:2, :3]``.
i R i ( i ( i ( i ( t tupleR� R R
t enumerateR Rp R t add( t
dimensionsR t NRn t it dimt tmpt newdimt val( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR< s < $c K s1 | j d t � } t | d | �} | | | � S( sG
Construct an array by executing a function over each coordinate.
The resulting array therefore has a value ``fn(x, y, z)`` at
coordinate ``(x, y, z)``.
Parameters
----------
function : callable
The function is called with N parameters, where N is the rank of
`shape`. Each parameter represents the coordinates of the array
varying along a specific axis. For example, if `shape`
were ``(2, 2)``, then the parameters in turn be (0, 0), (0, 1),
(1, 0), (1, 1).
shape : (N,) tuple of ints
Shape of the output array, which also determines the shape of
the coordinate arrays passed to `function`.
dtype : data-type, optional
Data-type of the coordinate arrays passed to `function`.
By default, `dtype` is float.
Returns
-------
fromfunction : any
The result of the call to `function` is passed back directly.
Therefore the shape of `fromfunction` is completely determined by
`function`. If `function` returns a scalar value, the shape of
`fromfunction` would match the `shape` parameter.
See Also
--------
indices, meshgrid
Notes
-----
Keywords other than `dtype` are passed to `function`.
Examples
--------
>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
array([[ True, False, False],
[False, True, False],
[False, False, True]], dtype=bool)
>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4]])
R ( t popt floatR< ( t functionRp t kwargsR t args( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR= K s 3c C s' t | t � r t St | � t k Sd S( s�
Returns True if the type of `num` is a scalar type.
Parameters
----------
num : any
Input argument, can be of any type and shape.
Returns
-------
val : bool
True if `num` is a scalar type, False if it is not.
Examples
--------
>>> np.isscalar(3.1)
True
>>> np.isscalar([3.1])
False
>>> np.isscalar(False)
True
N( R� t genericR� R� t
ScalarType( t num( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRA � s t 0000t 0t 0001t 1t 0010t 2t 0011t 3t 0100t 4t 0101t 5t 0110t 6t 0111t 7t 1000t 8t 1001t 9t 1010Rm t 1011R� t 1100t ct 1101t dt 1110t et 1111R� t Bt DR� R� R� t Lc C s� d } | d k r? | d k r. d } | } qY d | | } n | d k rY d | pW d St | � } d j g | d D] } t | ^ qv � } | j d � } | d k r� | j | � } n | | S( sI
Return the binary representation of the input number as a string.
For negative numbers, if width is not given, a minus sign is added to the
front. If width is given, the two's complement of the number is
returned, with respect to that width.
In a two's-complement system negative numbers are represented by the two's
complement of the absolute value. This is the most common method of
representing signed integers on computers [1]_. A N-bit two's-complement
system can represent every integer in the range
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
Parameters
----------
num : int
Only an integer decimal number can be used.
width : int, optional
The length of the returned string if `num` is positive, the length of
the two's complement if `num` is negative.
Returns
-------
bin : str
Binary representation of `num` or two's complement of `num`.
See Also
--------
base_repr: Return a string representation of a number in the given base
system.
Notes
-----
`binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
faster.
References
----------
.. [1] Wikipedia, "Two's complement",
http://en.wikipedia.org/wiki/Two's_complement
Examples
--------
>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011'
The two's complement is returned when the input number is negative and
width is specified:
>>> np.binary_repr(-3, width=4)
'1101'
R� i t -i R i N( R� t hext joint _lkupt lstript zfill( R� t widtht signt ostrt cht bin( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRB � s ;
* c C s� d } | t | � k r' t d � � n t | � } g } x) | rd | j | | | � | | } q< W| r | j d | � n | d k r� | j d � n d j t | p� d � � S( sR
Return a string representation of a number in the given base system.
Parameters
----------
number : int
The value to convert. Only positive values are handled.
base : int, optional
Convert `number` to the `base` number system. The valid range is 2-36,
the default value is 2.
padding : int, optional
Number of zeros padded on the left. Default is 0 (no padding).
Returns
-------
out : str
String representation of `number` in `base` system.
See Also
--------
binary_repr : Faster version of `base_repr` for base 2.
Examples
--------
>>> np.base_repr(5)
'101'
>>> np.base_repr(6, 5)
'11'
>>> np.base_repr(7, base=5, padding=3)
'00012'
>>> np.base_repr(10, base=16)
'A'
>>> np.base_repr(32, base=16)
'20'
t$ 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZs/ Bases greater than 36 not handled in base_repr.R i R R� ( R� R� t absRx R! t reversed( t numbert baset paddingt digitsR� Rn ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRC s & ( R? R@ c C s1 t | t d � � r' t | d � } n t | � S( s7
Wrapper around cPickle.load which accepts either a file-like object or
a filename.
Note that the NumPy binary format is not based on pickle/cPickle anymore.
For details on the preferred way of loading and saving files, see `load`
and `save`.
See Also
--------
load, save
R� t rb( R� R� t _filet _cload( t file( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR? = s c C s` t | � } | j } | d k r% | Sg | j D] } t | | d | � ^ q/ } t | � Sd S( Ni ( R t fieldsR� R� t _maketupR� ( t descrR� t dtR5 R� Rn ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR6 R s -c C s d d l m } | | d | �S( s@
Return the identity array.
The identity array is a square array with ones on
the main diagonal.
Parameters
----------
n : int
Number of rows (and columns) in `n` x `n` output.
dtype : data-type, optional
Data-type of the output. Defaults to ``float``.
Returns
-------
out : ndarray
`n` x `n` array with its main diagonal set to one,
and all other elements 0.
Examples
--------
>>> np.identity(3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
i����( t eyeR ( t numpyR9 ( R� R R9 ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRE \ s g�h㈵��>g:�0�yE>c C s� t | d t d d �} t | d t d d �} t | � } t | � } t | � s` t | � r� t | | k � sv t St | | | | k � s� t S| | } | | } n t t t | | � | | t | � � � S( s�
Returns True if two arrays are element-wise equal within a tolerance.
The tolerance values are positive, typically very small numbers. The
relative difference (`rtol` * abs(`b`)) and the absolute difference
`atol` are added together to compare against the absolute difference
between `a` and `b`.
If either array contains one or more NaNs, False is returned.
Infs are treated as equal if they are in the same place and of the same
sign in both arrays.
Parameters
----------
a, b : array_like
Input arrays to compare.
rtol : float
The relative tolerance parameter (see Notes).
atol : float
The absolute tolerance parameter (see Notes).
Returns
-------
allclose : bool
Returns True if the two arrays are equal within the given
tolerance; False otherwise.
See Also
--------
all, any, alltrue, sometrue
Notes
-----
If the following equation is element-wise True, then allclose returns
True.
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
The above equation is not symmetric in `a` and `b`, so that
`allclose(a, b)` might be different from `allclose(b, a)` in
some rare cases.
Examples
--------
>>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
False
>>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
True
>>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
False
>>> np.allclose([1.0, np.nan], [1.0, np.nan])
False
R~ R� i ( R R t isinft anyt allt
less_equalR+ ( Rm R� t rtolt atolR� R� t xinft yinf( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRF { s 7 c s4 � � f d � } t � d t d t d d �} t � d t d t d d �} t | � } t | � } t | � r� t | � r� | | | | | � S| | @}
t |
d t �} | t | � } | t | � } | | |
| |
| | � | |
<| |
| |
k | |
<| r,t | t | � t | � @<n | Sd S( s�
Returns a boolean array where two arrays are element-wise equal within a
tolerance.
The tolerance values are positive, typically very small numbers. The
relative difference (`rtol` * abs(`b`)) and the absolute difference
`atol` are added together to compare against the absolute difference
between `a` and `b`.
Parameters
----------
a, b : array_like
Input arrays to compare.
rtol : float
The relative tolerance parameter (see Notes).
atol : float
The absolute tolerance parameter (see Notes).
equal_nan : bool
Whether to compare NaN's as equal. If True, NaN's in `a` will be
considered equal to NaN's in `b` in the output array.
Returns
-------
y : array_like
Returns a boolean array of where `a` and `b` are equal within the
given tolerance. If both `a` and `b` are scalars, returns a single
boolean value.
See Also
--------
allclose
Notes
-----
.. versionadded:: 1.7.0
For finite values, isclose uses the following equation to test whether
two floating point values are equivalent.
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
The above equation is not symmetric in `a` and `b`, so that
`isclose(a, b)` might be different from `isclose(b, a)` in
some rare cases.
Examples
--------
>>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
array([True, False])
>>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
array([True, True])
>>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
array([False, True])
>>> np.isclose([1.0, np.nan], [1.0, np.nan])
array([True, False])
>>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
array([True, True])
c ss t d d � } z+ t t | | � | | t | � � } Wd t | � Xt � � ro t � � ro t | � } n | S( Nt invalidt ignore( RI R> R+ RA t bool( R� R� R@ R? t errt result( Rm R� ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt
within_tol� s + R~ Ri R� i N( R R R� t isfiniteR= R" R# t isnan( Rm R� R? R@ t equal_nanRH R� R� t xfint yfint finitet cond( ( Rm R� s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR> � s ;
! c C sW y t | � t | � } } Wn t SX| j | j k r> t St t | | � j � � S( s�
True if two arrays have the same shape and elements, False otherwise.
Parameters
----------
a1, a2 : array_like
Input arrays.
Returns
-------
b : bool
Returns True if the arrays are equal.
See Also
--------
allclose: Returns True if two arrays are element-wise equal within a
tolerance.
array_equiv: Returns True if input arrays are shape consistent and all
elements equal.
Examples
--------
>>> np.array_equal([1, 2], [1, 2])
True
>>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
True
>>> np.array_equal([1, 2], [1, 2, 3])
False
>>> np.array_equal([1, 2], [1, 4])
False
( R R Rp RE R� R= ( t a1t a2( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR: s ! c C s^ y t | � t | � } } Wn t SXy t t | | � j � � SWn t k
rY t SXd S( s�
Returns True if input arrays are shape consistent and all elements equal.
Shape consistent means they are either the same shape, or one input array
can be broadcasted to create the same shape as the other one.
Parameters
----------
a1, a2 : array_like
Input arrays.
Returns
-------
out : bool
True if equivalent, False otherwise.
Examples
--------
>>> np.array_equiv([1, 2], [1, 2])
True
>>> np.array_equiv([1, 2], [1, 3])
False
Showing the shape equivalence:
>>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
True
>>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
False
>>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
False
N( R R RE R� R= R� ( RP RQ ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyR; I s #
RD R� t raiset callt printt logc C s� t j � } t � } | d k r4 | p. | d } n | d k rS | pM | d } n | d k rr | pl | d } n | d k r� | p� | d } n t | t >t | t >t | t >t | t >} | | d <t j | � | S( s3
Set how floating-point errors are handled.
Note that operations on integer scalar types (such as `int16`) are
handled like floating point, and are affected by these settings.
Parameters
----------
all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Set treatment for all types of floating-point errors at once:
- ignore: Take no action when the exception occurs.
- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
- raise: Raise a `FloatingPointError`.
- call: Call a function specified using the `seterrcall` function.
- print: Print a warning directly to ``stdout``.
- log: Record error in a Log object specified by `seterrcall`.
The default is not to change the current behavior.
divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for division by zero.
over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for floating-point overflow.
under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for floating-point underflow.
invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for invalid floating-point operation.
Returns
-------
old_settings : dict
Dictionary containing the old settings.
See also
--------
seterrcall : Set a callback function for the 'call' mode.
geterr, geterrcall, errstate
Notes
-----
The floating-point exceptions are defined in the IEEE 754 standard [1]:
- Division by zero: infinite result obtained from finite numbers.
- Overflow: result too large to be expressed.
- Underflow: result so close to zero that some precision
was lost.
- Invalid operation: result is not an expressible number, typically
indicates that a NaN was produced.
.. [1] http://en.wikipedia.org/wiki/IEEE_754
Examples
--------
>>> old_settings = np.seterr(all='ignore') #seterr to known value
>>> np.seterr(over='raise')
{'over': 'ignore', 'divide': 'ignore', 'invalid': 'ignore',
'under': 'ignore'}
>>> np.seterr(all='ignore') # reset to default
{'over': 'raise', 'divide': 'ignore', 'invalid': 'ignore', 'under': 'ignore'}
>>> np.int16(32000) * np.int16(3)
30464
>>> old_settings = np.seterr(all='warn', over='raise')
>>> np.int16(32000) * np.int16(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
FloatingPointError: overflow encountered in short_scalars
>>> old_settings = np.seterr(all='print')
>>> np.geterr()
{'over': 'print', 'divide': 'print', 'invalid': 'print', 'under': 'print'}
>>> np.int16(32000) * np.int16(3)
Warning: overflow encountered in short_scalars
30464
t dividet overt underRC i N(
t umatht geterrobjRJ R� t _errdictt SHIFT_DIVIDEBYZEROt SHIFT_OVERFLOWt SHIFT_UNDERFLOWt
SHIFT_INVALIDt seterrobj( R= RV RW RX RC t pyvalst oldt maskvalue( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRI � s N #
c C s� t j � d } d } i } | t ?| @} t | | d <| t ?| @} t | | d <| t ?| @} t | | d <| t ?| @} t | | d <| S( s>
Get the current way of handling floating-point errors.
Returns
-------
res : dict
A dictionary with keys "divide", "over", "under", and "invalid",
whose values are from the strings "ignore", "print", "log", "warn",
"raise", and "call". The keys represent possible floating-point
exceptions, and the values define how these exceptions are handled.
See Also
--------
geterrcall, seterr, seterrcall
Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.
Examples
--------
>>> np.geterr()
{'over': 'warn', 'divide': 'warn', 'invalid': 'warn',
'under': 'ignore'}
>>> np.arange(3.) / np.arange(3.)
array([ NaN, 1., 1.])
>>> oldsettings = np.seterr(all='warn', over='raise')
>>> np.geterr()
{'over': 'raise', 'divide': 'warn', 'invalid': 'warn', 'under': 'warn'}
>>> np.arange(3.) / np.arange(3.)
__main__:1: RuntimeWarning: invalid value encountered in divide
array([ NaN, 1., 1.])
i i RV RW RX RC ( RY RZ R\ t _errdict_revR] R^ R_ ( Rc t maskRn R� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRJ � s %c C s� | d k r t d | � � n | d k r> t d | � � n | d d k ra t d | � � n t j � } t � } | | d <t j | � | S( s{
Set the size of the buffer used in ufuncs.
Parameters
----------
size : int
Size of buffer.
g �cAs Buffer size, %s, is too big.i s Buffer size, %s, is too small.i i s) Buffer size, %s, is not a multiple of 16.( R� RY RZ RL R` ( R� Ra Rb ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRK s
c C s t j � d S( s�
Return the size of the buffer used in ufuncs.
Returns
-------
getbufsize : int
Size of ufunc buffer in bytes.
i ( RY RZ ( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRL + s
c C s{ | d k rK t | � rK t | d � s9 t | j � rK t d � � qK n t j � } t � } | | d <t j | � | S( sn
Set the floating-point error callback function or log object.
There are two ways to capture floating-point error messages. The first
is to set the error-handler to 'call', using `seterr`. Then, set
the function to call using this function.
The second is to set the error-handler to 'log', using `seterr`.
Floating-point errors then trigger a call to the 'write' method of
the provided object.
Parameters
----------
func : callable f(err, flag) or object with write method
Function to call upon floating-point errors ('call'-mode) or
object whose 'write' method is used to log such message ('log'-mode).
The call function takes two arguments. The first is the
type of error (one of "divide", "over", "under", or "invalid"),
and the second is the status flag. The flag is a byte, whose
least-significant bits indicate the status::
[0 0 0 0 invalid over under invalid]
In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
If an object is provided, its write method should take one argument,
a string.
Returns
-------
h : callable, log instance or None
The old error handler.
See Also
--------
seterr, geterr, geterrcall
Examples
--------
Callback upon error:
>>> def err_handler(type, flag):
... print "Floating point error (%s), with flag %s" % (type, flag)
...
>>> saved_handler = np.seterrcall(err_handler)
>>> save_err = np.seterr(all='call')
>>> np.array([1, 2, 3]) / 0.0
Floating point error (divide by zero), with flag 1
array([ Inf, Inf, Inf])
>>> np.seterrcall(saved_handler)
<function err_handler at 0x...>
>>> np.seterr(**save_err)
{'over': 'call', 'divide': 'call', 'invalid': 'call', 'under': 'call'}
Log error message:
>>> class Log(object):
... def write(self, msg):
... print "LOG: %s" % msg
...
>>> log = Log()
>>> saved_handler = np.seterrcall(log)
>>> save_err = np.seterr(all='log')
>>> np.array([1, 2, 3]) / 0.0
LOG: Warning: divide by zero encountered in divide
<BLANKLINE>
array([ Inf, Inf, Inf])
>>> np.seterrcall(saved_handler)
<__main__.Log object at 0x...>
>>> np.seterr(**save_err)
{'over': 'log', 'divide': 'log', 'invalid': 'log', 'under': 'log'}
t writes% Only callable can be used as callbacki N( R� t callablet hasattrRf R� RY RZ RN R` ( t funcRa Rb ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRM 7 s Q
c C s t j � d S( s�
Return the current callback function used on floating-point errors.
When the error handling for a floating-point error (one of "divide",
"over", "under", or "invalid") is set to 'call' or 'log', the function
that is called or the log instance that is written to is returned by
`geterrcall`. This function or log instance has been set with
`seterrcall`.
Returns
-------
errobj : callable, log instance or None
The current error handler. If no handler was set through `seterrcall`,
``None`` is returned.
See Also
--------
seterrcall, seterr, geterr
Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.
Examples
--------
>>> np.geterrcall() # we did not yet set a handler, returns None
>>> oldsettings = np.seterr(all='call')
>>> def err_handler(type, flag):
... print "Floating point error (%s), with flag %s" % (type, flag)
>>> oldhandler = np.seterrcall(err_handler)
>>> np.array([1, 2, 3]) / 0.0
Floating point error (divide by zero), with flag 1
array([ Inf, Inf, Inf])
>>> cur_handler = np.geterrcall()
>>> cur_handler is err_handler
True
i ( RY RZ ( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRN � s *t _unspecifiedc B s e Z RS( ( Rd Re ( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRj � s c B s) e Z d Z d � Z d � Z d � Z RS( s�
errstate(**kwargs)
Context manager for floating-point error handling.
Using an instance of `errstate` as a context manager allows statements in
that context to execute with a known error handling behavior. Upon entering
the context the error handling is set with `seterr` and `seterrcall`, and
upon exiting it is reset to what it was before.
Parameters
----------
kwargs : {divide, over, under, invalid}
Keyword arguments. The valid keywords are the possible floating-point
exceptions. Each keyword should have a string value that defines the
treatment for the particular error. Possible values are
{'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
See Also
--------
seterr, geterr, seterrcall, geterrcall
Notes
-----
The ``with`` statement was introduced in Python 2.5, and can only be used
there by importing it: ``from __future__ import with_statement``. In
earlier Python versions the ``with`` statement is not available.
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.
Examples
--------
>>> from __future__ import with_statement # use 'with' in Python 2.5
>>> olderr = np.seterr(all='ignore') # Set error handling to known state.
>>> np.arange(3) / 0.
array([ NaN, Inf, Inf])
>>> with np.errstate(divide='warn'):
... np.arange(3) / 0.
...
__main__:2: RuntimeWarning: divide by zero encountered in divide
array([ NaN, Inf, Inf])
>>> np.sqrt(-1)
nan
>>> with np.errstate(invalid='raise'):
... np.sqrt(-1)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
FloatingPointError: invalid value encountered in sqrt
Outside the context the error handling behavior has not changed:
>>> np.geterr()
{'over': 'warn', 'divide': 'warn', 'invalid': 'warn',
'under': 'ignore'}
c K s" | j d t � | _ | | _ d S( NRS ( R� t _UnspecifiedRS R� ( t selfR� ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt __init__� s c C s: t | j � | _ | j t k r6 t | j � | _ n d S( N( RI R� t oldstateRS Rk RM t oldcall( Rl ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt __enter__
s c G s0 t | j � | j t k r, t | j � n d S( N( RI Rn RS Rk RM Ro ( Rl t exc_info( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt __exit__
s
( Rd Re Rf Rm Rp Rr ( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyRO � s ; c C s t t d g } t j | � d S( N( t UFUNC_BUFSIZE_DEFAULTt ERR_DEFAULT2R� RY R` ( t defval( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt _setdef
s (� Rq t sysR� Rl RY t numerictypest version_infot extendt RuntimeWarningR` t invertRY RZ R\ R[ R] R_ R^ R R R R R R R R� t sinR R� R� R" RD R# R} R R R R R R
R! R
R9 R R Rc Rb R R R t _fastCopyAndTransposeR R R R R R R RG RH R( R R R R R8 R R RP R� R� R R$ R% R) t _dotblasR' R* R& R+ R, t ImportErrorR0 R- R. R� R/ t
arrayprintR1 R2 R3 t int_t float_t complex_R� R� t intct intRx t longlongR4 R5 R6 t byteorderR7 R< R= RA R" RB RC t cPickleR? R@ R3 t openR2 R6 RE RF R> R: R; t
ERR_IGNOREt ERR_WARNt ERR_RAISEt ERR_CALLt ERR_PRINTt ERR_LOGR[ Rd Rv t keyRI RJ RK RL RM RN t objectRj Rk RO Rv t PINFRQ RR RS RT t NANRU RV t bool_RW RX t fromnumeric( ( ( s8 /usr/lib64/python2.7/site-packages/numpy/core/numeric.pyt <module> sv
6 7
F4 $ $X 9 ( '
6 ] J,
� @ 8 � H$ ;
I 7
L5
I\ ) -
` 2 Z , J