"""

This is only meant to add docs to objects defined in C-extension modules.

The purpose is to allow easier editing of the docstrings without

requiring a re-compile.

NOTE: Many of the methods of ndarray have corresponding functions.

If you update these docstrings, please keep also the ones in

core/fromnumeric.py, core/defmatrix.py up-to-date.

"""

from __future__ import division, absolute_import, print_function

from numpy.lib import add_newdoc

###############################################################################

#

# flatiter

#

# flatiter needs a toplevel description

#

###############################################################################

add_newdoc('numpy.core', 'flatiter',

"""

Flat iterator object to iterate over arrays.

A `flatiter` iterator is returned by ``x.flat`` for any array `x`.

It allows iterating over the array as if it were a 1-D array,

either in a for-loop or by calling its `next` method.

Iteration is done in C-contiguous style, with the last index varying the

fastest. The iterator can also be indexed using basic slicing or

advanced indexing.

See Also

--------

ndarray.flat : Return a flat iterator over an array.

ndarray.flatten : Returns a flattened copy of an array.

Notes

-----

A `flatiter` iterator can not be constructed directly from Python code

by calling the `flatiter` constructor.

Examples

--------

>>> x = np.arange(6).reshape(2, 3)

>>> fl = x.flat

>>> type(fl)

<type 'numpy.flatiter'>

>>> for item in fl:

... print item

...

0

1

2

3

4

5

>>> fl[2:4]

array([2, 3])

""")

# flatiter attributes

add_newdoc('numpy.core', 'flatiter', ('base',

"""

A reference to the array that is iterated over.

Examples

--------

>>> x = np.arange(5)

>>> fl = x.flat

>>> fl.base is x

True

"""))

add_newdoc('numpy.core', 'flatiter', ('coords',

"""

An N-dimensional tuple of current coordinates.

Examples

--------

>>> x = np.arange(6).reshape(2, 3)

>>> fl = x.flat

>>> fl.coords

(0, 0)

>>> fl.next()

0

>>> fl.coords

(0, 1)

"""))

add_newdoc('numpy.core', 'flatiter', ('index',

"""

Current flat index into the array.

Examples

--------

>>> x = np.arange(6).reshape(2, 3)

>>> fl = x.flat

>>> fl.index

0

>>> fl.next()

0

>>> fl.index

1

"""))

# flatiter functions

add_newdoc('numpy.core', 'flatiter', ('__array__',

"""__array__(type=None) Get array from iterator

"""))

add_newdoc('numpy.core', 'flatiter', ('copy',

"""

copy()

Get a copy of the iterator as a 1-D array.

Examples

--------

>>> x = np.arange(6).reshape(2, 3)

>>> x

array([[0, 1, 2],

[3, 4, 5]])

>>> fl = x.flat

>>> fl.copy()

array([0, 1, 2, 3, 4, 5])

"""))

###############################################################################

#

# nditer

#

###############################################################################

