Move docstrings from multiarraymodule.c to add_newdocs.py.

1 files changed, 261 insertions, 0 deletions

diff --git a/numpy/add_newdocs.py b/numpy/add_newdocs.py
index 0ef30da3a..58b80493f 100644
--- a/numpy/add_newdocs.py
+++ b/numpy/add_newdocs.py
@@ -17,3 +17,264 @@ add_newdoc('numpy.core','dtype',
             ('num', "Internally-used number for builtin base")
             ]
            )
+
+add_newdoc('numpy.core','fromobject',
+"""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','empty',
+"""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.
+
+""")
+
+
+add_newdoc('numpy.core','scalar',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','zeros',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','set_typeDict',
+"""set_typeDict(dict)
+
+Set the internal dictionary that can look up an array type using a
+registered code.
+
+""")
+
+add_newdoc('numpy.core','fromstring',
+"""fromstring(string, dtype=float, count=-1, sep='')
+
+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).
+
+""")
+
+add_newdoc('numpy.core','fromstring',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','fromfile',
+"""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.
+
+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','frombuffer',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','concatenate',
+"""concatenate((a1, a2, ...), axis=None)
+
+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.
+    
+Example:
+    
+>>> concatenate( ([0,1,2], [5,6,7]) )
+array([0, 1, 2, 5, 6, 7])
+
+""")
+
+add_newdoc('numpy.core','inner',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','matrixproduct',
+"""dot(a,v)
+
+Return matrix-multiplication between a and b.
+
+The product-sum is over the last dimension of a and the 
+second-to-last dimension of b.
+
+""")
+
+add_newdoc('numpy.core','fastCopyAndTranspose',
+"""_fastCopyAndTranspose(a)""")
+
+add_newdoc('numpy.core','cross_correlate',
+"""cross_correlate(a,v, mode=0)""")
+
+add_newdoc('numpy.core','arange',
+"""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 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','_get_ndarray_c_version',
+"""_get_ndarray_c_version()
+
+Return the compile time NDARRAY_VERSION number.
+
+""")
+
+add_newdoc('numpy.core','_reconstruct',
+"""_reconstruct(subtype, shape, dtype)
+
+Construct an empty array. Used by Pickles.
+
+""")
+
+
+add_newdoc('numpy.core','set_string_function',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','set_numeric_ops',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','where',
+"""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().
+
+To group the indices by element, rather than dimension, use
+
+    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.
+
+""")
+
+
+add_newdoc('numpy.core','lexsort',
+"""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.
+
+""")
+
+add_newdoc('numpy.core','can_cast_safely',
+"""can_cast_safely(from=d1, to=d2)
+
+Returns True if data type d1 can be cast to data type d2 without
+losing precision.
+
+""")
+
+add_newdoc('numpy.core','new_buffer',
+"""newbuffer(size)
+
+Return a new uninitialized buffer object of size bytes
+
+""")
+
+add_newdoc('numpy.core','getbuffer',
+"""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.
+
+""")