|
Server : Apache/2.2.17 (Unix) mod_ssl/2.2.17 OpenSSL/0.9.8e-fips-rhel5 DAV/2 PHP/5.2.17 System : Linux localhost 2.6.18-419.el5 #1 SMP Fri Feb 24 22:47:42 UTC 2017 x86_64 User : nobody ( 99) PHP Version : 5.2.17 Disable Function : NONE Directory : /proc/21585/root/usr/lib64/python2.4/site-packages/Numeric/ |
Upload File : |
m
aAc @ s3 d Z d k Z e i Z [ d k Z d k Td k Td k Z d k Z d k Z d k
Z
d Z e i
Z e i Z e i Z e i Z d d d Z d d d Z e i Z e i Z e i Z e i Z e i Z d d Z d Z d Z d d
Z e i Z e e Z! d Z" e i Z d d Z# d d
Z$ d d Z% d d Z& d d Z' d d Z( e i) Z* d Z+ d Z, d Z- d Z. y d k/ l- Z- l+ Z+ l. Z. Wn e0 j
o n Xe- Z1 d k2 l3 Z3 d d d d Z4 d d d d Z5 e i6 e5 d e i6 e4 d e d d d d d d j Z7 d Z8 d d! Z9 d" Z: d d d d# Z; d d d d$ Z< d% Z= d& Z> d k? Z? d k@ Z@ d' e? iA f d( YZA d) e? iB f d* YZB d+ kC lC ZC d, ZD d- ZE d. ZF d/ ZG d kH ZH e7 d0 ZI d1 ZJ eH i? e eJ eI d2 ZK d3 ZL d4 ZM d5 ZN d d6 ZO d7 ZP d8 d d9 ZQ d8 d: ZR d d; ZS d d< ZT d d= ZU d d> ZV d d? ZW d d@ ZX e i
Z
d dA ZY dB ZZ dC dD dE Z[ dF Z\ dG ZM d dH Z] d d d dI Z^ d S(J s Numeric module defining a multi-dimensional array and useful procedures for
Numerical computation.
Functions
- array - NumPy Array construction
- zeros - Return an array of all zeros
- empty - Return an unitialized array (200x faster than zeros)
- shape - Return shape of sequence or array
- rank - Return number of dimensions
- size - Return number of elements in entire array or a
certain dimension
- fromstring - Construct array from (byte) string
- take - Select sub-arrays using sequence of indices
- put - Set sub-arrays using sequence of 1-D indices
- putmask - Set portion of arrays using a mask
- reshape - Return array with new shape
- repeat - Repeat elements of array
- choose - Construct new array from indexed array tuple
- cross_correlate - Correlate two 1-d arrays
- searchsorted - Search for element in 1-d array
- sum - Total sum over a specified dimension
- average - Average, possibly weighted, over axis or array.
- cumsum - Cumulative sum over a specified dimension
- product - Total product over a specified dimension
- cumproduct - Cumulative product over a specified dimension
- alltrue - Logical and over an entire axis
- sometrue - Logical or over an entire axis
- allclose - Tests if sequences are essentially equal
More Functions:
- arrayrange (arange) - Return regularly spaced array
- asarray - Guarantee NumPy array
- sarray - Guarantee a NumPy array that keeps precision
- convolve - Convolve two 1-d arrays
- swapaxes - Exchange axes
- concatenate - Join arrays together
- transpose - Permute axes
- sort - Sort elements of array
- argsort - Indices of sorted array
- argmax - Index of largest value
- argmin - Index of smallest value
- innerproduct - Innerproduct of two arrays
- dot - Dot product (matrix multiplication)
- outerproduct - Outerproduct of two arrays
- resize - Return array with arbitrary new shape
- indices - Tuple of indices
- fromfunction - Construct array from universal function
- diagonal - Return diagonal array
- trace - Trace of array
- dump - Dump array to file object (pickle)
- dumps - Return pickled string representing data
- load - Return array stored in file object
- loads - Return array from pickled string
- ravel - Return array as 1-D
- nonzero - Indices of nonzero elements for 1-D array
- shape - Shape of array
- where - Construct array from binary result
- compress - Elements of array where condition is true
- clip - Clip array between two values
- ones - Array of all ones
- identity - 2-D identity array (matrix)
(Universal) Math Functions
add logical_or exp
subtract logical_xor log
multiply logical_not log10
divide maximum sin
divide_safe minimum sinh
conjugate bitwise_and sqrt
power bitwise_or tan
absolute bitwise_xor tanh
negative invert ceil
greater left_shift fabs
greater_equal right_shift floor
less arccos arctan2
less_equal arcsin fmod
equal arctan hypot
not_equal cos around
logical_and cosh sign
arccosh arcsinh arctanh
N( t *i c C s t i | | d d d | S( s} asarray(a,typecode=None) returns a as a NumPy array. Unlike array(),
no copy is performed if a is already an array.
t copyi t savespaceN( t
multiarrayt arrayt at typecodeR ( R R R ( ( t5 /usr/lib64/python2.4/site-packages/Numeric/Numeric.pyt asarray s c C s t i | | | d d S( s> sarray(a, typecode=None, copy=0) calls array with savespace=1.R i N( R R R R R ( R R R ( ( R t sarray s c C s t | d d } | i } t | t i o t | g | | } n t
| | | j o
t d n t i
| | | } | S( sJ repeat elements of a repeats times along axis
repeats is a sequence of length a.shape[axis]
telling how many times to repeat each element.
If repeats is an integer, it is interpreted as
a tuple of length a.shape[axis] containing repeats.
The argument a can be anything array(a) will accept.
R i sF repeat requires second argument integer or of length of a.shape[axis].N( R R t shapet st
isinstancet repeatst typest IntTypet tuplet axist lent
ValueErrorR t repeatt d( R R
R R R ( ( R R s
c C s2 t i | | t | d d i | i d S( s put(a, ind, v) results in a[n] = v[n] for all n in ind
If v is shorter than mask it will be repeated as necessary.
In particular v can be a scalar or length 1 array.
The routine put is the equivalent of the following (although the loop
is in C for speed):
ind = array(indices, copy=0)
v = array(values, copy=0).astype(a, typecode())
for i in ind: a.flat[i] = v[i]
a must be a contiguous Numeric array.
R i N( R t putR t indR t vt astypeR ( R R R ( ( R R s c C s | i } t | i t } t | d d i | } | t j o | i
f j o
d | _
n t | } t | } t | } t | | i
} xN t t | D]# } | | o | | | | <q q Wn t i | | | d S( s putmask(a, mask, v) results in a = v for all places mask is true.
If v is shorter than mask it will be repeated as necessary.
In particular v can be a scalar or length 1 array.
R i i N( i ( R R t tcR t maskR t IntR R t PyObjectR
t ravelt axt mxt vxt resizet rangeR t iR t putmask( R R R R$ R R! R R ( ( R R% s
i c C sU t | t | j o | } | } | } ~ n t | t | d d d | S( s Returns the discrete, linear convolution of 1-D
sequences a and v; mode can be 0 (valid), 1 (same), or 2 (full)
to specify size of the resulting sequence.
Ni( R R R t tempt cross_correlateR t mode( R R R( R& ( ( R t convolve s c C s t | d d } t | i } | d j o | Sn | d j o | | 7} n | d j o | | 7} n | d j p
| | j o
t d n | d j p
| | j o
t d n t | } | | | <| | | <t
i | | S( sU swapaxes(a, axis1, axis2) returns array a with axis1 and axis2
interchanged.
R i i s Bad axis1 argument to swapaxes.s Bad axis2 argument to swapaxes.N( R R R R
t nt axis1t axis2R t aranget new_axesR t transpose( R R+ R, R* R. ( ( R t swapaxes s"
c C sg | d j o t i | Sn1 g } x' | D] } | i t | | d q+ Wt t i | | d S( s\ concatenate(a, axis=0) joins the tuple of sequences in a into a single
NumPy array.
i N( R R t concatenateR t new_listt mt appendR0 ( R R R3 R2 ( ( R R1 s
c C s t i | | S( s transpose(a, axes=None) returns array with dimensions permuted
according to axes. If axes is None (default) returns array with
dimensions reversed.
N( R R/ R t axes( R R5 ( ( R R/ s ic C s t | d d } t | i } | d j o | | 7} n | d j p
| | j o
t d n | | d j o t | | | d } n t i | } | | d j o t | | d } n | S( sI sort(a,axis=-1) returns array with elements sorted along given axis.
R i s sort axis argument out of boundsi iN( R R R R
R* R R R0 R t sortR ( R R R* R ( ( R R6 s
c C s t | d d } t | i } | d j o | | 7} n | d j p
| | j o
t d n | | d j o t | | | d } n t i | } | | d j o t | | d } n | S( s argsort(a,axis=-1) return the indices into a of the sorted array
along the given axis, so that take(a,result,axis) is the sorted array.
R i s# argsort axis argument out of boundsi iN( R R R R
R* R R R0 R t argsortR ( R R R* R ( ( R R7 s
c C s t | d d } t | i } | d j o | | 7} n | d j p
| | j o
t d n | | d j o t | | | d } n t i | } | | d j o t | | d } n | S( so argmax(a,axis=-1) returns the indices to the maximum value of the
1-D arrays along the given axis.
R i s" argmax axis argument out of boundsi iN( R R R R
R* R R R0 R t argmaxR ( R R R* R ( ( R R8 s
c C s t | d d } | i } t d | } | d g j o t d | } n | | } t | i } | d j o | | 7} n | d j p
| | j o
t
d n | | d j o t | | | d } n t i
| } | | d j o t | | d } n | S( so argmin(a,axis=-1) returns the indices to the minimum value of the
1-D arrays along the given axis.
R i t bwui s" argmin axis argument out of boundsiN( R R t arraR t typet numR R
R* R R R0 R R8 R ( R R R: R* R R< R; ( ( R t argmin% s$
c C sx y t i | | SWn] t j
oQ } t | i f j p t | i f j o | | Sqt t | p d n Xd S( s innerproduct(a,b) returns the dot product of two arrays, which has
shape a.shape[:-1] + b.shape[:-1] with elements computed by summing the
product of the elements from the last dimensions of a and b.
s invalid types for dotN( R t innerproductR t bt TypeErrort detailR R
( R R? RA ( ( R R> ; s , c C s: t | i d d t f t | i t d d f S( s outerproduct(a,b) returns the outer product of two vectors.
result(i,j) = a(i)*b(j) when a and b are vectors
Will accept any arguments that can be made into vectors.
N( R R t flatt NewAxisR? ( R R? ( ( R t outerproductH s c C sx y t i | | SWn] t j
oQ } t | i f j p t | i f j o | | Sqt t | p d n Xd S( s dot(a,b) returns matrix-multiplication between a and b. The product-sum
is over the last dimension of a and the second-to-last dimension of b.
s invalid types for dotN( R t
matrixproductR R? R@ RA R R
( R R? RA ( ( R t dotQ s , c C s" t i t t | t | S( s Returns the dot product of 2 vectors (or anything that can be made into
a vector). NB: this is not the same as `dot`, as it takes the conjugate
of its first argument if complex and always returns a scalar.N( R RE t conjugateR R R? ( R R? ( ( R t vdot] s ( s dots innerproducts vdot( s array2stringc C s t | | | | d d S( Ns , i ( t array2stringR t max_line_widtht precisiont suppress_small( R RJ RK RL ( ( R t
array_reprn s c C s t | | | | d d S( Nt i ( RI R RJ RK RL ( R RJ RK RL ( ( R t array_strq s i s t i R$ c C s t | } t | p t | | i Sn t i | } t | t | } | t | } | d j o | d } t | | } n t | f | } | d j o | | } n t
| | S( s{ resize(a,new_shape) returns a new array with the specified shape.
The original array's total size can be any size.
i i N( R R R t zerost new_shapeR t multiplyt reducet
total_sizet intt n_copiest extraR1 t reshape( R RR RX RU RW ( ( R R" { s
c C sY t | | } g } x7 t t | D]# } | i t i
| | d q( Wt | S( s indices(dimensions,typecode=None) returns an array representing a grid
of indices with row-only, and column-only variation.
i N( t onest
dimensionsR t tmpt lstR# R R$ R4 t addt
accumulateR ( R[ R R\ R$ R] ( ( R t indices s !c C s t | t t | S( s fromfunction(function, dimensions) returns an array constructed by
calling function on a tuple of number grids. The function should
accept as many arguments as there are dimensions which is a list of
numbers indicating the length of the desired output for each axis.
N( t applyt functionR R` R[ ( Rb R[ ( ( R t fromfunction s c C s t | } | | j o | | } } n | d j oI t t | i } | | =| | =| | g | d d +t | | } n | i } t | d j o | d } | d }
| |
} | f } t
| | } | d j oF t | t |
| t |
| | |
d |
| |
d d Sqt | t | t | |
| |
d | |
d d SnF g } x2 t | d D] } | i t | | | qyWt | Sd S( s} diagonal(a, offset=0, axis1=0, axis2=1) returns the given diagonals
defined by the last two dimensions of the array.
i i i N( R R R, R+ R# R R
R. R/ R t n1t n2R* RY t offsett taket mint my_diagonalR$ R4 t diagonal( R Rf R+ R, Ri R$ R R* R. Rd Re ( ( R Rj s0
F= c C s t i t | | | | S( s~ trace(a,offset=0, axis1=0, axis2=1) returns the sum along diagonals
(defined by the last two dimenions) of the array.
N( R^ RT Rj R Rf R+ R, ( R Rf R+ R, ( ( R t trace s c C s | i d j o
t d n | i } t o
d } n d } | i d | i | | i f x | D] } | i d | qm W| i d | i | i d S( Nt Os. Numeric Pickler can't pickle arrays of Objectst Lt Bs A%s%s%d s %d s
( R3 R R@ R
R t LittleEndiant endiant fpt writet itemsizeR t tostring( R3 Rq R R Rp ( ( R t DumpArray s
&
c C s t i | i } | d d d j o | d d | d <n | d d } | d d } t d | d } t i | d d } t t | | } | i | } t | | } t | | } t o
| d j p t o | d j o | i Sn | Sd S( Ni t Ai c C s
t i | S( N( t stringt atoit x( Ry ( ( R t <lambda> s i Rn Rm ( Rw t splitRq t readlinet lnR Rp t mapR
Rx Rs RT RS t szt readt datat
fromstringR3 RY Ro t byteswapped( Rq R R} R3 R
R Rp Rs R ( ( R t LoadArray s )t Unpicklerc B s0 t Z d Z e i e i i Z e e d <RS( Nc C s | i i t | d S( N( t selft stackR4 R ( R ( ( R t
load_array s Rv ( t __name__t
__module__R R t pickleR t dispatch( ( ( R R s t Picklerc B s0 t Z d Z e i e i i Z e e e <RS( Nc C s t | | d S( N( Ru t objectR ( R R ( ( R t
save_array s ( R R R R R R R t ArrayType( ( ( R R s ( s StringIOc C s t | i | d S( sK dump(object, file) pickles (binary-writes) the object to an open file.
N( R t filet dumpR ( R R ( ( R R s c C s& t } t | i | | i S( sV dumps(object) pickles (binary-writes) the object and returns the byte
stream.
N( t StringIOR R R R t getvalue( R R ( ( R t dumps s c C s t | i S( sN load(file) returns an array from the open file pointing to pickled data.
N( R R t load( R ( ( R R
s c C s t | } t | i S( s^ loads(str) returns an array from a byte stream containing its pickled
representation.
N( R t strR R R ( R R ( ( R t loads s c C s; t | | } | | _ t | j o | i Sn | Sd S( N( R t thestrR Ry R
Ro t EndianR ( R
R R R Ry ( ( R t array_constructor s
c C s% t | i | i | i t f f S( N( R R R
R Rt Ro ( R ( ( R t pickle_array! s c C s
t | d S( sX ravel(m) returns a 1d array corresponding to all the elements of it's
argument.
iN( i( RY R3 ( R3 ( ( R R + s c C s" t t t | t | d S( s] nonzero(a) returns the indices of the elements of a which are not zero,
a must be 1d
i N( R R- R R t not_equal( R ( ( R t nonzero1 s c C s
t | i S( sf shape(a) returns the shape of a (as a function call which
also works on nested sequences).
N( R R R
( R ( ( R R
7 s c C s t t | d | | f S( s where(condition,x,y) is shaped like condition and has elements of x and
y where condition is respectively true or false.
i N( t chooseR t conditiont yRy ( R Ry R ( ( R t where= s c C s t | t | | S( s compress(condition, x, axis=-1) = those elements of x corresponding
to those elements of condition that are "true". condition must be the
same size as the given dimension of x.N( Rg R3 R R R ( R R3 R ( ( R t compressC s c C s6 t | | d t | | } t | | | | f S( s clip(m, m_min, m_max) = every entry in m that is less than m_min is
replaced by m_min, and every entry greater than m_max is replaced by
m_max.
i N( t lessR3 t m_mint greatert m_maxt selectorR ( R3 R R R ( ( R t clipI s t lc C s t | | | } d | d <| S( s{ ones(shape, typecode=Int, savespace=0) returns an array of the given
dimensions which is initialized to all ones.
i .N( RQ R
R R R ( R
R R R ( ( R RZ Q s
c C s- t t d g | d g d | | | f S( s< identity(n) returns the identity matrix of shape n x n.
i i R N( R" R R* R ( R* R ( ( R t identityY s c C s t | d d } t | i } | d j o | | 7} n | d j o | d d g j o | d Sn | d j p
| | j o
t d n t i | | S( s' Sum the array over the given axis.
R i is Improper axis argument to sum.N( R Ry R R
R* R R R^ RT ( Ry R R* ( ( R t sum^ s
c C s t | d d } t | i } | d j o | | 7} n | d j o | d d g j o | d Sn | d j p
| | j o t d f Sn t i | | S( s2 Product of the array elements over the given axis.R i is" Improper axis argument to product.N( R Ry R R
R* R R RS RT ( Ry R R* ( ( R t producti s
c C s t | d d } t | i } | d j o | | 7} n | d j o% | d d g j o | d d j Sn | d j p
| | j o t d f Sn t i | | S( s) Perform a logical_or over the given axis.R i is# Improper axis argument to sometrue.N( R Ry R R
R* R R t
logical_orRT ( Ry R R* ( ( R t sometrues s
c C s t | d d } t | i } | d j o | | 7} n | d j o% | d d g j o | d d j Sn | d j p
| | j o t d f Sn t i | | S( s* Perform a logical_and over the given axis.R i is" Improper axis argument to product.N( R Ry R R
R* R R t logical_andRT ( Ry R R* ( ( R t alltrue} s
c C s t | d d } t | i } | d j o | | 7} n | d j o | d d g j o | d Sn | d j p
| | j o t d f Sn t i | | S( s" Sum the array over the given axis.R i is! Improper axis argument to cumsum.N( R Ry R R
R* R R R^ R_ ( Ry R R* ( ( R t cumsum s
c C s t | d d } t | i } | d j o | | 7} n | d j o | d d g j o | d Sn | d j p
| | j o t d f Sn t i | | S( s" Sum the array over the given axis.R i is% Improper axis argument to cumproduct.N( R Ry R R
R* R R RS R_ ( Ry R R* ( ( R t
cumproduct s
c C s t | } t | } | o t | d | } n
t | } | t | i t } t t
| d t | t | } | o | | d | } n | | } | S( sw around(m, decimals=0) Round in the same way as standard python performs rounding. Returns
always a float.
f10.0f0.5N(
R R3 t signR t decimalst absoluteR R t remR R t floort ceil( R3 R R R ( ( R t around s '
c C s6 t | } t t | t | d t | d S( s sign(m) gives an array with shape of m with elements defined by sign
function: where m is less than 0 return -1, where m greater than 0, a=1,
elsewhere a=0.
i N( R R3 RQ R
R R ( R3 ( ( R R s f1.0000000000000001e-05f1e-08c C s[ t | d d } t | d d } t t | | | | t | } t
t | S( sU allclose(a,b,rtol=1.e-5,atol=1.e-8)
Returns true if all components of a and b are equal
subject to given tolerances.
The relative error rtol must be positive and << 1.0
The absolute error atol comes into play for those elements
of y that are very small or zero; it says how small x must be also.
R i N( R R Ry R? R R R t atolt rtolR R R ( R R? R R R R Ry ( ( R t allclose s
'c C s t t | S( sr Get the rank of sequence a (the number of dimensions, not a matrix rank)
The rank of a scalar is zero.
N( R R
R ( R ( ( R t rank s c C s& y | i SWn t | i Sn Xd S( s Get the shape of sequence aN( R R
R ( R ( ( R R
s
c C sT t | } | d j o/ t | d j o d SqP t d | Sn | | Sd S( sB Get the number of elements in sequence a, or along a certain axis.i i c C s | | S( N( Ry R ( Ry R ( ( R Rz s N( R
R R R t NoneR RT ( R R R ( ( R t size s
c C s^ | d
j ox t | i } | d
j o# t i | } t | d } q t | i d } t i | | } t i | } nt | } | i } | f j o
d | _ n | d
j oE t i | | } | | d } | o t t | | } q nt | d d d } | i } | f j o
d } n | | j o, t i | | | } t i | | } n | | | f j oy | | } t g | }
t d
d
d |
| <t d t t |
d } t i | | | } t i | | } n
t d t | t p | d j o
t d q9n | o | | | f Sn | | Sd
S(
s( average(a, axis=0, weights=None)
Computes average along indicated axis.
If axis is None, average over the entire array.
Inputs can be integer or floating types; result is type Float.
If weights are given, result is:
sum(a*weights)/(sum(weights))
weights must have a's shape or be the 1-d with length the size
of a in the given axis. Integer weights are converted to Float.
Not supplying weights is equivalent to supply weights that are
all 1.
If returned, return a tuple: the result and the sum of the weights
or count of values. The shape of these two results will be the same.
raises ZeroDivisionError if appropriate when result is scalar.
(The version in MA does not -- it returns masked values).
f1.0i R i s w[s ]*ones(ash, Float)s average: weights wrong shape.f0.0s! Numeric.average, zero denominatorN( i ( i ( R R R R RB t weightsR^ RT R* R R t wR
t asht returnedRZ t wsht niRC t rt slicet evalt reprR t w1R R R t ZeroDivisionError( R R R R R R R R R R* R R ( ( R t average sN
(_ t __doc__t numeric_versiont versiont __version__R t umatht Precisiont _numpyRw R t mathR RC R- t
arrayrangeR RQ t emptyR R R Rg RY R R' R R R% R) t arraytypeR R; t sint UfuncTypeR0 R1 R/ R6 R7 R8 R= t binarysearcht searchsortedR> RD RF RH t dotblast ImportErrort matrixmultiplyt ArrayPrinterRI RM RO t set_string_functionRo R" R` Rc Rj Rk Ru R R R R R R R R R R t copy_regR R R R R
R R R RZ R R R R R R R R R R R R R (S R% R R R
Ro R R R RC R Rw RZ R R- R R) R` R R R R R8 R R R R R R R R R R1 R RH R/ RI Rj R R R7 R R R R R R' R RQ R R R6 R R R R R R" Rc R= R R R Ru R R R> R RY Rg RO R R RD R Rk R R R R R RM R0 RF ( ( R t ?U s
!