add_newdoc('numpy.core', 'nditer',

"""

Efficient multi-dimensional iterator object to iterate over arrays.

To get started using this object, see the

:ref:`introductory guide to array iteration <arrays.nditer>`.

Parameters

----------

op : ndarray or sequence of array_like

The array(s) to iterate over.

flags : sequence of str, optional

Flags to control the behavior of the iterator.

* "buffered" enables buffering when required.

* "c_index" causes a C-order index to be tracked.

* "f_index" causes a Fortran-order index to be tracked.

* "multi_index" causes a multi-index, or a tuple of indices

with one per iteration dimension, to be tracked.

* "common_dtype" causes all the operands to be converted to

a common data type, with copying or buffering as necessary.

* "delay_bufalloc" delays allocation of the buffers until

a reset() call is made. Allows "allocate" operands to

be initialized before their values are copied into the buffers.

* "external_loop" causes the `values` given to be

one-dimensional arrays with multiple values instead of

zero-dimensional arrays.

* "grow_inner" allows the `value` array sizes to be made

larger than the buffer size when both "buffered" and

"external_loop" is used.

* "ranged" allows the iterator to be restricted to a sub-range

of the iterindex values.

* "refs_ok" enables iteration of reference types, such as

object arrays.

* "reduce_ok" enables iteration of "readwrite" operands

which are broadcasted, also known as reduction operands.

* "zerosize_ok" allows `itersize` to be zero.

op_flags : list of list of str, optional

This is a list of flags for each operand. At minimum, one of

"readonly", "readwrite", or "writeonly" must be specified.

* "readonly" indicates the operand will only be read from.

* "readwrite" indicates the operand will be read from and written to.

* "writeonly" indicates the operand will only be written to.

* "no_broadcast" prevents the operand from being broadcasted.

* "contig" forces the operand data to be contiguous.

* "aligned" forces the operand data to be aligned.

* "nbo" forces the operand data to be in native byte order.

* "copy" allows a temporary read-only copy if required.

* "updateifcopy" allows a temporary read-write copy if required.

* "allocate" causes the array to be allocated if it is None

in the `op` parameter.

* "no_subtype" prevents an "allocate" operand from using a subtype.

* "arraymask" indicates that this operand is the mask to use

for selecting elements when writing to operands with the

'writemasked' flag set. The iterator does not enforce this,

but when writing from a buffer back to the array, it only

copies those elements indicated by this mask.

* 'writemasked' indicates that only elements where the chosen

'arraymask' operand is True will be written to.

op_dtypes : dtype or tuple of dtype(s), optional

The required data type(s) of the operands. If copying or buffering

is enabled, the data will be converted to/from their original types.

order : {'C', 'F', 'A', 'K'}, optional

Controls the iteration order. 'C' means C order, 'F' means

Fortran order, 'A' means 'F' order if all the arrays are Fortran

contiguous, 'C' order otherwise, and 'K' means as close to the

order the array elements appear in memory as possible. This also

affects the element memory order of "allocate" operands, as they

are allocated to be compatible with iteration order.

Default is 'K'.

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur when making a copy

or buffering. Setting this to 'unsafe' is not recommended,

as it can adversely affect accumulations.

* 'no' means the data types should not be cast at all.

* 'equiv' means only byte-order changes are allowed.

* 'safe' means only casts which can preserve values are allowed.

* 'same_kind' means only safe casts or casts within a kind,

like float64 to float32, are allowed.

* 'unsafe' means any data conversions may be done.

op_axes : list of list of ints, optional

If provided, is a list of ints or None for each operands.

The list of axes for an operand is a mapping from the dimensions

of the iterator to the dimensions of the operand. A value of

-1 can be placed for entries, causing that dimension to be

treated as "newaxis".

itershape : tuple of ints, optional

The desired shape of the iterator. This allows "allocate" operands

with a dimension mapped by op_axes not corresponding to a dimension

of a different operand to get a value not equal to 1 for that

dimension.

buffersize : int, optional

When buffering is enabled, controls the size of the temporary

buffers. Set to 0 for the default value.

Attributes

----------

dtypes : tuple of dtype(s)

The data types of the values provided in `value`. This may be

different from the operand data types if buffering is enabled.

finished : bool

Whether the iteration over the operands is finished or not.

has_delayed_bufalloc : bool

If True, the iterator was created with the "delay_bufalloc" flag,

and no reset() function was called on it yet.

has_index : bool

If True, the iterator was created with either the "c_index" or

the "f_index" flag, and the property `index` can be used to

retrieve it.

has_multi_index : bool

If True, the iterator was created with the "multi_index" flag,

and the property `multi_index` can be used to retrieve it.

index :

When the "c_index" or "f_index" flag was used, this property

provides access to the index. Raises a ValueError if accessed

and `has_index` is False.

iterationneedsapi : bool

Whether iteration requires access to the Python API, for example

if one of the operands is an object array.

iterindex : int

An index which matches the order of iteration.

itersize : int

Size of the iterator.

itviews :

Structured view(s) of `operands` in memory, matching the reordered

and optimized iterator access pattern.

multi_index :

When the "multi_index" flag was used, this property

provides access to the index. Raises a ValueError if accessed

accessed and `has_multi_index` is False.

ndim : int

The iterator's dimension.

nop : int

The number of iterator operands.

operands : tuple of operand(s)

The array(s) to be iterated over.

shape : tuple of ints

Shape tuple, the shape of the iterator.

value :

Value of `operands` at current iteration. Normally, this is a

tuple of array scalars, but if the flag "external_loop" is used,

it is a tuple of one dimensional arrays.

Notes

-----

`nditer` supersedes `flatiter`. The iterator implementation behind

`nditer` is also exposed by the Numpy C API.

The Python exposure supplies two iteration interfaces, one which follows

the Python iterator protocol, and another which mirrors the C-style

do-while pattern. The native Python approach is better in most cases, but

if you need the iterator's coordinates or index, use the C-style pattern.

Examples

--------

Here is how we might write an ``iter_add`` function, using the

Python iterator protocol::

def iter_add_py(x, y, out=None):

addop = np.add

it = np.nditer([x, y, out], [],

[['readonly'], ['readonly'], ['writeonly','allocate']])

for (a, b, c) in it:

addop(a, b, out=c)

return it.operands[2]

Here is the same function, but following the C-style pattern::

def iter_add(x, y, out=None):

addop = np.add

it = np.nditer([x, y, out], [],

[['readonly'], ['readonly'], ['writeonly','allocate']])

while not it.finished:

addop(it[0], it[1], out=it[2])

it.iternext()

return it.operands[2]

Here is an example outer product function::

def outer_it(x, y, out=None):

mulop = np.multiply

it = np.nditer([x, y, out], ['external_loop'],

[['readonly'], ['readonly'], ['writeonly', 'allocate']],

op_axes=[range(x.ndim)+[-1]*y.ndim,

[-1]*x.ndim+range(y.ndim),

None])

for (a, b, c) in it:

mulop(a, b, out=c)

return it.operands[2]

>>> a = np.arange(2)+1

>>> b = np.arange(3)+1

>>> outer_it(a,b)

array([[1, 2, 3],

[2, 4, 6]])

Here is an example function which operates like a "lambda" ufunc::

def luf(lamdaexpr, *args, **kwargs):

"luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)"

nargs = len(args)

op = (kwargs.get('out',None),) + args

it = np.nditer(op, ['buffered','external_loop'],

[['writeonly','allocate','no_broadcast']] +

[['readonly','nbo','aligned']]*nargs,

order=kwargs.get('order','K'),

casting=kwargs.get('casting','safe'),

buffersize=kwargs.get('buffersize',0))

while not it.finished:

it[0] = lamdaexpr(*it[1:])

it.iternext()

return it.operands[0]

>>> a = np.arange(5)

>>> b = np.ones(5)

>>> luf(lambda i,j:i*i + j/2, a, b)

array([ 0.5, 1.5, 4.5, 9.5, 16.5])

""")

