Adds documentation to obj which is in module place.

If doc is a string add it to obj as a docstring

If doc is a tuple, then the first element is interpreted as

an attribute of obj and the second as the docstring

(method, docstring)

If doc is a list, then each element of the list should be a

sequence of length two --> [(method1, docstring1), (method2, docstring2), ...]

This routine never raises an error.

Return the length of a Python object interpreted as an array of at least 1 dimension.

Blah, Blah.

Return true if all elements of x are true:

See Also:

ndarray.all : equivalent method

alltrue : equivalent function

Returns True if all components of a and b are equal subject to given tolerances.

Perform a logical_and over the given axis.

See Also:

ndarray.all : equivalent method

all : equivalent function

Return the maximum of 'a' along dimension axis.

Blah, Blah.

Return the minimum of a along dimension axis.

Blah, Blah.

Return true if any elements of x are true.

See Also:

ndarray.any : equivalent method

Apply a function repeatedly over multiple axes, keeping the same shape for the resulting array.

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.

Returns array of indices of the maximum values of along the given axis.

Parameters:

a : {array_like}

Array to look in.

axis : {None, integer}

If None, the index is into the flattened array, otherwise along the specified axis

Returns:

index_array : {integer_array}

Examples

>>> a = arange(6).reshape(2,3)
>>> argmax(a)
5
>>> argmax(a,0)
array([1, 1, 1])
>>> argmax(a,1)
array([2, 2])

Return array of indices to the minimum values along the given axis.

Parameters:

a : {array_like}

Array to look in.

axis : {None, integer}

If None, the index is into the flattened array, otherwise along the specified axis

Returns:

index_array : {integer_array}

Examples

>>> a = arange(6).reshape(2,3)
>>> argmin(a)
0
>>> argmin(a,0)
array([0, 0, 0])
>>> argmin(a,1)
array([0, 0])

Returns array of indices that index 'a' in sorted order.

Perform 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.

Parameters:

a : array

Array to be sorted.

axis : {None, int} optional

Axis along which to sort. None indicates that the flattened array should be used.

kind : {'quicksort', 'mergesort', 'heapsort'}, optional

Sorting algorithm to use.

order : {None, list type}, optional

When a is an array with fields defined, this argument specifies which fields to compare first, second, etc. Not all fields need be specified.

Returns:

index_array : {integer_array}

Array of indices that sort 'a' along the specified axis.

See Also:

lexsort : Indirect stable sort with multiple keys.

sort : Inplace sort.

Notes

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

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.

Round a to the given number of decimals.

The real and imaginary parts of complex numbers are rounded separately. The result of rounding a float is a float so the type must be cast if integers are desired. Nothing is done if the input is an integer array and the decimals parameter has a value >= 0.

Parameters:

a : {array_like}

Array containing numbers whose rounded values are desired. If a is not an array, a conversion is attempted.

decimals : {0, int}, optional

Number of decimal places to round to. When decimals is negative it specifies the number of positions to the left of the decimal point.

out : {None, array}, optional

Alternative output array in which to place the result. It must have the same shape as the expected output but the type will be cast if necessary. Numpy rounds floats to floats by default.

Returns:

rounded_array : {array}

If out=None, returns a new array of the same type as a containing the rounded values, otherwise a reference to the output array is returned.

See Also:

round_ : equivalent function

ndarray.round : equivalent method

Notes

Numpy rounds to even. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round to 0.0, etc. Results may also be surprising due to the inexact representation of decimal fractions in IEEE floating point and the errors introduced when scaling by powers of ten.

Examples

>>> around([.5, 1.5, 2.5, 3.5, 4.5])
array([ 0.,  2.,  2.,  4.,  4.])
>>> around([1,2,3,11], decimals=1)
array([ 1,  2,  3, 11])
>>> around([1,2,3,11], decimals=-1)
array([ 0,  0,  0, 10])

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.

Return a string representation of an array.

>>> x = N.array([1e-16,1,2,3])
>>> print array2string(x,precision=2,separator=',',suppress_small=True)
[ 0., 1., 2., 3.]

Divide an array into a list of sub-arrays.

