Vérifier si le flotteur est équivalent à une valeur entière en python

En Python 3, je suis de vérifier si une valeur donnée est triangulaire, qui est, il peut être représenté comme n(n+1)/2, pour un certain entier positif n

Je peux juste écrire:

import math
def is_triangular1(x):
    num=(1/2) * (math.sqrt(8*x+1)-1 )
    return int(num)==num

Ou dois-je le faire comme cela? :

epsilon = 0.000000000001
def is_triangular2(x):
    num=(1/2) * (math.sqrt(8*x+1)-1 )
    return abs(int(num) - num)<epsilon

J'ai vérifié que les deux fonctions renvoient les mêmes résultats pour x jusqu'à 1 000 000. Mais je ne suis pas sûr si généralement int(x) == x sera toujours correctement déterminer si un nombre est entier, parce que le cas lorsque, par exemple, 5 est représenté comme 4.99999999999997 etc.

Autant que je sache, la deuxième voie est la bonne, si je le fais en C, mais je ne suis pas sûr à propos de Python 3.

Je sais que vous vous posez des questions à propos des flotteurs et des services de renseignements mais vous pouvez trouver la suite de Q utiles stackoverflow.com/questions/5595425/...
Les deux fonctions peuvent renvoyer le même, mais pour une raison quelconque, ils retournent Vrai pour tous les nombres que j'ai essayé.
êtes-vous à l'aide de Python3? En Python2 1/2==0 donc num sera toujours juste être 0
ah oui, je devrais lire plus attentivement

InformationsquelleAutor Sunny88 | 2011-06-01

floating-point python

9

Vous aurez envie de faire le dernier. Dans de la Programmation en Python 3 l'exemple suivant est donné comme le moyen le plus précis pour comparer
```
def equal_float(a, b):
    #return abs(a - b) <= sys.float_info.epsilon
    return abs(a - b) <= chosen_value #see edit below for more info
```
Aussi, depuis epsilon est la "plus petite différence, la machine peut distinguer entre deux nombres à virgule flottante", vous aurez envie d'utiliser <= dans votre fonction.

Modifier: Après avoir lu les commentaires ci-dessous, j'ai regardé en arrière à la livre, et plus particulièrement, elle a dit "Ici est une simple comparaison de la flotte pour l'égalité dans la limite de machines de précision". Je crois que c'était juste un exemple pour comparer les flotteurs d'une extrême précision, mais le fait que l'erreur est introduite avec beaucoup de flotteur de calculs ce qui devrait que rarement, voire jamais être utilisé. J'ai caractérisé comme le "plus précise" de façon à comparer dans ma réponse, qui en un sens est vrai, mais rarement à ce qui est prévu lors de la comparaison des flotteurs ou des entiers de flotteurs. Le choix d'une valeur (ex: 0.00000000001) basée sur le "domaine du problème" de la fonction au lieu d'utiliser sys.float_info.epsilon est la bonne approche.

Grâce à S. Lott et Sven Marnach pour leurs corrections, et je m'excuse si j'ai dirigé quiconque vers le bas le mauvais chemin.
- Ne fonctionne pas pour la question: 5 - 4.999999999999997 <= sys.float_info.epsilon est Faux (au moins sur mon python3.2 @64-bit)
- je pense que c'était juste un exemple par la question asker? Pas une réelle observée représentation du flotteur de 5.
- 4.999999999999997 n'est pas un exemple réel, j'ai juste écrit nombre arbitraire de 9s là. Peut-être qu'il ne puisse jamais se produire dans la vie réelle.
- La moitié droite. N'utilisez pas de sys.float_info.epsilon. Utiliser une valeur spécifique pour le domaine du problème.
- Pourquoi ne pas sys.float_info.epsilon ?
- Faire de l'algèbre. Il est possible que votre float valeur de la représentation de l'erreur est plus grande que sys.float_info.epsilon. epsilon = 0.000000000001 est plus susceptible d'être correct, car il dépend de quelque chose dans votre domaine de problème, pas assez arbitraire de la propriété de la représentation à virgule flottante.
- Une seule opération de virgule flottante doit avoir une erreur d'au plus sys.float_info.epsilon, mais si vous continuez à faire les opérations à virgule flottante vous permet d'accumuler de l'erreur.
- Ce n'est exact que si a - b < 1
- Veuillez expliquer. Si c'était > 1, alors il en serait exactement de retour Faux.
- L'erreur relative de la plupart des opérations en virgule flottante est au plus sys.float_info.epsilon. Le code ci-dessus vérifie que l'erreur absolue, qui est simplement faux. Par exemple, comparer 1011 et 1011.0 / 7.0 * 7.0 à l'aide de votre equal_float() fonction.
- Merci pour l'exemple de valeurs. En général j'ai entendu les critiques ci-dessus, mais il est bon d'avoir un exemple. En réalité, j'étais curieux si sur Pyson commentaire qui n'a pas de sens pour moi. Je veux dire, si a - b > 1, alors vous ne voudrais jamais revenir Véritable droit? Ou, est-il possible pour l'erreur de construire jusqu'à un point tel que la fonction doit prendre en compte un certain pourcentage d'erreur?
- ...d'un certain pourcentage d'erreur au lieu d'un nombre particulier? Il semble avoir une quelconque valeur peut conduire à un problème de sorte que toute fonction générique ne peut pas être utilisé dans tous les systèmes, ou des cas. Cela a été très utile d'informations pour moi dans la compréhension de la façon de les comparer. En regardant en arrière dans le livre, il dit: "Ici est une simple comparaison de la flotte pour l'égalité dans la limite de machines de précision". J'ai caractérisé comme le "plus précise" de façon à comparer dans ma réponse, qui peut être vrai, mais ce n'est évidemment pas le plus pratique.
- Je ne comprends pas Pyson la remarque. Mais même si abs(a - b) > 1 nous pourrions envisager les nombres égaux s'ils sont gros. Réitérer: FP numéros seulement ont une durée de relative erreur, alors que abs(a - b) > 1 est à nouveau une déclaration au sujet de la absolu d'erreur. Comme un exemple, a = 1e16 et b = 1e16 + 2.0 doit être considéré égal à FP de précision. Il est en fait pas represantable double précision nombre entre ces deux nombres.
- Votre livre est mauvais. La fonction ci-dessus la définition ne doit jamais être utilisé.
- Vous modifiez résout le problème que partiellement. Vous devez vérifier relative les erreurs à l'encontre de certains epsilon, et ce epsilon n'est pas nécessairement sys.float_info.epsilon. Peut-être vous voulez lire le la norme de référence sur ce sujet.
- Vous êtes de droite. J'ai besoin d'en savoir plus sur les flotteurs, donc je vous remercie pour le lien. Est-il une réponse déjà posté que vous, ou vous pouvez poster une réponse et puis je vais retirer mon propre? Est le principal changement nécessaire à ma réponse que la comparaison devrait être faite en comparant la différence en pourcentage d'un pourcentage calculé l'erreur? Quelque chose comme percent_error = percent_err(epsilon, func(epsilon)) ...et puis en fonction de comparaison... percent_diff(val1, val2) <= percent_diff?
InformationsquelleAutor Dan Roberts
27

Il est is_integer fonction en python type float:
```
>>> float(1.0).is_integer()
True
>>> float(1.001).is_integer()
False
>>> 
```
- meilleure réponse, de loin, pourquoi est-ce plus?
InformationsquelleAutor ndpu
10

Vos deux implémentations ont des problèmes. Il fait peut arriver que vous vous retrouvez avec quelque chose comme 4.999999999999997, afin de l'utiliser int() n'est pas une option.

J'irais pour une approche complètement différente: d'Abord supposer que votre numéro est triangulaire, et de calculer ce que n serait dans ce cas. Dans cette première étape, vous pouvez compléter généreusement, car il est seulement nécessaire pour obtenir le résultat si le nombre qui est en est triangulaire. Ensuite, calculer n * (n + 1) /2 pour cette n, et comparer le résultat à x. Maintenant, vous êtes à la comparaison de deux entiers, il n'y a pas d'inexactitudes gauche.

Le calcul de n peut être simplifiée par l'expansion de
```
(1/2) * (math.sqrt(8*x+1)-1) = math.sqrt(2 * x + 0.25) - 0.5
```
et en utilisant que
```
round(y - 0.5) = int(y)
```
positif y.
```
def is_triangular(x):
    n = int(math.sqrt(2 * x))
    return x == n * (n + 1) / 2
```
- round(y - 0.5) == int(y) ne semble pas être toujours correct: En Python 3, round(1-0.5)==0, mais int(1)==1
- Intéressant, le comportement de round() changé en Python 3.x. Mais étant donné que nous ne voulez arrondir les nombres qui sont assez proches des entiers, nous n'avons pas à vous inquiéter au sujet de l'affaire que la partie fractionnaire est exactement 0.5 ici. Comme je l'ai dit avant, nous pouvons être assez tolérant avec l'arrondissement depuis que nous avons seulement besoin d'avoir droit si le nombre est en réalité triangulaire. C'est pourquoi il est aussi ok pour omettre le 0.25.
- Vous pouvez simplement la liste de tous les nombres triangulaires ((x*x+x)/2 for x in count()) et test de la fonction renvoie Vrai pour les ces et Faux pour tout le reste ... il n', pour tous les nombres Python peut se transformer en ints.
InformationsquelleAutor Sven Marnach
5

Python n'ont Decimal classe (dans le décimal module), que vous pouvez utiliser pour éviter l'imprécision de la flotte.
- Bonne réponse, pour moi. J'espère qu'il ne sont pas tous les effets secondaires de l'utilisation de la Virgule au lieu de flotter.
InformationsquelleAutor Paul D. Waite
4

les flotteurs peuvent exactement représenter tous les entiers dans leur gamme - floating-point de l'égalité est difficile seulement si vous vous souciez de l'bits après la virgule. Donc, tant que tous les calculs dans votre formule de retour des nombres entiers pour le cas qui vous intéresse, int(num) == num est parfaitement sûr.

