web-dev-qa-db-fra.com

Quelle est la plage de valeurs qu'un flotteur peut avoir en Python?

Quelles sont ses plus petites et ses plus grandes valeurs en python?

pythonfloating-point
36
devoured elysium

Voir ceci post .

Parties pertinentes du poste:

 Dans [2]: importation de types 
 Dans [3]: kinds.default_float_kind.M 
 Kinds.default_float_kind.MAX kinds.default_float_kind.MIN 
 Kinds.default_float_kind .MAX_10_EXP kinds.default_float_kind.MIN_10_EXP 
 Kinds.default_float_kind.MAX_EXP kinds.default_float_kind.MIN_EXP 
 Dans [3]: kinds.default_float_kind.MIN 
 2.28507 308
15
Juha Syrjälä
>>> import sys
>>> sys.float_info
sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308,
min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, Dig=15, mant_Dig=53,
epsilon=2.2204460492503131e-16, radix=2, rounds=1)

Le plus petit est sys.float_info.min (2.2250738585072014e-308) et le plus grand est sys.float_info.max (1,7976931348623157e + 308). Voir documentation pour les autres propriétés.

sys.float_info.min est le min normalisé. Vous pouvez généralement obtenir le min dénormalisé comme sys.float_info.min * sys.float_info.epsilon. Notez que ces nombres sont représentés avec une perte de précision. Comme prévu, le min dénormalisé est inférieur au min normalisé.

73
Denis Otkidach

En guise de complément théorique aux réponses précédentes, je voudrais mentionner que la valeur "magique" ± 308 provient directement de la représentation binaire des flotteurs. Flotteurs double précision sont de la forme ± c * 2 ** q avec une "petite" valeur fractionnaire c (~ 1), et q un entier écrit avec 11 chiffres binaires (dont 1 bit pour son signe ). Le fait que 2 ** (2 ** 10-1) ait 308 chiffres (décimaux) explique l'apparition de 10 ** ± 308 dans les valeurs de flottement extrêmes.

Calcul en Python:

>>> print len(repr(2**(2**10-1)).rstrip('L'))
308
8
Eric O Lebigot

Python utilise des flotteurs à double précision, qui peuvent contenir des valeurs d'environ 10 à -308 à 10 à 308.

http://en.wikipedia.org/wiki/Double_precision_floating-point_format

Essayez cette expérience à partir de l'invite Python:

>>> 1e308
1e+308
>>> 1e309
inf

10 à la puissance 309 est un débordement, mais pas 10 à 38. QED.

En fait, vous pouvez probablement obtenir des nombres inférieurs à 1e-308 via denormals , mais il y a un impact significatif sur les performances. J'ai trouvé que Python est capable de gérer 1e-324 mais déborde sur 1e-325 et renvoie 0.0 comme valeur.

4
steveha

Je joue juste; voici une méthode algorithmique pour trouver le flottant positif minimum et maximum, avec un peu de chance dans n'importe quelle implémentation python où float("+inf") est acceptable:

def find_float_limits():
    """Return a Tuple of min, max positive numbers
    representable by the platform's float"""

    # first, make sure a float's a float
    if 1.0/10*10 == 10.0:
        raise RuntimeError("Your platform's floats aren't")

    minimum= maximum= 1.0
    infinity= float("+inf")

    # first find minimum
    last_minimum= 2*minimum
    while last_minimum > minimum > 0:
        last_minimum= minimum
        minimum*= 0.5

    # now find maximum
    operands= []
    while maximum < infinity:
        operands.append(maximum)
        try:
            maximum*= 2
        except OverflowError:
            break
    last_maximum= maximum= 0
    while operands and maximum < infinity:
        last_maximum= maximum
        maximum+= operands.pop()

    return last_minimum, last_maximum

if __name__ == "__main__":
    print (find_float_limits()) # python 2 and 3 friendly

Dans mon cas,

$ python so1835787.py
(4.9406564584124654e-324, 1.7976931348623157e+308)

donc les dénormals sont utilisés.

3
tzot

Techniquement parlant, le plus petit flotteur est -inf et le flottant max inf:

>>> (float('-inf')            #   negative infinity 
< -1.7976931348623157e+308    #*  smallest float that is not negative infinity 
< -4.9406564584124654e-324    #*  biggest negative float that is not zero
< 0                           #   zero duh
< 4.9406564584124654e-324     #*  smallest positive float that is not zero
< 1.7976931348623157e+308     #*  biggest float that is not positive infinity
< float('inf'))               #   positive infinity
True

numéros avec * dépendent de la machine et de l'implémentation.

3
Benoît Pilatte