arrays

datatype of the elements of a
Examples:

>>> array((1,2)).dtype, array((1.,2.)).dtype, array((1+2j,0+0j)).dtype
(dtype('<i4'), dtype('<f8'), dtype('<c16'))

See also: a.astype(), function typename
Corresponding function: none

Gives properties:

>>> array([[1,2,3],[4,5,6]]).flags
  CONTIGUOUS : True
  FORTRAN : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

Corresponding method: none

gives a flattened view (one-dim) of a. The array is not copied.
Example:

>>> a=array([[1,2,3],[4,5,6]])
>>> for i in range(a.size): print a.flat[i],

1 2 3 4 5 6

See also: a.flatten()

The array of imaginary values of array a. Works also if a is not complex.

>>> a=array((1., 2.j))
>>> print a
[ 1.+0.j 0.+2.j]
>>> print a.imag
[ 0. 2.]

See also: a.real
Corresponding function: imag

gives size in bytes of each array element
Example:

>>> array([[1,2,3],[4,5,6]]).itemsize
4

Total nr of bytes occupied by a.
a.nbytes = a.size * a.itemsize
Example:

>>> array([[1,2,3],[4,5,6]]).nbytes
24

number of dimensions of a
Example:

>>> array([[1,2,3],[4,5,6]]).ndim
2

Corresponding function: ndim

The array of real values of a complex array.

>>> a=array((1., 2.j))
>>> print a
[ 1.+0.j 0.+2.j]
>>> print a.real
[ 1. 0.]

See also: a.imag
Corresponding function: real

Gives the shape of a. The shape is a tuple listing the number of elements along each dimension. A dimension is called an axis . Axis=0 is the outermost bracket, axis=1,2, .. go successively inward. For a 2-dim array or a matrix, axis=0 specifies the rows; axis=1 specifies the columns.
One may also redefine the shape (see example).
Example:

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

See also: method a.reshape() ; function reshape

Gives the total number of elements in the array.
a.size = product(a.shape)
Example:

>>> array([[1,2,3],[4,5,6]]).size
6

Corresponding function: size

Gives the number of bytes that are skipped (in the contiguous mapping of the array in memory) when the index is increased by one. For a multidimensional array there is an index for each axis, and the result is a tuple.
Example:

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

Returns True if all elements of a along the specified axis are true. If axis=None (default) True is returned if all elements of a are true.

>>> a=array([[True,False],[True,True]])
>>> a.all()
False
>>> a.all(0)
array([True, False], dtype=bool)

See also: a.any()
Corresponding function: all

Returns True if any element of a along the specified axis is true. If axis=None (default) True is returned if any element of a is true.

>>> a=array([[True,False],[True,True]])
>>> a.any()
True
>>> a.any(0)
array([True, True], dtype=bool)

See also: a.all()
Corresponding function: any

Returns the indices to the maximum value of the 1-D arrays along the given axis. Axis=None returns the index of the maximum value in the flattened version of the whole array a.
Example:

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

See also: a.argmin(), a.argsort()
Corresponding function: argmax()

Returns the indices to the minimum value of the 1-D arrays along the given axis. Axis=None returns the index of the minimum value in the flattened version of the whole array a.
Example:

>>> a
array([[3, 6, 2],
[5, 1, 4]])
>>> a.argmin(0)
array([0, 1, 0])
>>> a.argmin(1)
array([2, 1])
>>> a.argmin()
4

See also: a.argmax(), a.argsort()
Corresponding function: argmin

Returns array of indexes of the elements along the specified axis, sorted with the specified kind of sorting routine.
Examples:

>>> a=array([[1,4],[3,2]])
>>> print a
[[1 4]
[3 2]]
>>> print a.argsort()
[[0 1]
[1 0]]

See also: a.argmin(), a.argmax()
Corresponding function: argsort

Casts array a as type t. Many type names are allowed, such as bool, int, integer, long, float, complex, but also int8, int64, '<f8', etc.
Example

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

Corresponding function: asarray, array

Swaps the bytes in the array. Returns the byteswapped array. If the first argument is TRUE, byteswap in-place and return a reference to self.

Corresponding function: None

Returns 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 in range(n+1).
Example:

>>> b0=array((1,2))
>>> b1=array((3,4))
>>> array((0,1)).choose(b0,b1)
array([1, 4])
>>> array((1,0)).choose(b0,b1)
array([3, 2])
>>> array((1,1)).choose(b0,b1)
array([3, 4])

Corresponding function: choose

Every entry in a that is less than min is replaced by min, and every entry greater than max is replaced by max.
Example

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

Corresponding function: clip

Those elements of a corresponding to those elements of condition that are True. condition must be a 1-d array or sequence with the same size as the given dimension of a. For axis=None (default) condition works on the flattened version of a and produces a 1d array. The corresponding function compress has default axis=-1.
Examples:

>>> print a
[[1 2 3]
[4 5 6]]
>>> cond=array([True,True,True,True,False,False])
>>> a.compress(cond)
array([1, 2, 3, 4])
>>> print a.compress((True,True,False),-1)
[[1 2]
[4 5]]

Corresponding function: compress

Returns the complex conjugate of a.
Example:

>>> print c
[[ 1.+1.j 2.+2.j]
[ 3.+3.j 4.+4.j]]
>>> print c.conj()
[[ 1.-1.j 2.-2.j]
[ 3.-3.j 4.-4.j]]

Equivalent method: a.conjugate()
Corresponding function: None

Equivalent to method a.conj().

Equivalent method: a.conj()
Corresponding function None

Returns a copy of the array.
If order is 'C' (False), which is the default, then the result is contiguous in memory with the inner axis=-1 filling sequential locations. If order is 'Fortran' (True) then the result has fortran order. If order is 'Any' (None) then the result has fortran order only if a is already in fortran order. The corresponding function copy has no argument to change the order, but can also take sequences as argument.
Example:

>>> a=array([[1,2,3],[4,5,6]])
>>> a.flags
CONTIGUOUS : True
FORTRAN : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
>>> a.copy('Fortran').flags
CONTIGUOUS : False
FORTRAN : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False

Corresponding function: copy

Returns the cumulative products of the elements along the given axis.
If axis=None (default), the cumulative product is taken over the flattened version of a: a.cumprod() = a.flatten().cumprod().
Examples:

>>>array((2,3,4,5)).cumprod()
array([ 2, 6, 24, 120])
>>> a=array([[2,3],[4,5]])
>>> print a
[[2 3]
[4 5]]
>>> print a.cumprod()
[ 2 6 24 120]
>>> print a.cumprod(0)
[[ 2 3]
[ 8 15]]
>>> print a.cumprod(1)
[[ 2 6]
[ 4 20]]

See also: a.cumsum(), a.prod(), a.sum()
Corresponding function: cumprod

Returns the cumulative sum of the elements along the given axis.
If axis=None (default), the cumulative sum is taken over the flattened version of a: a.cumsum() = a.flatten().cumsum().
Examples:

>>>array((2,3,4,5)).cumsum()
array([ 2, 5, 9, 14])
>>> a=array([[2,3],[4,5]])
>>> print a
[[2 3]
[4 5]]
>>> print a.cumsum()
[ 2 5 9 14]
>>> print a.cumsum(0)
[[ 2 3]
[ 6 8]]
>>> print a.cumsum(1)
[[ 2 5]
[ 4 9]]

See also: a.cumprod(), a.prod(), a.sum()
Corresponding function: cumsum

Returns the given diagonals defined by the last two dimensions of the array.
Example:

>>> print a
[[1 2 3]
[4 5 6]
[7 8 9]]
>>> print a.diagonal()
[1 5 9]
>>> print a.diagonal(1)
[2 6]

Corresponding function: diagonal

Places the scalar value at every position in the array.

Returns a 1-d array (always copy)

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.

Copies the first data point of the array to a standard Python scalar and returns it.

Returns the maximum of 'a' along dimension axis. If axis=None (default), the maximum over the whole array is returned.
Example:

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

See also: a.min()
Corresponding function: amax(a,0)

Averages 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 / a.shape[axis]
If axis is None, this equals:
a.sum(axis, dtype) * 1.0 / product(a.shape)
The optional dtype argument is the data type for intermediate calculations in the sum.
Example:

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

Returns the minimum of 'a' along dimension axis. If axis=None (default), the minimum over the whole array is returned.
Example:

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

See also: a.max()
Corresponding method: amin(a) =a.min(0)

Equivalent to a.view(a.dtype.newbytorder(<byteorder>))

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.

Example: a 2-d array with 3 non-zero elements at a(0,2), a(1,0) and a(1,1):

>>> print a
[[0 0 2]
[3 4 0]]
>>> a.nonzero()
(array([0, 1, 1]), array([2, 0, 1]))
>>> print a[a.nonzero()]
[2 3 4]
>>> print transpose(a.nonzero())
[[0 2]
[1 0]
[1 1]]

Returns the product of the elements along the given axis. If axis=None, the product of all elements of a is returned (a scalar).
Example:

>>> a
array([[1, 4],
[3, 2]])
>>> a.prod()
24
>>> a.prod(0)
array([3, 8])
>>> a.prod(1)
array([4, 6])

See also: cumprod, cumproduct, cumsum, product, sum
Corresponding function: prod, product()

a.ptp(axis)= a.max(axis)-a.min(axis)

Sets a.flat[n] = v[n] for each n in indices. v can be scalar or shorter than indices, will repeat.
Examples:

>>> a=zeros((2,3))
>>> print a
[[ 0. 0. 0.]
[ 0. 0. 0.]]
>>> a.put([1.,2.,3.],[0,2,4])
>>> print a
[[ 1. 0. 2.]
[ 0. 3. 0.]]
>>> a.put([1.,2.],range(6))
>>> print a
[[ 1. 2. 1.]
[ 2. 1. 2.]]

See also: a.putmask()
Corresponding function: put

Sets a.flat[n] = values[n] for each n where mask.flat[n] is True. v can be scalar.
Example

>>> a=zeros((2,3))
>>> print a
[[ 0. 0. 0.]
[ 0. 0. 0.]]
>>> mask=array([[1,0,1],[1,0,1]])
>>> a.putmask([2.],mask)
>>> print a
[[ 2. 0. 2.]
[ 2. 0. 2.]]

See also: a.put()
Corresponding function: putmask

Return a 1-d array (copy only if needed)

Copies elements of a, repeats times. The repeats argument must be a sequence of length a.shape[axis] or a scalar. In the case of a scalar with axis=None (default), a flat array is returned.
Examples:

>>> print a
[[1 2 3]
[4 5 6]]
>>> print a.repeat(2)
[1 1 2 2 3 3 4 4 5 5 6 6]
>>> print a.repeat(2,0)
[[1 2 3]
[1 2 3]
[4 5 6]
[4 5 6]]
>>> print a.repeat(2,1)
[[1 1 2 2 3 3]
[4 4 5 5 6 6]]

Corresponding function: repeat

Returns a new array from this one.
The new array must have the same number of elements as a. Always returns a view or raises a ValueError if that is impossible.
The inputs d1, d2, ..., dn mat also be arranged as tuple (d1, d2, ..., dn).
Example:

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

See also: attribute .shape ; method .resize()
Corresponding function: reshape

Changes size and shape of self inplace. Fills with zeros if the new size exceeds the size of a. Note: The function resize in that case fills with repeats of a.
Array must own its own memory and not be referenced by other arrays.
Returns None.
Example:

>>> print a
[[1 2 3]
[4 5 6]]
>>> a.resize(3,4)
>>> print a
[[1 2 3 4]
[5 6 0 0]
[0 0 0 0]]
>>> print a.resize(3,4)
None

See also: .reshape()
Corresponding function: resize

Rounds array a to the given number of decimal places. Rounding behaviour is equivalent to Python.
Returns 'a' if the array is not floating point. Rounds both the real and imaginary parts separately if the array is complex.
Example:

