Pourquoi les Mathématiques.Round(2.5) retour 2 au lieu de 3?

En C#, le résultat de Math.Round(2.5) est 2.

Il est censé être 3, n'est-ce pas? Pourquoi est-il 2 plutôt en C#?

C'est en fait une fonctionnalité. Voir <a href="" >msdn.microsoft.com/en-us/library/... la documentation MSDN</a>. Ce genre de arrondissement est connu comme l'arrondi. Comme pour une solution de contournement, il est <a href="" >msdn.microsoft.com/en-us/library/... la surcharge</a> qui permet à l'appelant de spécifier la façon de faire les arrondis.
Apparemment, le tour de méthode, lorsqu'on a demandé à arrondir un nombre exactement entre deux entiers, renvoie le nombre entier pair. Ainsi, Les Maths.Round(3.5) renvoie 4. Voir cet article
Math.Round(2.5, 0, MidpointRounding.AwayFromZero);
SQL Server tours de cette façon; les résultats de l'épreuve intéressants quand il y a un C# test de l'unité ti valider l'arrondissement fait en T-SQL.
ce n'est pas un bug. C'est la façon variable binaire points. 1.005 ne peuvent pas être représentés exactement en double. C'est probablement 1.00499.... Si vous utilisez Decimal ce problème disparaîtra. L'existence des Mathématiques.Tour de surcharge qui prend un certain nombre de chiffres après la virgule sur le double est douteuse choix de conception de l'OMI, depuis qu'il est rarement travaillent dans une manière significative.

OriginalL'auteur jeffu | 2009-06-10

.net rounding

519

Tout d'abord, ce ne serait pas un C# bug de toute façon, il serait une .NET bug. C# est le langage - ce n'est pas de décider de la façon dont Math.Round est mis en œuvre.

Et d'autre part, aucun - si vous lisez les docs, vous verrez que l'arrondi par défaut est "rond de même" (l'arrondi):

Valeur De Retour
Type: System.Double
L'entier le plus proche de un. Si l'
les fractions composant de un est à mi-chemin
entre deux entiers, dont l'un est
même et l'autre impair, alors le même
nombre est retourné. Notez que cette
la méthode retourne un Double au lieu d'une
type intégral.

Remarques
Le comportement de cette méthode suit la Norme IEEE 754,
section 4. Ce type d'arrondi est
parfois appelé d'arrondi au plus près,
ou de l'arrondi. Il minimise
les erreurs d'arrondi qui résultent de
de façon constante, arrondir une valeur médiane
dans une seule direction.

Vous pouvez spécifier comment Math.Round devrait ronde mi-points à l'aide de une surcharge qui prend un MidpointRounding valeur. Il y a une surcharge avec un MidpointRounding correspondant à chacune des surcharges qui n'en a pas:
Si ce défaut a été bien choisi ou non est une autre affaire. (MidpointRounding a été introduit en .NET 2.0. Avant cela je ne suis pas sûr qu'il y avait un moyen facile de mettre en œuvre le comportement désiré sans le faire vous-même.) En particulier, l'histoire a montré que ce n'est pas le devrait comportement - et dans la plupart des cas, c'est un péché cardinal de l'API de dessin. Je peux voir pourquoi l'Arrondi est utile... mais c'est toujours une surprise pour beaucoup.

Vous pouvez être intéressé à regarder le plus proche de Java équivalent enum ( RoundingMode ), ce qui offre encore plus d'options. (Il n'est pas seulement affaire avec les milieux.)

je ne sais pas si c'est un bug, je pense que c'était par sa conception depuis .5 est aussi proche de la plus proche à la plus faible entier comme il est de la plus proche à la plus haute entier.
Je me souviens de ce problème dans visual basic à l'avant .NET obtenu appliquée.
permettez-moi d'ajouter que l'arrondi au plus proche même est une partie de la virgule flottante standard?
En effet, la Norme IEEE 754, l'article 4 que les états de documentation.
+1 pour le "ce n'est pas le comportement attendu [...] c'est un péché cardinal dans la conception d'API"

OriginalL'auteur
190

Qui est appelé l'arrondissement de même (ou de l'arrondi), qui est valide arrondissement stratégie pour réduire les charges des erreurs dans les montants (MidpointRounding.ToEven). La théorie est que, si vous avez toujours autour de 0,5 nombre dans le même sens, les erreurs s'accumulent plus vite (tour-de-même est censé limiter l') ^a.

Suivez ces liens pour la MSDN descriptions de:
- Math.Étage, qui arrondit vers l'infini négatif.
- Math.Plafond, qui arrondit vers l'infini positif.
- Math.Tronquer, qui arrondit vers le haut ou vers le bas vers zéro.
- Math.Ronde, qui arrondit à l'entier le plus proche ou le nombre de décimales spécifié. Vous pouvez spécifier le comportement si c'est exactement à égale distance entre les deux possibilités, telles que l'arrondi de sorte que le dernier chiffre est le même ("Round(2.5,MidpointRounding.ToEven)" devenir 2) ou qu'il soit le plus loin possible à partir de zéro ("Round(2.5,MidpointRounding.AwayFromZero)" devenir 3).
Le diagramme suivant et le tableau peut aider:
```
-3        -2        -1         0         1         2         3
 +-- | ------+---------+---- | ----+-- | ------+---- | ----+------- | -+
    a                     b       c           d            e

                       a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                       ======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round(ToEven)            -3       0      0      2      3
Round(AwayFromZero)      -3      -1      0      2      3
```
Noter que Round est beaucoup plus puissant que ce qu'il semble, tout simplement parce qu'il peut arrondir à un nombre de décimales. Tous les autres tour à zéro décimales toujours. Par exemple:
```
n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       //3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); //3.15
```
Avec les autres fonctions, vous devez utiliser multiplier/diviser la ruse pour obtenir le même effet:
```
c = System.Math.Truncate (n * 100) / 100;                    //3.14
d = System.Math.Ceiling (n * 100) / 100;                     //3.15
```
^a bien sûr, cette théorie repose sur le fait que vos données ont une assez même la propagation de valeurs dans le même moitiés (0.5, 2.5, 4.5, ...) et de l'impair moitiés (1.5, 3.5, ...).

Si tous la "demi-valeurs" sont evens (par exemple), les erreurs s'accumulent tout aussi rapide que si vous avez toujours arrondi.

Aussi connu comme l'Arrondi
+2 très bonne explication
Bonne explication! Je voulais voir par moi-même comment l'erreur s'accumule et j'ai écrit un script qui montre que les valeurs arrondies à l'aide de l'arrondi, à long terme, ont leurs sommes et des moyennes beaucoup plus proche de ces valeurs d'origine. github.com/AmadeusW/RoundingDemo photos de parcelles disponibles)
Peu de temps après: ne devrait pas e tique (= 2.8), droit de 2 tique?
bonne prise, fixé maintenant.

OriginalL'auteur
41

De MSDN, les Maths.Round(double) retourne:

L'entier le plus proche de un. Si l'
les fractions composant de un est à mi-chemin
entre deux entiers, dont l'un est
même et l'autre impair, alors le même
nombre est retourné.

... et donc 2,5, étant à mi-chemin entre 2 et 3, est arrondi au nombre pair (2). ceci est appelé L'Arrondi (ou tour-de-même), et est couramment utilisé arrondi standard.

Même article MSDN:

Le comportement de cette méthode suit
La Norme IEEE 754, section 4. Cette
type d'arrondi est parfois appelé
d'arrondi au plus près, ou du banquier
l'arrondissement des chiffres. Il minimise les erreurs d'arrondi
qui résultent de la constante de l'arrondissement
une valeur médiane dans un seul
direction.

Vous pouvez spécifier un autre arrondissement comportement en appelant les surcharges de Mathématiques.Autour de prendre un MidpointRounding mode.

OriginalL'auteur
35

Vous devriez vérifier MSDN pour Math.Ronde:

Le comportement de cette méthode suit la Norme IEEE 754, section 4. Ce type d'arrondi est parfois appelé d'arrondi au plus près, ou de l'arrondi.

Vous pouvez spécifier le comportement de Math.Round à l'aide d'une surcharge:
```
Math.Round(2.5, 0, MidpointRounding.AwayFromZero); //gives 3

Math.Round(2.5, 0, MidpointRounding.ToEven); //gives 2
```
OriginalL'auteur
29

La nature de l'arrondissement

Considérer la tâche de l'arrondi d'un nombre qui contient une fraction, par exemple, un nombre entier. Le processus de l'arrondissement dans ce cas, c'est de déterminer le nombre entier qui représente le mieux le nombre vous d'arrondi.

En commun, ou "arithmétique" de l'arrondissement, il est clair que, 2.1, 2.2, 2.3 et 2.4 tour à 2.0 et 2.6, 2.7, 2.8 et 2.9 3.0.

Que les feuilles de 2,5, ce qui est loin d'être à la 2.0 que c'est à la version 3.0. C'est à vous de choisir entre 2.0 et 3.0, serait tout aussi valable.

Pour moins numéros, -2.1, -2.2, -2.3 et -2.4, deviendrait -2.0; et -2.6, 2.7, 2.8 et 2.9 deviendrait -3.0 en vertu de l'arrondi arithmétique.

Pour -2.5 un choix est nécessaire entre -2.0 et -3.0.

D'autres formes de l'arrondissement

'Arrondi' prend un nombre avec décimales et en fait le suivant 'ensemble de l' nombre. Ainsi, non seulement 2.5 et 2.6 tour à 3.0, mais il ne faut 2.1 et 2.2.

Arrondissement se déplace à la fois positifs et les nombres négatifs, loin de zéro. Par exemple. De 2.5 à 3.0 et -2.5 à -3.0.

'Arrondi vers le bas" tronque les numéros de débitage hors les chiffres. Cela a pour effet de déplacer les numéros de vers zéro. Par exemple. 2.5 2.0 et -2.5 à -2.0

Dans "l'arrondi" - dans sa forme la plus courante - l'.5 être arrondi est arrondi vers le haut ou vers le bas de sorte que le résultat de l'arrondi est toujours un nombre pair. Ainsi, à 2,5 tours à 2.0, 3.5 et 4.0, 4.5 4.0, 5.5 à 6.0, et ainsi de suite.

'Autre arrondi' alterne le processus pour tout .5 entre l'arrondi vers le bas et arrondi vers le haut.

L'arrondissement aléatoire des tours d'une .5 vers le haut ou vers le bas de façon totalement aléatoire.

La symétrie et l'asymétrie

Un arrondissement la fonction est dite "symétrique" si elle arrondit tous les numéros de loin à partir de zéro ou de tours tous les numéros de vers zéro.

Une fonction est "asymétriques" si les tours des nombres positifs vers zéro et les nombres négatifs à l'écart à partir de zéro.. par exemple. De 2,5 à 2,0; et -2.5 à -3.0.

Également asymétrique est une fonction qui arrondit les nombres positifs, loin de zéro et les nombres négatifs vers zéro. Par exemple. De 2.5 à 3.0; et -2.5 à -2.0.

La plupart du temps les gens pensent d'arrondi symétrique, où -2.5 sera arrondi vers -3.0 et 3,5 sera arrondi vers 4.0. (en C# Round(AwayFromZero))

OriginalL'auteur
23

La valeur par défaut MidpointRounding.ToEven, ou des Banquiers d'arrondi (2.5 devenir 2, 4.5 devient 4 et ainsi de suite) a m'a piqué avant avec la rédaction de rapports pour la comptabilité, donc je vais écrire quelques mots de ce que j'ai trouvé, précédemment et de la recherche pour ce poste.

Qui sont ces banquiers qui sont arrondis vers le bas sur le même nombre (British bankers, peut-être!)?

De wikipedia

L'origine du terme banquiers
l'arrondissement reste plus obscur. Si ce
méthode d'arrondi a jamais été une norme dans
bancaire, la preuve a révélé
extrêmement difficile à trouver. À l'
contraire, l'article 2 de l'European
Rapport de la Commission de L'Introduction de
l'Euro et de l'Arrondissement de Monnaie
Les montants suggère qu'il y avait
déjà été pas d'approche standard
de l'arrondissement dans le secteur bancaire; et il
spécifie que "mi-chemin" montants
doit être arrondi.

Il semble que d'une manière très étrange de l'arrondissement en particulier pour des opérations bancaires, à moins bien sûr que les banques utilisent pour recevoir beaucoup de dépôts de même montant. Dépôt de € 2,4 m, mais nous allons l'appeler £2m sir.

La Norme IEEE 754 remonte à 1985 et donne à la fois des moyens de d'arrondissement, mais avec du banquier comme recommandé par la norme. Cette article de wikipedia a une longue liste de langues de mettre en œuvre l'arrondissement (corrigez-moi si l'un des ci-dessous sont fausses) et la plupart n'utilisent pas des Banquiers mais la arrondissement on vous apprend à l'école:
- C/C++ round() de mathématiques.h rondes loin de zéro (pas de l'arrondi)
- Java Les mathématiques.Ronde tours loin de zéro (c'étages le résultat, ajoute 0.5, jette un entier). Il existe une alternative à BigDecimal
- Perl utilise d'une manière similaire à C
- Javascript est le même que Java Mathématiques.Tour de.
Merci pour l'information. Je n'ai jamais compris cela. Votre exemple sur les millions se moque un peu, mais même si vous ronde sur cents, avoir à payer des intérêts sur les 10 millions de comptes bancaires, le prix de la banque de beaucoup de choses, si toutes les demi-cents sont arrondis, ou le prix de la les clients d'un lot si toutes les demi-cents sont arrondis vers le bas. Donc, je peux imaginer que c'est la norme convenue. Vous ne savez pas si c'est vraiment utilisé par les banquiers. La plupart des clients ne sera pas un avis arrondi vers le bas, tout en apportant beaucoup d'argent, mais je peux imaginer que c'est tenu par des lois si vous résidez dans un pays avec clientèle amical lois

OriginalL'auteur
14

À partir de MSDN:

Par défaut, les Maths.Tour utilise
MidpointRounding.ToEven. La plupart des gens
ne sont pas familiers avec "l'arrondi à
même" comme une alternative, "arrondi
loin de zéro" est plus communément
enseigné à l'école. .NET par défaut
"L'arrondissement de même", comme il est
statistiquement supérieure parce qu'elle
ne partage pas la tendance de
"l'arrondissement loin de zéro" pour arrondir
légèrement plus souvent que des tours de
vers le bas (en supposant que les chiffres soient
arrondis ont tendance à être positive.)

http://msdn.microsoft.com/en-us/library/system.math.round.aspx

OriginalL'auteur
3

Depuis Silverlight ne prend pas en charge la MidpointRounding option, vous devez écrire votre propre. Quelque chose comme:
```
public double RoundCorrect(double d, int decimals)
{
    double multiplier = Math.Pow(10, decimals);

    if (d < 0)
        multiplier *= -1;

    return Math.Floor((d * multiplier) + 0.5) / multiplier;

}
```
Pour les exemples, y compris la façon de l'utiliser comme une extension de voir le post: .NET et Silverlight Arrondissement

OriginalL'auteur
2

J'ai eu ce problème où mon serveur SQL tours jusqu'à 0,5 à 1 alors que mon application C# n'a pas. Donc, vous voyez deux résultats différents.

Voici une implémentation de l'int/long. C'est la façon dont Java tours.
```
int roundedNumber = (int)Math.Floor(d + 0.5);
```
C'est probablement la méthode la plus efficace que vous pourriez penser ainsi.

Si vous voulez garder un lit double et d'utilisation, la précision décimale , puis c'est vraiment juste une question de l'utilisation des exposants de 10, basé sur le nombre de décimales.
```
public double getRounding(double number, int decimalPoints)
{
    double decimalPowerOfTen = Math.Pow(10, decimalPoints);
    return Math.Floor(number * decimalPowerOfTen + 0.5)/ decimalPowerOfTen;
}
```
Vous pouvez entrer un négatif virgule pour les décimales et c'est fin mot.
```
getRounding(239, -2) = 200
```
OriginalL'auteur
0

Ce post a la réponse que vous cherchez:

http://weblogs.asp.net/sfurman/archive/2003/03/07/3537.aspx

Fondamentalement, c'est ce qu'il dit:

Valeur De Retour

Le nombre le plus proche de la valeur avec précision égale aux chiffres. Si la valeur est à mi-chemin entre les deux nombres, dont l'un est pair et l'autre impair, le même nombre est retourné. Si la précision de la valeur est de moins de chiffres, alors la valeur est retourné à l'identique.

Le comportement de cette méthode suit la Norme IEEE 754, section 4. Ce type d'arrondi est parfois appelé d'arrondi au plus près, ou de l'arrondi. Si les chiffres est égale à zéro, ce type d'arrondi est parfois appelé arrondi vers zéro.

OriginalL'auteur

Silverlight ne prend pas en charge la MidpointRounding option.
Voici une méthode d'extension pour Silverlight qui ajoute de la MidpointRounding enum:

public enum MidpointRounding
{
    ToEven,
    AwayFromZero
}

public static class DecimalExtensions
{
    public static decimal Round(this decimal d, MidpointRounding mode)
    {
        return d.Round(0, mode);
    }

    ///<summary>
    ///Rounds using arithmetic (5 rounds up) symmetrical (up is away from zero) rounding
    ///</summary>
    ///<param name="d">A Decimal number to be rounded.</param>
    ///<param name="decimals">The number of significant fractional digits (precision) in the return value.</param>
    ///<returns>The number nearest d with precision equal to decimals. If d is halfway between two numbers, then the nearest whole number away from zero is returned.</returns>
    public static decimal Round(this decimal d, int decimals, MidpointRounding mode)
    {
        if ( mode == MidpointRounding.ToEven )
        {
            return decimal.Round(d, decimals);
        }
        else
        {
            decimal factor = Convert.ToDecimal(Math.Pow(10, decimals));
            int sign = Math.Sign(d);
            return Decimal.Truncate(d * factor + 0.5m * sign) / factor;
        }
    }
}

Source: http://anderly.com/2009/08/08/silverlight-midpoint-rounding-solution/

OriginalL'auteur

0

à l'aide d'un personnalisé arrondi
```
public int Round(double value)
{
    double decimalpoints = Math.Abs(value - Math.Floor(value));
    if (decimalpoints > 0.5)
        return (int)Math.Round(value);
    else
        return (int)Math.Floor(value);
}
```
>.5 produit le même comportement que Math.Round. La question est de whas se produit lorsque la partie décimale est exactement 0.5. Les mathématiques.Tour vous permet de spécifier le type de l'arrondissement de l'algorithme que vous voulez

OriginalL'auteur

Moyen Simple est:

Math.Ceiling(decimal.Parse(yourNumber + ""));

OriginalL'auteur

-1

Voici la façon dont j'ai eu à travailler autour de :
```
Public Function Round(number As Double, dec As Integer) As Double
    Dim decimalPowerOfTen = Math.Pow(10, dec)
    If CInt(number * decimalPowerOfTen) = Math.Round(number * decimalPowerOfTen, 2) Then
        Return Math.Round(number, 2, MidpointRounding.AwayFromZero)
    Else
        Return CInt(number * decimalPowerOfTen + 0.5) / 100
    End If
End Function
```
Essayer avec 1.905 avec 2 décimales donnera 1.91 comme prévu, mais Math.Round(1.905,2,MidpointRounding.AwayFromZero) donne 1.90! Les mathématiques.Tour méthode est absolument incohérent et inutilisable pour la plupart des notions de base des problèmes de programmeurs peuvent rencontrer. Je dois vérifier si (int) 1.905 * decimalPowerOfTen = Math.Round(number * decimalPowerOfTen, 2) car je ne veux pas rond jusqu'à ce que doit être arrondi à l'inférieur.

Math.Round(1.905,2,MidpointRounding.AwayFromZero) retourne 1.91

OriginalL'auteur

-2

C'est laid comme tout l'enfer, mais produit toujours correct arrondi arithmétique.

public double ArithRound(double number,int places){

  string numberFormat = "###.";

  numberFormat = numberFormat.PadRight(numberFormat.Length + places, '#');

  return double.Parse(number.ToString(numberFormat));

}

Donc fait appel Math.Round et de préciser la façon dont vous le souhaitez arrondir.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.

La nature de l'arrondissement

Qui sont ces banquiers qui sont arrondis vers le bas sur le même nombre (British bankers, peut-être!)?