Fonction SQL Round

Question

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 la version antérieure de cette question était valeur suggérant 46)

Answer 1

La fonction SQL ROND() arrondit un nombre à une précision ...

Par exemple:

tour (45,65, 1) donne le résultat = 45,7

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

car la précision dans ce cas est calculée à partir du point décimal. Si positif, il considérera le nombre du côté droit et le arrondira vers le haut s'il est> = 5, et si < = 4 alors arrondi vers le bas ... et de même si c'est négatif alors la précision est calculée pour le côté gauche de la décimale le point ... si elle est> = 5

par exemple ronde (44,65, -1) donne 40 mais rond (45,65, -1) donne 50 ...

Answer 2

Il ne pour moi sur MySQL:

mysql> select round(45.923,-1); 
+------------------+ 
| round(45.923,-1) | 
+------------------+ 
|    50 | 
+------------------+ 
1 row in set (0.00 sec) 

Answer 3

Et Sql Server 2005:

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

Quelle base de données utilisez-vous?

Answer 4

ROUND (748,58, -1) 750,00

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

From

Answer 5

il devrait être 50.

ronde (45,923, 0) => 46

expl: le dernier chiffre décimal non est arrondi (5), le 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: le premier chiffre décimal est arrondi (9), le desicion est basé sur le chiffre suivant (2) 2 est dans la moitié basse, ergo 9 séjours 9

votre cas: ronde (45,923, 1-) => 45.Expl: le dernier chiffre non décimal est arrondi (4), la dessication est basée sur le chiffre suivant (5) 5 est dans la moitié supérieure, ergo 4 est arrondi à 5, le reste de la digiste sont remplis avec 0s

Answer 6

Comme pour comment, commencez par considérer comment vous arrondir un flottant (positif) à l'entier le plus proche. Lancer un flottant dans un int le tronque. Ajouter 0.5 à un flottant (positif) incrémentera la partie entière précisément quand nous voulons arrondir (quand 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 le paramètre de précision, notez que (par exemple round(123456.789, -3)) en ajoutant 500 et tronquer en milliers lieu est essentiellement le même que l'ajout de 0,5 et arrondi au plus proche entier, c'est juste que le point décimal est dans une position différente. Pour déplacer le point de base, nous avons besoin d'opérations de décalage vers la gauche et vers la droite, ce qui équivaut à multiplier par la base élevée à la quantité de décalage. Autrement dit, 0x1234 >> 3 est le même que 0x1234/2**3 et 0x1234 * 2**-3 dans la 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 la multiplication ci-dessus pour déplacer le point décimal, ajouter 0,5, tronquer, puis effectuez la multiplication inverse pour reculer le point décimal.

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

Arrondi en ajoutant 0,5 et tronquer fonctionne bien pour les numéros non-négatifs, mais il arrondit la mauvaise façon pour les nombres négatifs. Il y a quelques solutions. Si vous avez une fonction sign() efficace (qui renvoie -1, 0 ou 1, selon si un 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); 
}