FM / doc

/usr/lib64/python2.6/site-packages/numpy/doc/

/usr/lib64/python2.6/site-packages/numpy/doc

Name	Size	Mode	Actions
basics.py	5181	0644	edit dl rm
basics.pyc	5338	0644	edit dl rm
basics.pyo	5338	0644	edit dl rm
broadcasting.py	5511	0644	edit dl rm
broadcasting.pyc	5674	0644	edit dl rm
broadcasting.pyo	5674	0644	edit dl rm
byteswapping.py	4783	0644	edit dl rm
byteswapping.pyc	4942	0644	edit dl rm
byteswapping.pyo	4942	0644	edit dl rm
constants.py	8906	0644	edit dl rm
constants.pyc	8158	0644	edit dl rm
constants.pyo	8158	0644	edit dl rm
creation.py	5425	0644	edit dl rm
creation.pyc	5584	0644	edit dl rm
creation.pyo	5584	0644	edit dl rm
glossary.py	10984	0644	edit dl rm
glossary.pyc	11143	0644	edit dl rm
glossary.pyo	11143	0644	edit dl rm
howtofind.py	94	0644	edit dl rm
howtofind.pyc	254	0644	edit dl rm
howtofind.pyo	254	0644	edit dl rm
indexing.py	14286	0644	edit dl rm
indexing.pyc	14445	0644	edit dl rm
indexing.pyo	14445	0644	edit dl rm
internals.py	9608	0644	edit dl rm
internals.pyc	9768	0644	edit dl rm
internals.pyo	9768	0644	edit dl rm
io.py	82	0644	edit dl rm
io.pyc	235	0644	edit dl rm
io.pyo	235	0644	edit dl rm
jargon.py	96	0644	edit dl rm
jargon.pyc	253	0644	edit dl rm
jargon.pyo	253	0644	edit dl rm
methods_vs_functions.py	130	0644	edit dl rm
methods_vs_functions.pyc	301	0644	edit dl rm
methods_vs_functions.pyo	301	0644	edit dl rm
misc.py	5725	0644	edit dl rm
misc.pyc	5880	0644	edit dl rm
misc.pyo	5880	0644	edit dl rm
performance.py	100	0644	edit dl rm
performance.pyc	262	0644	edit dl rm
performance.pyo	262	0644	edit dl rm
structured_arrays.py	7212	0644	edit dl rm
structured_arrays.pyc	7380	0644	edit dl rm
structured_arrays.pyo	7380	0644	edit dl rm
subclassing.py	20160	0644	edit dl rm
subclassing.pyc	20322	0644	edit dl rm
subclassing.pyo	20322	0644	edit dl rm
ufuncs.py	5520	0644	edit dl rm
ufuncs.pyc	5675	0644	edit dl rm
ufuncs.pyo	5675	0644	edit dl rm
__init__.py	464	0644	edit dl rm
__init__.pyc	755	0644	edit dl rm
__init__.pyo	755	0644	edit dl rm

Edit: /usr/lib64/python2.6/site-packages/numpy/doc/glossary.py (10984B)