>>> a=pi*arange(5)
>>> print a.round(2)
[ 0. 3.14 6.28 9.42 12.57]

Corresponding functions: around, round_

Assuming that a is a 1-D array, in ascending order and represents bin boundaries, then a.searchsorted(values) gives an array of bin numbers, giving the bin into which each value would be placed. This method is helpful for histograming. Note: No warning is given if the boundaries, in a, are not in ascending order.

Places val into field of the given array defined by the data type and offset.

Sorts a in place (Return is None) and kind can be 'quicksort', 'mergesort', or 'heapsort'

Eliminates all length-1 dimensions

Returns the standard deviation, a 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)).
For multidimensional arrays, std is computed by default along the first axis.

Sums 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:

x.dtype	default sum() dtype
bool, Int8, Int16, Int32	Int32

Examples:

>>> sum([0.5, 1.5])
2.0
>>> sum([0.5, 1.5], dtype=Int32)
1
>>> sum([[0, 1], [0, 5]])
array([0, 6])
>>> sum([[0, 1], [0, 5]], axis=1)
array([1, 5])

Returns new view with axes swapped.

Selects the elements in indices from array a along the given axis.

Writes the data to a file.

Copies the data portion of the array to a hierarchical python list and returns that list.

Constructs a Python string containing the raw bytes in the array

Returns the sum along the offset diagonal of the arrays indicated axis1 and axis2.

Returns a view of the array with dimensions permuted according to axes. axes is a tuple indicating the permuted sequence of dimensions. If axes is None (default) the array a is returned with dimensions reversed.
Note:
For a two-dimensional array transpose(a) is equivalent to swapaxes(a,0,1).
Example:

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

[[-1 -2 -3]
[-4 -5 -6]]]
>>> print transpose(a,[2,0,1])
[[[ 1 4]
[-1 -4]]

[[ 2 5]
[-2 -5]]

[[ 3 6]
[-3 -6]]]

Returns a new view of array with same data. type can be either a new sub-type object or a data-descriptor object

(obj, docstring) --> None

Add a docstring to a built-in obj if possible.
If the obj already has a docstring raise a RuntimeError
If this routine does not know how to add a docstring to the object raise a TypeError

See also: add_newdoc

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.

See also: add_docstring
Corresponding method: none

Return the length of a Python object interpreted as an array of at least 1 dimension.
Remark: This function returns a zero-dimensional array, with value identical to the result of the python standard function len(a) , which also works on arrays.
Example

>>> a=array([[1,2,3],[4,5,6]])
>>> alen(a)
2
>>> len(a)
2

See also: shape, size
Corresponding method: none

Returns true if all elements of x are true

See also: alltrue, any
Corresponding method: a.all (axis=None)

Returns true if all components of a and b are equal subject to given tolerances. The relative error rtol must be positive and < 1.0
The absolute error atol comes into play for those elements of b that are very small or zero; it says how small a must be also.

Corresponding method: none

Perform a logical_and over the given axis.
Example

>>> m=array([[True, False, False],[True, True, False]])
>>> alltrue(m)
array([True, False, False], dtype=bool)
>>> alltrue(m, axis=1)
array([False, False], dtype=bool)

See also: all, any
Corresponding method: none

alterdot() changes all dot functions to use blas.

Corresponding method: none

Returns the maximum of 'a' along dimension axis. If axis=None, the maximum over the whole array is returned.
Example:

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

See also: a.min()
Corresponding method: a.max() =amax(a,None)

Returns the minimum of 'a' along dimension axis. If axis=None, the minimum over the whole array is returned.
Example:

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

See also: a.max()
Corresponding method: a.min() =amin(a,None)

Returns the angle (in radian) of the complex argument z. Works also on arrays.
Example:

>>> z=1.+1.j
>>> phi=angle(z)
>>> print phi, 180.*phi/pi
0.785398163397 45.0

Corresponding method: none

Returns True if any elements of x are true:

See also: all, alltrue
Corresponding method: any

Execute func1d(arr[i],*args) where func1d takes 1-D arrays and arr is an N-d array. i varies so as to apply the function along the given axis for each 1-d subarray in arr.

Corresponding method: none

Apply a function repeatedly over multiple axes, keeping the same shape for the resulting array.
func is called as res = func(a, axis). The result is assumed to be either the same shape as a or have one less dimension. This call is repeated for each axis in the axes sequence.

Corresponding method: 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 be greater than stop.
Examples:

>>> arange(5)
array([0, 1, 2, 3, 4])
>>> arange(5.)
array([ 0., 1., 2., 3., 4.])
>>> arange(1.,5.)
array([ 1., 2., 3., 4.])
>>> arange(1.,3.,0.5)
array([ 1. , 1.5, 2. , 2.5])

Corresponding method: none

Returns the indices to the maximum value of the 1-D arrays along the given axis. Axis -1 is the last axis (in a matrix these are the rows). For examples see method a.argmax().

See also: argmin, argsort
Corresponding method: a.argmax()

Returns the indices to the minimum value of the 1-D arrays along the given axis. Axis -1 is the last axis (in a matrix these are the rows). For examples see method a.argmin().

See also: argmax, argsort
Corresponding method: a.argmin()

Returns the indices into a of the sorted array along the given axis. Axis -1 is the last axis (in a matrix these are the rows). For examples see method a.argsort().

See also: argmin, argmax
Corresponding method: a.argsort()

Returs a 2-d array of shape N x a.ndim where each row is a sequence of indices into a. This sequence must be converted to a tuple in order to be used to index into a.

Corresponding method: none

Returns 'a' rounded to the given number of decimal places. Rounding behaviour is equivalent to Python.
Returns 'a' if the array is not floating point. Round both the real and imaginary parts separately if the array is complex. When a is a scalar, around defaults to the python built-in function 'round'.
Example:

>>> a=pi*arange(1,5)
>>> print a
[ 3.14159265 6.28318531 9.42477796 12.56637061]
>>> print around(a,decimals=2)
[ 3.14 6.28 9.42 12.57]

See also: round_
Corresponding method: a.round()

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

Examples:

>>> a=array([[1,2],[3,4]])
>>> print a
[[1 2]
[3 4]]
>>> b=array((1.,2,3+1.j))
>>> print b
[ 1.+0.j 2.+0.j 3.+1.j]

Corresponding method: none

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 -- 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, but we've agreed most other functions should default to axis=-1. Perhaps we should use axis=-1 for consistency. However, we could also make the argument that NumPy works on "rows" by default. sum() sums up rows of values. split() will split data into rows. Opinions?

Corresponding method: none

Returns a as an array, but will pass subclasses through.

Corresponding method: none

Returns a as an array.
Unlike array(), no copy is performed if a is already an array. Subclasses are converted to base class ndarray.

Corresponding method: none

Like asarray, but check that no NaNs or Infs are present.

Corresponding method: none

Returns 'a' as an array contiguous in memory (C order).

Corresponding method: none

Returns a as a float array.

Corresponding method: none

Returns 'a' as an array laid out in Fortran-order in memory.

Corresponding method: none

Returns 'data' as a matrix. Unlike matrix(), no copy is performed if 'data' is already a matrix or array. Equivalent to: matrix(data, copy=False)

Corresponding method: none

Converts an array of size 1 to its scalar equivalent.

Corresponding method: none

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.

Corresponding method: none

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.

Corresponding method: none

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.

Corresponding method: none

Average the array over the given axis. If the axis is None, average over all dimensions of the array. Equivalent to the method a.mean(axis), but with a default axis of 0 instead of None.
If an integer axis is given, this equals: a.sum(axis) * 1.0 / a.shape[axis]
If axis is None, this equals: a.sum(axis) * 1.0 / product(a.shape)
If weights are given, result is: sum(a * weights) / sum(weights),
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).

See also: mean, median
Corresponding method (without weights): a.mean()

Returns array with the M-point Bartlett window (used in signal processing). It is a triangular function starting and ending with 0. M is an integer.

See also blackman, hamming, hanning, kaiser
Corresponding method: none

Returns the representation of a number in any given base.

Returns the binary representation of the input number as a string.
This is equivalent to using base_repr with base 2, but about 25x faster.

Corresponding method: none

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

See also: histogram, digitize, unique.
Corresponding method: none

Returns array with the M-point Blackman window (used in signal processing). It is a bell-shaped function starting and ending with 0. M is an integer.

See also bartlett, hamming, hanning, kaiser
Corresponding method: none

Build a matrix object (= 2-dim array) from string, nested sequence, or array.
Example:

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.

See also: asmatrix, mat, matrix
Corresponding method: none

Returns True if data type d1 can be cast to data type d2 without losing precision.

Corresponding method: none

Returns weights for an Np-point central derivative of order ndiv assuming equally-spaced function points.
If weights are in the vector w, then derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx)
Can be inaccurate for large number of points.

Corresponding method: none

For description and example see method a.choose().

Corresponding method: a.choose()

Every entry in a that is less than min is replaced by min, and every entry greater than max is replaced by max.

Corresponding method: a.clip()

Stacks 1D arrays as columns into a 2D array
Description:
Takes a sequence of 1D arrays and stacks them as columns to make a single 2D array. All arrays in the sequence must have the same length.
Arguments:
tup -- sequence of 1D arrays. All arrays must have the same length.
Example:

>>> a = array((1,2,3))
>>> b = array((2,3,4))
>>> column_stack((a,b))
array([[1, 2],
[2, 3],
[3, 4]])

Corresponding method: none

Binomial (combinatorial) coefficient N over k: number ways k items can be chosen from a set of N items. Equal to N!/[k!(N-k)!]
If exact==0, then floating point precision is used, otherwise exact long integer is computed.
Notes:
- Array arguments accepted only for exact=0 case.
- If k > N, N < 0, or k < 0, then a 0 is returned.
Example:

>>> a=arange(6)
>>> comb(5,a)
array([ 1., 5., 10., 10., 5., 1.])

See also: factorial
Corresponding method: none

Given a sequence of arrays as arguments, returns the best inexact scalar type which is "most" common amongst them.
The return type will always be a inexact scalar type, even if all the arrays are integer arrays.

Those elements of a corresponding to those elements of condition that are True. condition must be the same size as the given dimension of a. See method compress for examples.

Corresponding method: a.compress()

Joins arrays together. The tuple of sequences (a1, a2, ...) are joined along the given axis (default is the first one) into a single array.
Example:

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

Corresponding method: none

Returns the discrete, linear convolution of 1-D sequences a and v; mode can be 0 (valid), 1 (same), or 2 (full) to specify size of the resulting sequence. Produces the correlation between a and the reverse of v, when v is shorter or of equal length as a; otherwise a and v are interchanged.

See also: correlate
Corresponding method: none

Returns an array copy of the given object, which may be an array or a sequence. The corresponding method a.copy() can also change the order ('C' or 'Fortran') in which the array elements are stored.
Example

>>> a=[1, 2., 3+1j]
>>> copy(a)
array([ 1.+0.j, 2.+0.j, 3.+1.j])

Corresponding method: a.copy()

Returns the correlation coefficients derived from the covariance matrix. See cov for details.
The correlation coefficient between two sets of observations x and y is defined as
cov(x,y)/sqrt(var(x)*var(y))

See also: cov, std, var

Corresponding method: none

Estimates the covariance matrix. The covariance of two sets of N observations x ₀,..x _N-1, y ₀,..y _N-1 is defined as
cov(x,y) = (1./(N-1)) Σ _i (x _i - <x>)(y _i - <y>),
where <x> stands for the mean or average of x. Normalization is by (N-1), where N is the number of observations (unbiased estimate). If bias=1 then normalization is by N.
The input data are a set of n variables with N observations each. If there is one variable (i.e., m is a vector), the variance is returned. If there are two variables, m and y, each being a vector of the same length N, the function can be called as cov(m,y) and a symmetric 2*2 matrix is returned containing

cov(m,m)=var(m)	cov(m,y)
cov(y,m)	cov(y,y)=var(y)

