FM / core

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

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

Name	Size	Mode	Actions
include/	-	0755	rm
lib/	-	0755	rm
tests/	-	0755	rm
arrayprint.py	16812	0644	edit dl rm
arrayprint.pyc	15601	0644	edit dl rm
arrayprint.pyo	15601	0644	edit dl rm
defchararray.py	69952	0644	edit dl rm
defchararray.pyc	78326	0644	edit dl rm
defchararray.pyo	78326	0644	edit dl rm
defmatrix.py	28094	0644	edit dl rm
defmatrix.pyc	30970	0644	edit dl rm
defmatrix.pyo	30970	0644	edit dl rm
fromnumeric.py	71135	0644	edit dl rm
fromnumeric.pyc	75079	0644	edit dl rm
fromnumeric.pyo	75079	0644	edit dl rm
function_base.py	5201	0644	edit dl rm
function_base.pyc	5569	0644	edit dl rm
function_base.pyo	5569	0644	edit dl rm
generate_numpy_api.py	6444	0644	edit dl rm
generate_numpy_api.pyc	6202	0644	edit dl rm
generate_numpy_api.pyo	6141	0644	edit dl rm
getlimits.py	8790	0644	edit dl rm
getlimits.pyc	10068	0644	edit dl rm
getlimits.pyo	10068	0644	edit dl rm
info.py	4635	0644	edit dl rm
info.pyc	4806	0644	edit dl rm
info.pyo	4806	0644	edit dl rm
machar.py	10658	0644	edit dl rm
machar.pyc	8694	0644	edit dl rm
machar.pyo	8694	0644	edit dl rm
memmap.py	9301	0644	edit dl rm
memmap.pyc	9534	0644	edit dl rm
memmap.pyo	9534	0644	edit dl rm
multiarray.so	584824	0755	edit dl rm
multiarray_tests.so	13008	0755	edit dl rm
numeric.py	68280	0644	edit dl rm
numeric.pyc	72033	0644	edit dl rm
numeric.pyo	72033	0644	edit dl rm
numerictypes.py	25088	0644	edit dl rm
numerictypes.pyc	24189	0644	edit dl rm
numerictypes.pyo	24144	0644	edit dl rm
records.py	26838	0644	edit dl rm
records.pyc	24437	0644	edit dl rm
records.pyo	24437	0644	edit dl rm
scalarmath.so	164928	0755	edit dl rm
scons_support.py	8352	0644	edit dl rm
scons_support.pyc	9342	0644	edit dl rm
scons_support.pyo	9342	0644	edit dl rm
setup.py	32450	0644	edit dl rm
setup.pyc	23292	0644	edit dl rm
setup.pyo	23292	0644	edit dl rm
setupscons.py	4516	0644	edit dl rm
setupscons.pyc	4087	0644	edit dl rm
setupscons.pyo	4087	0644	edit dl rm
setup_common.py	10069	0644	edit dl rm
setup_common.pyc	8353	0644	edit dl rm
setup_common.pyo	8353	0644	edit dl rm
shape_base.py	6294	0644	edit dl rm
shape_base.pyc	7123	0644	edit dl rm
shape_base.pyo	7123	0644	edit dl rm
umath.so	325904	0755	edit dl rm
umath_tests.so	12192	0755	edit dl rm
_dotblas.so	20712	0755	edit dl rm
_internal.py	10368	0644	edit dl rm
_internal.pyc	10870	0644	edit dl rm
_internal.pyo	10870	0644	edit dl rm
_mx_datetime_parser.py	33252	0644	edit dl rm
_mx_datetime_parser.pyc	29029	0644	edit dl rm
_mx_datetime_parser.pyo	29029	0644	edit dl rm
_sort.so	90736	0755	edit dl rm
__init__.py	983	0644	edit dl rm
__init__.pyc	1261	0644	edit dl rm
__init__.pyo	1261	0644	edit dl rm

Edit: /usr/lib64/python2.6/site-packages/numpy/core/machar.py (10658B)

"""
Machine arithmetics - determine the parameters of the
floating-point arithmetic system
"""
# Author: Pearu Peterson, September 2003

__all__ = ['MachAr']

from numpy.core.fromnumeric import any
from numpy.core.numeric import seterr

# Need to speed this up...especially for longfloat