# nditer methods

add_newdoc('numpy.core', 'nditer', ('copy',

"""

copy()

Get a copy of the iterator in its current state.

Examples

--------

>>> x = np.arange(10)

>>> y = x + 1

>>> it = np.nditer([x, y])

>>> it.next()

(array(0), array(1))

>>> it2 = it.copy()

>>> it2.next()

(array(1), array(2))

"""))

add_newdoc('numpy.core', 'nditer', ('debug_print',

"""

debug_print()

Print the current state of the `nditer` instance and debug info to stdout.

"""))

add_newdoc('numpy.core', 'nditer', ('enable_external_loop',

"""

enable_external_loop()

When the "external_loop" was not used during construction, but

is desired, this modifies the iterator to behave as if the flag

was specified.

"""))

add_newdoc('numpy.core', 'nditer', ('iternext',

"""

iternext()

Check whether iterations are left, and perform a single internal iteration

without returning the result. Used in the C-style pattern do-while

pattern. For an example, see `nditer`.

Returns

-------

iternext : bool

Whether or not there are iterations left.

"""))

add_newdoc('numpy.core', 'nditer', ('remove_axis',

"""

remove_axis(i)

Removes axis `i` from the iterator. Requires that the flag "multi_index"

be enabled.

"""))

add_newdoc('numpy.core', 'nditer', ('remove_multi_index',

"""

remove_multi_index()

When the "multi_index" flag was specified, this removes it, allowing

the internal iteration structure to be optimized further.

"""))

