Submit
Path:
~
/
/
proc
/
thread-self
/
root
/
opt
/
alt
/
python35
/
lib64
/
python3.5
/
site-packages
/
numpy
/
core
/
__pycache__
/
File Content:
numeric.cpython-35.pyc
X��f�Z � j @ s� d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z d d l m Z d d l m Z m Z m Z m Z m Z m Z d d l m Z e j! d d k r@d d l" Z" e# Z$ d d l% Z% n d d l& Z" d d l' Z% e" j( Z( 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` da db dc dd de df dg dh di dj dk dl dm dn do dp dq dr ds dt gj Z) e j! d d k r�e) j* du dv g � Gdw dl � dl e+ � Z, e Z- e j. Z. e j/ Z/ e j0 Z0 e j1 Z1 e j2 Z2 e j3 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< e= e � Z> d dx dy dz d- � Z? d d{ d| dP � Z@ d dx dy d} d. � ZA d d{ d~ dm � ZB d dx dy d dn � ZC d� d� � ZD d ZE e jF ZF e jG ZG e jH ZH e jI ZI e jJ ZJ e jK ZK e jL ZL e jM ZM e jN ZN e jO ZO e jP ZP e jQ ZQ e j! d d k r�e jR ZR e jS ZS e jT ZT e jU ZU e jV ZV e jW ZX e jY ZY e jZ ZZ e j[ Z[ e j\ Z\ e j] Z] e j^ Z^ e j_ Z_ e j` Z` e ja Za e jb Zb e jc Zc e jd Zd e je Ze d d d� d' � Zf d d d� d( � Zg d d� d) � Zh d d� d* � Zi d d d� dD � Zj d� d+ � Zk d� d � Zl d� d\ � Zm d� d d� d d� d� i Zn d� d� � Zo d� d� d/ � Zp dm d� d0 � Zq d d� d4 � Zr d� d6 � Zs d� d7 � Zt d� d� d< � Zu d d� d8 � Zv d d� d9 � Zw d� d� � Zx d� d: � Zy d� d� � Zz d� d� d� d d� d; � Z{ d d� l| m} Z} m~ Z~ m Z e e e g Z� e� e e� � r�e� j� e � e� e e� � r�e� j� e � d d d d� d@ � Z� d d d d� dA � Z� dy d� dB � Z� e� e� d � e� e� d � e j� d� k Z� e� d� dH � Z� d� dI � Z� d� dM � Z� 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� i Z� d d� dN � Z� d� d d� dO � Z� d� dK � Z� d� d� � Z� d d� dQ � Z� d� d� d� d� dR � Z� d� d� d� d� dJ � Z� d� dF � Z� d� dG � Z� d� e d� e d� e d� e d� e d� e i Z� i Z� x" e� j� � D] Z� e� e� e� e� <q�W[� d d d d d d� dU � Z� d� dV � Z� d� dW � Z� d� dX � Z� d� dY � Z� d� dZ � Z� Gd� d� � d� e� � Z� e� � Z� Gd� d[ � d[ e� � Z� d� d� � Z� e� � e Z� Z� Z� Z� e Z� Z� e d� � Z� e dy � Z� d d� l Td d� l Td d� l m� Z� d d� l� TeD e� � eD e � eD e � d S)�� )�division�absolute_import�print_functionN)� multiarray� )�umath) �invert�sin�UFUNC_BUFSIZE_DEFAULT� ERR_IGNORE�ERR_WARN� ERR_RAISE�ERR_CALL� ERR_PRINT�ERR_LOG� ERR_DEFAULT�PINF�NAN)� numerictypes)�longlong�intc�int_�float_�complex_�bool_)� TooHardError� �newaxis�ndarray�flatiter�nditer� nested_iters�ufunc�arange�array�zeros� count_nonzero�empty� broadcast�dtype� fromstring�fromfile� frombuffer� int_asbuffer�where�argwhere�copyto� concatenate�fastCopyAndTranspose�lexsort�set_numeric_ops�can_cast� promote_types�min_scalar_type� result_type�asarray� asanyarray�ascontiguousarray�asfortranarray� isfortran� empty_like� zeros_like� ones_like� correlate�convolve�inner�dot�einsum�outer�vdot�alterdot� restoredot�roll�rollaxis�moveaxis�cross� tensordot� array2string�get_printoptions�set_printoptions� array_repr� array_str�set_string_function� little_endian�require�fromiter� array_equal� array_equiv�indices� fromfunction�isclose�load�loads�isscalar� binary_repr� base_repr�ones�identity�allclose�compare_chararrays�putmask�seterr�geterr� setbufsize� getbufsize� seterrcall� geterrcall�errstate� flatnonzero�Inf�inf�infty�Infinity�nan�NaN�False_�True_� bitwise_not�CLIP�RAISE�WRAP�MAXDIMS�BUFSIZE� ALLOW_THREADS�ComplexWarning�full� full_like�matmul� shares_memory�may_share_memory�MAY_SHARE_BOUNDS�MAY_SHARE_EXACTr � getbuffer� newbufferc @ s e Z d Z d Z d S)r~ z� 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. N)�__name__� __module__� __qualname__�__doc__� r� r� � /numeric.pyr~ 7 s �KTc C sM t | d | d | d | �} t d d | j �} t j | | d d �| S)a> Return an array of zeros with the same shape and type as a given array. 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. .. versionadded:: 1.6.0 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. .. versionadded:: 1.6.0 subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. 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) �order�subokr �casting�unsafe)r> r% r) r r0 )�ar) r� r� �res�zr� r� r� r? V s 8 �Cc C s, t | | | � } t j | d d d �| S)a� Return a new array of given shape and type, filled with ones. Parameters ---------- shape : int or sequence of ints Shape of the new array, e.g., ``(2, 3)`` or ``2``. dtype : data-type, optional The desired data-type for the array, e.g., `numpy.int8`. Default is `numpy.float64`. order : {'C', 'F'}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column-wise) order in memory. Returns ------- out : ndarray Array of ones with the given shape, dtype, and order. 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.]]) r r� r� )r' r r0 )�shaper) r� r� r� r� r� rb � s *c C s8 t | d | d | d | �} t j | d d d �| S)a< Return an array of ones with the same shape and type as a given array. 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. .. versionadded:: 1.6.0 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. .. versionadded:: 1.6.0 subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. 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) r� r� r r� r� )r> r r0 )r� r) r� r� r� r� r� r� r@ � s 8 c C sx t | | | � } | d k r^ t | � j | j k r^ t j d j | | t | � j � t � t j | | d d �| S)aU Return a new array of given shape and type, filled with `fill_value`. Parameters ---------- shape : int or sequence of ints Shape of the new array, e.g., ``(2, 3)`` or ``2``. fill_value : scalar Fill value. dtype : data-type, optional The desired data-type for the array, e.g., `np.int8`. Default is `float`, but will change to `np.array(fill_value).dtype` in a future release. order : {'C', 'F'}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column-wise) order in memory. Returns ------- out : ndarray Array of `fill_value` with the given shape, dtype, and order. See Also -------- zeros_like : Return an array of zeros with shape and type of input. 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. full_like : Fill an 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 -------- >>> np.full((2, 2), np.inf) array([[ inf, inf], [ inf, inf]]) >>> np.full((2, 2), 10, dtype=np.int) array([[10, 10], [10, 10]]) Nz=in the future, full({0}, {1!r}) will return an array of {2!r}r� r� ) r' r$ r) �warnings�warn�format� FutureWarningr r0 )r� � fill_valuer) r� r� r� r� r� r � s +$ c C s8 t | d | d | d | �} t j | | d d �| S)a* Return a full array with the same shape and type as a given array. Parameters ---------- a : array_like The shape and data-type of `a` define these same attributes of the returned array. fill_value : scalar Fill value. 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. subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. Returns ------- out : ndarray Array of `fill_value` with the same shape and type as `a`. See Also -------- zeros_like : Return an array of zeros with shape and type of input. 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. full : Fill a new array. Examples -------- >>> x = np.arange(6, dtype=np.int) >>> np.full_like(x, 1) array([1, 1, 1, 1, 1, 1]) >>> np.full_like(x, 0.1) array([0, 0, 0, 0, 0, 0]) >>> np.full_like(x, 0.1, dtype=np.double) array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) >>> np.full_like(x, np.nan, dtype=np.double) array([ nan, nan, nan, nan, nan, nan]) >>> y = np.arange(6, dtype=np.double) >>> np.full_like(y, 0.1) array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) r) r� r� r� r� )r> r r0 )r� r� r) r� r� r� r� r� r� r� 1 s 7 c C s� i } x t D] } d | | <q Wy t | d � } Wn. t k rd d d � | j j � D� } Yn Xx' | D] } | | k rl t j | � ql Wd S)Nr �__all__c S s% g | ] } | j d � s | � q S)�_)� startswith)�.0�kr� r� r� � <listcomp>t s z extend_all.<locals>.<listcomp>)r� �getattr�AttributeError�__dict__�keys�append)�moduleZadictr� Zmallr� r� r� � extend_allm s ! r� c C s t | | d d d | �S)a� 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-style) or column-major (Fortran-style) 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 �copyFr� )r$ )r� r) r� r� r� r� r9 � s Dc C s t | | d d d | d d �S)a< 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-style) or column-major (Fortran-style) 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� Fr� r� T)r$ )r� r) r� r� r� r� r: � s 1c C s t | | d d d d d d �S)aE 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� Fr� r� �ndminr )r$ )r� r) r� r� r� r; s "c C s t | | d d d d d d �S)aU 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� Fr� �Fr� r )r$ )r� r) r� r� r� r< ; s "c s{ 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 i � | sp t | d | �St � f d d � | D� � } d | k r� | j d � d } n d } d } | t d d g � k r� t d � � nA d | k rd } | j d � n d | k r%d } | j d � t | d | d | d d d | �} x+ | D]# } | j | sP| j | � } PqPW| S)a 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. If None preserve the current dtype. If your application requires the data to be in native byteorder, include a byteorder specification as a part of the dtype specification. 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 * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass 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� Z C_CONTIGUOUSZ CONTIGUOUSr� Z F_CONTIGUOUSZFORTRAN�AZALIGNED�WZ WRITEABLE�OZOWNDATA�EZ ENSUREARRAYr) c 3 s | ] } � | j � Vq d S)N)�upper)r� �x)�possible_flagsr� r� � <genexpr>� s zrequire.<locals>.<genexpr>FTz%Cannot specify both "C" and "F" orderr� r� r� )r: �set�remove� ValueErrorr$ �flagsr� )r� r) Z requirementsr� r� �arrZpropr� )r� r� rV _ s8 < $ c C s | j j S)a� Returns True if the array is Fortran contiguous but *not* C contiguous. This function is obsolete and, because of changes due to relaxed stride checking, its return value for the same array may differ for versions of Numpy >= 1.10 and previous versions. If you only want to check if an array is Fortran contiguous use ``a.flags.f_contiguous`` instead. 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 C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. >>> np.isfortran(np.array([1, 2], order='FORTRAN')) False )r� Zfnc)r� r� r� r� r= � s ;c C s t t | � � S)a� 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]]) )� transpose�nonzero)r� r� r� r� r/ � s &c C s | j � j � d S)a< 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]) r )�ravelr� )r� r� r� r� rn # s %�v�s�f� c C s% t | t � r! t | j � d S| S)Nr )� isinstance� basestring�_mode_from_name_dict�lower)�moder� r� r� �_mode_from_nameN s r� Zvalidc C s t | � } t j | | | � S)a� Cross-correlation of two 1-dimensional sequences. This function computes the correlation as generally defined in signal processing texts:: c_{av}[k] = sum_n a[n+k] * conj(v[n]) 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 `old_behavior` was removed in NumPy 1.10. If you need the old behavior, use `multiarray.correlate`. Returns ------- out : ndarray Discrete cross-correlation of `a` and `v`. See Also -------- convolve : Discrete, linear convolution of two one-dimensional sequences. multiarray.correlate : Old, no conjugate, version of correlate. Notes ----- The definition of correlation above is not unique and sometimes correlation may be defined differently. Another common definition is:: c'_{av}[k] = sum_n a[n] conj(v[n+k]) which is related to ``c_{av}[k]`` by ``c'_{av}[k] = c_{av}[-k]``. 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. ]) Using complex sequences: >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full') array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ]) Note that you get the time reversed, complex conjugated result when the two input sequences change places, i.e., ``c_{va}[k] = c^{*}_{av}[-k]``: >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full') array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j]) )r� r Z correlate2)r� r� r� r� r� r� rA S s @ c C s� t | d d d d �t | d d d d �} } t | � t | � k rV | | } } t | � d k rt t d � � t | � d k r� t d � � t | � } t j | | d d d � | � S) a 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. If `v` is longer than `a`, the arrays are swapped before computation. 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. polymul : Polynomial multiplication. Same output as convolve, but also accepts poly1d objects as input. Notes ----- The discrete convolution operation is defined as .. math:: (a * v)[n] = \sum_{m = -\infty}^{\infty} a[m] v[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� Fr� r r za cannot be emptyzv cannot be emptyN���)r$ �lenr� r� r rA )r� r� r� r� r� r� rB � s W1 c C sT t | � } t | � } t | j � d d � t f | j � t d d � f | � S)a� 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 : (M,) array_like First input vector. Input is flattened if not already 1-dimensional. b : (N,) array_like Second input vector. Input is flattened if not already 1-dimensional. out : (M, N) ndarray, optional A location where the result is stored .. versionadded:: 1.9.0 Returns ------- out : (M, N) ndarray ``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)r9 �multiplyr� r )r� �b�outr� r� r� rF � s L c C s t j d t � d S)a Change `dot`, `vdot`, and `inner` to use accelerated BLAS functions. Typically, as a user of Numpy, you do not explicitly call this function. If Numpy is built with an accelerated BLAS, this function is automatically called when Numpy is imported. When Numpy is built with an accelerated BLAS like ATLAS, these functions are replaced to make use of the faster implementations. The faster implementations only affect float32, float64, complex64, and complex128 arrays. Furthermore, the BLAS API only includes matrix-matrix, matrix-vector, and vector-vector products. Products of arrays with larger dimensionalities use the built in functions and are not accelerated. .. note:: Deprecated in Numpy 1.10 The cblas functions have been integrated into the multarray module and alterdot now longer does anything. It will be removed in Numpy 1.11.0. See Also -------- restoredot : `restoredot` undoes the effects of `alterdot`. z!alterdot no longer does anything.N)r� r� �DeprecationWarningr� r� r� r� rH H s c C s t j d t � d S)a� Restore `dot`, `vdot`, and `innerproduct` to the default non-BLAS implementations. Typically, the user will only need to call this when troubleshooting and installation problem, reproducing the conditions of a build without an accelerated BLAS, or when being very careful about benchmarking linear algebra operations. .. note:: Deprecated in Numpy 1.10 The cblas functions have been integrated into the multarray module and restoredot now longer does anything. It will be removed in Numpy 1.11.0. See Also -------- alterdot : `restoredot` undoes the effects of `alterdot`. z#restoredot no longer does anything.N)r� r� r� r� r� r� r� rI f s c s� y t | � Wn3 t t | d � � � t t d | � � � Yn X| \ � � y t � � } t � � � Wn! t k r� � g � d } Yn Xy t � � } t � � � Wn! t k r� � g � d } Yn Xt | � t | � } } | j � t | j � } | j � t | j � } d } | | k r4d } nv xs t | � D]e } � � | � � | k rjd } P� | d k r�� | | 7<� | d k rA� | | 7<qAW| s�t d � � � f d d � t | � D� } | � } d } x � D] } | � | 9} q�Wd | f } � f d d � | D� } � f d d � t | � D� } � | } d } x � D] } | � | 9} qeW| d f } � f d d � | D� } | j | � j | � } | j | � j | � } t | | � } | j | | � S) a� 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 : int or (2,) array_like * integer_like If an int N, sum over the last N axes of `a` and the first N axes of `b` in order. The sizes of the corresponding axes must match. * (2,) array_like Or, a list of axes to be summed over, first sequence applying to `a`, second to `b`. Both elements array_like must be of the same length. See Also -------- dot, einsum Notes ----- Three common use cases are: ``axes = 0`` : tensor product $a\otimes b$ ``axes = 1`` : tensor dot product $a\cdot b$ ``axes = 2`` : (default) tensor double contraction $a:b$ When `axes` is integer_like, the sequence for evaluation will be: first the -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and Nth axis in `b` last. 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 for double-contraction 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) # tensor product (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) r r TFzshape-mismatch for sumc s" g | ] } | � k r | � q Sr� r� )r� r� )�axes_ar� r� r� " s z tensordot.<locals>.<listcomp>c s g | ] } � | � q Sr� r� )r� �axis)�as_r� r� r� ( s c s" g | ] } | � k r | � q Sr� r� )r� r� )�axes_br� r� r� * s c s g | ] } � | � q Sr� r� )r� r� )�bsr� r� r� 0 s r� r� ) �iter�list�ranger� � TypeErrorr9 r� r� r� �reshaperD )r� r� �axesZnaZnbZndaZndbZequalr� ZnotinZ newaxes_aZN2r� Z newshape_aZoldaZ newaxes_bZ newshape_bZoldbZatZbtr� r� )r� r� r� r� r� rN ~ sl z c C s� t | � } | d k r* | j } d } n? y | j | } Wn% t k rb t d | j � � Yn Xd } | d k ry | S| | ;} t t | | | � t | | � f � } | j | | � } | r� | j | j � } | S)a� 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]]) NTzaxis must be >= 0 and < %dFr ) r: �sizer� � IndexErrorr� �ndimr1 r# Ztaker� )r� Zshiftr� �nr� Zindexesr� r� r� r� rJ 7 s" 1 )c C s | j } | d k r | | 7} | d k r5 | | 7} d } d | k oR | k n sp t | d | | f � � d | k o� | d k n s� t | d | | d f � � | | k r� | d 8} | | k r� | d St t d | � � } | j | � | j | | � | j | � S)a! 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 For Numpy >= 1.10 a view of `a` is always returned. For earlier Numpy versions a view of `a` is returned only if the order of the axes is changed, otherwise the input array is returned. See Also -------- moveaxis : Move array axes to new positions. 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) r z&rollaxis: %s (%d) must be >=0 and < %dr� r �start.)r� r� r� r� r� �insertr� )r� r� r� r� �msgr� r� r� r� rK | s$ ' c s� y t j | � g } Wn t k r6 t | � } Yn X� f d d � | D� } t j � f d d � | D� � s� t d | � � t t | � � t | � k r� t d | � � | S)Nc s, g | ]" } | d k r" | � n | � q S)r r� )r� r� )r� r� r� r� � s z"_validate_axis.<locals>.<listcomp>c 3 s+ | ]! } d | k o � k n Vq d S)r Nr� )r� r� )r� r� r� r� � s z!_validate_axis.<locals>.<genexpr>z,invalid axis for this array in `%s` argumentz repeated axis in `%s` argument) �operator�indexr� r� �builtins�allr� r� r� )r� r� Zargnamer� )r� r� �_validate_axis� s " r� c s� y | j } Wn' t k r6 t | � } | j } Yn Xt � | j d � � t | | j d � } t � � t | � k r� t d � � � f d d � t | j � D� } x3 t t | � � � D] \ } } | j | | � q� W| | � } | S)au Move axes of an array to new positions. Other axes remain in their original order. .. versionadded::1.11.0 Parameters ---------- a : np.ndarray The array whose axes should be reordered. source : int or sequence of int Original positions of the axes to move. These must be unique. destination : int or sequence of int Destination positions for each of the original axes. These must also be unique. Returns ------- result : np.ndarray Array with moved axes. This array is a view of the input array. See Also -------- transpose: Permute the dimensions of an array. swapaxes: Interchange two axes of an array. Examples -------- >>> x = np.zeros((3, 4, 5)) >>> np.moveaxis(x, 0, -1).shape (4, 5, 3) >>> np.moveaxis(x, -1, 0).shape (5, 3, 4) These all achieve the same result: >>> np.transpose(x).shape (5, 4, 3) >>> np.swapaxis(x, 0, -1).shape (5, 4, 3) >>> np.moveaxis(x, [0, 1], [-1, -2]).shape (5, 4, 3) >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape (5, 4, 3) �source� destinationzJ`source` and `destination` arguments must have the same number of elementsc s" g | ] } | � k r | � q Sr� r� )r� r� )r� r� r� r� s z moveaxis.<locals>.<listcomp>) r� r� r9 r� r� r� r� r� �sorted�zipr� )r� r� r� r� r� �dest�src�resultr� )r� r� rL � s 1 "" c C s t | | d � S)Nr )rK )r� r� r� r� r� �_move_axis_to_0 s r� c C sN | d k r" | f d \ } } } t | � } t | � } d } | | j k s_ | | j k rt t | j d � � � | | j k s� | | j k r� t | j d � � � t | | | j � } t | | | j � } d } | j d d k s� | j d d k r t | � � t | d | d � j } | j d d k sJ| j d d k r�| d 7} | t | � k sy| t | � k r�t | j d � � � t | j | j � } t | | � } | d } | d } | j d d k r�| d } | d } | d } | j d d k r| d } | j d k rT| j d d k rT| d } | d } | d! } | j d" d k r| j d# d k r�t | | d | �| | | 8} | S| j d$ d k s�t � t | | d | �t | | d | �t | d | �t | | d | �| | | 8} n,| j d% d k s+t � | j d& d k r�t | | d | �t | | � } | | 8} t | | d | �t | | d | �| | 8} t | | d | �t | | d | �| | 8} np | j d' d k s�t � t | | d | �t | d | �t | | d | �t | | d | �| | | 8} t | d( | � S))a 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). Ignored if both input vectors have dimension 2, as the return is scalar. 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. Notes ----- .. versionadded:: 1.9.0 Supports full broadcasting of the inputs. 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]]) Nr z'axis{0}' out of boundsr� r� zDincompatible dimensions for cross product (dimension must be 2 or 3)r r� .r �cr� r� )r� r r� )r� r ).r ).r r� r� )r ).r ).r r� ).r� ).r ).r r� ).r� r� ).r ).r ).r� r� r� r� r� r� r� r� )r9 r� r� r� rK r� r( r� r6 r) r' r� �AssertionErrorZnegativer$ )r� r� ZaxisaZaxisbZaxiscr� Zaxis_msgr� r� r) �cpZa0�a1�a2Zb0Zb1Zb2Zcp0Zcp1Zcp2�tmpr� r� r� rM s| q & & % " )rO rP rQ c C sa | 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 | } d } t | j j t � rH| j j r!d t | j � } n d t | j � } d d t d � } | d | | | f Sd S)a� 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. ])' r z, zarray(z [], shape=%sr$ z%s(%s)z'%s'� z%s� � z(%s, %sdtype=%s)N)r )r� r� rO �repr� __class__r r� r) �type� _typelessdata�name�isalpha�isalnum� issubclassZflexible�names�strr� ) r� �max_line_width� precision�suppress_smallZlstZcNameZ skipdtype�typenameZlfr� r� r� rR � s( * ! # c C s t | | | | d d t � S)a= 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� )rO r� )r� r� r r r� r� r� rS + s "c C sI | d k r5 | r" t j t d � St j t d � Sn t j | | � Sd S)a 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])' Nr r )r rT rR rS )r� r� r� r� r� rT O s 3 �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 | | d d � } t | | � } t | | | | � qZ W| S)a� 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]``. r r) r N)r )r )r ) �tupler� r$ r' � enumerater# r� r% �add) Z dimensionsr) �Nr� �iZdimr� Znewdim�valr� r� r� rZ � s < $&c K s1 | j d t � } t | d | �} | | | � S)aG 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) )�pop�floatrZ )�functionr� �kwargsr) �argsr� r� r� r[ � s 3c C s' t | t � r d St | � t k Sd S)a� 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 TN)r� Zgenericr� Z ScalarType)�numr� r� r� r_ s �0Z0000�1Z0001�2Z0010�3Z0011�4Z0100�5Z0101�6Z0110�7Z0111�8Z1000�9Z1001r� Z1010r� Z1011r� Z1100�dZ1101�eZ1110Z1111r� �B�Dr� r� �Lr� c C s� d } | d k r? | d k r. d } | } qY d | | } n | d k rY d | pW d St | � } d j d d � | d d � D� � } | j d � } | d k r� | j | � } | | S) aI 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� r N�-r� r r c S s g | ] } t | � q Sr� )�_lkup)r� Zchr� r� r� r� � s z binary_repr.<locals>.<listcomp>)�hex�join�lstrip�zfill)r �widthZsignZostr�binr� r� r� r` F s ; & c C s� d } | t | � k r$ t d � � t | � } g } x) | ra | j | | | � | | } q9 W| ry | j d | � | d k r� | j d � d j t | p� d � � S)aR 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' Z$0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZz/Bases greater than 36 not handled in base_repr.r r r r� )r� r� �absr� r" �reversed)Znumber�baseZpadding�digitsr r� r� r� r� ra � s & c C s1 t | t d � � r$ t | d � } t j | � S)a7 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� �rb)r� r� �open�pickler] )�filer� r� r� r] � s c sR t | � } | j � � d k r% � S� � f d d � | j D� } t | � Sd S)Nc s' g | ] } t � | d � � � q S)r )�_maketup)r� r� )�fieldsr r� r� r� � s z _maketup.<locals>.<listcomp>)r) r0 r� r )Zdescrr �dtr� r� )r0 r r� r/ � s r/ c C s d d l m } | | d | �S)a@ 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.]]) r )�eyer) )Znumpyr2 )r� r) r2 r� r� r� rc � s g�h㈵��>g:�0�yE>Fc C s1 t t | | d | d | d | �� } t | � S)a� 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). 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. .. versionadded:: 1.10.0 Returns ------- allclose : bool Returns True if the two arrays are equal within the given tolerance; False otherwise. See Also -------- isclose, all, any 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 >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) True �rtol�atol� equal_nan)r� r\ �bool)r� r� r3 r4 r5 r� r� r� r� rd s >'c s� � � f d d � } t � d d d d d d �} t � d d d d d d �} t j | d � } t | d | d d d d �} t | � } t | � } t | � r� t | � r� | | | | | � S| | @} t | d d �} | t | � } | t | � } | | | | | | | � | | <| | | | k | | <| rft | � t | � @} | | | | <t � � r�t � � r�t | � S| Sd S) a� 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 sf t d d � �, t t | | � | | t | � � } Wd QRXt � � rb t � � rb t | � } | S)N�invalid�ignore)rm Z less_equalr' r_ r6 )r� �yr4 r3 r� )r� r� r� r� � within_tol� s . zisclose.<locals>.within_tolr� Fr� Tr� r g �?r) N) r$ r r8 �isfiniter� r? r@ �isnanr_ r6 )r� r� r3 r4 r5 r: r� r9 r1 ZxfinZyfinZfiniteZcondZboth_nanr� )r� r� r� r\ G s* ; ! c C s^ y t | � t | � } } Wn d SYn X| j | j k rB d St t | | k � j � � S)a� 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 F)r9 r� r6 r� )r� r� r� r� r� rX � s ! c C sk y t | � t | � } } Wn d SYn Xy t j | | � Wn d SYn Xt t | | k � j � � S)a� 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 F)r9 r r( r6 r� )r� r� r� r� r� rY � s # r8 r� �raise�call�print�logc C s� t j � } t � } | d k r1 | p. | d } | d k rM | pJ | d } | d k ri | pf | d } | d k r� | p� | d } t | t >t | t >t | t >t | t >} | | d <t j | � | S)a5 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(**old_settings) # 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 N�divide�over�underr7 r ) r � geterrobjrh �_errdict�SHIFT_DIVIDEBYZERO�SHIFT_OVERFLOW�SHIFT_UNDERFLOW� SHIFT_INVALID� seterrobj)r� rA rB rC r7 �pyvals�old� maskvaluer� r� r� rg s N # c C s� t j � d } d } i } | t ?| @} t | | d <| t ?| @} t | | d <| t ?| @} t | | d <| t ?| @} t | | d <| S)a> 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.]) r � rA rB rC r7 )r rD rF � _errdict_revrG rH rI )rM �maskr� r r� r� r� rh t s %c C s� | d k r t d | � � | d k r8 t d | � � | d d k rX t d | � � t j � } t � } | | d <t j | � | S)z{ Set the size of the buffer used in ufuncs. Parameters ---------- size : int Size of buffer. g �cAz Buffer size, %s, is too big.� z Buffer size, %s, is too small.� r z)Buffer size, %s, is not a multiple of 16.)r� r rD rj rJ )r� rK rL r� r� r� ri � s c C s t j � d S)z� Return the size of the buffer used in ufuncs. Returns ------- getbufsize : int Size of ufunc buffer in bytes. r )r rD r� r� r� r� rj � s c C s� | d k rQ t | t j � rQ t | d � sE t | j t j � rQ t d � � t j � } t � } | | d <t j | � | S)a� 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 a string describing the type of error (such as "divide by zero", "overflow", "underflow", or "invalid value"), and the second is the status flag. The flag is a byte, whose four least-significant bits indicate the type of error, one of "divide", "over", "under", "invalid":: [0 0 0 0 divide 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'} N�writez%Only callable can be used as callbackr� ) r� � collections�Callable�hasattrrS r� r rD rl rJ )�funcrK rL r� r� r� rk � s R & c C s t j � d S)a� 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 r� )r rD r� r� r� r� rl $ s *c @ s e Z d Z d S)� _unspecifiedN)r� r� r� r� r� r� r� rX P s rX c @ s: e Z d Z d Z d d � Z d d � Z d d � Z d S) rm a� 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)Nr> )r � _Unspecifiedr> r )�selfr r� r� r� �__init__� s zerrstate.__init__c C s7 t | j � | _ | j t k r3 t | j � | _ d S)N)rg r �oldstater> rY rk �oldcall)rZ r� r� r� � __enter__� s zerrstate.__enter__c G s- t | j � | j t k r) t | j � d S)N)rg r\ r> rY rk r] )rZ �exc_infor� r� r� �__exit__� s zerrstate.__exit__N)r� r� r� r� r[ r^ r` r� r� r� r� rm T s ; c C s t t d g } t j | � d S)N)r r r rJ )Zdefvalr� r� r� �_setdef� s ra )�*)� fromnumericr� r� r� )�Z __future__r r r �sysr� r� rT Z numpy.corer r� r r r r r r r r r r r r r r r r r r r r Z _internalr � version_infor- r� r� r� �cPickle� __builtin__r^ r� �extend�RuntimeWarningr~ rw rx rz ry r{ r} r| r� r� r r r r! r( r) r0 r� r" r? rb r@ r r� r� r r# r$ r% r& r' r> r* rW r+ r, r� r� r� r� r- r. r1 Z_fastCopyAndTransposer2 r4 r5 r6 r7 r8 r3 re rf rE rD rC rG r� r9 r: r; r< rV r= r/ rn r� r� rA rB rF rH rI rN rJ rK r� rL r� rM Z arrayprintrO rP rQ r� r� �intr� rR rS rT � byteorderrU rZ r[ r_ r r` ra r] r/ rc rd r\ rX rY rE rO r� �keyrg rh ri rj rk rl �objectrX rY rm ra ro rp rq rr rs rt ru rv rc r� r� r� r� �<module> s� R. >.<3< F3$$_ = ( ' CaQ �E< H � H$; I 7 L6 Ae ) / d 2 [ , N
Submit
FILE
FOLDER
Name
Size
Permission
Action
__init__.cpython-35.opt-1.pyc
2132 bytes
0644
__init__.cpython-35.pyc
2132 bytes
0644
_internal.cpython-35.opt-1.pyc
14636 bytes
0644
_internal.cpython-35.pyc
14636 bytes
0644
_methods.cpython-35.opt-1.pyc
3846 bytes
0644
_methods.cpython-35.pyc
3846 bytes
0644
arrayprint.cpython-35.opt-1.pyc
21766 bytes
0644
arrayprint.cpython-35.pyc
21766 bytes
0644
cversions.cpython-35.opt-1.pyc
599 bytes
0644
cversions.cpython-35.pyc
599 bytes
0644
defchararray.cpython-35.opt-1.pyc
69050 bytes
0644
defchararray.cpython-35.pyc
69050 bytes
0644
fromnumeric.cpython-35.opt-1.pyc
98792 bytes
0644
fromnumeric.cpython-35.pyc
98792 bytes
0644
function_base.cpython-35.opt-1.pyc
6502 bytes
0644
function_base.cpython-35.pyc
6502 bytes
0644
generate_numpy_api.cpython-35.opt-1.pyc
6625 bytes
0644
generate_numpy_api.cpython-35.pyc
6625 bytes
0644
getlimits.cpython-35.opt-1.pyc
9582 bytes
0644
getlimits.cpython-35.pyc
9582 bytes
0644
info.cpython-35.opt-1.pyc
4846 bytes
0644
info.cpython-35.pyc
4846 bytes
0644
machar.cpython-35.opt-1.pyc
8200 bytes
0644
machar.cpython-35.pyc
8200 bytes
0644
memmap.cpython-35.opt-1.pyc
9819 bytes
0644
memmap.cpython-35.pyc
9819 bytes
0644
numeric.cpython-35.opt-1.pyc
87423 bytes
0644
numeric.cpython-35.pyc
87535 bytes
0644
numerictypes.cpython-35.opt-1.pyc
25473 bytes
0644
numerictypes.cpython-35.pyc
25518 bytes
0644
records.cpython-35.opt-1.pyc
23883 bytes
0644
records.cpython-35.pyc
23883 bytes
0644
setup.cpython-35.opt-1.pyc
25063 bytes
0644
setup.cpython-35.pyc
25063 bytes
0644
setup_common.cpython-35.opt-1.pyc
10328 bytes
0644
setup_common.cpython-35.pyc
10328 bytes
0644
shape_base.cpython-35.opt-1.pyc
9719 bytes
0644
shape_base.cpython-35.pyc
9719 bytes
0644
N4ST4R_ID | Naxtarrr
