SQL Fonction Round

round(45.923,-1) donne un résultat de 50. Pourquoi est-ce? Comment est-il calculé?

(désolé les gars je me suis trompé avec une version antérieure de cette question, ce qui suggère valeur était de 46)

Il donne 50 sur MySQL 5.0.67-0ubuntu6, comme décrit dans la dev.mysql.com/doc/refman/5.0/en/... - ce que vous utilisez?
les gars ...je knw cela, mais pourquoi? comment c'est calculé
Peut-être certains plus d'informations sur ce que vous essayez de faire est en ordre? C'est des informations incorrectes sur son propre.

OriginalL'auteur hrishi | 2009-07-10

  1. 12

    SQL fonction ROUND() arrondit un nombre à un niveau de précision...

    Par exemple:

    ronde(45.65, 1) donne le résultat = 45.7

    ronde(45.65, -1) donne le résultat = 50

    parce que la précision dans ce cas, est calculé à partir de la virgule décimale. S'il est positif, alors il va considérer le côté droit nombre et de l'arrondir à la hausse si c'est >= 5, et si <=4 puis rond vers le bas... et même si il est négatif, alors la précision est calculée pour le côté gauche de la virgule... si c'est >= 5

    par exemple ronde(de 44,65, -1) donne 40
    mais ronde(45.65, -1) donne 50...

    Dans votre question(45.923,-1) permet d'obtenir 50.. cependant ronde(44.923, -1) donnera à 40.
    Simillarly ronde(45.923,-2) permet d'obtenir la .00

    OriginalL'auteur S M Kamran

  2. 4

    RONDE(748.58, -1) 750.00

    le deuxième paramètre: Longueur, est la précision avec laquelle expression_numérique doit être arrondie. la longueur doit être une expression de type tinyint, smallint, ou int. Lorsque la longueur est un nombre positif, expression_numérique est arrondie au nombre de décimales indiqué par la longueur. Lorsque la longueur est un nombre négatif, expression_numérique est arrondie sur le côté gauche de la virgule, comme spécifié par la longueur.

    À partir de

    OriginalL'auteur Elzo Valugi

  3. 2

    Il devrait être de 50.

    ronde(45.923, 0) => 46

    expl: le dernier non-décimale est arrondie (5), la desicion est basé sur le chiffre suivant (9)
    9 est dans la moitié haute, ergo 5 est arrondi à 6

    ronde(45.923, 1) => 45.9

    expl: la première décimale est arrondie (9), la desicion est basé sur le chiffre suivant (2)
    2 est dans la moitié basse, ergo 9 séjours de 9

    votre cas:
    round(45.923, 1-) => 45.92

    expl: la secon-dernier non décimale est arrondie (4), la desicion est basé sur le chiffre suivant (5)
    5 est dans la moitié supérieure, ergo 4 est arrondi à 5, le reste de la digist sont remplis avec des 0

    OriginalL'auteur markus

  4. 2

    Quant à la façon dont, à commencer par examiner comment vous pouvez ronde a (positif) flottent à l'entier le plus proche. Le moulage d'un float en int tronque. L'ajout de 0,5 à un (positif) flotteur va incrémenter la partie entière précisément lorsque l'on veut arrondir (lorsque la partie décimale >= 0.5). Cela donne les éléments suivants:

    double round(double x) {
    return (long long)(x + 0.5);
}

    Pour ajouter le support pour la précision du paramètre, il faut noter que, pour, par exemple,round(123456.789, -3)) l'ajout de 500 et tronquer des milliers le lieu est essentiellement le même que l'ajout de 0,5 et à l'arrondi à l'entier le plus proche, c'est juste que le point décimal est dans une position différente. Pour déplacer le radix point, nous avons besoin de gauche et de droite des opérations de déplacement, ce qui équivaut à multiplier par le socle élevé pour le décalage. C'est, 0x1234 >> 3 est le même que 0x1234 /2**3 et 0x1234 * 2**-3 en base 2. En base 10:

    123456.789 >> 3 == 123456.789 / 10**3 == 123456.789 * 10**-3 == 123.456789

    Pour round(123456.789, -3), cela signifie que nous pouvons faire au-dessus de la multiplication pour déplacer le point décimal, ajouter 0,5, tronquer, puis procéder à l'opposé de multiplication pour déplacer le point décimal de retour.

    double round(double x, double p) {
    return ((long long)((x * pow10(p))) + 0.5) * pow10(-p);
}

    Arrondissement en ajoutant 0.5 et tronquer des œuvres d'amende pour non-nombres négatifs, mais il arrondit le mauvais sens pour les nombres négatifs. Il existe quelques solutions. Si vous avez un efficace sign() fonction (qui renvoie -1, 0 ou 1, selon que le nombre est <0, ==0 ou >0, respectivement), vous pouvez:

    double round(double x, double p) {
    return ((long long)((x * pow10(p))) + sign(x) * 0.5) * pow10(-p);
}

    Sinon, il y a:

    double round(double x, double p) {
    if (x<0) 
      return - round(-x, p);
    return ((long long)((x * pow10(p))) + 0.5) * pow10(-p);
}

    OriginalL'auteur outis

  5. 1

    Il n'est pas pour moi sur MySQL:

    mysql> select round(45.923,-1);
+------------------+
| round(45.923,-1) |
+------------------+
|               50 |
+------------------+
1 row in set (0.00 sec)
    Même sur SQL Server
    Détaché... oh bien.

    OriginalL'auteur Greg

  6. 0

    Et sur Sql Server 2005:

    select round(45.923,-1)
------
50.000

    La base de données, exécutez-vous?

    OriginalL'auteur Matt Howells