[Numpy-svn] r3105 - in trunk/numpy: . core core/src

numpy-svn at scipy.org numpy-svn at scipy.org
Sun Sep 3 12:49:54 CDT 2006


Author: charris
Date: 2006-09-03 12:49:51 -0500 (Sun, 03 Sep 2006)
New Revision: 3105

Modified:
   trunk/numpy/add_newdocs.py
   trunk/numpy/core/fromnumeric.py
   trunk/numpy/core/src/arraymethods.c
Log:
Change ndarray.searchsorted keyword "value" to "keys".
Tweak documentation of searchsorted.
Indent many docstrings in add_newdocs.


Modified: trunk/numpy/add_newdocs.py
===================================================================
--- trunk/numpy/add_newdocs.py	2006-09-03 02:26:26 UTC (rev 3104)
+++ trunk/numpy/add_newdocs.py	2006-09-03 17:49:51 UTC (rev 3105)
@@ -57,255 +57,255 @@
            )
 
 add_newdoc('numpy.core.multiarray','array',
-"""array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0)
+    """array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0)
 
-Return an array from object with the specified date-type.
+    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.
+    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 @@
 
 
 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,86 +361,118 @@
 
 
 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.
 
+    """))
 
+
 ##############################################################################
 #
 # ndarray methods
@@ -449,594 +481,604 @@
 
 
 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)
+    """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.
+    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]])
+    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
 
-"""))
+    """))

Modified: trunk/numpy/core/fromnumeric.py
===================================================================
--- trunk/numpy/core/fromnumeric.py	2006-09-03 02:26:26 UTC (rev 3104)
+++ trunk/numpy/core/fromnumeric.py	2006-09-03 17:49:51 UTC (rev 3105)
@@ -220,42 +220,49 @@
         return _wrapit(a, 'argmin', axis)
     return argmin(axis)
 
-def searchsorted(a, v, side ='left'):
-    """-> array ind. Inserting v[i] before a[ind[i]] will leave a in order.
+def searchsorted(a, v, side='left'):
+    """-> index array. Inserting v[i] before a[index[i]] maintains a in order.
 
-    Required Arguments:
+    Required arguments:
         a -- sorted 1-D array to be searched.
-        v -- keys to be searched for in a.
+        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:
+        array of indices with the same shape as a.
 
+    The array to be searched must be 1-D and is assumed to be sorted in
+    ascending order.
+
+    The function call
+
         searchsorted(a, 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 function call
 
         searchsorted(a, 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.
 
     """
     try:

Modified: trunk/numpy/core/src/arraymethods.c
===================================================================
--- trunk/numpy/core/src/arraymethods.c	2006-09-03 02:26:26 UTC (rev 3104)
+++ trunk/numpy/core/src/arraymethods.c	2006-09-03 17:49:51 UTC (rev 3105)
@@ -695,16 +695,16 @@
 static PyObject *
 array_searchsorted(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *values;
+	PyObject *keys;
         char *side = "left";
-        static char *kwlist[] = {"values","side", NULL};
+        static char *kwlist[] = {"keys", "side", NULL};
         NPY_SEARCHKIND which;
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|s", kwlist, &values, &side))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|s", kwlist, &keys, &side))
             return NULL;
 	if (strlen(side) < 1) {
 		PyErr_SetString(PyExc_ValueError,
-                        "Searchsorted side string must be at least length 1");
+                        "Searchsorted: side must be nonempty string");
 		return PY_FAIL;
 	}
 
@@ -714,11 +714,11 @@
                 which = NPY_SEARCHRIGHT;
         else {
 		PyErr_Format(PyExc_ValueError,
-                        "%s is an unrecognized side", side);
+                        "%s is not a valid value of side", side);
 		return PY_FAIL;
 	}
 
-	return _ARET(PyArray_SearchSorted(self, values, which));
+	return _ARET(PyArray_SearchSorted(self, keys, which));
 }
 
 static void



More information about the Numpy-svn mailing list