Donc, nous devons prouver que, pour tout nombre triangulaire, chaque morceau de maths vous ne peut être fait avec l'arithmétique des nombres entiers (et tout ce qui en sort est aussi un non-entier implique que x n'est pas triangulaire):

Pour commencer, nous pouvons supposer que x doit être un entier - ce qui est requis dans la définition de "triangulaire" nombre de.

Cela étant le cas, 8*x + 1 sera un entier, depuis les entiers sont fermés en vertu de + et * .

mathématiques.sqrt() retourne un float; mais si x est triangulaire, puis la racine carrée sera un nombre entier - c'est à dire, encore une fois exactement représentés.

Alors, pour tous x, qui doit retourner true dans vos fonctions, int(num) == num sera vrai, et si votre istriangular1 le sera toujours. Le seul point d'achoppement, comme mentionné dans les commentaires à la question, est-ce que Python 2 par défaut n'division entière de la même manière qu'en C - int/int => int, tronquer si le résultat ne peut pas être représenté exactement comme un int. Donc, 1/2 == 0. Ce problème est résolu en Python 3, ou en ayant la ligne
```
from __future__ import division
```
près du haut de votre code.

InformationsquelleAutor lvc
2

Je pense que le module décimal est ce que vous avez besoin
- Soin d'expliquer le fonctionnement de ce module d'aide à l'OP (ou tout du Google public) ou au moins poster un lien?
- Dans l'absolu, vous n'avez pas tort. Mais relativement à l'océan de postes dans la mienne allait être perdu, je doute, je ne considère pas la peine d'en écrire une réponse détaillée qui aurait re-expliquer ce qui est déjà expliqué dans le documenbtation. Parfois, il suffit de montrer le sens est utile.
- Juste assez, votre réponse me semblait être de prendre une direction différente que les autres. Je souhaitais je pouvais cliquer sur le mot décimal et obtenir un lien à ce module. (Il pourrait même vous faire gagner un vote!)
- J'ai une sorte de principe: je parie sur l'intelligence des autres. Ce jour, j'étais probablement fatigué et n'avait pas l'énergie pour expliquer que decimal gère les problèmes de précision, et j'ai pensé que tout le monde a été assez formé en Python pour savoir où trouver de la documentation sur ce module, soit en cliquant sur Aide bouton à la position de RALENTI, soit sur python.org site (d'ailleurs tout le monde a sa préférence) - Concernant upvote, oh j'ai d'autres réponses ayant pas de points dans plusieurs threads, et j'ai encore bien dormir.
InformationsquelleAutor eyquem
1

Vous pouvez de votre tour de nombre, par exemple 14 décimales ou moins:
```
 >>> round(4.999999999999997, 14)
 5.0
```
PS: double précision est d'environ 15 décimales

InformationsquelleAutor JBernardo
1

Il est difficile d'argumenter avec des normes.

En C99 et POSIX, le standard pour l'arrondi d'un float en int est défini par nearbyint() Le concept important est la direction de l'arrondissement et les paramètres régionaux spécifiques à l'arrondissement de la convention.

En supposant que la convention est commune de l'arrondissement, c'est le même que le C99 convention en Python:
```
#!/usr/bin/python

import math

infinity = math.ldexp(1.0, 1023) * 2

def nearbyint(x): 
   """returns the nearest int as the C99 standard would"""

   # handle NaN
   if x!=x:
       return x      

   if x >= infinity:
       return infinity

   if x <= -infinity:
       return -infinity

   if x==0.0:
       return x

   return math.floor(x + 0.5)
```
Si vous voulez plus de contrôle sur l'arrondissement, pensez à utiliser le Décimal module et choisissez l'arrondissement à la convention que vous souhaitez employer. Vous souhaiterez peut-être utiliser L'Arrondi par exemple.

Une fois que vous avez décidé de la convention, arrondie à un int et de la comparer aux autres int.

InformationsquelleAutor
0

Python utilise toujours la même représentation à virgule flottante et les opérations de C t, de sorte que la seconde est la voie correcte.

InformationsquelleAutor Aurojit Panda
0

Sous le capot, le Python de type float est un C double.

Le plus robuste serait d'obtenir l'entier le plus proche de num, puis de tester si les entiers satisfait la propriété que vous recherchez:
```
import math
def is_triangular1(x):
    num = (1/2) * (math.sqrt(8*x+1)-1 )
    inum = int(round(num))
    return inum*(inum+1) == 2*x  # This line uses only integer arithmetic
```
- Pourquoi inum = int(round(num)) et pas seulement inum = int(num) ou inum = round(num)?
- tronque plutôt que de tours (donc 0.9999 deviendrait 0). round(num) tours, mais renvoie un float.
- Apparemment valeur de retour de la ronde() a changé en python 3. Maintenant, il est entier si il n'y a qu'un seul argument.
InformationsquelleAutor Daniel Stutzbach

Vous devez vous connecter pour publier un commentaire.