If there are n=2 or more variables, arranged in an array of shape (n,N) (i.e., the rows contain the N the observations of one variable), and y=None (default), the n*n covariance matrix of the rows is returned. However, if rowvar=False, the covariance matrix of the columns is returned, and the correct covariance is obtained if the columns contain the N observations of one variable (the shape of the array must then be (N,n)).
Examples:

>>> x=array((-1.,0.,1.))
>>> y=array((3.,0.,-3.))
>>> print cov(x,y)
[[ 1. -3.]
[-3. 9.]]
>>> z=asarray([x,y])
>>> print z
[[-1. 0. 1.]
[ 3. 0. -3.]]
>>> print cov(z)
[[ 1. -3.]
[-3. 9.]]
>>> print cov(z,rowvar=False)
[[ 8. 0. -8.]
[ 0. 0. 0. ]
[-8. 0. 8.]]
>>> print corrcoef(x,y)
[[ 1. -1.]
[-1. 1.]]

See also: corrcoef, std, var
Corresponding method: none

Returns the cross product of two (arrays of) vectors.
The cross product is performed over the last axis of a and b by default, and can handle axes with dimensions 2 and 3. For a dimension of 2, the z-component of the equivalent three-dimensional cross product is returned.
Example

>>> x=array((1,0,0))
>>> y=array((0,1,0))
>>> cross(x,y)
array([0, 0, 1])
>>> cross(y,x)
array([ 0, 0, -1])

Corresponding method: none

# Adapted from Albert Strasheim

Corresponding method: none

Returns the cumulative product of the elements along the given axis. cumprod(a) = a.cumprod(0). For examples see method a.cumprod()

See also: cumproduct, cumsum, prod, product, sum
Corresponding method: a.cumprod()

Equal to cumprod.

See also: cumprod, cumsum, prod, product, sum
Corresponding method: a.cumprod()

Returns the cumulative sum of the elements along the given axis. See method a.cumsum() for examples. Note that method and function have different default axes.

See also: cumprod, cumproduct, prod, product, sum
Corresponding method: a.cumsum()

Corresponding method: none

Given a function, use a central difference formula with spacing dx to compute the nth derivative at x0.
order is the number of points to use and must be odd.
Warning: Decreasing the step size too small can result in round-off error.

Corresponding method: none

Returns a copy of the the k-th diagonal if v is a 2-d array or returns a 2-d array with v as the k-th diagonal if v is a 1-d array.
Examples:

>> > v=array((1,2,3))
>>> diag(v)
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> diag(v,k=-1)
array([[0, 0, 0, 0],
       [1, 0, 0, 0],
       [0, 2, 0, 0],
       [0, 0, 3, 0]])

Corresponding method: none

Returns the given diagonals defined by the last two dimensions of the array. See method a.diagonal() for examples.

Corresponding method: a.diagonal()

Calculates the n-th order discrete difference along given axis.

Corresponding method: none

Returns 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.
Beyond the bounds of the bins 0 or len(bins) is returned as appropriate.

Corresponding method: none

Displays a message to the given device (default is sys.stdout) with or without a linefeed.

Corresponding method: none

matrix product (a,b)
Returns the dot product of a and b for arrays of floating point types. Like the generic numpy equivalent the product sum is over the last dimension of a and the second-to-last dimension of b.
NB: The first argument, if complex, is not conjugated.
Examples:
Two one-dim arrays (of equal length) are considered as vectors and yield the scalar or dot product (Σ _i a _i b _i )

>>> a=array([1.,1.,1.])
>>> dot(a,a)
3.

Two-dimensional matrices yield the matrix product C=AB; C _ij = Σ _k A _ik B _kj:

>>> A=array([[1.,1.,1.]])
>>> print A
[[1. 1. 1.]]
>>> B=A.transpose()
>>> print B
[[1.]
[1.]
[1.]]
>>> print dot(A,B)
[[3.]]
>>> print dot(B,A)
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]

See also: inner, vdot
Corresponding method: none

Splits ary into multiple sub-arrays along the 3rd axis (depth)
Description: Splits a single array into multiple subarrays. 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.
Examples:

>>> a = array([[[1,2,3,4],[1,2,3,4]]])
>>>dsplit(a,2)
[array([ [[1, 2],
[1, 2]]]), array([ [[3, 4],
[3, 4]]])]

See also: dstack, split, array_split, hsplit, vsplit
Corresponding method: none

Stacks arrays in sequence depth wise (along third dimension)
Description:
Takes a sequence of arrays and stacks 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:

>>> a = array((1,2,3))
>>> b = array((2,3,4))
>>> dstack((a,b))
array([[ [1, 2],
[2, 3],
[3, 4]]])

See also: dsplit, split, array_split, hsplit, vsplit
Corresponding method: none

Returns an empty (uninitialized) array of the specified shape and typecode.
Note that this does NOT initialize the returned array. If you require your array to be initialized, you should use zeros or ones.

See also: empty_like, ones, ones_like, zeros, zeros_like
Corresponding method: none

Returns an empty (uninitialized) array of the shape and typecode of a.
Note that this does NOT initialize the returned array. If you require your array to be initialized, you should use zeros_like or ones_like.

See also: empty, ones, ones_like, zeros, zeros_like
Corresponding method: none

Expands the shape of a by including newaxis before given axis.

Corresponding method: none

Returns the elements of ravel(arr) where ravel(condition) is True (in 1D).
Equivalent to compress(ravel(condition), ravel(arr)).

Corresponding method: none

Returns a N-by-M 2-d array where the k-th diagonal is all ones, and everything else is zeros.

Corresponding method: none

n! = special.gamma(n+1)
If exact==0, then floating point precision is used, otherwise exact long integer is computed.
Notes: - Array argument accepted only for exact=0 case.
- If n < 0, the return value is 0.

Corresponding method: none

n!! = special.gamma(n/2+1)*2**((m+1)/2)/sqrt(pi) n odd = 2**(n) * n! n even
If exact==0, then floating point precision is used, otherwise exact long integer is computed.
Notes
- Array argument accepted only for exact=0 case.
- If n < 0, the return value is 0.

Corresponding method: none

n(!!...!) = multifactorial of order k
k times

Corresponding method: none

Returns transposed copy of array a

Corresponding method: none

Rounds x to nearest integer towards zero.

See also: around, round_
Corresponding method: none

Returns an array m with the rows preserved and columns flipped in the left/right direction. Works on the first two dimensions of m.

Corresponding method: none

Returns an array with the columns preserved and rows flipped in the up/down direction. Works on the first dimension of m.

Corresponding method: none

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 not in machine byte-order, than use a proper data type descriptor. The data will not be byteswapped, but the array will manage it in future operations.

Corresponding method: none

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

Corresponding method: none

Returns an array constructed by calling function on a tuple of number grids. The function should accept as many arguments as there are dimensions which is a list of numbers indicating the length of the desired output for each axis.
The function can also accept keyword arguments which will be passed in as well.

Corresponding method: none

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

Corresponding method: none

Takes an arbitrary python function that takes nin objects as input and returns nout objects and return a universal function (ufunc). This ufunc always returns PyObject arrays

Corresponding method: none

Returns a new 1d array initialized from the raw binary data in string. If count is positive, the new array will have count elements, otherwise it's 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).

Corresponding method: none

Returns 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()])

Corresponding method: none

Returns 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()])

get_numpy_include is DEPRECATED in numpy: use get_include instead.
Returns 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()])

Corresponding method: none

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

Corresponding method: none

Returns the size of the buffer used in ufuncs.

Corresponding method: none

Get the current way of handling floating-point errors.
Returns a dictionary with entries "divide", "over", "under", and "invalid", whose values are from the strings "ignore", "warn", "raise", and "call".

Corresponding method: none

Returns the current callback function used on floating-point errors.

Corresponding method: none

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

Corresponding method: none

Returns array with the M-point Hamming window (used in signal processing). It is a bell-shaped function starting and ending with 0. M is an integer.

See also: bartlett, blackman, hanning, kaiser
Corresponding method: none

Goto: array functions

Returns array with the M-point Hanning window (used in signal processing). It is a bell-shaped function (one cosine cycle + 1), starting and ending with 0. M is an integer.

See also: bartlett, blackman, hamming, kaiser
Corresponding method: none

Returns the distribution of a collection of samples.
Input:

a -- array containing samples
bins -- number of bins
range -- lower and upper bin edges (default: [sample.min(), sample.max()]). Does not really work, all values greater than range are stored in the last bin.
normed -- If False (default), returns the number of samples in each bin. If True, return a frequency distribution.

Output:
histogram array, left bin edges array.
Example:

>>> a=randn(100)
>>> result=histogram(a, bins=8, range=[-4.,4.])
>>> print result[0] # nr of samples in each bin
[ 0 1 5 42 37 12 2 1]
>>> print result[1] # left bin boundaries
[-4. -3. -2. -1. 0. 1. 2. 3.]

Corresponding method: none

Computes the 2D histogram for a dataset (x,y) given the edges or the number of bins.
Returns histogram, xedges, yedges.
The histogram array is a count of the number of samples in each bin. The array is oriented such that H[i,j] is the number of samples falling into binx[j] and biny[i]. Setting normed to True returns a density rather than a bin count. Data falling outside of the edges are not counted.

Corresponding method: none

Splits ary into multiple columns of sub-arrays
Description:
Splits 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.
Examples:

>>> a= array((1,2,3,4))
>>> hsplit(a,2)
[array([1, 2]), array([3, 4])]
>>> a = array([[1,2,3,4],[1,2,3,4]])
[array([[1, 2],
[1, 2]]), array([[3, 4],
[3, 4]])]

See also: array_split, dsplit, hstack, split, vsplit
Corresponding method: none

Stacks arrays in sequence horizontally (column wise)
Description:
Takes a sequence of arrays and stacks 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:

>>> a=array((1,2,3))
>>> b=array((4,5,6))
>>> hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> a=array([[1],[2],[3]])
>>> b=array([[4],[5],[6]])
>>> hstack((a,b))
array([[1, 4]
[2, 5],
[3, 6]])

See also: array_split, dsplit, hsplit, split, vsplit
Corresponding method: none

Returns zero-order Bessel function for real or complex argument array.
Example:

>>> i0(arange(5.))
array([ 1. , 1.26606588, 2.2795853 , 4.88079259, 11.30192195])

Corresponding method: none

identity(n) returns the identity 2-d array of shape n x n.
Example:

>>> identity(2)
array([[ 1., 0.],
[ 0., 1.]])

Corresponding method: none

Returns the imaginary part of val as an array. The argument val maybe a scalar or an array. See attribute a.imag for examples.

See also: real
Corresponding attribute: a.imag

Returns an array representing a grid of indices with row-only, and column-only variation.

Corresponding method: none

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

>>> info(polyval)
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]

Corresponding method: none

innerproduct(a,b)
Returns the inner product of a and b for arrays of floating point types. Like the generic NumPy equivalent the product sum is over the last dimension of a and b.
For two one-dim arrays of the same length, inner(a,b) is equivalent to dot(a,b), yielding the scalar or inner product of two vectors.
For two-dimensional arrays, inner(A,B) computes the matrix product AB ^T, which is equivalent to dot(A,B.transpose()). For matrix products in the usual mathematical sense, one should use dot and not inner.
NB: The first argument, if complex, is not conjugated.
Examples:

>>> A=array([[1.,1.],[0.,2.]])
>>> B=array([[0.,1.],[-1.,0.]])
>>> inner(A,B)
array([[ 1., -1.],
[ 2., 0.]])
>>> dot(A,B)
array([[-1., 1.],
[-2., 0.]])

See also: dot, vdot
Corresponding method: none

Similar to putmask arr [mask] = vals but the 1D array vals has the same number of elements as the non-zero values of mask. Inverse of extract. The insertion is done in place; the function returns None.
Example:

>>> a=zeros((2,3))
>>> print a
[[ 0. 0. 0.]
[ 0. 0. 0.]]
>>> mask=array([[1,0,1],[1,0,1]])
>>> insert(a,mask,[2.,1.,1.,2.])
>>> print a
[[ 2. 0. 1.]
[ 1. 0. 2.]]

See also: put ; putmask
Corresponding method: none

Intersection of 1D arrays with unique elements.

Corresponding method: none

Intersection of 1D arrays with any elements.

Corresponding method: none

Returns a boolean array where elements are True if that element is complex (has non-zero imaginary part).
For scalars, returns a boolean.

Corresponding method: none

Returns True if x is a complex type or an array of complex numbers.
Unlike iscomplex(x), complex(3.0) is considered a complex object.

Corresponding method: none

Returns True if 'a' is laid out in Fortran-order in memory.

Corresponding method: none

Returns a boolean array y with y[i] True for x[i] = -Inf.
If y is an array, the result replaces the contents of y.

Corresponding method: none

Returns a boolean array y with y[i] True for x[i] = +Inf.
If y is an array, the result replaces the contents of y.

Corresponding method: none

Return a boolean array where elements are True if that element is real (has zero imaginary part)
For scalars, return a boolean.

Corresponding method: none

Return True if x is not a complex type.
Unlike isreal(x), complex(3.0) is considered a complex object.

Corresponding method: none

Returns True if the type of num is a scalar type.

Determines whether the given object represents a numeric array type.

Corresponding method: none

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

a[1,2] a[1,5] a[1,8]
a[3,2] a[3,5] a[3,8]
a[7,2] a[7,5] a[7,8]

Corresponding method: none

Returns a Kaiser window of length M with shape parameter beta. The Kaiser window is a function that looks like a half sine wave, but consists of a modified Bessel function and a sinh function; it is used as a filter in signal processing.

See also: bartlett, blackman, hamming, hanning
Corresponding method: none

Kronecker product of a and b
The Kronecker product of two matrices is a block matrix

[	[	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	]	]

Example:

>>> d=diag([1,1])
>>> a=array([[1,2],[3,4]])
>>> kron(d,a)
array([[1, 2, 0, 0],
       [3, 4, 0, 0],
       [0, 0, 1, 2],
       [0, 0, 3, 4]])

Corresponding method: none

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

Corresponding method: none

Returns evenly spaced floating point numbers.
Return num evenly spaced numbers from start to stop. If endpoint is True, the last number is stop. If retstep is True then return the step value used.

See also: logspace
Corresponding method: none

Wrapper around cPickle.load which accepts either a file-like object or a filename.

Corresponding method: none

Loads a pickle from the given string

Corresponding method: none

Returns the base 2 logarithm of x
If y is an array, the result replaces the contents of y.

Corresponding method: none

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

See also: linspace
Corresponding method: none

Returns 'data' as a matrix (two-dim array). Unlike matrix(), no copy is performed if 'data' is already a matrix or array. Equivalent to: matrix(data, copy=False)

See also: asmatrix, bmat, matrix
Corresponding method: none

Returns 'data' as a matrix (two-dim array). A copy is performed if 'data' is already a matrix or array.

See also: asmatrix, bmat, mat
Corresponding method: none

Returns the scalar type of highest precision of the same general kind as 't'
Example:

>>> maximum_sctype(array((1., 2, 3+1j)))
<type 'complex128scalar'>

Corresponding method: none

Returns the arithmetic mean. Equivalent to average, except that no weights can be specified. The method a.mean() has default axis None.
The mean is the sum of the elements divided by the number of elements. Averaging is done over the given axis; if axis=None, all elements are averaged.

See also: average, median
Corresponding method: a.mean()

Returns the median of m along the first dimension of m. There are as many values below as there are above the median. If m contains an even number of items (along its first dimension), the median is halfway between two successive values.
Examples:

>>> m=array((1,2,3,4,6,8))
>>> median(m)
3.5

See also: average, mean
Corresponding method: none

For vectors x, y with lengths Nx=len(x) and Ny=len(y), return X, Y where X and Y are (Ny, Nx) shaped arrays with the elements of x and y repeated to fill the matrix
Example:

>>> [X, Y] = meshgrid([1,2,3], [4,5,6,7])
>>> print X
[[1 2 3]
[1 2 3]
[1 2 3]
[1 2 3]]
>>> print Y
[[4 4 4]
[5 5 5]
[6 6 6]
[7 7 7]]

Corresponding method: none

Returns a minimum data type character from typeset that handles all typechars given.
The returned type character must be the smallest size such that an array of the returned type can handle the data from an array of type t for each t in typechars (or if typechars is an array, then its dtype.char).
If the typechars does not intersect with the typeset, then default is returned.
If t in typechars is not a string then t=asarray(t).dtype.char is applied.

Corresponding method: none

Finds the maximum over the given axis ignoring NaNs.

Corresponding method: none

Finds the indices of the minimium over the given axis ignoring NaNs.

Corresponding method: none

Finds the maximum over the given axis ignoring NaNs.

Corresponding method: none

Finds the minimium over the given axis, ignoring NaNs.

Corresponding method: none

Sums the array over the given axis, treating NaNs as 0.

Corresponding method: none

Returns a new uninitialized buffer object of size bytes

Returns the indices of the elements of a which are not zero, a must be 1d. Works also on sequences (lists and tuples). The method a.nonzero() applies to any array.
Examples:

>>> a=array((0,1,2,0))
>>> nonzero(a)
array([1, 2])
>>> nonzero([0,1,2,0])
array([1, 2])

Corresponding method: a.nonzero()

ones(shape, dtype=None) returns an array of the given dimensions which is initialized to all ones (floats).
If you don't explicitly need the array to be initialized, you should instead use empty, which is faster as it only allocates memory.
Example:

>>> a=ones((2,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.]])

See also: empty, empty_like, ones_like, zeros, zeros_like

Returns an array of the same shape and typecode as a which is initialized to all ones (floats).
If you don't explicitly need the array to be initialized, you should instead use empty_like, which is faster as it only allocates memory.

See also: empty, empty_like, ones, zeros, zeros_like

outer(a,b) returns the outer product of two vectors. result(i,j) = a(i)*b(j) when a and b are vectors Will accept any arguments that can be made into vectors.
Example:

>>> a=array((1,2))
>>> b=array((3,4))
>>> outer(a,b)
array([[3, 4],
[6, 8]])
>>> outer(b,a)
array([[3, 6],
[4, 8]])

Given Taylor series coefficients in an, return a Pade approximation to the function as the ratio of two polynomials p / q where the order of q is m.

Return a piecewise-defined function.
Input:

x -- the domain
condlist -- a list of boolean arrays or a single boolean array The length of the condition list must be n2 or n2-1 where n2 is the length of the function list. If len(condlist)==n2-1, then an 'otherwise' condition is formed by |'ing all the conditions and inverting.
funclist -- a list of functions to call of length (n2). Each function should return an array output for an array input Each function can take (the same set) of extra arguments and keyword arguments which are passed in after the function list. A constant may be used in funclist for a function that returns a constant (e.g. val and lambda x: val are equivalent in a funclist).

The output is the same shape and type as x and is found by calling the functions on the appropriate portions of x.
Note: This is similar to choose or select, except that the functions are only evaluated on elements of x that satisfy the corresponding condition.
The result is f1(x) for condition-1, f2(x) for condition-2, ..., fn(x) for condition-n

Returns a sequence representing a polynomial given a sequence of roots. If the input is a matrix, return the characteristic polynomial.
Example:

>>> b = roots([1,3,1,5,6])
>>> poly(b)
array([1., 3., 1., 5., 6.])

Adds two polynomials represented as sequences

Returns the mth derivative of the polynomial p.

Computes q and r polynomials so that u(s) = q(s)*v(s) + r(s) and deg r < deg v.

Does a best fit polynomial of order N of y to x. Return value is a vector of polynomial coefficients [pk ... p1 p0].
E.g., for N=2
p2*x0^2 + p1*x0 + p0 = y1
p2*x1^2 + p1*x1 + p0 = y1
p2*x2^2 + p1*x2 + p0 = y2
.....
p2*xk^2 + p1*xk + p0 = yk

Method: if X is a the Vandermonde Matrix computed from x (see http://mathworld.wolfram.com/VandermondeMatrix.html), then the polynomial least squares solution is given by the 'p' in
X*p = y
where X is a len(x) * N+1 matrix, p is a N+1 length vector, and y is a len(x) * 1 vector
This equation can be solved as
p = (XT*X)^-1 * XT * y
where XT is the transpose of X and -1 denotes the inverse.
For more info, see http://mathworld.wolfram.com/LeastSquaresFittingPolynomial.html, but note the k's and n's in the superscripts and subscripts on that page. The linear algebra is correct, however.

See also: polyval

Returns the mth analytical integral of the polynomial p.
If k is None, then zero-valued constants of integration are used. otherwise, k should be a list of length m (or a scalar if m=1) to represent the constants of integration to use for each integration (starting with k[0])

Multiplies two polynomials represented as sequences.

Subtracts two polynomials represented as sequences

Evaluate the polynomial p at x. If x is a polynomial then composition.
Description: br> 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]
x can be a sequence and p(x) will be returned for all elements of x, or x can be another polynomial and the composite polynomial p(x) will be returned.
Notice: This can produce inaccurate results for polynomials with significant variability. Use carefully.

Returns the product of the elements along the given axis
Example:

>>> a
array([[1, 4],
[3, 2]])
>>> prod(a)
array([3, 8])
>>> prod(a,1)
array([4, 6])

See also: cumprod, cumproduct, cumsum, product, sum
Corresponding method: a.prod()

Product of the array elements over the given axis. Is equivalent to prod.

See also: cumprod, cumproduct, cumsum, prod, sum
Corresponding method: a.prod()

Returns maximum - minimum along the the given dimension

Results in a[n] = v[n] for all n in ind. If v is shorter than mask it will be repeated as necessary. In particular v can be a scalar or length 1 array. The routine put is the equivalent of the following (although the loop is in C for speed):
  ind = array(indices, copy=False)
  v = array(values, copy=False).astype(a.dtype)
  for i in ind: a.flat[i] = v[i]
a must be a contiguous numpy array.
For examples see the method a.put()

See also: insert ; putmask
Corresponding method: a.put()

Results in a = v for all places where mask is true. If v is shorter than mask it will be repeated as necessary. In particular v can be a scalar or length 1 array.
For examples see the method a.putmask()

See also: insert ; put
Corresponding method: a.putmask()

Returns an array of shape (d0, d1, ..., dn) which is initialized to random numbers from a uniform distribution in the range [0,1).
rand() -> random values
Note: This is a convenience function. If you want an interface that takes a tuple as the first argument use numpy.random.random_sample(shape_tuple).

Returns zero-mean, unit-variance Gaussian random numbers in an array of shape (d0, d1, ..., dn).
randn() -> random values
Note: This is a convenience function. If you want an interface that takes a tuple as the first argument use numpy.random.standard_normal(shape_tuple).

Gets the rank of sequence a (the number of dimensions, not a matrix rank) The rank of a scalar is zero.

Returns a 1d array corresponding to all the elements of it's argument. The new array is a view of m if possible, otherwise it is a copy.

Returns the real part of val as an array. The argument val maybe a scalar or an array. See attribute a.real for examples.

See also: imag
Corresponding attribute: a.real

If a is a complex array, returns it as a real array if the imaginary part is close enough to zero.
"Close enough" is defined as tol*(machine epsilon of a's element type).

Repeats elements of a repeats times along axis. Repeats is a sequence of length a.shape[axis] telling how many times to repeat each element. If repeats is an integer, it is interpreted as a tuple of length a.shape[axis] containing repeats. The argument a can be anything array(a) will accept.
For examples see method .repeat().

See also: repmat
Corresponding method: .repeat()

Repeats a 0-d to 2-d array m*n times
Example:

>>> m=matrix((1,2,3)).transpose()
>>> print m
[[1]
[2]
[3]]
>>> print repmat(m,1,3)
[[1 1 1]
[2 2 2]
[3 3 3]]

See also: repeat
Corresponding method: None

Changes the shape of a to newshape. Returns a new view object if possible otherwise returns a copy. For examples see method .reshape().

See also: attribute shape ; function .resize()
Corresponding method: .reshape()

Returns a new array with the specified shape. The original array's total size can be any size. It fills the new array with repeated copies of a.
Note that the method a.resize(new_shape) will fill array with 0's beyond current definition of a.
Example:

>>> print a
[[1 2 3]
[4 5 6]]
>>> print resize(a,(3,4))
[[1 2 3 4]
[5 6 1 2]
[3 4 5 6]]

See also: reshape
Corresponding method: .resize()

restoredot() restores dots to defaults.

Returns the roots of the polynomial coefficients in p.
The values in the rank-1 array p are coefficients of a polynomial. If the length of p is n+1 then the polynomial is
p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]

Returns the array found by rotating m by k*90 degrees in the counterclockwise direction. Works on the first two dimensions of m.

Rounds 'a' to the given number of decimal places. Equivalent to the array function around. Rounding behaviour is equivalent to Python.
Returns 'a' if the array is not floating point. Rounds both the real and imaginary parts separately if the array is complex.
Note the underscore behind 'round'! Round without underscore is a standard Python function that acts on scalars only.

See also: around, fix
Corresponding method: a.round()

Stacks arrays in sequence vertically (row wise)
Description: Takes a sequence of arrays and stacks them vertically to make a single array. All arrays in the sequence must have the same shape along all but the first axis. vstack will rebuild arrays divided by vsplit.
Arguments:

tup -- sequence of arrays. All arrays must have the same shape.

Examples:

>>> a = array((1,2,3))
>>> b = array((2,3,4))
>>> vstack((a,b))
array([[1, 2, 3],
       [2, 3, 4]])
>>> a = array([[1],[2],[3]])
>>> b = array([[2],[3],[4]])
>>> vstack((a,b))
array([[1],
       [2],
       [3],
       [2],
       [3],
       [4]])

Returns an array composed of different elements of choicelist depending on the list of conditions.
Input:

condlist is a list of condition arrays containing ones or zeros
choicelist is a list of choice arrays (of the "same" size as the arrays in condlist). The result array has the "same" size as the arrays in choicelist. If condlist is [c0, ..., cN-1] then choicelist must be of length N. The elements of the choicelist can then be represented as [v0, ..., vN-1]. The default choice if none of the conditions are met is given as the default argument.

The conditions are tested in order and the first one statisfied is used to select the choice. In other words, the elements of the output array are found from the following tree (notice the order of the conditions matters):

if c0: v0
elif c1: v1
elif c2: v2
...
elif cN-1: vN-1
else: default

Note that one of the condition arrays must be large enough to handle the largest array in the choice list.

Sets some or all of the number methods for all array objects. Don't forget **dict can be used as the argument list. Returns the functions that were replaced -- can be stored and set later.

Sets options associated with printing.
Inputs:

precision -- the default number of digits of precision for floating point output (default 8)
threshold -- total number of array elements which trigger summarization rather than full repr. (default 1000)
edgeitems -- number of array items in summary at beginning and end of each dimension. (default 3)
linewidth -- the number of characters per line for the purpose of inserting line breaks. (default 75)
suppress -- Boolean value indicating whether or not suppress printing of small floating point values using scientific notation (default False)

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

Sets the size of the buffer used in ufuncs.

Sets difference of 1D arrays with unique elements.

Sets how floating-point errors are handled.
Valid values for each type of error are the strings "ignore", "warn", "raise", and "call". Returns the old settings.
Note that operations on integer scalar types (such as int16) are handled like floating point, and are affected by these settings.
Example:

>>> seterr(over='raise')
{'over': 'ignore', 'divide': 'ignore', 'invalid': 'ignore', 'under': 'ignore'}
>>> int16(32000) * int16(3)
Traceback (most recent call last):
File "
<stdin>
", line 1, in ?
FloatingPointError: overflow encountered in short_scalars

Sets the callback function used when a floating-point error handler is set to 'call'.
'func' should be a function that takes two arguments. The first is type of error ("divide", "over", "under", or "invalid"), and the second is the status flag (= divide + 2*over + 4*under + 8*invalid).
Returns the old handler.

Returns an array of shape of ar1 containing 1 where the elements of ar1 are in ar2 and 0 otherwise.

Sets exclusive-or of 1D arrays with unique elements.

Returns the shape of a (as a function call which also works on nested sequences).
Examples:

>>> a=[[1,2,3],[4,5,6]]
>>> b=array(a)
>>> c=array((1,2,3))
>>> d=array([[1,2,3]])
>>> print shape(a), shape(b), shape(c), shape(d)
(2, 3) (2, 3) (3,) (1, 3)

See also: alen, size
Corresponding attribute: a.shape

Shows information on availability of scipy subpackages. No arguments.

Returns sin(pi*x)/(pi*x) at all points of array x. Beware of the multiplication by pi!
Example: (prints extrema of sinc)

>>> a=0.5*array([0]+range(3,10,2))
>>> print a
[ 0. 1.5 2.5 3.5 4.5]
>>> print sinc(a)
[ 1. -0.21220659 0.12732395 -0.09094568 0.07073553]

Gets the number of elements in sequence a, or along a certain axis.
Example:

>>> a=array([[1,2,3],[4,5,6]])
>>> print size(a), size(a,0), size(a,1)
6 2 3
>>> print shape(a)
(2, 3)
>>> print len(a), alen(a)
2 2

See also: alen, shape

Performs a logical_or over the given axis.

Returns array with elements sorted along given axis.
Example:

>>> a=array([[3,1,5],[2,6,4]])
>>> print a
[[3 1 5]
[2 6 4]]
>>> print sort(a)
[[1 3 5]
[2 4 6]]
>>> print sort(a,0)
[[2 1 4]
[3 6 5]]

Sort 'a' as a complex array using the real part first and then the imaginary part if the real part is equal (the default sort order for complex arrays). This function is a wrapper ensuring a complex return type.

Write source for this object to output.

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, an error is raised. This is the only way this function differs from the array_split() function. If indices_or_sections is a list of sorted integers, its entries define the indexes where ary is split.
Input:

ary -- 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, but we've agreed most other functions should default to axis=-1. Perhaps we should use axis=-1 for consistency. However, we could also make the argument that NumPy works on "rows" by default. sum() sums up rows of values. split() will split data into rows. Opinions?

Returns a with any ones from the shape of a removed
Example:

>>> a=array([[1,2,3]])
>>> at=a.transpose()
>>> print a
[[1 2 3]]
>>> print squeeze(a)
[1 2 3]
>>> print at
[[1]
[2]
[3]]
>>> squeeze(at)
array([1, 2, 3])

Returns the standard deviation of the elements of a.
The standard deviation is the square root of the variance var; var is the average of the squared deviations from the mean, i.e. std = sqrt(mean((x - x.mean())**2)).
Note:
var is really the mean-square deviation from the mean and not the unbiased expectation of the variance of the underlying distribution, which equals n/(n-1)*var for uncorrelated samples. Likewise std is the rms (root-mean-square) deviation from the mean, and not the unbiased estimate of the standard deviation of the distribution, which equals std*sqrt(n/(n-1)).

See also: corrcoeff, cov, var

Sums the array over the given axis. The optional dtype argument is the data type for intermediate calculations.
The default is to upcast (promote) smaller integer types to the platform-dependent Int. For example, on 32-bit platforms:

x.dtype	default sum() dtype
bool, Int8, Int16, Int32	Int32

Examples:

>>> sum([0.5, 1.5])
2.0
>>> sum([0.5, 1.5], dtype=Int32)
1
>>> sum([[0, 1], [0, 5]])
array([0, 6])
>>> sum([[0, 1], [0, 5]], axis=1)
array([1, 5])

See also: cumprod, cumproduct, cumsum, prod, product

Returns array a with axis1 and axis2 interchanged.
Note:
For a two-dimensional array swapaxes(a,0,1) is equivalent to transpose(a). swapaxes swaps two axes, while transpose is able to permute all axes.

See also: transpose

Runs Scipy tests suite with level and verbosity.

Returns the sum along diagonals (defined by the last two dimensions) of the array.

Returns a view of the array with dimensions permuted according to axes. axes is a tuple indicating the permuted sequence of dimensions. If axes is None (default) the array a is returned with dimensions reversed.
Note:
For a two-dimensional array transpose(a) is equivalent to swapaxes(a,0,1).

Example: >>> a=array([[[1,2,3],[4,5,6]],[[-1,-2,-3],[-4,-5,-6]]])
>>> print a
[[[ 1 2 3]
[ 4 5 6]]

[[-1 -2 -3]
[-4 -5 -6]]]
>>> print transpose(a,[2,0,1])
[[[ 1 4]
[-1 -4]]

[[ 2 5]
[-2 -5]]

[[ 3 6]
[-3 -6]]]

See also: swapaxes

Integrates y(x) using samples along the given axis and the composite trapezoidal rule. If x is None, spacing given by dx is assumed.
Example Integrate f(x)=x**2 from 0 to 100: exact value is 333333.3....

>>> x=arange(101)
>>> y=x*x
>>> trapz(y)
333350.0

Returns a N-by-M array where all the diagonals starting from lower left corner up to the k-th are all ones.

Returns the elements on and below the k-th diagonal of matrix m. k=0 is the main diagonal, k > 0 is above and k < 0 is below the main diagonal.
Example:

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

Trims the leading and trailing zeros from a 1D array.
Example:

>>> a = array((0, 0, 0, 1, 2, 3, 2, 1, 0))
>>> trim_zeros(a)
array([1, 2, 3, 2, 1])

returns the elements on and above the k-th diagonal of m. k=0 is the main diagonal, k > 0 is above and k < 0 is below the main diagonal.

Returns an english description for the given data type character.
Examples:

>>> for c in ('b','i','l','f','d','g','h','q'): print c, typename(c)
b signed char
i integer
l long integer
f single precision
d double precision
g long precision
h short
q long long integer

Returns sorted unique items from an array or sequence.
Example:

>>> unique([5,2,4,0,4,4,2,2,1])
array([0,1,2,4,5])

Unique elements of 1D array. When ret_indx is True, return also the indices indx such that ar1.flat[indx] is the resulting array of unique elements.

Convert a flat index into an index tuple for an array of given shape.
e.g. for a 2x2 array, unravel_index(2,(2,2)) returns (1,0).
Example:

>>> x=array([[1,3,7],[4,2,5]])
>>> p=x.argmax()
>>> unravel_index(p,x.shape)
>>> print p, idx, x[idx], x.max()
2 (0, 2) 7 7

Note: x.flat[p] == x.max()
Thus, it may be easier to use flattened indexing than to re-map the index to a tuple.

Unwrap radian phase p by changing absolute jumps greater than 'discont' to their 2*pi complement along the given axis.

Returns the Vandermonde matrix X of vector x. The i-th column of X is the the i-th power of x. N is the maximum power to compute; if N is None it defaults to len(x).
Example:

>>> x=arange(1.,5.,1.)
>>> print x
[ 1. 2. 3. 4.]
>>> print vander(x)
[[ 1. 1. 1. 1.]
[ 8. 4. 2. 1.]
[ 27. 9. 3. 1.]
[ 64. 16. 4. 1.]]

Returns the variance of the elements of a.
var is the average of the squared deviations from the mean, i.e. var = mean((x - x.mean())**2).
Note:
var is really the mean-square deviation from the mean and not the unbiased expectation of the variance of the underlying distribution, which equals n/(n-1)*var for uncorrelated samples.

See also: corrcoef, cov, std

Returns the dot product of a and b for scalars and vectors of floating point and complex types. The first argument, a, is conjugated, i.e., the signs of its imaginary parts are reversed.

See also: dot

Splits ary into multiple rows of sub-arrays
Description:
Splits a single array into multiple sub arrays. The array is divided into groups of rows. 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.
Input:

ary -- 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:
How should we handle 1D arrays here? I am currently raising an error when I encounter them. Any better approach? Should we reduce the returned array to their minium dimensions by getting rid of any dimensions that are 1?

Example:

>>> a=array([[1,2,3,4],[1,2,3,4]])
>>> vsplit(a,2)
[array([[1, 2, 3, 4]]), array([[1, 2, 3, 4]])]

See also: array_split, dsplit, hsplit, hstack, split, vstack

Stacks arrays in sequence vertically (row wise)
Description: Takes a sequence of arrays and stacks them vertically to make a single array. All arrays in the sequence must have the same shape along all but the first axis. vstack will rebuild arrays divided by vsplit.
Input:

tup -- sequence of arrays. All arrays must have the same shape.

Examples:

>>> a=array((1,2,3))
>>> b=array((4,5,6))
>>> vstack((a,b))
array([[1, 2, 3],
       [4, 5, 6]])
>>> a = array([[1],[2],[3]])
>>> b = array([[2],[3],[4]])
>>> vstack((a,b))
array([[1],
       [2],
       [3],
       [2],
       [3],
       [4]])

See also: array_split, dsplit, hsplit, hstack, split, vsplit

Returns array that 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. The result of this is always a 2d array, with a row of indices for each element that satisfies the condition.

Print the scipy arrays in the given dictionary (or globals() if None).

Returns an array of zeros of the specified shape and typecode.
If you don't explicitly need the array to be zeroed, you should instead use empty, which is faster as it only allocates memory.

See also: empty, empty_like, ones, ones_like, zeros_like

Return an array of zeros of the shape and typecode of a.
If you don't explicitly need the array to be zeroed, you should instead use empty_like, which is faster as it only allocates memory.

See also: empty, empty_like, ones, ones_like, zeros

Vector Quantization / Kmeans
============================

Clustering Algorithms are useful in Information Theory, target detection, communications, compression, and other areas. Currently only Vector Quantization and the KMeans algorithm are supported by the vq module. Self Organized Feature Maps (SOM) and other approaches are also scheduled to appear at a theater near you.

Discrete Fourier Transform algorithms
=====================================

Fast Fourier Transforms:

fft	FFT of arbitrary type periodic sequences
ifft	Inverse of fft
fftn	Multi-dimensional FFT
ifftn	Inverse of fftn
fft2	Two-dimensional FFT
ifft2	Inverse of fft2
rfft	FFT of real periodic sequences
irfft	Inverse of rfft

Differential and pseudo-differential operators:

diff	Differentiation and integration of periodic sequences
tilbert	Tilbert transform: cs_diff(x,h,h)
itilbert	Inverse Tilbert transform: sc_diff(x,h,h)
hilbert	Hilbert transform: cs_diff(x,inf,inf)
ihilbert	Inverse Hilbert transform: sc_diff(x,inf,inf)
cs_diff	cosh/sinh pseudo-derivative of periodic sequences
sc_diff	sinh/cosh pseudo-derivative of periodic sequences
ss_diff	sinh/sinh pseudo-derivative of periodic sequences
cc_diff	cosh/cosh pseudo-derivative of periodic sequences
shift	Shift periodic sequences

Helper functions:

fftshift	Shift zero-frequency component to center of spectrum
ifftshift	Inverse of freqshift
dftfreq	DFT sample frequencies
rfftfreq	DFT sample frequencies(specific to rfft,irfft)

Extension modules:

_fftpack	Provides functions zfft, drfft, zrfft, zfftnd, destroy_*_cache
convolve	Provides functions convolve, convolve_z, init_convolution_kernel, destroy_convolve_cache

Integration routines
====================

Methods for Integrating Functions given function object.

quad	General purpose integration.
dblquad	General purpose double integration.
tplquad	General purpose triple integration.
fixed_quad	Integrate func(x) using Gaussian quadrature of order n.
quadrature	Integrate with given tolerance using Gaussian quadrature.
romberg	Integrate func using Romberg integration.

Methods for Integrating Functions given fixed samples.

trapz	Use trapezoidal rule to compute integral from samples.
cumtrapz	Use trapezoidal rule to cumulatively compute integral.
simps	Use Simpson's rule to compute integral from samples.
romb	Use Romberg Integration to compute integral from (2**k + 1) evenly-spaced samples.

See the special module's orthogonal polynomials (special) for Gaussian quadrature roots and weights for other weighting factors and regions.

Interface to numerical integrators of ODE systems.

odeint	General integration of ordinary differential equations.
ode	Integrate ODE using vode routine.

Interpolation Tools
===================

Wrappers around FITPACK functions:

splrep	find smoothing spline given (x,y) points on curve.
splprep	find smoothing spline given parametrically defined curve.
splev	evaluate the spline or its derivatives.
splint	compute definite integral of a spline.
sproot	find the roots of a cubic spline.
spalde	compute all derivatives of a spline at given points.
bisplrep	find bivariate smoothing spline representation.
bisplev	evaluate bivariate smoothing spline.

Interpolation Class

interp1d

Create a class whose instances can linearly interpolate to compute unknown values.

Data input and output
=====================

Classes

fopen

a class for easily reading and writing binary data.

Functions

read_array	reading ascii streams into Numeric arrays
write_array	write an array to an ascii stream
loadmat	read a MATLAB style mat file (version 4 and 5)
savemat	write a MATLAB (version < 4) style mat file
fread	low-level reading
fwrite	low-level writing
bswap	in-place byte-swapping
packbits	Pack a binary array of 1's and 0's into an array of bytes
unpackbits	Unpack an array packed by packbits.
save	simple storing of Python dictionary into module that can then be imported and the data accessed as attributes of the module.
mminfo	query matrix info from Matrix Market formatted file
mmread	read matrix from Matrix Market formatted file
mmwrite	write matrix to Matrix Market formatted file

Python wrappers to external libraries
=====================================

lapack	wrappers for LAPACK/ATLAS libraries
blas	wrappers for BLAS/ATLAS libraries

Linear algebra routines
=======================

Linear Algebra Basics:

inv	Find the inverse of a square matrix
solve	Solve a linear system of equations
solve_banded	Solve a linear system of equations with a banded matrix
det	Find the determinant of a square matrix
norm	matrix and vector norm
lstsq	Solve linear least-squares problem
pinv	Pseudo-inverse (Moore-Penrose) using lstsq
pinv2	Pseudo-inverse using svd

Eigenvalues and Decompositions:

eig	Find the eigenvalues and vectors of a square matrix
eigvals	Find the eigenvalues of a square matrix
eig_banded	Find the eigenvalues and vectors of a band matrix
eigvals_banded	Find the eigenvalues of a band matrix
lu	LU decomposition of a matrix
lu_factor	LU decomposition returning unordered matrix and pivots
lu_solve	solve Ax=b using back substitution with output of lu_factor
svd	Singular value decomposition of a matrix
svdvals	Singular values of a matrix
diagsvd	construct matrix of singular values from output of svd
orth	construct orthonormal basis for range of A using svd
cholesky	Cholesky decomposition of a matrix
cho_factor	Cholesky decomposition for use in solving linear system
cho_solve	Solve previously factored linear system
qr	QR decomposition of a matrix
schur	Schur decomposition of a matrix
rsf2csf	Real to complex schur form
hessenberg	Hessenberg form of a matrix

matrix Functions:

expm2	matrix exponential using Eigenvalue decomp.
expm3	matrix exponential using Taylor-series expansion
logm	matrix logarithm
cosm	matrix cosine
sinm	matrix sine
tanm	matrix tangent
coshm	matrix hyperbolic cosine
sinhm	matrix hyperbolic sine
tanhm	matrix hyperbolic tangent
signm	matrix sign
sqrtm	matrix square root
funm	Evaluating an arbitrary matrix function.

Iterative linear systems solutions

cg	Conjugate gradient (symmetric systems only)
cgs	Conjugate gradient squared
qmr	Quasi-minimal residual
gmres	Generalized minimal residual
bicg	Bi-conjugate gradient
bicgstab	Bi-conjugate gradient stabilized

Linear Solvers
==============

linear solvers for sparse matrices: in development

Routines for fitting maximum entropy models
===========================================

Contains two classes for fitting maximum entropy models subject to linear constraints on the expectations of arbitrary feature statistics. One class, "model", is for small discrete sample spaces, using explicit summation. The other, "bigmodel", is for sample spaces that are either continuous (and perhaps high-dimensional) or discrete but too large to sum over, and uses importance sampling. conditional Monte Carlo methods.
The maximum entropy model has exponential form

p(x) = exp(theta^T . f_vec(x)) / Z(theta).

with a real parameter vector theta of the same length as the feature statistic f_vec. For more background, see, for example, Cover and Thomas (1991), Elements of Information Theory.

See the file bergerexample.py for a walk-through of how to use these routines when the sample space is small enough to be enumerated.

See bergerexamplesimulated.py for a a similar walk-through using simulation.

Copyright: Ed Schofield, 2003-2006
License: BSD-style (see LICENSE.txt in main source directory)

Various utilities that don't have another home.

n-dimensional image package
===========================

This package contains various functions for multi-dimensional image processing.

Optimization Tools
==================

A collection of general-purpose optimization routines.

fmin	Nelder-Mead Simplex algorithm (uses only function calls)
fmin_powell	Powell's (modified) level set method (uses only function calls)
fmin_cg	Non-linear (Polak-Ribiere) conjugate gradient algorithm (can use function and gradient).
fmin_bfgs	Quasi-Newton method (Broydon-Fletcher-Goldfarb-Shanno); (can use function and gradient)
fmin_ncg	Line-search Newton Conjugate Gradient (can use function, gradient and Hessian).
leastsq	Minimize the sum of squares of M equations in N unknowns given a starting estimate.

Constrained Optimizers (multivariate)

fmin_l_bfgs_b	Zhu, Byrd, and Nocedal's L-BFGS-B constrained optimizer (if you use this please quote their papers -- see help)
fmin_tnc	Truncated Newton Code originally written by Stephen Nash and adapted to C by Jean-Sebastien Roy.
fmin_cobyla	Constrained Optimization BY Linear Approximation

Global Optimizers

anneal	Simulated Annealing
brute	Brute force searching optimizer

Scalar function minimizers

fminbound	Bounded minimization of a scalar function.
brent	1-D function minimization using Brent method.
golden	1-D function minimization using Golden Section method
bracket	Bracket a minimum (given two starting points)

Also a collection of general-purpose root-finding routines.

fsolve

Non-linear multi-variable equation solver.

Scalar function solvers

brentq	quadratic interpolation Brent method
brenth	Brent method (modified by Harris with hyperbolic extrapolation)
ridder	Ridder's method
bisect	Bisection method
newton	Secant method or Newton's method
fixed_point	Single-variable fixed-point solver.

Utility Functions

line_search	Return a step that satisfies the strong Wolfe conditions.
check_grad	Check the supplied derivative using finite difference techniques.

Sandbox:
A repository of unused routines.

Signal Processing Tools
===========================

Convolution:

convolve	N-dimensional convolution.
correlate	N-dimensional correlation.
fftconvolve	N-dimensional convolution using the FFT.
convolve2d	2-dimensional convolution (more options).
correlate2d	2-dimensional correlation (more options).
sepfir2d	Convolve with a 2-D separable FIR filter.

B-splines:

bspline	B-spline basis function of order n.
gauss_spline	Gaussian approximation to the B-spline basis function.
cspline1d	Coefficients for 1-D cubic (3rd order) B-spline.
qspline1d	Coefficients for 1-D quadratic (2nd order) B-spl
cspline2d	Coefficients for 2-D cubic (3rd order) B-spline.
qspline2d	Coefficients for 2-D quadratic (2nd order) B-spline.
spline_filter	Smoothing spline (cubic) filtering of a rank-2 array.

Filtering:

order_filter	N-dimensional order filter.
medfilt	N-dimensional median filter.
medfilt2	2-dimensional median filter (faster).
wiener	N-dimensional wiener filter.
symiirorder1	2nd-order IIR filter (cascade of first-order systems).
symiirorder2	4th-order IIR filter (cascade of second-order systems).
lfilter	1-dimensional FIR and IIR digital linear filtering.
deconvolve	1-d deconvolution using lfilter.
hilbert	Compute the analytic signal of a 1-d signal.
get_window	Create FIR window.
detrend	Remove linear and/or constant trends from data.

Filter design:

remez	Optimal FIR filter design.
firwin	Windowed FIR filter design.
iirdesign	IIR filter design given bands and gains
iirfilter	IIR filter design given order and critical frequencies
freqs	Analog filter frequency response
freqz	Digital filter frequency response

Matlab-style IIR filter design:

butter (buttord)	Butterworth
cheby1 (cheb1ord)	Chebyshev Type I
cheby2 (cheb2ord)	Chebyshev Type II
ellip (ellipord)	Elliptic (Cauer)
bessel	Bessel (no order selection available -- try butterod)

Linear Systems:

lti	linear time invariant system object.
lsim	continuous-time simulation of output to linear system.
impulse	impulse response of linear, time-invariant (LTI) system.
step	step response of continous-time LTI system.

LTI Representations:

tf2zpk	transfer function to zero-pole-gain.
zpk2tf	zero-pole-gain to transfer function.
tf2ss	transfer function to state-space.
ss2tf	state-pace to transfer function.
zpk2ss	zero-pole-gain to state-space.
ss2zpk	state-space to pole-zero-gain.

Waveforms:

sawtooth	Periodic sawtooth
square	Square wave
gausspulse	Gaussian modulated sinusoid
chirp	Frequency swept cosine signal

Wavelets:

daub	return low-pass filter for daubechies wavelets
qmf	return quadrature mirror filter from low-pass
cascade	compute scaling function and wavelet from coefficients

Sparse matrix
=============

Scipy 2D sparse matrix module.

Original code by Travis Oliphant. Modified and extended by Ed Schofield and Robert Cimrman.

There are four available sparse matrix types:
(1) csc_matrix: Compressed Sparse Column format
(2) csr_matrix: Compressed Sparse Row format
(3) lil_matrix: List of Lists format
(4) dok_matrix: Dictionary of Keys format

To construct a matrix efficiently, use either lil_matrix (recommended) or dok_matrix. The lil_matrix class supports basic slicing and fancy indexing with a similar syntax to NumPy arrays.

To perform manipulations such as multiplication or inversion, first convert the matrix to either CSC or CSR format. The lil_matrix format is row-based, so conversion to CSR is efficient, whereas conversion to CSC is less so.

Example:
Construct a 10x1000 lil_matrix and add some values to it:

>>> from scipy import sparse, linsolve
>>> from numpy import rand, linalg
>>> A = sparse.lil_matrix((1000, 1000))
>>> A[0, :100] = rand(100)
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag(rand(1000))

Now convert it to CSR format and solve (A A^T) x = b for x:

>>> A = A.tocsr()
>>> b = rand(1000)
>>> x = linsolve.spsolve(A * A.T, b)

Convert it to a dense matrix and solve, and check that the result is the same:

>>> A_ = A.todense()
>>> x_ = linalg.solve(A_ * A_.T, b)
>>> err = linalg.norm(x-x_)

Now we can print the error norm with:

print "Norm error =", err

It should be small :)

Special Functions
=================

Airy Functions

airy	Airy functions and their derivatives.
airye	Exponentially scaled Airy functions
ai_zeros	**Zeros of Airy functions Ai(x) and Ai'(x)
bi_zeros	**Zeros of Airy functions Bi(x) and Bi'(x)

Elliptic Functions and Integrals

ellipj	Jacobian elliptic functions
ellipk	Complete elliptic integral of the first kind.
ellipkinc	Incomplete elliptic integral of the first kind.
ellipe	Complete elliptic integral of the second kind.
ellipeinc	Incomplete elliptic integral of the second kind.

Bessel Functions

jn	Bessel function of integer order and real argument.
jv	Bessel function of real-valued order and complex argument.
jve	Exponentially scaled Bessel function.
yn	Bessel function of second kind (integer order).
yv	Bessel function of the second kind (real-valued order).
yve	Exponentially scaled Bessel function of the second kind.
kn	Modified Bessel function of the third kind (integer order).
kv	Modified Bessel function of the third kind (real order).
kve	Exponentially scaled modified Bessel function of the third kind.
iv	Modified Bessel function.
ive	Exponentially scaled modified Bessel function.
hankel1	Hankel function of the first kind.
hankel1e	Exponentially scaled Hankel function of the first kind.
hankel2	Hankel function of the second kind.
hankel2e	Exponentially scaled Hankel function of the second kind.
lmbda	**Sequence of lambda functions with arbitrary order v.

Zeros of Bessel Functions