add_newdoc('numpy.core', 'nditer', ('reset',

"""

reset()

Reset the iterator to its initial state.

"""))

###############################################################################

#

# broadcast

#

###############################################################################

add_newdoc('numpy.core', 'broadcast',

"""

Produce an object that mimics broadcasting.

Parameters

----------

in1, in2, ... : array_like

Input parameters.

Returns

-------

b : broadcast object

Broadcast the input parameters against one another, and

return an object that encapsulates the result.

Amongst others, it has ``shape`` and ``nd`` properties, and

may be used as an iterator.

Examples

--------

Manually adding two vectors, using broadcasting:

>>> x = np.array([[1], [2], [3]])

>>> y = np.array([4, 5, 6])

>>> b = np.broadcast(x, y)

>>> out = np.empty(b.shape)

>>> out.flat = [u+v for (u,v) in b]

>>> out

array([[ 5., 6., 7.],

[ 6., 7., 8.],

[ 7., 8., 9.]])

Compare against built-in broadcasting:

>>> x + y

array([[5, 6, 7],

[6, 7, 8],

[7, 8, 9]])

""")

# attributes

add_newdoc('numpy.core', 'broadcast', ('index',

"""

current index in broadcasted result

Examples

--------

>>> x = np.array([[1], [2], [3]])

>>> y = np.array([4, 5, 6])

>>> b = np.broadcast(x, y)

>>> b.index

0

>>> b.next(), b.next(), b.next()

((1, 4), (1, 5), (1, 6))

>>> b.index

3

"""))

add_newdoc('numpy.core', 'broadcast', ('iters',

"""

tuple of iterators along ``self``'s "components."

Returns a tuple of `numpy.flatiter` objects, one for each "component"

of ``self``.

See Also

--------

numpy.flatiter

Examples

--------

>>> x = np.array([1, 2, 3])

>>> y = np.array([[4], [5], [6]])

>>> b = np.broadcast(x, y)

>>> row, col = b.iters

>>> row.next(), col.next()

(1, 4)

"""))

add_newdoc('numpy.core', 'broadcast', ('nd',

"""

Number of dimensions of broadcasted result.

Examples

--------

>>> x = np.array([1, 2, 3])

>>> y = np.array([[4], [5], [6]])

>>> b = np.broadcast(x, y)

>>> b.nd

2

"""))

add_newdoc('numpy.core', 'broadcast', ('numiter',

"""

Number of iterators possessed by the broadcasted result.

Examples

--------

>>> x = np.array([1, 2, 3])

>>> y = np.array([[4], [5], [6]])

>>> b = np.broadcast(x, y)

>>> b.numiter

2

"""))

add_newdoc('numpy.core', 'broadcast', ('shape',

"""

Shape of broadcasted result.

Examples

--------

>>> x = np.array([1, 2, 3])

>>> y = np.array([[4], [5], [6]])

>>> b = np.broadcast(x, y)

>>> b.shape

(3, 3)

"""))

add_newdoc('numpy.core', 'broadcast', ('size',

"""

Total size of broadcasted result.

Examples

--------

>>> x = np.array([1, 2, 3])

>>> y = np.array([[4], [5], [6]])

>>> b = np.broadcast(x, y)

>>> b.size

9

"""))

add_newdoc('numpy.core', 'broadcast', ('reset',

"""

reset()

Reset the broadcasted result's iterator(s).

Parameters

----------

None

Returns

-------

None

Examples

--------

>>> x = np.array([1, 2, 3])

>>> y = np.array([[4], [5], [6]]

>>> b = np.broadcast(x, y)

>>> b.index

0

>>> b.next(), b.next(), b.next()

((1, 4), (2, 4), (3, 4))

>>> b.index

3

>>> b.reset()

>>> b.index

0

"""))

###############################################################################

#

# numpy functions

#

###############################################################################