"""
========
Glossary
========

along an axis
    Axes are defined for arrays with more than one dimension.  A
    2-dimensional array has two corresponding axes: the first running
    vertically downwards across rows (axis 0), and the second running
    horizontally across columns (axis 1).

Many operation can take place along one of these axes.  For example,
    we can sum each row of an array, in which case we operate along
    columns, or axis 1::

>>> x = np.arange(12).reshape((3,4))

>>> x
      array([[ 0,  1,  2,  3],
             [ 4,  5,  6,  7],
             [ 8,  9, 10, 11]])

>>> x.sum(axis=1)
      array([ 6, 22, 38])

array
    A homogeneous container of numerical elements.  Each element in the
    array occupies a fixed amount of memory (hence homogeneous), and
    can be a numerical element of a single type (such as float, int
    or complex) or a combination (such as ``(float, int, float)``).  Each
    array has an associated data-type (or ``dtype``), which describes
    the numerical type of its elements::

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

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

>>> x.dtype # floating point number, 64 bits of memory per element
      dtype('float64')

# More complicated data type: each array element is a combination of
      # and integer and a floating point number
      >>> np.array([(1, 2.0), (3, 4.0)], dtype=[('x', int), ('y', float)])
      array([(1, 2.0), (3, 4.0)],
            dtype=[('x', '<i4'), ('y', '<f8')])

Fast element-wise operations, called `ufuncs`_, operate on arrays.

array_like
    Any sequence that can be interpreted as an ndarray.  This includes
    nested lists, tuples, scalars and existing arrays.

attribute
    A property of an object that can be accessed using ``obj.attribute``,
    e.g., ``shape`` is an attribute of an array::

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

BLAS
    `Basic Linear Algebra Subprograms <http://en.wikipedia.org/wiki/BLAS>`_

broadcast
    NumPy can do operations on arrays whose shapes are mismatched::

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

>>> x
      array([1, 2])

>>> y
      array([[3],
             [4]])

>>> x + y
      array([[4, 5],
             [5, 6]])

See `doc.broadcasting`_ for more information.

C order
    See `row-major`

column-major
    A way to represent items in a N-dimensional array in the 1-dimensional
    computer memory. In column-major order, the leftmost index "varies the
    fastest": for example the array::

[[1, 2, 3],
          [4, 5, 6]]

is represented in the column-major order as::

[1, 4, 2, 5, 3, 6]

Column-major order is also known as the Fortran order, as the Fortran
    programming language uses it.

decorator
    An operator that transforms a function.  For example, a ``log``
    decorator may be defined to print debugging information upon
    function execution::

>>> def log(f):
      ...     def new_logging_func(*args, **kwargs):
      ...         print "Logging call with parameters:", args, kwargs
      ...         return f(*args, **kwargs)
      ...
      ...     return new_logging_func

Now, when we define a function, we can "decorate" it using ``log``::

>>> @log
      ... def add(a, b):
      ...     return a + b

Calling ``add`` then yields:

>>> add(1, 2)
    Logging call with parameters: (1, 2) {}
    3

dictionary
    Resembling a language dictionary, which provides a mapping between
    words and descriptions thereof, a Python dictionary is a mapping
    between two objects::

>>> x = {1: 'one', 'two': [1, 2]}

Here, `x` is a dictionary mapping keys to values, in this case
    the integer 1 to the string "one", and the string "two" to
    the list ``[1, 2]``.  The values may be accessed using their
    corresponding keys::

>>> x[1]
      'one'

>>> x['two']
      [1, 2]

Note that dictionaries are not stored in any specific order.  Also,
    most mutable (see *immutable* below) objects, such as lists, may not
    be used as keys.

For more information on dictionaries, read the
    `Python tutorial <http://docs.python.org/tut>`_.

Fortran order
    See `column-major`

flattened
    Collapsed to a one-dimensional array. See `ndarray.flatten`_ for details.

immutable
    An object that cannot be modified after execution is called
    immutable.  Two common examples are strings and tuples.

instance
    A class definition gives the blueprint for constructing an object::

>>> class House(object):
      ...     wall_colour = 'white'

Yet, we have to *build* a house before it exists::

>>> h = House() # build a house

Now, ``h`` is called a ``House`` instance.  An instance is therefore
    a specific realisation of a class.

iterable
    A sequence that allows "walking" (iterating) over items, typically
    using a loop such as::

>>> x = [1, 2, 3]
      >>> [item**2 for item in x]
      [1, 4, 9]

It is often used in combintion with ``enumerate``::

>>> for n, k in enumerate(keys):
      ...     print "Key %d: %s" % (n, k)
      ...
      Key 0: a
      Key 1: b
      Key 2: c

list
    A Python container that can hold any number of objects or items.
    The items do not have to be of the same type, and can even be
    lists themselves::

>>> x = [2, 2.0, "two", [2, 2.0]]

The list `x` contains 4 items, each which can be accessed individually::

>>> x[2] # the string 'two'
      'two'

>>> x[3] # a list, containing an integer 2 and a float 2.0
      [2, 2.0]

It is also possible to select more than one item at a time,
    using *slicing*::

>>> x[0:2] # or, equivalently, x[:2]
      [2, 2.0]

In code, arrays are often conveniently expressed as nested lists::

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

For more information, read the section on lists in the `Python
    tutorial <http://docs.python.org/tut>`_.  For a mapping
    type (key-value), see *dictionary*.

mask
    A boolean array, used to select only certain elements for an operation::

>>> x = np.arange(5)
      >>> x
      array([0, 1, 2, 3, 4])

>>> mask = (x > 2)
      >>> mask
      array([False, False, False, True,  True], dtype=bool)

>>> x[mask] = -1
      >>> x
      array([ 0,  1,  2,  -1, -1])

masked array
    Array that suppressed values indicated by a mask::

>>> x = np.ma.masked_array([np.nan, 2, np.nan], [True, False, True])
      >>> x
      masked_array(data = [-- 2.0 --],
            mask = [ True False  True],
            fill_value=1e+20)

>>> x + [1, 2, 3]
      masked_array(data = [-- 4.0 --],
            mask = [ True False  True],
            fill_value=1e+20)

Masked arrays are often used when operating on arrays containing
    missing or invalid entries.

matrix
    A 2-dimensional ndarray that preserves its two-dimensional nature
    throughout operations.  It has certain special operations, such as ``*``
    (matrix multiplication) and ``**`` (matrix power), defined::

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

>>> x
      matrix([[1, 2],
              [3, 4]])

>>> x**2
      matrix([[ 7, 10],
            [15, 22]])

method
    A function associated with an object.  For example, each ndarray has a
    method called ``repeat``::

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

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

ndarray
    See *array*.

reference
    If ``a`` is a reference to ``b``, then ``(a is b) == True``.  Therefore,
    ``a`` and ``b`` are different names for the same Python object.

row-major
    A way to represent items in a N-dimensional array in the 1-dimensional
    computer memory. In row-major order, the rightmost index "varies
    the fastest": for example the array::

[[1, 2, 3],
          [4, 5, 6]]

is represented in the row-major order as::

[1, 2, 3, 4, 5, 6]

Row-major order is also known as the C order, as the C programming
    language uses it. New Numpy arrays are by default in row-major order.

self
    Often seen in method signatures, ``self`` refers to the instance
    of the associated class.  For example:

>>> class Paintbrush(object):
      ...     color = 'blue'
      ...
      ...     def paint(self):
      ...         print "Painting the city %s!" % self.color
      ...
      >>> p = Paintbrush()
      >>> p.color = 'red'
      >>> p.paint() # self refers to 'p'
      Painting the city red!

slice
    Used to select only certain elements from a sequence::

>>> x = range(5)
      >>> x
      [0, 1, 2, 3, 4]

>>> x[1:3] # slice from 1 to 3 (excluding 3 itself)
      [1, 2]

>>> x[1:5:2] # slice from 1 to 5, but skipping every second element
      [1, 3]

>>> x[::-1] # slice a sequence in reverse
      [4, 3, 2, 1, 0]

Arrays may have more than one dimension, each which can be sliced
    individually::

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

>>> x[:, 1]
      array([2, 4])

tuple
    A sequence that may contain a variable number of types of any
    kind.  A tuple is immutable, i.e., once constructed it cannot be
    changed.  Similar to a list, it can be indexed and sliced::

>>> x = (1, 'one', [1, 2])

>>> x
      (1, 'one', [1, 2])

>>> x[0]
      1

>>> x[:2]
      (1, 'one')

A useful concept is "tuple unpacking", which allows variables to
    be assigned to the contents of a tuple::

>>> x, y = (1, 2)
      >>> x, y = 1, 2

This is often used when a function returns multiple values:

>>> def return_many():
      ...     return 1, 'alpha'

>>> a, b, c = return_many()
      >>> a, b, c
      (1, 'alpha', None)

>>> a
      1
      >>> b
      'alpha'

ufunc
    Universal function.  A fast element-wise array operation.  Examples include
    ``add``, ``sin`` and ``logical_or``.

view
    An array that does not own its data, but refers to another array's
    data instead.  For example, we may create a view that only shows
    every second element of another array::

>>> x = np.arange(5)
      >>> x
      array([0, 1, 2, 3, 4])

>>> y = x[::2]
      >>> y
      array([0, 2, 4])

>>> x[0] = 3 # changing x changes y as well, since y is a view on x
      >>> y
      array([3, 2, 4])

wrapper
    Python is a high-level (highly abstracted, or English-like) language.
    This abstraction comes at a price in execution speed, and sometimes
    it becomes necessary to use lower level languages to do fast
    computations.  A wrapper is code that provides a bridge between
    high and the low level languages, allowing, e.g., Python to execute
    code written in C or Fortran.

Examples include ctypes, SWIG and Cython (which wraps C and C++)
    and f2py (which wraps Fortran).

"""

cmd: