Na}{

File Content: `constants.pyo`

�
�9Zc�����������@`�sg��d��Z��d�d�l�m�Z�m�Z�m�Z�d�d�l�Z�d�d�l�Z�g��Z�d����Z�e�d�d�d���e�d�d�d���e�d�d	�d
���e�d�d�d���e�d�d
�d���e�d�d�d���e�d�d�d���e�d�d�d���e�d�d�d���e�d�d�d���e�d�d�d���e�d�d�d���e�d�d�d���e��r]g��Z	�e�j
����x��e�D]��\�Z�Z�e�j
�e���j�d�d���Z�e�j�d���Z�g��Z�x~�e�D]v�Z�e�j�d�e���Z�e�r�e�r�e�j
�e�j������Z�e�j�d �e�j�d!���e�f���e�j�d"���qye�j�e���qyWd�j�e���Z�e	�j�d#�e�e�f���q6Wd�j�e	���Z	�e��e�d$�e	���Z��[	�[�[�[�[�[�[�[�[�n��[�[�d�S(%���sU���
=========
Constants
=========

Numpy includes several constants:

%(constant_list)s
i����(���t���divisiont���absolute_importt���print_functionNc���������C`�s���t��j�|�|�f���d��S(���N(���t	���constantst���append(���t���modulet���namet���doc(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/doc/constants.pyt
���add_newdoc���s����t���numpyt���Infs����
    IEEE 754 floating point representation of (positive) infinity.

    Use `inf` because `Inf`, `Infinity`, `PINF` and `infty` are aliases for
    `inf`. For more details, see `inf`.

    See Also
    --------
    inf

    t���Infinityt���NANs����
    IEEE 754 floating point representation of Not a Number (NaN).

    `NaN` and `NAN` are equivalent definitions of `nan`. Please use
    `nan` instead of `NAN`.

    See Also
    --------
    nan

    t���NINFs���
    IEEE 754 floating point representation of negative infinity.

    Returns
    -------
    y : float
        A floating point representation of negative infinity.

    See Also
    --------
    isinf : Shows which elements are positive or negative infinity

    isposinf : Shows which elements are positive infinity

    isneginf : Shows which elements are negative infinity

    isnan : Shows which elements are Not a Number

    isfinite : Shows which elements are finite (not one of Not a Number,
    positive infinity and negative infinity)

    Notes
    -----
    Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic
    (IEEE 754). This means that Not a Number is not equivalent to infinity.
    Also that positive infinity is not equivalent to negative infinity. But
    infinity is equivalent to positive infinity.

    Examples
    --------
    >>> np.NINF
    -inf
    >>> np.log(0)
    -inf

    t���NZEROs���
    IEEE 754 floating point representation of negative zero.

    Returns
    -------
    y : float
        A floating point representation of negative zero.

    See Also
    --------
    PZERO : Defines positive zero.

    isinf : Shows which elements are positive or negative infinity.

    isposinf : Shows which elements are positive infinity.

    isneginf : Shows which elements are negative infinity.

    isnan : Shows which elements are Not a Number.

    isfinite : Shows which elements are finite - not one of
               Not a Number, positive infinity and negative infinity.

    Notes
    -----
    Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic
    (IEEE 754). Negative zero is considered to be a finite number.

    Examples
    --------
    >>> np.NZERO
    -0.0
    >>> np.PZERO
    0.0

    >>> np.isfinite([np.NZERO])
    array([ True], dtype=bool)
    >>> np.isnan([np.NZERO])
    array([False], dtype=bool)
    >>> np.isinf([np.NZERO])
    array([False], dtype=bool)

    t���NaNs����
    IEEE 754 floating point representation of Not a Number (NaN).

    `NaN` and `NAN` are equivalent definitions of `nan`. Please use
    `nan` instead of `NaN`.

    See Also
    --------
    nan

    t���PINFt���PZEROs���
    IEEE 754 floating point representation of positive zero.

    Returns
    -------
    y : float
        A floating point representation of positive zero.

    See Also
    --------
    NZERO : Defines negative zero.

    isinf : Shows which elements are positive or negative infinity.

    isposinf : Shows which elements are positive infinity.

    isneginf : Shows which elements are negative infinity.

    isnan : Shows which elements are Not a Number.

    isfinite : Shows which elements are finite - not one of
               Not a Number, positive infinity and negative infinity.

    Notes
    -----
    Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic
    (IEEE 754). Positive zero is considered to be a finite number.

    Examples
    --------
    >>> np.PZERO
    0.0
    >>> np.NZERO
    -0.0

    >>> np.isfinite([np.PZERO])
    array([ True], dtype=bool)
    >>> np.isnan([np.PZERO])
    array([False], dtype=bool)
    >>> np.isinf([np.PZERO])
    array([False], dtype=bool)

    t���es=��
    Euler's constant, base of natural logarithms, Napier's constant.

    ``e = 2.71828182845904523536028747135266249775724709369995...``

    See Also
    --------
    exp : Exponential function
    log : Natural logarithm

    References
    ----------
    .. [1] http://en.wikipedia.org/wiki/Napier_constant

    t���infs���
    IEEE 754 floating point representation of (positive) infinity.

    Returns
    -------
    y : float
        A floating point representation of positive infinity.

    See Also
    --------
    isinf : Shows which elements are positive or negative infinity

    isposinf : Shows which elements are positive infinity

    isneginf : Shows which elements are negative infinity

    isnan : Shows which elements are Not a Number

    isfinite : Shows which elements are finite (not one of Not a Number,
    positive infinity and negative infinity)

    Notes
    -----
    Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic
    (IEEE 754). This means that Not a Number is not equivalent to infinity.
    Also that positive infinity is not equivalent to negative infinity. But
    infinity is equivalent to positive infinity.

    `Inf`, `Infinity`, `PINF` and `infty` are aliases for `inf`.

    Examples
    --------
    >>> np.inf
    inf
    >>> np.array([1]) / 0.
    array([ Inf])

    t���inftyt���nans���
    IEEE 754 floating point representation of Not a Number (NaN).

    Returns
    -------
    y : A floating point representation of Not a Number.

    See Also
    --------
    isnan : Shows which elements are Not a Number.
    isfinite : Shows which elements are finite (not one of
               Not a Number, positive infinity and negative infinity)

    Notes
    -----
    Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic
    (IEEE 754). This means that Not a Number is not equivalent to infinity.

    `NaN` and `NAN` are aliases of `nan`.

    Examples
    --------
    >>> np.nan
    nan
    >>> np.log(-1)
    nan
    >>> np.log([-1, 1, 2])
    array([        NaN,  0.        ,  0.69314718])

    t���newaxiss9��
    A convenient alias for None, useful for indexing arrays.

    See Also
    --------
    `numpy.doc.indexing`

    Examples
    --------
    >>> newaxis is None
    True
    >>> x = np.arange(3)
    >>> x
    array([0, 1, 2])
    >>> x[:, newaxis]
    array([[0],
    [1],
    [2]])
    >>> x[:, newaxis, newaxis]
    array([[[0]],
    [[1]],
    [[2]]])
    >>> x[:, newaxis] * x
    array([[0, 0, 0],
    [0, 1, 2],
    [0, 2, 4]])

    Outer product, same as ``outer(x, y)``:

    >>> y = np.arange(3, 6)
    >>> x[:, newaxis] * y
    array([[ 0,  0,  0],
    [ 3,  4,  5],
    [ 6,  8, 10]])

    ``x[newaxis, :]`` is equivalent to ``x[newaxis]`` and ``x[None]``:

    >>> x[newaxis, :].shape
    (1, 3)
    >>> x[newaxis].shape
    (1, 3)
    >>> x[None].shape
    (1, 3)
    >>> x[:, newaxis].shape
    (3, 1)

    s���
s���
    s���^(\s+)[-=]+\s*$s���%s.. rubric:: %si���t����s���.. const:: %s
    %st
���constant_list(���t���__doc__t
���__future__R����R���R���t���textwrapt���reR���R���t
���constants_strt���sortR���R���t���dedentt���replacet���st���splitt���linest	���new_linest���linet���matcht���mt���popt���prevR���t���groupt���joint���dict(����(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/doc/constants.pyt���<module>	���sf���					$	+			+		&			/

Name	Size	Permission
__init__.py	574 bytes	0644
__init__.pyc	1080 bytes	0644
__init__.pyo	1080 bytes	0644
basics.py	7870 bytes	0644
basics.pyc	8097 bytes	0644
basics.pyo	8097 bytes	0644
broadcasting.py	5565 bytes	0644
broadcasting.pyc	5798 bytes	0644
broadcasting.pyo	5798 bytes	0644
byteswapping.py	5349 bytes	0644
byteswapping.pyc	5578 bytes	0644
byteswapping.pyo	5578 bytes	0644
constants.py	8954 bytes	0644
constants.pyc	8274 bytes	0644
constants.pyo	8274 bytes	0644
creation.py	5507 bytes	0644
creation.pyc	5736 bytes	0644
creation.pyo	5736 bytes	0644
glossary.py	12346 bytes	0644
glossary.pyc	12575 bytes	0644
glossary.pyo	12575 bytes	0644
indexing.py	15672 bytes	0644
indexing.pyc	15901 bytes	0644
indexing.pyo	15901 bytes	0644
internals.py	9673 bytes	0644
internals.pyc	9903 bytes	0644
internals.pyo	9903 bytes	0644
misc.py	6165 bytes	0644
misc.pyc	6390 bytes	0644
misc.pyo	6390 bytes	0644
structured_arrays.py	11442 bytes	0644
structured_arrays.pyc	11680 bytes	0644
structured_arrays.pyo	11680 bytes	0644
subclassing.py	20243 bytes	0644
subclassing.pyc	20475 bytes	0644
subclassing.pyo	20475 bytes	0644
ufuncs.py	5427 bytes	0644
ufuncs.pyc	5652 bytes	0644
ufuncs.pyo	5652 bytes	0644

File Content: constants.pyo

File Content: `constants.pyo`