Description:
   Divide ary into a list of sub-arrays along the
   specified axis.  If indices_or_sections is an integer,
   ary is divided into that many equally sized arrays.
   If it is impossible to make an equal split, each of the
   leading arrays in the list have one additional member.  If
   indices_or_sections is a list of sorted integers, its
   entries define the indexes where ary is split.

Arguments:
   ary -- N-D array.
      Array to be divided into sub-arrays.
   indices_or_sections -- integer or 1D array.
      If integer, defines the number of (close to) equal sized
      sub-arrays.  If it is a 1D array of sorted indices, it
      defines the indexes at which ary is divided.  Any empty
      list results in a single sub-array equal to the original
      array.
   axis -- integer. default=0.
      Specifies the axis along which to split ary.
Caveats:
   Currently, the default for axis is 0.  This
   means a 2D array is divided into multiple groups
   of rows.  This seems like the appropriate default,

Returns a as an array.

Force a sequence of arrays to each be at least 1D.

Description:
   Force an array to be at least 1D.  If an array is 0D, the
   array is converted to a single row of values.  Otherwise,
   the array is unaltered.
Arguments:
   *arys -- arrays to be converted to 1 or more dimensional array.
Returns:
   input array converted to at least 1D array.

Force a sequence of arrays to each be at least 2D.

Description:
   Force an array to each be at least 2D.  If the array
   is 0D or 1D, the array is converted to a single
   row of values.  Otherwise, the array is unaltered.
Arguments:
   arys -- arrays to be converted to 2 or more dimensional array.
Returns:
   input array converted to at least 2D array.

Force a sequence of arrays to each be at least 3D.

Description:
   Force an array each be at least 3D.  If the array is 0D or 1D,
   the array is converted to a single 1xNx1 array of values where
   N is the orginal length of the array. If the array is 2D, the
   array is converted to a single MxNx1 array of values where MxN
   is the orginal shape of the array. Otherwise, the array is
   unaltered.
Arguments:
   arys -- arrays to be converted to 3 or more dimensional array.
Returns:
   input array converted to at least 3D array.

Average the array over the given axis. If the axis is None, average over all dimensions of the array. Equivalent to a.mean(axis) and to

a.sum(axis) / size(a, axis)

If weights are given, result is:

sum(a * weights,axis) / sum(weights,axis),

where the weights must have a's shape or be 1D with length the size of a in the given axis. Integer weights are converted to Float. Not specifying weights is equivalent to specifying weights that are all 1.

If 'returned' is True, return a tuple: the result and the sum of the weights or count of values. The shape of these two results will be the same.

Raises ZeroDivisionError if appropriate. (The version in MA does not -- it returns masked values).

Return the representation of a number in the given base.

Return the binary representation of the input number as a string.

This is equivalent to using base_repr with base 2, but about 25x faster.

Return the number of occurrences of each value in x.

x must be a list of non-negative integers. The output, b[i], represents the number of times that i is found in x. If weights is specified, every occurrence of i at a position p contributes weights[p] instead of 1.

Build a matrix object from string, nested sequence, or array.

Ex:  F = bmat('A, B; C, D')
     F = bmat([[A,B],[C,D]])
     F = bmat(r_[c_[A,B],c_[C,D]])

    all produce the same Matrix Object    [ A  B ]
                                          [ C  D ]

    if A, B, C, and D are appropriately shaped 2-d arrays.

(low, high) are pointers to the end-points of an array

low is the first byte high is just *past* the last byte

If the array is not single-segment, then it may not actually use every byte between these bounds.

Use an index array to construct a new array from a set of choices.

Given an array of integers in {0, 1, ..., n-1} and a set of n choice arrays, this function will create a new array that merges each of the choice arrays. Where a value in a is i, then the new array will have the value that choices[i] contains in the same place.

Parameters:

a : int array

This array must contain integers in [0, n-1], where n is the number of choices.

choices : sequence of arrays

Each of the choice arrays should have the same shape as the index array.

out : array, optional

If provided, the result will be inserted into this array. It should be of the appropriate shape and dtype

mode : {'raise', 'wrap', 'clip'}, optional

Specifies how out-of-bounds indices will behave. 'raise' : raise an error 'wrap' : wrap around 'clip' : clip to the range

Returns:

merged_array : array

See Also:

ndarray.choose : equivalent method

Examples