class MachAr(object):
    """
    Diagnosing machine parameters.

Attributes
    ----------
    ibeta : int
        Radix in which numbers are represented.
    it : int
        Number of base-`ibeta` digits in the floating point mantissa M.
    machep : int
        Exponent of the smallest (most negative) power of `ibeta` that,
        added to 1.0, gives something different from 1.0
    eps : float
        Floating-point number ``beta**machep`` (floating point precision)
    negep : int
        Exponent of the smallest power of `ibeta` that, substracted
        from 1.0, gives something different from 1.0.
    epsneg : float
        Floating-point number ``beta**negep``.
    iexp : int
        Number of bits in the exponent (including its sign and bias).
    minexp : int
        Smallest (most negative) power of `ibeta` consistent with there
        being no leading zeros in the mantissa.
    xmin : float
        Floating point number ``beta**minexp`` (the smallest [in
        magnitude] usable floating value).
    maxexp : int
        Smallest (positive) power of `ibeta` that causes overflow.
    xmax : float
        ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
        usable floating value).
    irnd : int
        In ``range(6)``, information on what kind of rounding is done
        in addition, and on how underflow is handled.
    ngrd : int
        Number of 'guard digits' used when truncating the product
        of two mantissas to fit the representation.
    epsilon : float
        Same as `eps`.
    tiny : float
        Same as `xmin`.
    huge : float
        Same as `xmax`.
    precision : float
        ``- int(-log10(eps))``
    resolution : float
        ``- 10**(-precision)``

Parameters
    ----------
    float_conv : function, optional
        Function that converts an integer or integer array to a float
        or float array. Default is `float`.
    int_conv : function, optional
        Function that converts a float or float array to an integer or
        integer array. Default is `int`.
    float_to_float : function, optional
        Function that converts a float array to float. Default is `float`.
        Note that this does not seem to do anything useful in the current
        implementation.
    float_to_str : function, optional
        Function that converts a single float to a string. Default is
        ``lambda v:'%24.16e' %v``.
    title : str, optional
        Title that is printed in the string representation of `MachAr`.

See Also
    --------
    finfo : Machine limits for floating point types.
    iinfo : Machine limits for integer types.

References
    ----------
    .. [1] Press, Teukolsky, Vetterling and Flannery,
           "Numerical Recipes in C++," 2nd ed,
           Cambridge University Press, 2002, p. 31.

"""
    def __init__(self, float_conv=float,int_conv=int,
                 float_to_float=float,
                 float_to_str = lambda v:'%24.16e' % v,
                 title = 'Python floating point number'):
        """
          float_conv - convert integer to float (array)
          int_conv   - convert float (array) to integer
          float_to_float - convert float array to float
          float_to_str - convert array float to str
          title        - description of used floating point numbers
        """
        # We ignore all errors here because we are purposely triggering
        # underflow to detect the properties of the runninng arch.
        saverrstate = seterr(under='ignore')
        try:
            self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)
        finally:
            seterr(**saverrstate)

def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title):
        max_iterN = 10000
        msg = "Did not converge after %d tries with %s"
        one = float_conv(1)
        two = one + one
        zero = one - one

# Do we really need to do this?  Aren't they 2 and 2.0?
        # Determine ibeta and beta
        a = one
        for _ in xrange(max_iterN):
            a = a + a
            temp = a + one
            temp1 = temp - a
            if any(temp1 - one != zero):
                break
        else:
            raise RuntimeError, msg % (_, one.dtype)
        b = one
        for _ in xrange(max_iterN):
            b = b + b
            temp = a + b
            itemp = int_conv(temp-a)
            if any(itemp != 0):
                break
        else:
            raise RuntimeError, msg % (_, one.dtype)
        ibeta = itemp
        beta = float_conv(ibeta)

# Determine it and irnd
        it = -1
        b = one
        for _ in xrange(max_iterN):
            it = it + 1
            b = b * beta
            temp = b + one
            temp1 = temp - b
            if any(temp1 - one != zero):
                break
        else:
            raise RuntimeError, msg % (_, one.dtype)

betah = beta / two
        a = one
        for _ in xrange(max_iterN):
            a = a + a
            temp = a + one
            temp1 = temp - a
            if any(temp1 - one != zero):
                break
        else:
            raise RuntimeError, msg % (_, one.dtype)
        temp = a + betah
        irnd = 0
        if any(temp-a != zero):
            irnd = 1
        tempa = a + beta
        temp = tempa + betah
        if irnd==0 and any(temp-tempa != zero):
            irnd = 2

# Determine negep and epsneg
        negep = it + 3
        betain = one / beta
        a = one
        for i in range(negep):
            a = a * betain
        b = a
        for _ in xrange(max_iterN):
            temp = one - a
            if any(temp-one != zero):
                break
            a = a * beta
            negep = negep - 1
            # Prevent infinite loop on PPC with gcc 4.0:
            if negep < 0:
                raise RuntimeError, "could not determine machine tolerance " \
                                    "for 'negep', locals() -> %s" % (locals())
        else:
            raise RuntimeError, msg % (_, one.dtype)
        negep = -negep
        epsneg = a

# Determine machep and eps
        machep = - it - 3
        a = b

for _ in xrange(max_iterN):
            temp = one + a
            if any(temp-one != zero):
                break
            a = a * beta
            machep = machep + 1
        else:
            raise RuntimeError, msg % (_, one.dtype)
        eps = a

# Determine ngrd
        ngrd = 0
        temp = one + eps
        if irnd==0 and any(temp*one - one != zero):
            ngrd = 1

# Determine iexp
        i = 0
        k = 1
        z = betain
        t = one + eps
        nxres = 0
        for _ in xrange(max_iterN):
            y = z
            z = y*y
            a = z*one # Check here for underflow
            temp = z*t
            if any(a+a == zero) or any(abs(z)>=y):
                break
            temp1 = temp * betain
            if any(temp1*beta == z):
                break
            i = i + 1
            k = k + k
        else:
            raise RuntimeError, msg % (_, one.dtype)
        if ibeta != 10:
            iexp = i + 1
            mx = k + k
        else:
            iexp = 2
            iz = ibeta
            while k >= iz:
                iz = iz * ibeta
                iexp = iexp + 1
            mx = iz + iz - 1

# Determine minexp and xmin
        for _ in xrange(max_iterN):
            xmin = y
            y = y * betain
            a = y * one
            temp = y * t
            if any(a+a != zero) and any(abs(y) < xmin):
                k = k + 1
                temp1 = temp * betain
                if any(temp1*beta == y) and any(temp != y):
                    nxres = 3
                    xmin = y
                    break
            else:
                break
        else:
            raise RuntimeError, msg % (_, one.dtype)
        minexp = -k

# Determine maxexp, xmax
        if mx <= k + k - 3 and ibeta != 10:
            mx = mx + mx
            iexp = iexp + 1
        maxexp = mx + minexp
        irnd = irnd + nxres
        if irnd >= 2:
            maxexp = maxexp - 2
        i = maxexp + minexp
        if ibeta == 2 and not i:
            maxexp = maxexp - 1
        if i > 20:
            maxexp = maxexp - 1
        if any(a != y):
            maxexp = maxexp - 2
        xmax = one - epsneg
        if any(xmax*one != xmax):
            xmax = one - beta*epsneg
        xmax = xmax / (xmin*beta*beta*beta)
        i = maxexp + minexp + 3
        for j in range(i):
            if ibeta==2:
                xmax = xmax + xmax
            else:
                xmax = xmax * beta

self.ibeta = ibeta
        self.it = it
        self.negep = negep
        self.epsneg = float_to_float(epsneg)
        self._str_epsneg = float_to_str(epsneg)
        self.machep = machep
        self.eps = float_to_float(eps)
        self._str_eps = float_to_str(eps)
        self.ngrd = ngrd
        self.iexp = iexp
        self.minexp = minexp
        self.xmin = float_to_float(xmin)
        self._str_xmin = float_to_str(xmin)
        self.maxexp = maxexp
        self.xmax = float_to_float(xmax)
        self._str_xmax = float_to_str(xmax)
        self.irnd = irnd

self.title = title
        # Commonly used parameters
        self.epsilon = self.eps
        self.tiny = self.xmin
        self.huge = self.xmax

import math
        self.precision = int(-math.log10(float_to_float(self.eps)))
        ten = two + two + two + two + two
        resolution = ten ** (-self.precision)
        self.resolution = float_to_float(resolution)
        self._str_resolution = float_to_str(resolution)

def __str__(self):
        return '''\
Machine parameters for %(title)s
---------------------------------------------------------------------
ibeta=%(ibeta)s it=%(it)s iexp=%(iexp)s ngrd=%(ngrd)s irnd=%(irnd)s
machep=%(machep)s     eps=%(_str_eps)s (beta**machep == epsilon)
negep =%(negep)s  epsneg=%(_str_epsneg)s (beta**epsneg)
minexp=%(minexp)s   xmin=%(_str_xmin)s (beta**minexp == tiny)
maxexp=%(maxexp)s    xmax=%(_str_xmax)s ((1-epsneg)*beta**maxexp == huge)
---------------------------------------------------------------------
''' % self.__dict__

if __name__ == '__main__':
    print MachAr()

cmd: