Pourquoi le module opérateur renvoie le nombre fractionnaire en javascript?

Pourquoi ne 49.90 % 0.10 en JavaScript retour 0.09999999999999581? Je m'attendais à être 0.

Floating point encore 🙁
Voir [Est du JavaScript Math cassé? ](stackoverflow.com/questions/588004/is-javascripts-math-broken).
Voir: Python modulo sur flotteurs (différent de la langue, mais la question -- virgule flottante erreur-est le même)

InformationsquelleAutor Edgar | 2010-10-19

51

Parce que JavaScript utilise le calcul en virgule flottante qui conduit toujours à des erreurs d'arrondi.

Si vous avez besoin d'un résultat exact avec deux décimales, multipliez vos numéros avec 100 avant l'opération, puis de diviser à nouveau par la suite:
```
var result = ( 4990 % 10 ) / 100;
```
Tour si nécessaire.
- +1 Dans de nombreux systèmes financiers, c'est la façon de change sont gérées en interne (le tout multiplié par 100) et lors du rendu, les règles de la monnaie sont appliquées.
- Ah, tour de nice, en évitant les flotteurs en tournant le numéro en entier à l'avance. Si joliment facile.
- Il est également appelé "point fixe de l'arithmétique" depuis que vous avez toujours 2 (ou N) décimales.
- Merci pour votre perspicacité, mais cette approche n'était pas parfait. (40.55 * 100 %1000)/100 retourne 0.549999... au lieu de 0,55.
InformationsquelleAutor Aaron Digulla
18

Javascript du Numéro à l'aide de "double-précision IEEE" pour stocker les valeurs. Ils sont incapables de stocker tous les nombres décimaux exactement. Le résultat n'est pas nul, en raison de l'erreur d'arrondi lors de la conversion du nombre décimal en binaire.
```
49.90 = 49.89999999999999857891452848...
 0.10 =  0.10000000000000000555111512...
```
Ainsi plancher(49.90 /0.10) est seulement 498, et le reste sera 0.09999....

Il me semble que vous êtes en utilisant des numéros de stocker quantité de dollars. Ne faites pas cette, comme d'opérations en virgule flottante de propager et d'amplifier l'erreur d'arrondi. Enregistrer le numéro de la quantité de cents à la place. Entier peut être représenté exactement, et 4990 % 10 sera de retour 0.

InformationsquelleAutor kennytm

Je vais juste laisser ça ici pour référence future, mais ici, c'est une fonction très pratique qui peut plus précisément poignée Reste (depuis JS n'est pas un opérateur modulo) impliquant des chars.

  function floatSafeRemainder(val, step){
    var valDecCount = (val.toString().split('.')[1] || '').length;
    var stepDecCount = (step.toString().split('.')[1] || '').length;
    var decCount = valDecCount > stepDecCount? valDecCount : stepDecCount;
    var valInt = parseInt(val.toFixed(decCount).replace('.',''));
    var stepInt = parseInt(step.toFixed(decCount).replace('.',''));
    return (valInt % stepInt) / Math.pow(10, decCount);
  }

JS:

$(function() {
  
  
  function floatSafeModulus(val, step) {
    var valDecCount = (val.toString().split('.')[1] || '').length;
    var stepDecCount = (step.toString().split('.')[1] || '').length;
    var decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
    var valInt = parseInt(val.toFixed(decCount).replace('.', ''));
    var stepInt = parseInt(step.toFixed(decCount).replace('.', ''));
    return (valInt % stepInt) / Math.pow(10, decCount);
  }
  
  
  $("#form").submit(function(e) {
    e.preventDefault();
    var safe = 'Invalid';
    var normal = 'Invalid';
    var var1 = parseFloat($('#var1').val());
    var var2 = parseFloat($('#var2').val());
    if (!isNaN(var1) && !isNaN(var2)) {
      safe = floatSafeModulus(var1, var2);
      normal = var1 % var2
    }
    $('#safeResult').text(safe);
    $('#normalResult').text(normal);
  });
});

HTML:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<form id="form" novalidate>
  <div>
    <input type="number" id="var1">%
    <input type="number" id="var2">
  </div>
  <div>safe: <span id="safeResult"></span><div>
  <div>normal (%): <span id="normalResult"></span></div>
  <input type="submit" value="try it out">
</form>

Cette réponse est sous-estimée. Alors qu'un peu plus verbeux, le script est beaucoup plus robuste.
Peut sembler effrayant, mais prenez le temps de lire celui-ci. Il fonctionne très bien. Seule chose que je voudrais ajouter: si vous vous souciez de nombres négatifs, javascript modulo ne pas les gérer comme vous le souhaitez. Vous pouvez modifier le retourner à: return (((valInt % stepInt) + stepInt) % stepInt) / Math.pow(10, decCount)

InformationsquelleAutor TheSharpieOne

2

Cause