jnjnp_zeros	**Zeros of integer-order Bessel functions and derivatives sorted in order.
jnyn_zeros	**Zeros of integer-order Bessel functions and derivatives as separate arrays.
jn_zeros	**Zeros of Jn(x)
jnp_zeros	**Zeros of Jn'(x)
yn_zeros	**Zeros of Yn(x)
ynp_zeros	**Zeros of Yn'(x)
y0_zeros	**Complex zeros: Y0(z0)=0 and values of Y0'(z0)
y1_zeros	**Complex zeros: Y1(z1)=0 and values of Y1'(z1)
y1p_zeros	**Complex zeros of Y1'(z1')=0 and values of Y1(z1')

Faster versions of common Bessel Functions.

j0	Bessel function of order 0.
j1	Bessel function of order 1.
y0	Bessel function of second kind of order 0.
y1	Bessel function of second kind of order 1.
i0	Modified Bessel function of order 0.
i0e	Exponentially scaled modified Bessel function of order 0.
i1	Modified Bessel function of order 1.
i1e	Exponentially scaled modified Bessel function of order 1.
k0	Modified Bessel function of the third kind of order 0.
k0e	Exponentially scaled modified Bessel function of the third kind of order 0.
k1	Modified Bessel function of the third kind of order 1.
k1e	Exponentially scaled modified Bessel function of the third kind of order 1.

Integrals of Bessel Functions.

itj0y0	Basic integrals of j0 and y0 from 0 to x.
it2j0y0	Integrals of (1-j0(t))/t from 0 to x and y0(t)/t from x to inf.
iti0k0	Basic integrals of i0 and k0 from 0 to x.
it2i0k0	Integrals of (i0(t)-1)/t from 0 to x and k0(t)/t from x to inf.
besselpoly	Integral of a bessel function: Jv(2ax) * x**lambda from x=0 to 1.

Derivatives of Bessel Functions.

jvp	Nth derivative of Jv(v,z)
yvp	Nth derivative of Yv(v,z)
kvp	Nth derivative of Kv(v,z)
ivp	Nth derivative of Iv(v,z)
h1vp	Nth derivative of H1v(v,z)
h2vp	Nth derivative of H2v(v,z)

Spherical Bessel Functions

sph_jn	**Sequence of spherical Bessel functions, jn(z)
sph_yn	**Sequence of spherical Bessel functions, yn(z)
sph_jnyn	**Sequence of spherical Bessel functions, jn(z) and yn(z)
sph_in	**Sequence of spherical Bessel functions, in(z)
sph_kn	**Sequence of spherical Bessel functions, kn(z)
sph_inkn	**Sequence of spherical Bessel functions, in(z) and kn(z)

Ricatti-Bessel Functions

riccati_jn	**Sequence of Ricatti-Bessel functions of first kind.
riccati_yn	**Sequence of Ricatti-Bessel functions of second kind.

Struve Functions

struve	Struve function --- Hv(x)
modstruve	Modified struve function --- Lv(x)
itstruve0	Integral of H0(t) from 0 to x
it2struve0	Integral of H0(t)/t from x to Inf.
itmodstruve0	Integral of L0(t) from 0 to x.

Raw Statistical Functions (Friendly versions in scipy.stats)

bdtr	Sum of terms 0 through k of of the binomial pdf.
bdtrc	Sum of terms k+1 through n of the binomial pdf.
bdtri	Inverse of bdtr
btdtr	Integral from 0 to x of beta pdf.
btdtri	Quantiles of beta distribution
fdtr	Integral from 0 to x of F pdf.
fdtrc	Integral from x to infinity under F pdf.
fdtri	Inverse of fdtrc
gdtr	Integral from 0 to x of gamma pdf.
gdtrc	Integral from x to infinity under gamma pdf.
gdtri	Quantiles of gamma distribution
nbdtr	Sum of terms 0 through k of the negative binomial pdf.
nbdtrc	Sum of terms k+1 to infinity under negative binomial pdf.
nbdtri	Inverse of nbdtr
pdtr	Sum of terms 0 through k of the Poisson pdf.
pdtrc	Sum of terms k+1 to infinity of the Poisson pdf.
pdtri	Inverse of pdtr
stdtr	Integral from -infinity to t of the Student-t pdf.
stdtri	Inverse of stdtr (quantiles)
chdtr	Integral from 0 to x of the Chi-square pdf.
chdtrc	Integral from x to infnity of Chi-square pdf.
chdtri	Inverse of chdtrc.
ndtr	Integral from -infinity to x of standard normal pdf
ndtri	Inverse of ndtr (quantiles)
smirnov	Kolmogorov-Smirnov complementary CDF for one-sided test statistic (Dn+ or Dn-)
smirnovi	Inverse of smirnov.
kolmogorov	The complementary CDF of the (scaled) two-sided test statistic (Kn*) valid for large n.
tklmbda	Tukey-Lambda CDF

Gamma and Related Functions

gamma	Gamma function.
gammaln	Log of the absolute value of the gamma function.
gammainc	Incomplete gamma integral.
gammaincinv	Inverse of gammainc.
gammaincc	Complemented incomplete gamma integral.
gammainccinv	Inverse of gammaincc.
beta	Beta function.
betaln	Log of the absolute value of the beta function.
betainc	Incomplete beta integral.
betaincinv	Inverse of betainc.
betaincinva	Inverse (in first argument, a) of betainc
betaincinvb	Inverse (in first argument, b) of betainc
psi(digamma)	Logarithmic derivative of the gamma function.
rgamma	One divided by the gamma function.
polygamma	Nth derivative of psi function.

Error Function and Fresnel Integrals

erf	Error function.
erfc	Complemented error function (1- erf(x))
erfinv	Inverse of error function
erfcinv	Inverse of erfc
erf_zeros	**Complex zeros of erf(z)
fresnel	Fresnel sine and cosine integrals.
fresnel_zeros	Complex zeros of both Fresnel integrals
fresnelc_zeros	**Complex zeros of fresnel cosine integrals
fresnels_zeros	**Complex zeros of fresnel sine integrals
modfresnelp	Modified Fresnel integrals F_+(x) and K_+(x)
modfresnelm	Modified Fresnel integrals F_-(x) and K_-(x)

Legendre Functions

lpn	**Legendre Functions (polynomials) of the first kind
lqn	**Legendre Functions of the second kind.
lpmn	**Associated Legendre Function of the first kind.
lqmn	**Associated Legendre Function of the second kind.
lpmv	Associated Legendre Function of arbitrary non-negative degree v.
sph_harm	Spherical Harmonics (complex-valued) Y^m_n(theta,phi)

Orthogonal polynomials --- 15 types

** These functions all return a polynomial class which can then be evaluated: vals = chebyt(n)(x) This class also has an attribute 'weights' which return the roots, weights, and total weights for the appropriate form of Gaussian quadrature. These are returned in an n x 3 array with roots in the first column, weights in the second column, and total weights in the final column

legendre	**Legendre polynomial P_n(x) (lpn for function).
chebyt	**Chebyshev polynomial T_n(x)
chebyu	**Chebyshev polynomial U_n(x)
chebyc	**Chebyshev polynomial C_n(x)
chebys	**Chebyshev polynomial S_n(x)
jacobi	**Jacobi polynomial P^(alpha,beta)_n(x)
laguerre	**Laguerre polynomial, L_n(x)
genlaguerre	**Generalized (Associated) Laguerre polynomial, L^alpha_n(x)
hermite	**Hermite polynomial H_n(x)
hermitenorm	**Normalized Hermite polynomial, He_n(x)
gegenbauer	**Gegenbauer (Ultraspherical) polynomials, C^(alpha)_n(x)
sh_legendre	*shifted Legendre polynomial, P_n(x)
sh_chebyt	*shifted Chebyshev polynomial, T_n(x)
sh_chebyu	*shifted Chebyshev polynomial, U_n(x)
sh_jacobi	*shifted Jacobi polynomial, J_n(x) = G^(p,q)_n(x)

HyperGeometric Functions

hyp2f1	Gauss hypergeometric function (2F1)
hyp1f1	Confluent hypergeometric function (1F1)
hyperu	Confluent hypergeometric function (U)
hyp0f1	Confluent hypergeometric limit function (0F1)
hyp2f0	Hypergeometric function (2F0)
hyp1f2	Hypergeometric function (1F2)
hyp3f0	Hypergeometric function (3F0)

Parabolic Cylinder Functions

pbdv	Parabolic cylinder function Dv(x) and derivative.
pbvv	Parabolic cylinder function Vv(x) and derivative.
pbwa	Parabolic cylinder function W(a,x) and derivative.
pbdv_seq	**Sequence of parabolic cylinder functions Dv(x)
pbvv_seq	**Sequence of parabolic cylinder functions Vv(x)
pbdn_seq	**Sequence of parabolic cylinder functions Dn(z), complex z

mathieu and Related Functions (and derivatives)
** All the following return both function and first derivative **

mathieu_a	Characteristic values for even solution (ce_m)
mathieu_b	Characteristic values for odd solution (se_m)
mathieu_even_coef	**sequence of expansion coefficients for even solution
mathieu_odd_coef	**sequence of expansion coefficients for odd solution
mathieu_cem	Even mathieu function
mathieu_sem	Odd mathieu function
mathieu_modcem1	Even modified mathieu function of the first kind
mathieu_modcem2	Even modified mathieu function of the second kind
mathieu_modsem1	Odd modified mathieu function of the first kind
mathieu_modsem2	Odd modified mathieu function of the second kind

Spheroidal Wave Functions
** The following functions require pre-computed characteristic values **

pro_ang1	Prolate spheroidal angular function of the first kind
pro_rad1	Prolate spheroidal radial function of the first kind
pro_rad2	Prolate spheroidal radial function of the second kind
obl_ang1	Oblate spheroidal angluar function of the first kind
obl_rad1	Oblate spheroidal radial function of the first kind
obl_rad2	Oblate spheroidal radial function of the second kind
pro_cv	Compute characteristic value for prolate functions
obl_cv	Compute characteristic value for oblate functions
pro_cv_seq	Compute sequence of prolate characteristic values
obl_cv_seq	Compute sequence of oblate characteristic values
pro_ang1_cv	Prolate spheroidal angular function of the first kind
pro_rad1_cv	Prolate spheroidal radial function of the first kind
pro_rad2_cv	Prolate spheroidal radial function of the second kind
obl_ang1_cv	Oblate spheroidal angluar function of the first kind
obl_rad1_cv	Oblate spheroidal radial function of the first kind
obl_rad2_cv	Oblate spheroidal radial function of the second kind

Kelvin Functions

kelvin	All Kelvin functions (order 0) and derivatives.
kelvin_zeros	**Zeros of All Kelvin functions (order 0) and derivatives
ber	Kelvin function ber x
bei	Kelvin function bei x
berp	Derivative of Kelvin function ber x
beip	Derivative of Kelvin function bei x
ker	Kelvin function ker x
kei	Kelvin function kei x
kerp	Derivative of Kelvin function ker x
keip	Derivative of Kelvin function kei x
ber_zeros	**Zeros of Kelvin function bei x
bei_zeros	**Zeros of Kelvin function ber x
berp_zeros	**Zeros of derivative of Kelvin function ber x
beip_zeros	**Zeros of derivative of Kelvin function bei x
ker_zeros	**Zeros of Kelvin function kei x
kei_zeros	**Zeros of Kelvin function ker x
kerp_zeros	**Zeros of derivative of Kelvin function ker x
keip_zeros	**Zeros of derivative of Kelvin function kei x

Other Special Functions

expn	Exponential integral.
exp1	Exponential integral of order 1 (for complex argument)
expi	Another exponential integral Ei(x)
wofz	Fadeeva function.
dawsn	Dawson's integral.
shichi	Hyperbolic sine and cosine integrals.
sici	Integral of the sinc and "cosinc" functions.
spence	Dilogarithm integral.
zeta	Riemann zeta function of two arguments.
zetac	1.0 - standard Riemann zeta function.

Convenience Functions

cbrt	Cube root.
exp10	10 raised to the x power.
exp2	2 raised to the x power.
radian	radian angle given degrees, minutes, and seconds.
cosdg	cosine of the angle given in degrees.
sindg	sine of the angle given in degrees.
tandg	tangent of the angle given in degrees.
cotdg	cotangent of the angle given in degrees.
log1p	log(1+x)
expm1	exp(x)-1
cosm1	cos(x)-1
round	round the argument to the nearest integer. If argument ends in 0.5 exactly, pick the nearest even integer.

** in the description indicates a function which is not a universal function and does not follow broadcasting and automatic array-looping rules.

Error handling:
Errors are handled by returning nans, or other appropriate values. Some of the special function routines will print an error message when an error occurs. By default this printing is disabled. To enable such messages use errprint(1) To disable such messages use errprint(0).

Example:

>>> print scipy.special.bdtr(-1,10,0.3)
>>> scipy.special.errprint(1)
>>> print scipy.special.bdtr(-1,10,0.3)

Statistical Functions
=====================

This module contains a large number of probability distributions as well as a growing library of statistical functions.
Each included distribution is an instance of the class rv_continous. For each given name the following methods are available. See docstring for rv_continuous for more information

rvs	random variates with the distribution
pdf	probability density function
cdf	cummulative distribution function
sf	survival function (1.0 - cdf)
ppf	percent-point function (inverse of cdf)
isf	inverse survival function
stats	mean, variance, and optionally skew and kurtosis

Calling the instance as a function returns a frozen pdf whose shape, location, and scale parameters are fixed.
The distributions available with the above methods are:

CONTINUOUS (Total == 81 distributions)
===========

norm	Normal (Gaussian)
alpha	Alpha
anglit	Anglit
arcsine	Arcsine
beta	Beta
betaprime	Beta Prime
bradford	Bradford
burr	Burr
fisk	Fisk
cauchy	Cauchy
chi	Chi
chi2	Chi-squared
cosine	Cosine
dgamma	Double Gamma
dweibull	Double Weibull
erlang	Erlang
expon	Exponential
exponweib	Exponentiated Weibull
exponpow	Exponential Power
fatiguelife	Fatigue Life (Birnbaum-Sanders)
foldcauchy	Folded Cauchy
f	F (Snecdor F)
foldnorm	Folded Normal
frechet_r	Frechet Right Sided, Extreme Value Type II (Extreme LB) or weibull_min
frechet_l	Frechet Left Sided, Weibull_max
genlogistic	Generalized Logistic
genpareto	Generalized Pareto
genexpon	Generalized Exponential
genextreme	Generalized Extreme Value
gausshyper	Gauss Hypergeometric
gamma	Gamma
gengamma	Generalized gamma
genhalflogistic	Generalized Half Logistic
gompertz	Gompertz (Truncated Gumbel)
gumbel_r	Right Sided Gumbel, Log-Weibull, Fisher-Tippett, Extreme Value Type I
gumbel_l	Left Sided Gumbel, etc.
halfcauchy	Half Cauchy
halflogistic	Half Logistic
halfnorm	Half Normal
hypsecant	Hyperbolic Secant
invgamma	Inverse Gamma
invnorm	Inverse Normal
invweibull	Inverse Weibull
johnsonsb	Johnson SB
johnsonsu	Johnson SU
laplace	Laplace
logistic	Logistic
loggamma	Log-Gamma
loglaplace	Log-Laplace (Log Double Exponential)
lognorm	Log-Normal
gilbrat	Gilbrat
lomax	Lomax (Pareto of the second kind)
maxwell	Maxwell
mielke	Mielke's Beta-Kappa
nakagami	Nakagami
ncx2	Non-central chi-squared
ncf	Non-central F
t	Student's T
nct	Non-central Student's T
pareto	Pareto
powerlaw	Power-function
powerlognorm	Power log normal
powernorm	Power normal
rdist	R distribution
reciprocal	Reciprocal
rayleigh	Rayleigh
rice	Rice
recipinvgauss	Reciprocal Inverse Gaussian
semicircular	Semicircular
triang	Triangular
truncexpon	Truncated Exponential
truncnorm	Truncated Normal
tukeylambda	Tukey-Lambda
uniform	Uniform
von_mises	Von-Mises (Circular)
wald	Waldv
weibull_min	Minimum Weibull (see Frechet)
weibull_max	Maximum Weibull (see Frechet)
wrapcauchy	Wrapped Cauchy
ksone	Kolmogorov-Smirnov one-sided (no stats)
kstwobign	Kolmogorov-Smirnov two-sided test for Large N (no stats)

DISCRETE (Total == 10 distributions)
============

binom	Binomial
bernoulli	Bernoulli
nbinom	Negative Binomial
geom	Geometric
hypergeom	Hypergeometric
logser	Logarithmic (Log-Series, Series)
poisson	Poisson
planck	Planck (Discrete Exponential)
boltzmann	Boltzmann (Truncated Discrete Exponential)
randint	Discrete Uniform
zipf	Zipf
dlaplace	Discrete Laplacian

Statistical Functions (adapted from Gary Strangman)

gmean	_
hmean	_
mean	_
cmedian	_
median	_
mode	_
tmean	_
tvar	_
tmin	_
tmax	_
tstd	_
tsem	_
moment	_
variation	_
skew	_
kurtosis	_
describe	_
skewtest	_
kurtosistest	_
normaltest	_
itemfreq	_
scoreatpercentile	_
percentileofscore	_
histogram2	_
histogram	_
cumfreq	_
relfreq	_
obrientransform	_
samplevar	_
samplestd	_
signaltonoise	_
bayes_mvs	_
var	_
std	_
stderr	_
sem	_
z	_
zs	_
zmap	_
threshold	_
trimboth	_
trim1	_
cov	_
corrcoef	_
f_oneway	_
paired	_
pearsonr	_
spearmanr	_
pointbiserialr	_
kendalltau	_
linregress	_
ttest_1samp	_
ttest_ind	_
ttest_rel	_
kstest	_
chisquare	_
ks_2samp	_
meanwhitneyu	_
tiecorrect	_
ranksums	_
wilcoxon	_
kruskal	_
friedmanchisquare	_
ansari	_
bartlett	_
levene	_
shapiro	_
anderson	_
binom_test	_
fligner	_
mood	_
oneway	_
glm	_
anova	_

Plot-tests

probplot	_
ppcc_max	_
ppcc_plot	_

For many more stat related functions install the software R and the interface package rpy.

C/C++ integration
=================

inline	a function for including C/C++ code within Python
blitz	a function for compiling Numeric expressions to C++
ext_tools	a module that helps construct C/C++ extension modules.
accelerate	a module that inline accelerates Python functions

ARRAYS

ARRAY OBJECTS

Array construction

ARRAY ATTRIBUTES

ARRAY METHODS

ARRAY FUNCTIONS

SCIPY SUBPACKAGES