>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
...   [20, 21, 22, 23], [30, 31, 32, 33]]
>>> choose([2, 3, 1, 0], choices)
array([20, 31, 12,  3])
>>> choose([2, 4, 1, 0], choices, mode='clip')
array([20, 31, 12,  3])
>>> choose([2, 4, 1, 0], choices, mode='wrap')
array([20,  1, 12,  3])

Limit the values of a to [a_min, a_max]. Equivalent to

a[a < a_min] = a_min a[a > a_max] = a_max

Stack 1D arrays as columns into a 2D array

Description:
    Take a sequence of 1D arrays and stack them as columns
    to make a single 2D array.  All arrays in the sequence
    must have the same first dimension.  2D arrays are
    stacked as-is, just like with hstack.  1D arrays are turned
    into 2D columns first.

Arguments:
    tup -- sequence of 1D or 2D arrays.  All arrays must have the same
           first dimension.
Examples:
    >>> import numpy
    >>> a = array((1,2,3))
    >>> b = array((2,3,4))
    >>> numpy.column_stack((a,b))
    array([[1, 2],
           [2, 3],
           [3, 4]])

Given a sequence of arrays as arguments, return the best inexact scalar type which is "most" common amongst them.

Return a where condition is true.

Equivalent to a[condition].

concatenate((a1, a2, ...), axis=0)

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.

>>> concatenate( ([0,1,2], [5,6,7]) )
array([0, 1, 2, 5, 6, 7])

Estimate the covariance matrix.

If m is a vector, return the variance. For matrices return the covariance matrix.

If y is given it is treated as an additional (set of) variable(s).

Normalization is by (N-1) where N is the number of observations (unbiased estimate). If bias is 1 then normalization is by N.

If rowvar is non-zero (default), then each row is a variable with observations in the columns, otherwise each column is a variable and the observations are in the rows.

Return the cross product of two (arrays of) vectors.

Return the cumulative product of the elements along the given axis.

Blah, Blah.

Return the cumulative product over the given axis.

Blah, Blah.

Sum the array over the given axis.

Blah, Blah.

Return a new array with sub-arrays along an axis deleted.

Return a new array with the sub-arrays (i.e. rows or columns) deleted along the given axis as specified by obj

obj may be a slice_object (s_[3:5:2]) or an integer or an array of integers indicated which sub-arrays to remove.

If axis is None, then ravel the array first.

Example: >>> arr = [[3,4,5], ... [1,2,3], ... [6,7,8]]

>>> delete(arr, 1, 1)
array([[3, 5],
       [1, 3],
       [6, 8]])
>>> delete(arr, 1, 0)
array([[3, 4, 5],
       [6, 7, 8]])

Return specified diagonals.

If a is 2-d, returns the diagonal of self with the given offset, i.e., the collection of elements of the form a[i,i+offset]. If a has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-d subarray whose diagonal is returned. The shape of the resulting array can be determined by removing axis1 and axis2 and appending an index to the right equal to the size of the resulting diagonals.

Parameters:

a : {array_like}

Array from whis the diagonals are taken.

offset : {0, integer}, optional

Offset of the diagonal from the main diagonal. Can be both positive and negative. Defaults to main diagonal.

axis1 : {0, integer}, optional

Axis to be used as the first axis of the 2-d subarrays from which the diagonals should be taken. Defaults to first axis.

axis2 : {1, integer}, optional

Axis to be used as the second axis of the 2-d subarrays from which the diagonals should be taken. Defaults to second axis.

Returns:

array_of_diagonals : array of same type as a

If a is 2-d, a 1-d array containing the diagonal is returned. If a has larger dimensions, then an array of diagonals is returned.

See Also:

diag : Matlab workalike for 1-d and 2-d arrays.

diagflat : Create diagonal arrays.

trace : Sum along diagonals.

Examples

>>> a = arange(4).reshape(2,2)
>>> a
array([[0, 1],
       [2, 3]])
>>> a.diagonal()
array([0, 3])
>>> a.diagonal(1)
array([1])

>>> a = arange(8).reshape(2,2,2)
>>> a
array([[[0, 1],
        [2, 3]],
       [[4, 5],
        [6, 7]]])
>>> a.diagonal(0,-2,-1)
array([[0, 3],
       [4, 7]])

Return the index of the bin to which each value of x belongs.

Each index i returned is such that bins[i-1] <= x < bins[i] if bins is monotonically increasing, or bins [i-1] > x >= bins[i] if bins is monotonically decreasing.

Split ary into multiple sub-arrays along the 3rd axis (depth)

Description:
    Split a single array into multiple sub arrays.  The array is
    divided into groups along the 3rd axis.  If indices_or_sections is
    an integer, ary is divided into that many equally sized sub arrays.
    If it is impossible to make the sub-arrays equally sized, the
    operation throws a ValueError exception. See array_split and
    split for other options on indices_or_sections.
Arguments:
   ary -- N-D array.
      Array to be divided into sub-arrays.
   indices_or_sections -- integer or 1D array.
      If integer, defines the number of (close to) equal sized
      sub-arrays.  If it is a 1D array of sorted indices, it
      defines the indexes at which ary is divided.  Any empty
      list results in a single sub-array equal to the original
      array.
Returns:
    sequence of sub-arrays.  The returned arrays have the same
    number of dimensions as the input array.
Caveats:
   See vsplit caveats.
Related:
    dstack, split, array_split, hsplit, vsplit.
Examples:
    >>> a = array([[[1,2,3,4],[1,2,3,4]]])
    >>> dsplit(a,2)
    [array([[[1, 2],
            [1, 2]]]), array([[[3, 4],
            [3, 4]]])]

Stack arrays in sequence depth wise (along third dimension)

Description:
    Take a sequence of arrays and stack them along the third axis.
    All arrays in the sequence must have the same shape along all
    but the third axis.  This is a simple way to stack 2D arrays
    (images) into a single 3D array for processing.
    dstack will rebuild arrays divided by dsplit.
Arguments:
    tup -- sequence of arrays.  All arrays must have the same
           shape.
Examples:
    >>> import numpy
    >>> a = array((1,2,3))
    >>> b = array((2,3,4))
    >>> numpy.dstack((a,b))
    array([[[1, 2],
            [2, 3],
            [3, 4]]])
    >>> a = array([[1],[2],[3]])
    >>> b = array([[2],[3],[4]])
    >>> numpy.dstack((a,b))
    array([[[1, 2]],
    <BLANKLINE>
           [[2, 3]],
    <BLANKLINE>
           [[3, 4]]])

The differences between consecutive elements of an array, possibly with prefixed and/or appended values.

• `ary` : array This array will be flattened before the difference is taken.
• `to_end` : number, optional If provided, this number will be tacked onto the end of the returned differences.
• `to_begin` : number, optional If provided, this number will be taked onto the beginning of the returned differences.

• `ed` : array The differences. Loosely, this will be (ary[1:] - ary[:-1]).

empty((d1,...,dn),dtype=float,order='C')

Return an empty (uninitialized) array of the shape and typecode of a.

Return the elements of ravel(arr) where ravel(condition) is True (in 1D).

Equivalent to compress(ravel(condition), ravel(arr)).

Return indicies that are not-zero in flattened version of a

Required arguments:
    file -- open file object or string containing file name.

Keyword arguments:
    dtype -- type and order of the returned array (default float)
    count -- number of items to input (default all)
    sep -- separater between items if file is a text file (default "")

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 the entire file is read, otherwise count is the
number of items of the given type to read in.  If 'sep' is "" it means to
read binary data from the file using the specified dtype, otherwise it gives
the separator between elements in a text file. The 'dtype' value is also
used to determine the size and order of the items in binary files.


Data written using the tofile() method can be conveniently recovered using
this function.

WARNING: This function should be used sparingly as the binary files are not
platform independent. In particular, they contain no endianess or datatype
information. Nevertheless it can be useful for reading in simply formatted
or binary data quickly.

Returns:

array

Returns an array constructed by calling a function on a tuple of number grids.

The function should accept as many arguments as the length of shape and work on array inputs. The shape argument is a sequence of numbers indicating the length of the desired output for each axis.

Return a new 1d array initialized from the raw binary data in string.

Find the wrapper for the array with the highest priority.

Return the directory in the package that contains the numpy/*.h header
files.

Extension modules that need to compile against numpy should use this
function to locate the appropriate include directory. Using distutils:

  import numpy
  Extension('extension_name', ...
            include_dirs=[numpy.get_include()])

Return the directory in the package that contains the numpy/*.h header
files.

Extension modules that need to compile against numpy should use this
function to locate the appropriate include directory. Using distutils:

  import numpy
  Extension('extension_name', ...
            include_dirs=[numpy.get_numarray_include()])

get_numpy_include is DEPRECATED in numpy: use get_include instead
Return the directory in the package that contains the numpy/*.h header
    files.

    Extension modules that need to compile against numpy should use this
    function to locate the appropriate include directory. Using distutils:

      import numpy
      Extension('extension_name', ...
                include_dirs=[numpy.get_include()])
    

Returns:

dictionary of current print options with keys - precision : int - threshold : int - edgeitems : int - linewidth : int - suppress : bool - nanstr : string - infstr : string

Get the current way of handling floating-point errors.

Calculate the gradient of an N-dimensional scalar function.

Uses central differences on the interior and first differences on boundaries to give the same shape.

Inputs:

f -- An N-dimensional array giving samples of a scalar function

varargs -- 0, 1, or N scalars giving the sample distances in each direction

Outputs:

N arrays of the same shape as f giving the derivative of f with respect to each dimension.

Compute the histogram from a set of data.

Parameters:

a : array

The data to histogram. n-D arrays will be flattened.

bins : int or sequence of floats

If an int, then the number of equal-width bins in the given range. Otherwise, a sequence of the lower bound of each bin.

range : (float, float)

The lower and upper range of the bins. If not provided, then (a.min(), a.max()) is used. Values outside of this range are allocated to the closest bin.

normed : bool

If False, the result array will contain the number of samples in each bin. If True, the result array is the value of the probability density function at the bin normalized such that the integral over the range is 1. Note that the sum of all of the histogram values will not usually be 1; it is not a probability mass function.

Returns:

hist : array

The values of the histogram. See normed for a description of the possible semantics.

lower_edges : float array

The lower edges of each bin.

SeeAlso:

histogramdd

Compute the 2D histogram from samples x,y.

• `x,y` : Sample arrays (1D).
• `bins` : Number of bins -or- [nbin x, nbin y] -or- [bin edges] -or- [x bin edges, y bin edges].
• `range` : A sequence of lower and upper bin edges (default: [min, max]).
• `normed` : Boolean, if False, return the number of samples in each bin, if True, returns the density.
• `weights` : An array of weights. The weights are normed only if normed is True. Should weights.sum() not equal N, the total bin count will not be equal to the number of samples.

• `hist` : Histogram array.
• `xedges, yedges` : Arrays defining the bin edges.

>>> x = random.randn(100,2)
>>> hist2d, xedges, yedges = histogram2d(x, bins = (6, 7))

Returns:

H, xedges, yedges

Return the N-dimensional histogram of the sample.

Parameters:

sample : sequence or array

A sequence containing N arrays or an NxM array. Input data.

bins : sequence or scalar

A sequence of edge arrays, a sequence of bin counts, or a scalar which is the bin count for all dimensions. Default is 10.

range : sequence

A sequence of lower and upper bin edges. Default is [min, max].

normed : boolean

If False, return the number of samples in each bin, if True, returns the density.

weights : array

Array of weights. The weights are normed only if normed is True. Should the sum of the weights not equal N, the total bin count will not be equal to the number of samples.

Returns:

hist : array

Histogram array.

edges : list

List of arrays defining the lower bin edges.

SeeAlso:

histogram

Example

>>> x = random.randn(100,3)
>>> hist3d, edges = histogramdd(x, bins = (5, 6, 7))

Split ary into multiple columns of sub-arrays

Description:
    Split a single array into multiple sub arrays.  The array is
    divided into groups of columns.  If indices_or_sections is
    an integer, ary is divided into that many equally sized sub arrays.
    If it is impossible to make the sub-arrays equally sized, the
    operation throws a ValueError exception. See array_split and
    split for other options on indices_or_sections.
Arguments:
   ary -- N-D array.
      Array to be divided into sub-arrays.
   indices_or_sections -- integer or 1D array.
      If integer, defines the number of (close to) equal sized
      sub-arrays.  If it is a 1D array of sorted indices, it
      defines the indexes at which ary is divided.  Any empty
      list results in a single sub-array equal to the original
      array.
Returns:
    sequence of sub-arrays.  The returned arrays have the same
    number of dimensions as the input array.
Related:
    hstack, split, array_split, vsplit, dsplit.
Examples:
    >>> import numpy
    >>> a= array((1,2,3,4))
    >>> numpy.hsplit(a,2)
    [array([1, 2]), array([3, 4])]
    >>> a = array([[1,2,3,4],[1,2,3,4]])
    >>> hsplit(a,2)
    [array([[1, 2],
           [1, 2]]), array([[3, 4],
           [3, 4]])]

Stack arrays in sequence horizontally (column wise)

Description:
    Take a sequence of arrays and stack them horizontally
    to make a single array.  All arrays in the sequence
    must have the same shape along all but the second axis.
    hstack will rebuild arrays divided by hsplit.
Arguments:
    tup -- sequence of arrays.  All arrays must have the same
           shape.
Examples:
    >>> import numpy
    >>> a = array((1,2,3))
    >>> b = array((2,3,4))
    >>> numpy.hstack((a,b))
    array([1, 2, 3, 2, 3, 4])
    >>> a = array([[1],[2],[3]])
    >>> b = array([[2],[3],[4]])
    >>> numpy.hstack((a,b))
    array([[1, 2],
           [2, 3],
           [3, 4]])

Returns the identity 2-d array of shape n x n.

identity(n)[i,j] == 1 for all i == j
                 == 0 for all i != j

Return the imaginary part of val.

Get help information for a function, class, or module.

Example:
   >>> from numpy import *
   >>> info(polyval) # doctest: +SKIP

   polyval(p, x)

     Evaluate the polymnomial p at x.

     Description:
         If p is of length N, this function returns the value:
         p[0]*(x**N-1) + p[1]*(x**N-2) + ... + p[N-2]*x + p[N-1]

Return a new array with values inserted along the given axis before the given indices

If axis is None, then ravel the array first.

The obj argument can be an integer, a slice, or a sequence of integers.

Example: >>> a = array([[1,2,3], ... [4,5,6], ... [7,8,9]])

>>> insert(a, [1,2], [[4],[5]], axis=0)
array([[1, 2, 3],
       [4, 4, 4],
       [4, 5, 6],
       [5, 5, 5],
       [7, 8, 9]])

Return the value of a piecewise-linear function at each value in x.

The piecewise-linear function, f, is defined by the known data-points fp=f(xp). The xp points must be sorted in increasing order but this is not checked.

Intersection of 1D arrays with unique elements.

Use unique1d() to generate arrays with only unique elements to use as inputs
to this function. Alternatively, use intersect1d_nu() which will find the
unique values for you.

:Parameters:
  - `ar1` : array
  - `ar2` : array

:Returns:
  - `intersection` : array

:See also:
  numpy.lib.arraysetops has a number of other functions for performing set
  operations on arrays.

Intersection of 1D arrays with any elements.

The input arrays do not have unique elements like intersect1d() requires.

:Parameters:
  - `ar1` : array
  - `ar2` : array

:Returns:
  - `intersection` : array

:See also:
  numpy.lib.arraysetops has a number of other functions for performing set
  operations on arrays.

Return a boolean array where elements are True if that element is complex (has non-zero imaginary part).

Return True if x is a complex type or an array of complex numbers.

Return a boolean array y with y[i] True for x[i] = -Inf.

Return a boolean array y with y[i] True for x[i] = +Inf.

Return a boolean array where elements are True if that element is real (has zero imaginary part)

Return True if x is not a complex type.

Construct an open mesh from multiple sequences.

This function takes n 1-d sequences and returns n outputs with n dimensions each such that the shape is 1 in all but one dimension and the dimension with the non-unit shape value cycles through all n dimensions.

Using ix_() one can quickly construct index arrays that will index the cross product.

a[ix_([1,3,7],[2,5,8])] returns the array

kronecker product of a and b

Kronecker product of two arrays is block array
[[ a[ 0 ,0]*b, a[ 0 ,1]*b, ... , a[ 0 ,n-1]*b  ],
 [ ...                                   ...   ],
 [ a[m-1,0]*b, a[m-1,1]*b, ... , a[m-1,n-1]*b  ]]

Argsort with list of keys.

Perform an indirect sort using a list of keys. The first key is sorted,
then the second, and so on through the list of keys. At each step the
previous order is preserved when equal keys are encountered. 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 last key being
used for the primary sort order, the second-to-last key for the secondary
sort order, and so on).  The keys argument must be a sequence of things
that can be converted to arrays of the same shape.

Parameters:

    a : array type
        Array containing values that the returned indices should sort.

    axis : integer
        Axis to be indirectly sorted. None indicates that the flattened
        array should be used. Default is -1.

Returns:

    indices : integer array
        Array of indices that sort the keys along the specified axis. The
        array has the same shape as the keys.

SeeAlso:

    argsort : indirect sort
    sort : inplace sort

Returns:

array of indices

Return evenly spaced numbers.

Return num evenly spaced samples from start to stop. If endpoint is True, the last sample is stop. If retstep is True then return (seq, step_value), where step_value used.

Parameters:

• start ({float}) - The value the sequence starts at.
• stop ({float}) - The value the sequence stops at. If endpoint is false, then this is not included in the sequence. Otherwise it is guaranteed to be the last value.
• num ({integer}) - Number of samples to generate. Default is 50.
• endpoint ({boolean}) - If true, stop is the last sample. Otherwise, it is not included. Default is true.
• retstep ({boolean}) - If true, return (samples, step), where step is the spacing used in generating the samples.

Returns:

samples : {array}

num equally spaced samples from the range [start, stop] or [start, stop).

step : {float} (Only if retstep is true)

Size of spacing between samples.

Load ASCII data from fname into an array and return the array.

The data must be regular, same number of values in every row

fname can be a filename or a file handle.  Support for gzipped files is
automatic, if the filename ends in .gz

See scipy.loadmat to read and write matfiles.

Example usage:

  X = loadtxt('test.dat')  # data in two columns
  t = X[:,0]
  y = X[:,1]

Alternatively, you can do the same with "unpack"; see below

  X = loadtxt('test.dat')    # a matrix of data
  x = loadtxt('test.dat')    # a single column of data


dtype - the data-type of the resulting array.  If this is a
record data-type, the the resulting array will be 1-d and each row will
be interpreted as an element of the array. The number of columns
used must match the number of fields in the data-type in this case.

comments - the character used to indicate the start of a comment
in the file

delimiter is a string-like character used to seperate values in the
file. If delimiter is unspecified or none, any whitespace string is
a separator.

converters, if not None, is a dictionary mapping column number to
a function that will convert that column to a float.  Eg, if
column 0 is a date string: converters={0:datestr2num}

skiprows is the number of rows from the top to skip

usecols, if not None, is a sequence of integer column indexes to
extract where 0 is the first column, eg usecols=(1,4,5) to extract
just the 2nd, 5th and 6th columns

unpack, if True, will transpose the matrix allowing you to unpack
into named arguments on the left hand side

    t,y = load('test.dat', unpack=True) # for  two column data
    x,y,z = load('somefile.dat', usecols=(3,5,7), unpack=True)

Returns the base 2 logarithm of x

Evenly spaced numbers on a logarithmic scale.

Computes int(num) evenly spaced exponents from base**start to base**stop. If endpoint=True, then last number is base**stop

Determine if two arrays can share memory

The memory-bounds of a and b are computed. If they overlap then this function returns True. Otherwise, it returns False.

Compute the mean along the specified axis.

Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. The dtype returned for integer type arrays is float

Parameters:

a : {array_like}

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axis : {None, integer}, optional

Axis along which the means are computed. The default is to compute the standard deviation of the flattened array.

dtype : {None, dtype}, optional

Type to use in computing the means. For arrays of integer type the default is float32, for arrays of float types it is the same as the array type.

out : {None, array}, optional

Alternative output array in which to place the result. It must have the same shape as the expected output but the type will be cast if necessary.

Returns:

mean : {array, scalar}, see dtype parameter above

If out=None, returns a new array containing the mean values, otherwise a reference to the output array is returned.

See Also:

var : Variance

std : Standard deviation

Notes