add_newdoc('numpy.core.multiarray', 'array',

"""

array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

Create an array.

Parameters

----------

object : array_like

An array, any object exposing the array interface, an

object whose __array__ method returns an array, or any

(nested) sequence.

dtype : data-type, optional

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 : bool, optional

If true (default), then the object is copied. Otherwise, a copy

will only be made if __array__ returns a copy, if obj is a

nested sequence, or if a copy is needed to satisfy any of the other

requirements (`dtype`, `order`, etc.).

order : {'C', 'F', 'A'}, optional

Specify the order of the array. If order is 'C' (default), then the

array will be in C-contiguous order (last-index varies the

fastest). If order is 'F', then the returned array

will be in Fortran-contiguous order (first-index varies the

fastest). If order is 'A', then the returned array may

be in any order (either C-, Fortran-contiguous, or even

discontiguous).

subok : bool, optional

If True, then sub-classes will be passed-through, otherwise

the returned array will be forced to be a base-class array (default).

ndmin : int, optional

Specifies the minimum number of dimensions that the resulting

array should have. Ones will be pre-pended to the shape as

needed to meet this requirement.

Returns

-------

out : ndarray

An array object satisfying the specified requirements.

See Also

--------

empty, empty_like, zeros, zeros_like, ones, ones_like, fill

Examples

--------

>>> np.array([1, 2, 3])

array([1, 2, 3])

Upcasting:

>>> np.array([1, 2, 3.0])

array([ 1., 2., 3.])

More than one dimension:

>>> np.array([[1, 2], [3, 4]])

array([[1, 2],

[3, 4]])

Minimum dimensions 2:

>>> np.array([1, 2, 3], ndmin=2)

array([[1, 2, 3]])

Type provided:

>>> np.array([1, 2, 3], dtype=complex)

array([ 1.+0.j, 2.+0.j, 3.+0.j])

Data-type consisting of more than one element:

>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])

>>> x['a']

array([1, 3])

Creating an array from sub-classes:

>>> np.array(np.mat('1 2; 3 4'))

array([[1, 2],

[3, 4]])

>>> np.array(np.mat('1 2; 3 4'), subok=True)

matrix([[1, 2],

[3, 4]])

""")

add_newdoc('numpy.core.multiarray', 'empty',

"""

empty(shape, dtype=float, order='C')

Return a new array of given shape and type, without initializing entries.

Parameters

----------

shape : int or tuple of int

Shape of the empty array

dtype : data-type, optional

Desired output data-type.

order : {'C', 'F'}, optional

Whether to store multi-dimensional data in C (row-major) or

Fortran (column-major) order in memory.

Returns

-------

out : ndarray

Array of uninitialized (arbitrary) data with the given

shape, dtype, and order.

See Also

--------

empty_like, zeros, ones

Notes

-----

`empty`, unlike `zeros`, does not set the array values to zero,

and may therefore be marginally faster. On the other hand, it requires

the user to manually set all the values in the array, and should be

used with caution.

Examples

--------

>>> np.empty([2, 2])

array([[ -9.74499359e+001, 6.69583040e-309],

[ 2.13182611e-314, 3.06959433e-309]]) #random

>>> np.empty([2, 2], dtype=int)

array([[-1073741821, -1067949133],

[ 496041986, 19249760]]) #random

""")

add_newdoc('numpy.core.multiarray', 'empty_like',

"""

empty_like(a, dtype=None, order='K', subok=True)

Return a new array with the same shape and type as a given array.

Parameters

----------

a : array_like

The shape and data-type of `a` define these same attributes of the

returned array.

dtype : data-type, optional

.. versionadded:: 1.6.0

Overrides the data type of the result.

order : {'C', 'F', 'A', or 'K'}, optional

.. versionadded:: 1.6.0

Overrides the memory layout of the result. 'C' means C-order,

'F' means F-order, 'A' means 'F' if ``a`` is Fortran contiguous,

'C' otherwise. 'K' means match the layout of ``a`` as closely

as possible.

subok : bool, optional.

If True, then the newly created array will use the sub-class

type of 'a', otherwise it will be a base-class array. Defaults

to True.

Returns

-------

out : ndarray

Array of uninitialized (arbitrary) data with the same

shape and type as `a`.

See Also

--------

ones_like : Return an array of ones with shape and type of input.

zeros_like : Return an array of zeros with shape and type of input.

empty : Return a new uninitialized array.

ones : Return a new array setting values to one.

zeros : Return a new array setting values to zero.

Notes

-----

This function does *not* initialize the returned array; to do that use

`zeros_like` or `ones_like` instead. It may be marginally faster than

the functions that do set the array values.

Examples

--------

>>> a = ([1,2,3], [4,5,6]) # a is array-like

>>> np.empty_like(a)

array([[-1073741821, -1073741821, 3], #random

[ 0, 0, -1073741821]])

>>> a = np.array([[1., 2., 3.],[4.,5.,6.]])

>>> np.empty_like(a)

array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000],#random

[ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]])

""")

add_newdoc('numpy.core.multiarray', 'scalar',

"""

scalar(dtype, obj)

Return a new scalar array of the given type initialized with obj.

This function is meant mainly for pickle support. `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 as zeros for all other types.

""")

add_newdoc('numpy.core.multiarray', 'zeros',

"""

zeros(shape, dtype=float, order='C')

Return a new array of given shape and type, filled with zeros.

Parameters

----------

shape : int or sequence of ints

Shape of the new array, e.g., ``(2, 3)`` or ``2``.

dtype : data-type, optional

The desired data-type for the array, e.g., `numpy.int8`. Default is

`numpy.float64`.

order : {'C', 'F'}, optional

Whether to store multidimensional data in C- or Fortran-contiguous

(row- or column-wise) order in memory.

Returns

-------

out : ndarray

Array of zeros with the given shape, dtype, and order.

See Also

--------

zeros_like : Return an array of zeros with shape and type of input.

ones_like : Return an array of ones with shape and type of input.

empty_like : Return an empty array with shape and type of input.

ones : Return a new array setting values to one.

empty : Return a new uninitialized array.

Examples

--------

>>> np.zeros(5)

array([ 0., 0., 0., 0., 0.])

>>> np.zeros((5,), dtype=numpy.int)

array([0, 0, 0, 0, 0])

>>> np.zeros((2, 1))

array([[ 0.],

[ 0.]])

>>> s = (2,2)

>>> np.zeros(s)

array([[ 0., 0.],

[ 0., 0.]])

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype

array([(0, 0), (0, 0)],

dtype=[('x', '<i4'), ('y', '<i4')])

""")

add_newdoc('numpy.core.multiarray', 'count_nonzero',

"""

count_nonzero(a)

Counts the number of non-zero values in the array ``a``.

Parameters

----------

a : array_like

The array for which to count non-zeros.

Returns

-------

count : int or array of int

Number of non-zero values in the array.

See Also

--------

nonzero : Return the coordinates of all the non-zero values.

Examples

--------

>>> np.count_nonzero(np.eye(4))

4

>>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]])

5

""")

add_newdoc('numpy.core.multiarray', 'set_typeDict',

"""set_typeDict(dict)

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='')

A new 1-D array initialized from raw binary or text data in a string.

Parameters

----------

string : str

A string containing the data.

dtype : data-type, optional

The data type of the array; default: float. For binary input data,

the data must be in exactly this format.

count : int, optional

Read this number of `dtype` elements from the data. If this is

negative (the default), the count will be determined from the

length of the data.

sep : str, optional

If not provided or, equivalently, the empty string, the data will

be interpreted as binary data; otherwise, as ASCII text with

decimal numbers. Also in this latter case, this argument is

interpreted as the string separating numbers in the data; extra

whitespace between elements is also ignored.

Returns

-------

arr : ndarray

The constructed array.

Raises

------

ValueError

If the string is not the correct size to satisfy the requested

`dtype` and `count`.

See Also

--------

frombuffer, fromfile, fromiter

Examples

--------

>>> np.fromstring('\\x01\\x02', dtype=np.uint8)

array([1, 2], dtype=uint8)

>>> np.fromstring('1 2', dtype=int, sep=' ')

array([1, 2])

>>> np.fromstring('1, 2', dtype=int, sep=',')

array([1, 2])

>>> np.fromstring('\\x01\\x02\\x03\\x04\\x05', dtype=np.uint8, count=3)

array([1, 2, 3], dtype=uint8)

""")

add_newdoc('numpy.core.multiarray', 'fromiter',

"""

fromiter(iterable, dtype, count=-1)

Create a new 1-dimensional array from an iterable object.

Parameters