diff options
Diffstat (limited to 'numpy/add_newdocs.py')
| -rw-r--r-- | numpy/add_newdocs.py | 1030 |
1 files changed, 536 insertions, 494 deletions
diff --git a/numpy/add_newdocs.py b/numpy/add_newdocs.py index 2dcc8ca23..6b48acbdc 100644 --- a/numpy/add_newdocs.py +++ b/numpy/add_newdocs.py @@ -57,255 +57,255 @@ add_newdoc('numpy.core', 'broadcast', ) add_newdoc('numpy.core.multiarray','array', -"""array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0) - -Return an array from object with the specified date-type. - -Inputs: - object - an array, any object exposing the array interface, any - object whose __array__ method returns an array, or any - (nested) sequence. - dtype - The desired data-type for the array. If not given, then - the type will be determined as the minimum type required - to hold the objects in the sequence. This argument can only - be used to 'upcast' the array. For downcasting, use the - .astype(t) method. - copy - If true, then force a copy. Otherwise a copy will only occur - if __array__ returns a copy, obj is a nested sequence, or - a copy is needed to satisfy any of the other requirements - order - Specify the order of the array. If order is 'C', then the - array will be in C-contiguous order (last-index varies the - fastest). If order is 'FORTRAN', then the returned array - will be in Fortran-contiguous order (first-index varies the - fastest). If order is None, then the returned array may - be in either C-, or Fortran-contiguous order or even - discontiguous. - subok - If True, then sub-classes will be passed-through, otherwise - the returned array will be forced to be a base-class array - ndmin - Specifies the minimum number of dimensions that the resulting - array should have. 1's will be pre-pended to the shape as - needed to meet this requirement. - -""") + """array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0) + + Return an array from object with the specified date-type. + + Inputs: + object - an array, any object exposing the array interface, any + object whose __array__ method returns an array, or any + (nested) sequence. + dtype - The desired data-type for the array. If not given, then + the type will be determined as the minimum type required + to hold the objects in the sequence. This argument can only + be used to 'upcast' the array. For downcasting, use the + .astype(t) method. + copy - If true, then force a copy. Otherwise a copy will only occur + if __array__ returns a copy, obj is a nested sequence, or + a copy is needed to satisfy any of the other requirements + order - Specify the order of the array. If order is 'C', then the + array will be in C-contiguous order (last-index varies the + fastest). If order is 'FORTRAN', then the returned array + will be in Fortran-contiguous order (first-index varies the + fastest). If order is None, then the returned array may + be in either C-, or Fortran-contiguous order or even + discontiguous. + subok - If True, then sub-classes will be passed-through, otherwise + the returned array will be forced to be a base-class array + ndmin - Specifies the minimum number of dimensions that the resulting + array should have. 1's will be pre-pended to the shape as + needed to meet this requirement. + + """) add_newdoc('numpy.core.multiarray','empty', -"""empty((d1,...,dn),dtype=float,order='C') + """empty((d1,...,dn),dtype=float,order='C') -Return a new array of shape (d1,...,dn) and given type with all its -entries uninitialized. This can be faster than zeros. + Return a new array of shape (d1,...,dn) and given type with all its + entries uninitialized. This can be faster than zeros. -""") + """) add_newdoc('numpy.core.multiarray','scalar', -"""scalar(dtype,obj) + """scalar(dtype,obj) -Return a new scalar array of the given type initialized with -obj. Mainly for pickle support. The dtype must be a valid data-type -descriptor. If dtype corresponds to an OBJECT descriptor, then obj -can be any object, otherwise obj must be a string. If obj is not given -it will be interpreted as None for object type and zeros for all other -types. + Return a new scalar array of the given type initialized with + obj. Mainly for pickle support. The dtype must be a valid data-type + descriptor. If dtype corresponds to an OBJECT descriptor, then obj + can be any object, otherwise obj must be a string. If obj is not given + it will be interpreted as None for object type and zeros for all other + types. -""") + """) add_newdoc('numpy.core.multiarray','zeros', -"""zeros((d1,...,dn),dtype=float,order='C') + """zeros((d1,...,dn),dtype=float,order='C') -Return a new array of shape (d1,...,dn) and type typecode with all -it's entries initialized to zero. + Return a new array of shape (d1,...,dn) and type typecode with all + it's entries initialized to zero. -""") + """) add_newdoc('numpy.core.multiarray','set_typeDict', -"""set_typeDict(dict) + """set_typeDict(dict) -Set the internal dictionary that can look up an array type using a -registered code. + Set the internal dictionary that can look up an array type using a + registered code. -""") + """) add_newdoc('numpy.core.multiarray','fromstring', -"""fromstring(string, dtype=float, count=-1, sep='') + """fromstring(string, dtype=float, count=-1, sep='') -Return a new 1d array initialized from the raw binary data in string. + Return a new 1d array initialized from the raw binary data in string. -If count is positive, the new array will have count elements, otherwise its -size is determined by the size of string. If sep is not empty then the -string is interpreted in ASCII mode and converted to the desired number type -using sep as the separator between elements (extra whitespace is ignored). + If count is positive, the new array will have count elements, otherwise its + size is determined by the size of string. If sep is not empty then the + string is interpreted in ASCII mode and converted to the desired number type + using sep as the separator between elements (extra whitespace is ignored). -""") + """) add_newdoc('numpy.core.multiarray','fromstring', -"""fromiter(iterable, dtype, count=-1) + """fromiter(iterable, dtype, count=-1) -Return a new 1d array initialized from iterable. If count is -nonegative, the new array will have count elements, otherwise it's -size is determined by the generator. + Return a new 1d array initialized from iterable. If count is + nonegative, the new array will have count elements, otherwise it's + size is determined by the generator. -""") + """) add_newdoc('numpy.core.multiarray','fromfile', -"""fromfile(file=, dtype=float, count=-1, sep='') + """fromfile(file=, dtype=float, count=-1, sep='') -Return an array of the given data type from a (text or binary) file. -The file argument can be an open file or a string with the name of a -file to read from. If count==-1, then the entire file is read, -otherwise count is the number of items of the given type read in. If -sep is '' then read a binary file, otherwise it gives the separator -between elements in a text file. + Return an array of the given data type from a (text or binary) file. + The file argument can be an open file or a string with the name of a + file to read from. If count==-1, then the entire file is read, + otherwise count is the number of items of the given type read in. If + sep is '' then read a binary file, otherwise it gives the separator + between elements in a text file. -WARNING: This function should be used sparingly, as it is not a -platform-independent method of persistence. But it can be useful to -read in simply-formatted or binary data quickly. + WARNING: This function should be used sparingly, as it is not a + platform-independent method of persistence. But it can be useful to + read in simply-formatted or binary data quickly. -""") + """) add_newdoc('numpy.core.multiarray','frombuffer', -"""frombuffer(buffer=, dtype=float, count=-1, offset=0) + """frombuffer(buffer=, dtype=float, count=-1, offset=0) -Returns a 1-d array of data type dtype from buffer. The buffer -argument must be an object that exposes the buffer interface. If -count is -1 then the entire buffer is used, otherwise, count is the -size of the output. If offset is given then jump that far into the -buffer. If the buffer has data that is out not in machine byte-order, -than use a propert data type descriptor. The data will not be -byteswapped, but the array will manage it in future operations. + Returns a 1-d array of data type dtype from buffer. The buffer + argument must be an object that exposes the buffer interface. If + count is -1 then the entire buffer is used, otherwise, count is the + size of the output. If offset is given then jump that far into the + buffer. If the buffer has data that is out not in machine byte-order, + than use a propert data type descriptor. The data will not be + byteswapped, but the array will manage it in future operations. -""") + """) add_newdoc('numpy.core.multiarray','concatenate', -"""concatenate((a1, a2, ...), axis=0) + """concatenate((a1, a2, ...), axis=0) -Join arrays together. + Join arrays together. -The tuple of sequences (a1, a2, ...) are joined along the given axis -(default is the first one) into a single numpy array. + The tuple of sequences (a1, a2, ...) are joined along the given axis + (default is the first one) into a single numpy array. -Example: + Example: ->>> concatenate( ([0,1,2], [5,6,7]) ) -array([0, 1, 2, 5, 6, 7]) + >>> concatenate( ([0,1,2], [5,6,7]) ) + array([0, 1, 2, 5, 6, 7]) -""") + """) add_newdoc('numpy.core.multiarray','inner', -"""inner(a,b) + """inner(a,b) -Returns the dot product of two arrays, which has shape a.shape[:-1] + -b.shape[:-1] with elements computed by the product of the elements -from the last dimensions of a and b. + Returns the dot product of two arrays, which has shape a.shape[:-1] + + b.shape[:-1] with elements computed by the product of the elements + from the last dimensions of a and b. -""") + """) add_newdoc('numpy.core','fastCopyAndTranspose', -"""_fastCopyAndTranspose(a)""") + """_fastCopyAndTranspose(a)""") add_newdoc('numpy.core.multiarray','correlate', -"""cross_correlate(a,v, mode=0)""") + """cross_correlate(a,v, mode=0)""") add_newdoc('numpy.core.multiarray','arange', -"""arange([start,] stop[, step,], dtype=None) + """arange([start,] stop[, step,], dtype=None) -For integer arguments, just like range() except it returns an array -whose type can be specified by the keyword argument dtype. If dtype -is not specified, the type of the result is deduced from the type of -the arguments. + For integer arguments, just like range() except it returns an array + whose type can be specified by the keyword argument dtype. If dtype + is not specified, the type of the result is deduced from the type of + the arguments. -For floating point arguments, the length of the result is ceil((stop - -start)/step). This rule may result in the last element of the result -being greater than stop. + For floating point arguments, the length of the result is ceil((stop - + start)/step). This rule may result in the last element of the result + being greater than stop. -""") + """) add_newdoc('numpy.core.multiarray','_get_ndarray_c_version', -"""_get_ndarray_c_version() + """_get_ndarray_c_version() -Return the compile time NDARRAY_VERSION number. + Return the compile time NDARRAY_VERSION number. -""") + """) add_newdoc('numpy.core.multiarray','_reconstruct', -"""_reconstruct(subtype, shape, dtype) + """_reconstruct(subtype, shape, dtype) -Construct an empty array. Used by Pickles. + Construct an empty array. Used by Pickles. -""") + """) add_newdoc('numpy.core.multiarray','set_string_function', -"""set_string_function(f, repr=1) + """set_string_function(f, repr=1) -Set the python function f to be the function used to obtain a pretty -printable string version of an array whenever an array is printed. -f(M) should expect an array argument M, and should return a string -consisting of the desired representation of M for printing. + Set the python function f to be the function used to obtain a pretty + printable string version of an array whenever an array is printed. + f(M) should expect an array argument M, and should return a string + consisting of the desired representation of M for printing. -""") + """) add_newdoc('numpy.core.multiarray','set_numeric_ops', -"""set_numeric_ops(op=func, ...) + """set_numeric_ops(op=func, ...) -Set some or all of the number methods for all array objects. Don't -forget **dict can be used as the argument list. Return the functions -that were replaced, which can be stored and set later. + Set some or all of the number methods for all array objects. Don't + forget **dict can be used as the argument list. Return the functions + that were replaced, which can be stored and set later. -""") + """) add_newdoc('numpy.core.multiarray','where', -"""where(condition, | x, y) + """where(condition, | x, y) -The result is shaped like condition and has elements of x and y where -condition is respectively true or false. If x or y are not given, -then it is equivalent to condition.nonzero(). + The result is shaped like condition and has elements of x and y where + condition is respectively true or false. If x or y are not given, + then it is equivalent to condition.nonzero(). -To group the indices by element, rather than dimension, use + To group the indices by element, rather than dimension, use - transpose(where(condition, | x, y)) + transpose(where(condition, | x, y)) -instead. This always results in a 2d array, with a row of indices for -each element that satisfies the condition. + instead. This always results in a 2d array, with a row of indices for + each element that satisfies the condition. -""") + """) add_newdoc('numpy.core.multiarray','lexsort', -"""lexsort(keys=, axis=-1) + """lexsort(keys=, axis=-1) -Return an array of indices similar to argsort, except the sorting is -done using the provided sorting keys. First the sort is done using -key[0], then the resulting list of indices is further manipulated by -sorting on key[1], and so forth. The result is a sort on multiple -keys. If the keys represented columns of a spreadsheet, for example, -this would sort using multiple columns. The keys argument must be a -sequence of things that can be converted to arrays of the same shape. + Return an array of indices similar to argsort, except the sorting is + done using the provided sorting keys. First the sort is done using + key[0], then the resulting list of indices is further manipulated by + sorting on key[1], and so forth. The result is a sort on multiple + keys. If the keys represented columns of a spreadsheet, for example, + this would sort using multiple columns. The keys argument must be a + sequence of things that can be converted to arrays of the same shape. -""") + """) add_newdoc('numpy.core.multiarray','can_cast', -"""can_cast(from=d1, to=d2) + """can_cast(from=d1, to=d2) -Returns True if data type d1 can be cast to data type d2 without -losing precision. + Returns True if data type d1 can be cast to data type d2 without + losing precision. -""") + """) add_newdoc('numpy.core.multiarray','newbuffer', -"""newbuffer(size) + """newbuffer(size) -Return a new uninitialized buffer object of size bytes + Return a new uninitialized buffer object of size bytes -""") + """) add_newdoc('numpy.core.multiarray','getbuffer', -"""getbuffer(obj [,offset[, size]]) + """getbuffer(obj [,offset[, size]]) -Create a buffer object from the given object referencing a slice of -length size starting at offset. Default is the entire buffer. A -read-write buffer is attempted followed by a read-only buffer. + Create a buffer object from the given object referencing a slice of + length size starting at offset. Default is the entire buffer. A + read-write buffer is attempted followed by a read-only buffer. -""") + """) ############################################################################## # @@ -328,29 +328,29 @@ read-write buffer is attempted followed by a read-only buffer. add_newdoc('numpy.core.multiarray', 'ndarray', -"""An array object represents a multidimensional, homogeneous array -of fixed-size items. An associated data-type-descriptor object -details the data-type in an array (including byteorder and any -fields). An array can be constructed using the numpy.array -command. Arrays are sequence, mapping and numeric objects. -More information is available in the numpy module and by looking -at the methods and attributes of an array. + """An array object represents a multidimensional, homogeneous array + of fixed-size items. An associated data-type-descriptor object + details the data-type in an array (including byteorder and any + fields). An array can be constructed using the numpy.array + command. Arrays are sequence, mapping and numeric objects. + More information is available in the numpy module and by looking + at the methods and attributes of an array. -ndarray.__new__(subtype, shape=, dtype=float, buffer=None, - offset=0, strides=None, order=None) + ndarray.__new__(subtype, shape=, dtype=float, buffer=None, + offset=0, strides=None, order=None) - There are two modes of creating an array using __new__: - 1) If buffer is None, then only shape, dtype, and order - are used - 2) If buffer is an object exporting the buffer interface, then - all keywords are interpreted. - The dtype parameter can be any object that can be interpreted - as a numpy.dtype object. + There are two modes of creating an array using __new__: + 1) If buffer is None, then only shape, dtype, and order + are used + 2) If buffer is an object exporting the buffer interface, then + all keywords are interpreted. + The dtype parameter can be any object that can be interpreted + as a numpy.dtype object. - No __init__ method is needed because the array is fully - initialized after the __new__ method. + No __init__ method is needed because the array is fully + initialized after the __new__ method. -""") + """) ############################################################################## @@ -361,84 +361,116 @@ ndarray.__new__(subtype, shape=, dtype=float, buffer=None, add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_interface__', -"""Array protocol: Python side.""")) + """Array protocol: Python side.""")) add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_finalize__', -"""None.""")) + """None.""")) add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_priority__', -"""Array priority.""")) + """Array priority.""")) add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_struct__', -"""Array protocol: C-struct side.""")) + """Array protocol: C-struct side.""")) add_newdoc('numpy.core.multiarray', 'ndarray', ('_as_parameter_', -"""Allow the array to be interpreted as a ctypes object by returning the -data-memory location as an integer""")) + """Allow the array to be interpreted as a ctypes object by returning the + data-memory location as an integer + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('base', -"""Base object if memory is from some other object.""")) + """Base object if memory is from some other object. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('ctypes', -"""A ctypes interface object.""")) + """A ctypes interface object. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('data', -"""Buffer object pointing to the start of the data.""")) + """Buffer object pointing to the start of the data. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('dtype', -"""Data-type for the array.""")) + """Data-type for the array. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('imag', -"""Imaginary part of the array.""")) + """Imaginary part of the array. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('itemsize', -"""Length of one element in bytes.""")) + """Length of one element in bytes. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('flags', -"""Special object providing array flags.""")) + """Special object providing array flags. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('flat', -"""A 1-d flat iterator.""")) + """A 1-d flat iterator. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('nbytes', -"""Number of bytes in the array.""")) + """Number of bytes in the array. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('ndim', -"""Number of array dimensions.""")) + """Number of array dimensions. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('real', -"""Real part of the array.""")) + """Real part of the array. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('shape', -"""Tuple of array dimensions.""")) + """Tuple of array dimensions. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('size', -"""Number of elements in the array.""")) + """Number of elements in the array. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('strides', -"""Tuple of bytes to step in each dimension.""")) + """Tuple of bytes to step in each dimension. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('T', -"""Equivalent to self.transpose() except self is returned for self.ndim < 2.""")) + """Same as self.transpose() except self is returned for self.ndim < 2. + + """)) ############################################################################## @@ -449,594 +481,604 @@ add_newdoc('numpy.core.multiarray', 'ndarray', ('T', add_newdoc('numpy.core.multiarray', 'ndarray', ('__array__', -""" a.__array__(|dtype) -> reference if type unchanged, copy otherwise. + """ a.__array__(|dtype) -> reference if type unchanged, copy otherwise. -Returns either a new reference to self if dtype is not given or a new array -of provided data type if dtype is different from the current dtype of the -array. + Returns either a new reference to self if dtype is not given or a new array + of provided data type if dtype is different from the current dtype of the + array. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('__array_wrap__', -"""a.__array_wrap__(obj) -> Object of same type as a from ndarray obj. + """a.__array_wrap__(obj) -> Object of same type as a from ndarray obj. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('__copy__', -"""a.__copy__(|order) -> copy, possibly with different order. + """a.__copy__(|order) -> copy, possibly with different order. -Return a copy of the array. + Return a copy of the array. -Argument: - order -- Order of returned copy (default 'C') - If order is 'C' (False) then the result is contiguous (default). - If order is 'Fortran' (True) then the result has fortran order. - If order is 'Any' (None) then the result has fortran order - only if m is already in fortran order.; + Argument: + order -- Order of returned copy (default 'C') + If order is 'C' (False) then the result is contiguous (default). + If order is 'Fortran' (True) then the result has fortran order. + If order is 'Any' (None) then the result has fortran order + only if m is already in fortran order.; -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('__deepcopy__', -"""a.__deepcopy__() -> Deep copy of array. + """a.__deepcopy__() -> Deep copy of array. -Used if copy.deepcopy is called on an array. + Used if copy.deepcopy is called on an array. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('__reduce__', -"""a.__reduce__() + """a.__reduce__() -For pickling. + For pickling. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('__setstate__', -"""a.__setstate__(version, shape, typecode, isfortran, rawdata) + """a.__setstate__(version, shape, typecode, isfortran, rawdata) -For unpickling. + For unpickling. -Arguments: - version -- optional pickle version. If omitted defaults to 0. - shape -- a tuple giving the shape - typecode -- a typecode - isFortran -- a bool stating if Fortran or no - rawdata -- a binary string with the data (or a list if Object array) + Arguments: + version -- optional pickle version. If omitted defaults to 0. + shape -- a tuple giving the shape + typecode -- a typecode + isFortran -- a bool stating if Fortran or no + rawdata -- a binary string with the data (or a list if Object array) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('all', -""" a.all(axis=None) + """ a.all(axis=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('any', -""" a.any(axis=None, out=None) + """ a.any(axis=None, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('argmax', -""" a.argmax(axis=None, out=None) + """ a.argmax(axis=None, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('argmin', -""" a.argmin(axis=None, out=None) + """ a.argmin(axis=None, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('argsort', -"""a.argsort(axis=-1, kind='quicksort') -> indices that sort a along given axis. + """a.argsort(axis=-1, kind='quicksort') -> indices that sort a along axis. -Keyword arguments: + Keyword arguments: -axis -- axis to be indirectly sorted (default -1) -kind -- sorting algorithm (default 'quicksort') - Possible values: 'quicksort', 'mergesort', or 'heapsort' + axis -- axis to be indirectly sorted (default -1) + kind -- sorting algorithm (default 'quicksort') + Possible values: 'quicksort', 'mergesort', or 'heapsort' -Returns: array of indices that sort a along the specified axis. + Returns: array of indices that sort a along the specified axis. -This method executes an indirect sort along the given axis using the -algorithm specified by the kind keyword. It returns an array of indices of -the same shape as a that index data along the given axis in sorted order. + This method executes an indirect sort along the given axis using the + algorithm specified by the kind keyword. It returns an array of indices of + the same shape as a that index data along the given axis in sorted order. -The various sorts are characterized by average speed, worst case -performance, need for work space, and whether they are stable. A stable -sort keeps items with the same key in the same relative order. The three -available algorithms have the following properties: + The various sorts are characterized by average speed, worst case + performance, need for work space, and whether they are stable. A stable + sort keeps items with the same key in the same relative order. The three + available algorithms have the following properties: -|------------------------------------------------------| -| kind | speed | worst case | work space | stable| -|------------------------------------------------------| -|'quicksort'| 1 | o(n^2) | 0 | no | -|'mergesort'| 2 | o(n*log(n)) | ~n/2 | yes | -|'heapsort' | 3 | o(n*log(n)) | 0 | no | -|------------------------------------------------------| + |------------------------------------------------------| + | kind | speed | worst case | work space | stable| + |------------------------------------------------------| + |'quicksort'| 1 | o(n^2) | 0 | no | + |'mergesort'| 2 | o(n*log(n)) | ~n/2 | yes | + |'heapsort' | 3 | o(n*log(n)) | 0 | no | + |------------------------------------------------------| -All the sort algorithms make temporary copies of the data when the sort is not -along the last axis. Consequently, sorts along the last axis are faster and use -less space than sorts along other axis. + All the sort algorithms make temporary copies of the data when the sort is + not along the last axis. Consequently, sorts along the last axis are faster + and use less space than sorts along other axis. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('astype', -"""a.astype(t) -> Copy of array cast to type t. + """a.astype(t) -> Copy of array cast to type t. -Cast array m to type t. t can be either a string representing a typecode, -or a python type object of type int, float, or complex. + Cast array m to type t. t can be either a string representing a typecode, + or a python type object of type int, float, or complex. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('byteswap', -"""a.byteswap(False) -> View or copy. Swap the bytes in the array. + """a.byteswap(False) -> View or copy. Swap the bytes in the array. -Swap the bytes in the array. Return the byteswapped array. If the first -argument is TRUE, byteswap in-place and return a reference to self. + Swap the bytes in the array. Return the byteswapped array. If the first + argument is TRUE, byteswap in-place and return a reference to self. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('choose', -""" a.choose(b0, b1, ..., bn, out=None, mode='raise') + """ a.choose(b0, b1, ..., bn, out=None, mode='raise') -Return an array that merges the b_i arrays together using 'a' as -the index The b_i arrays and 'a' must all be broadcastable to the -same shape. The output at a particular position is the input -array b_i at that position depending on the value of 'a' at that -position. Therefore, 'a' must be an integer array with entries -from 0 to n+1.; + Return an array that merges the b_i arrays together using 'a' as + the index The b_i arrays and 'a' must all be broadcastable to the + same shape. The output at a particular position is the input + array b_i at that position depending on the value of 'a' at that + position. Therefore, 'a' must be an integer array with entries + from 0 to n+1.; -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('clip', -"""a.clip(min=, max=, out=None) + """a.clip(min=, max=, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('compress', -"""a.compress(condition=, axis=None, out=None) + """a.compress(condition=, axis=None, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('conj', -"""a.conj() + """a.conj() -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('conjugate', -"""a.conjugate() + """a.conjugate() -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('copy', -"""a.copy(|order) -> copy, possibly with different order. + """a.copy(|order) -> copy, possibly with different order. -Return a copy of the array. + Return a copy of the array. -Argument: - order -- Order of returned copy (default 'C') - If order is 'C' (False) then the result is contiguous (default). - If order is 'Fortran' (True) then the result has fortran order. - If order is 'Any' (None) then the result has fortran order - only if m is already in fortran order.; + Argument: + order -- Order of returned copy (default 'C') + If order is 'C' (False) then the result is contiguous (default). + If order is 'Fortran' (True) then the result has fortran order. + If order is 'Any' (None) then the result has fortran order + only if m is already in fortran order.; -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('cumprod', -"""a.cumprod(axis=None, dtype=None) + """a.cumprod(axis=None, dtype=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('cumsum', -"""a.cumsum(axis=None, dtype=None, out=None) + """a.cumsum(axis=None, dtype=None, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('diagonal', -"""a.diagonal(offset=0, axis1=0, axis2=1) + """a.diagonal(offset=0, axis1=0, axis2=1) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('dump', -"""a.dump(file) Dump to specified file. + """a.dump(file) Dump to specified file. -Arguments: - file -- string naming the dump file. + Arguments: + file -- string naming the dump file. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('dumps', -"""a.dumps() -> string containing the dump? + """a.dumps() -> string containing the dump? -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('fill', -"""a.fill(value) -> None. Fill the array with the scalar value. -""")) + """a.fill(value) -> None. Fill the array with the scalar value. + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('flatten', -"""a.flatten([fortran]) return a 1-d array (always copy) -""")) + """a.flatten([fortran]) return a 1-d array (always copy) + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('getfield', -"""a.getfield(dtype, offset) -> field of array as given type. + """a.getfield(dtype, offset) -> field of array as given type. -Returns a field of the given array as a certain type. A field is a view of -the array's data with each itemsize determined by the given type and the -offset into the current array. + Returns a field of the given array as a certain type. A field is a view of + the array's data with each itemsize determined by the given type and the + offset into the current array. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('item', -"""a.item() -> copy of first array item as Python scalar. + """a.item() -> copy of first array item as Python scalar. -Copy the first element of array to a standard Python scalar and return -it. The array must be of size one. + Copy the first element of array to a standard Python scalar and return + it. The array must be of size one. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('max', -"""a.max(axis=None) + """a.max(axis=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('mean', -"""a.mean(axis=None, dtype=None) + """a.mean(axis=None, dtype=None) - Average the array over the given axis. If the axis is None, - average over all dimensions of the array. If an integer axis - is given, this equals: - a.sum(axis, dtype) * 1.0 / len(a). - If axis is None, this equals: - a.sum(axis, dtype) * 1.0 / product(a.shape,axis=0) - The optional dtype argument is the data type for intermediate - calculations in the sum.; + Average the array over the given axis. If the axis is None, + average over all dimensions of the array. If an integer axis + is given, this equals: + a.sum(axis, dtype) * 1.0 / len(a). + If axis is None, this equals: + a.sum(axis, dtype) * 1.0 / product(a.shape,axis=0) + The optional dtype argument is the data type for intermediate + calculations in the sum.; -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('min', -"""a.min(axis=None) + """a.min(axis=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('newbyteorder', -"""a.newbyteorder(<byteorder>) is equivalent to -a.view(a.dtype.newbytorder(<byteorder>)) -""")) + """a.newbyteorder(<byteorder>) is equivalent to + a.view(a.dtype.newbytorder(<byteorder>)) + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('nonzero', -"""a.nonzero() returns a tuple of arrays + """a.nonzero() returns a tuple of arrays -Returns a tuple of arrays, one for each dimension of a, -containing the indices of the non-zero elements in that -dimension. The corresponding non-zero values can be obtained -with - a[a.nonzero()]. + Returns a tuple of arrays, one for each dimension of a, + containing the indices of the non-zero elements in that + dimension. The corresponding non-zero values can be obtained + with + a[a.nonzero()]. -To group the indices by element, rather than dimension, use - transpose(a.nonzero()) -instead. The result of this is always a 2d array, with a row for -each non-zero element.; + To group the indices by element, rather than dimension, use + transpose(a.nonzero()) + instead. The result of this is always a 2d array, with a row for + each non-zero element.; -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('prod', -""" a.prod(axis=None, dtype=None) + """a.prod(axis=None, dtype=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('ptp', -"""a.ptp(axis=None) a.max(axis)-a.min(axis) + """a.ptp(axis=None) a.max(axis)-a.min(axis) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('put', -"""a.put(values, indices, mode) sets a.flat[n] = values[n] for -each n in indices. v can be scalar or shorter than indices, and -it will repeat. + """a.put(values, indices, mode) sets a.flat[n] = values[n] for + each n in indices. v can be scalar or shorter than indices, and + it will repeat. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('putmask', -"""a.putmask(values, mask) sets a.flat[n] = v[n] for each n where -mask.flat[n] is true. v can be scalar. + """a.putmask(values, mask) sets a.flat[n] = v[n] for each n where + mask.flat[n] is true. v can be scalar. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('ravel', -"""a.ravel([fortran]) return a 1-d array (copy only if needed) + """a.ravel([fortran]) return a 1-d array (copy only if needed) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('repeat', -"""a.repeat(repeats=, axis=none) + """a.repeat(repeats=, axis=none) -copy elements of a, repeats times. the repeats argument must be a sequence -of length a.shape[axis] or a scalar. + copy elements of a, repeats times. the repeats argument must be a sequence + of length a.shape[axis] or a scalar. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('reshape', -"""a.reshape(d1, d2, ..., dn, order='c') + """a.reshape(d1, d2, ..., dn, order='c') -Return a new array from this one. The new array must have the same number -of elements as self. Also always returns a view or raises a ValueError if -that is impossible.; + Return a new array from this one. The new array must have the same number + of elements as self. Also always returns a view or raises a ValueError if + that is impossible.; -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('resize', -"""a.resize(new_shape, refcheck=True, order=False) -> None. Change array shape. + """a.resize(new_shape, refcheck=True, order=False) -> None. Change array shape. -Change size and shape of self inplace. Array must own its own memory and -not be referenced by other arrays. Returns None. + Change size and shape of self inplace. Array must own its own memory and + not be referenced by other arrays. Returns None. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('round', -"""a.round(decimals=0, out=None) + """a.round(decimals=0, out=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('searchsorted', -"""a.searchsorted(values=v, side='left') -> array of indices. + """a.searchsorted(v, side='left') -> index array. - Required Arguments: - v -- keys to be searched for in a. + Required arguments: + v -- array of keys to be searched for in a. - Keyword arguments + Keyword arguments: side -- {'left', 'right'}, default('left'). - If a is a 1-D array in ascending order, then + Returns: + index array with the same shape as keys. + + The array to be searched must be 1-D and is assumed to be sorted in + ascending order. + + The method call a.searchsorted(v, side='left') - returns an array of indices i such that for each element of values the - following holds: + returns an index array with the same shape as v such that for each value i + in the index and the corresponding key in v the following holds: a[j] < key <= a[i] for all j < i, If such an index does not exist, a.size() is used. The result is such that - if the key were to be inserted in the slot before the index i, then the - order of a would be preserved and i would be the smallest index with that - property. + if the key were to be inserted into a in the slot before the index i, then + the order of a would be preserved and i would be the smallest index with + that property. - If a is a 1-D array in ascending order, then + The method call a.searchsorted(v, side='right') - returns an array of indices i such that for each element of values the - following holds: + returns an index array with the same shape as v such that for each value i + in the index and the corresponding key in v the following holds: a[j] <= key < a[i] for all j < i, - If such an index does not exist, a.size() is used. The result is that if the - key were to be inserted in the slot before the index i, then the order of a - would be preserved and i would be the largest index with that property. + If such an index does not exist, a.size() is used. The result is such that + if the key were to be inserted into a in the slot before the index i, then + the order of a would be preserved and i would be the largest index with + that property. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('setfield', -"""m.setfield(value, dtype, offset) -> None. -places val into field of the given array defined by the data type and offset. + """m.setfield(value, dtype, offset) -> None. + places val into field of the given array defined by the data type and offset. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('setflags', -"""a.setflags(write=None, align=None, uic=None) + """a.setflags(write=None, align=None, uic=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('sort', -"""a.sort(axis=-1, kind='quicksort') -> None. Sort a along the given axis. + """a.sort(axis=-1, kind='quicksort') -> None. Sort a along the given axis. -Keyword arguments: + Keyword arguments: -axis -- axis to be sorted (default -1) -kind -- sorting algorithm (default 'quicksort') - Possible values: 'quicksort', 'mergesort', or 'heapsort'. + axis -- axis to be sorted (default -1) + kind -- sorting algorithm (default 'quicksort') + Possible values: 'quicksort', 'mergesort', or 'heapsort'. -Returns: None. + Returns: None. -This method sorts a in place along the given axis using the algorithm -specified by the kind keyword. + This method sorts a in place along the given axis using the algorithm + specified by the kind keyword. -The various sorts may characterized by average speed, worst case -performance, need for work space, and whether they are stable. A stable -sort keeps items with the same key in the same relative order and is most -useful when used with argsort where the key might differ from the items -being sorted. The three available algorithms have the following properties: + The various sorts may characterized by average speed, worst case + performance, need for work space, and whether they are stable. A stable + sort keeps items with the same key in the same relative order and is most + useful when used with argsort where the key might differ from the items + being sorted. The three available algorithms have the following properties: -|------------------------------------------------------| -| kind | speed | worst case | work space | stable| -|------------------------------------------------------| -|'quicksort'| 1 | o(n) | 0 | no | -|'mergesort'| 2 | o(n*log(n)) | ~n/2 | yes | -|'heapsort' | 3 | o(n*log(n)) | 0 | no | -|------------------------------------------------------| + |------------------------------------------------------| + | kind | speed | worst case | work space | stable| + |------------------------------------------------------| + |'quicksort'| 1 | o(n) | 0 | no | + |'mergesort'| 2 | o(n*log(n)) | ~n/2 | yes | + |'heapsort' | 3 | o(n*log(n)) | 0 | no | + |------------------------------------------------------| -All the sort algorithms make temporary copies of the data when the sort is -not along the last axis. Consequently, sorts along the last axis are faster -and use less space than sorts along other axis. + All the sort algorithms make temporary copies of the data when the sort is + not along the last axis. Consequently, sorts along the last axis are faster + and use less space than sorts along other axis. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('squeeze', -"""m.squeeze() eliminate all length-1 dimensions + """m.squeeze() eliminate all length-1 dimensions -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('std', -"""a.std(axis=None, dtype=None, out=None) -> standard deviation. + """a.std(axis=None, dtype=None, out=None) -> standard deviation. -The standard deviation isa measure of the spread of a -distribution. + The standard deviation isa measure of the spread of a + distribution. -The standard deviation is the square root of the average of the -squared deviations from the mean, i.e. - std = sqrt(mean((x - x.mean())**2,axis=0)). + The standard deviation is the square root of the average of the + squared deviations from the mean, i.e. + std = sqrt(mean((x - x.mean())**2,axis=0)). -For multidimensional arrays, std is computed by default along the -first axis. + For multidimensional arrays, std is computed by default along the + first axis. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('sum', -"""a.sum(axis=None, dtype=None) -> Sum of array over given axis. + """a.sum(axis=None, dtype=None) -> Sum of array over given axis. -Sum the array over the given axis. If the axis is None, sum over -all dimensions of the array. + Sum the array over the given axis. If the axis is None, sum over + all dimensions of the array. -The optional dtype argument is the data type for the returned -value and intermediate calculations. The default is to upcast -(promote) smaller integer types to the platform-dependent int. -For example, on 32-bit platforms: + The optional dtype argument is the data type for the returned + value and intermediate calculations. The default is to upcast + (promote) smaller integer types to the platform-dependent int. + For example, on 32-bit platforms: - a.dtype default sum dtype - --------------------------------------------------- - bool, int8, int16, int32 int32 + a.dtype default sum dtype + --------------------------------------------------- + bool, int8, int16, int32 int32 -Examples: + Examples: ->>> array([0.5, 1.5]).sum() -2.0 ->>> array([0.5, 1.5]).sum(dtype=int32) -1 ->>> array([[0, 1], [0, 5]]).sum(axis=0) -array([0, 6]) ->>> array([[0, 1], [0, 5]]).sum(axis=1) -array([1, 5]) + >>> array([0.5, 1.5]).sum() + 2.0 + >>> array([0.5, 1.5]).sum(dtype=int32) + 1 + >>> array([[0, 1], [0, 5]]).sum(axis=0) + array([0, 6]) + >>> array([[0, 1], [0, 5]]).sum(axis=1) + array([1, 5]) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('swapaxes', -"""a.swapaxes(axis1, axis2) -> new view with axes swapped. + """a.swapaxes(axis1, axis2) -> new view with axes swapped. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('take', -"""a.take(indices, axis=None, out=None, mode='raise') -> new array. + """a.take(indices, axis=None, out=None, mode='raise') -> new array. -The new array is formed from the elements of a indexed by indices along the -given axis. + The new array is formed from the elements of a indexed by indices along the + given axis. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('tofile', -"""a.tofile(fid, sep="") -> None. Write the data to a file. + """a.tofile(fid, sep="") -> None. Write the data to a file. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('tolist', -"""a.tolist() -> Array as hierarchical list. + """a.tolist() -> Array as hierarchical list. -Copy the data portion of the array to a hierarchical python list and return -that list. + Copy the data portion of the array to a hierarchical python list and return + that list. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('tostring', -"""a.tostring(order='C') -> binary array data as Python string. + """a.tostring(order='C') -> binary array data as Python string. -Construct a Python string containing the raw bytes in the array. + Construct a Python string containing the raw bytes in the array. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('trace', -"""a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None) -return the sum along the offset diagonal of the array's indicated -axis1 and axis2. + """a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None) + return the sum along the offset diagonal of the array's indicated + axis1 and axis2. -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('transpose', -"""a.transpose(*axes) - -Returns a view of 'a' with axes transposed. If no axes are given, -or None is passed, switches the order of the axes. For a 2-d -array, this is the usual matrix transpose. If axes are given, -they describe how the axes are permuted. - -Example: ->>> a = array([[1,2],[3,4]]) ->>> a -array([[1, 2], - [3, 4]]) ->>> a.transpose() -array([[1, 3], - [2, 4]]) ->>> a.transpose((1,0)) -array([[1, 3], - [2, 4]]) ->>> a.transpose(1,0) -array([[1, 3], - [2, 4]]) - -""")) + """a.transpose(*axes) + + Returns a view of 'a' with axes transposed. If no axes are given, + or None is passed, switches the order of the axes. For a 2-d + array, this is the usual matrix transpose. If axes are given, + they describe how the axes are permuted. + + Example: + >>> a = array([[1,2],[3,4]]) + >>> a + array([[1, 2], + [3, 4]]) + >>> a.transpose() + array([[1, 3], + [2, 4]]) + >>> a.transpose((1,0)) + array([[1, 3], + [2, 4]]) + >>> a.transpose(1,0) + array([[1, 3], + [2, 4]]) + + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('var', -"""a.var(axis=None, dtype=None) + """a.var(axis=None, dtype=None) -""")) + """)) add_newdoc('numpy.core.multiarray', 'ndarray', ('view', -"""a.view(<type>) -> new view of array with same data. + """a.view(<type>) -> new view of array with same data. -Type can be either a new sub-type object or a data-descriptor object + Type can be either a new sub-type object or a data-descriptor object -""")) + """)) |