À virgule flottante ne peut pas stocker toutes les valeurs décimales exactement. Donc, lorsque vous utilisez floating point format, il y aura toujours des erreurs d'arrondi sur les valeurs d'entrée.
Les erreurs sur les données de résultats de cours sur les erreurs sur la sortie.
Dans le cas d'une fonction discrète ou de l'opérateur, il peut y avoir une grande différence sur la sortie de autour du point où la fonction ou de l'opérateur est discret.
Le modula opérateur est discret et votre cas est clairement un exemple de ce problème.

D'entrée et de sortie pour les valeurs à virgule flottante

Donc, lors de l'utilisation de variables à virgule flottante, vous devriez toujours être conscient de cela. Et quelle que soit la sortie que vous voulez à partir d'un calcul avec floating points doivent toujours être formaté/conditionnés avant d'afficher avec cela à l'esprit.

Lorsque seules des fonctions continues et les opérateurs sont utilisés, arrondi à la précision souhaitée souvent faire (ne pas tronquer). Standard de fonctionnalités de mise en forme utilisé pour convertir les flotteurs pour la chaîne va généralement de le faire pour vous.

Pour avoir un bon de sortie en fonction de la précision des entrées et de la précision souhaitée de sortie, vous devez également
- Ronde entrées à la précision attendue ou assurez-vous pas de les valeurs peuvent être entrées avec plus de précision.
- Ajouter une petite valeur pour les sorties avant l'arrondi/mise en forme, qui est plus petite ou égale à 1/4 de la précision souhaitée et plus grand que le maximum prévu erreur causée par des erreurs d'arrondi sur l'entrée et pendant le calcul. Si cela n'est pas possible, la combinaison de la précision du type de données n'est pas suffisant pour fournir le résultat souhaité de précision pour votre calcul.
Ces 2 choses sont souvent pas faite et, dans la plupart des cas, les différences causées par ne pas les faire trop petits pour être important pour la plupart des utilisateurs, mais j'ai déjà eu un projet où la production n'a pas été acceptée par les utilisateurs sans que ces corrections.

Fonctions discrètes ou des opérateurs (comme modula)

Lorsque discret opérateurs ou fonctions sont impliqués, corrections supplémentaires pourraient être nécessaires pour assurer que la sortie est aussi prévue. L'arrondi et l'ajout de petites corrections avant l'arrondi ne pouvez pas résoudre le problème.

Une spéciale de vérification/correction sur les intermédiaires de résultats de calcul, immédiatement après l'application de la fonction discrète ou l'exploitant peut être nécessaire.

Cas particulier de cette question

Dans ce cas, vous vous attendez d'entrée avec une certaine précision, de sorte qu'il est possible de corriger la sortie de l'impact des erreurs d'arrondi qui sont beaucoup plus petites que la précision souhaitée.

Si nous disons que la précision de vos données est de type e.

Vos commentaires ne seront pas stockées comme les valeurs de a et b que vous avez entré, mais a*(1+/-e) et b*(1+/e -)

Le résultat d'une division a*(1+/-e) par b*(1+/-e) aurait pour conséquence (a/b)(1+/-2e).

Le modula fonction a pour tronquer le résultat et se multiplier encore.
De sorte que le résultat sera (a/bb)(1+/-3e) = a(1+/-3e), ce qui entraîne une erreur d'un*3e.

Le mod ajoute un*e de l'erreur d'un*3e en raison de la soustraction de 2 valeurs avec une possible erreur de*3e et un*e.

Vous devez donc vérifier que le total de la possible erreur a*4e est plus petite que la précision souhaitée et si cette condition est remplie et que le résultat diffère pas de plus de b que le maximum d'erreur possible, vous pouvez le remplacer par 0.

Mieux éviter d'avoir le problème

Il est souvent plus efficace d'éviter ces problèmes en utilisant des types de données (entier ou à virgule fixe formats) pour les calculs comme ce qui peut stocker les données à saisir sans les erreurs d'arrondi.
Un exemple est que vous ne devez jamais utiliser des valeurs à virgule flottante pour les calculs financiers.

InformationsquelleAutor Stefan Mondelaers
1

http://en.wikipedia.org/wiki/Modulo_operation
Ne soyez pas en colère modulo est utilisé avec des entiers ^^
Donc, les valeurs flottantes survenir dans certaines erreurs.

InformationsquelleAutor MatTheCat
1

Prendre un coup d'oeil à floating points et ses inconvénients - un nombre comme 0.1 ne peuvent pas être enregistrées correctement la virgule flottante, donc il y aura toujours de tels problèmes. Prenez vos chiffres *10 ou *100 et de faire les calculs avec des entiers à la place.

InformationsquelleAutor oezi
-3

Ce n'est pas une réponse parfaite, mais il fonctionne.
```
function format_float_bug(num)
{
   return parseFloat( num.toFixed(15) ); 
} 
```
vous pouvez utiliser comme suit,
```
format_float_bug(4990 % 10);
```
car en-dessous du numéro (49.89999999999999857891452848) 15 premières décimales sont comme 9999999
- Cela ne fonctionne pas du tout, et votre exemple d'appel n'a même pas d'utiliser des flotteurs!
InformationsquelleAutor Viranga

Vous devez vous connecter pour publier un commentaire.