Comment arrondir un nombre à n décimales en Java
https://stackoverflow.com/questions/153724
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Ce que je voudrais, c’est une méthode pour convertir un double en chaîne qui arrondit à l’aide de la méthode de demi-utilisation - c’est-à-dire que si la décimale à arrondir est 5, elle arrondit toujours au nombre précédent. C’est la méthode standard d’arrondi attendue par la plupart des gens dans la plupart des situations.
Je voudrais aussi que seuls les chiffres significatifs soient affichés - c’est-à-dire qu’il ne devrait pas y avoir de zéros à la fin.
Je sais qu'une méthode pour ce faire consiste à utiliser la méthode String.format :
String.format("%.5g%n", 0.912385);
renvoie:
0.91239
ce qui est excellent, mais il affiche toujours les nombres avec 5 décimales, même s’ils ne sont pas significatifs:
String.format("%.5g%n", 0.912300);
renvoie:
0.91230
Une autre méthode consiste à utiliser DecimalFormatter :
DecimalFormat df = new DecimalFormat("#.#####");
df.format(0.912385);
renvoie:
0.91238
Cependant, comme vous pouvez le constater, cette méthode est arrondie à moitié. C'est-à-dire qu'il sera arrondi si le chiffre précédent est pair. Ce que j'aimerais, c'est ceci:
0.912385 -> 0.91239
0.912300 -> 0.9123
Quel est le meilleur moyen de réaliser cela en Java?
La solution
Utilisez setRoundingMode , définissez le RoundingMode de manière explicite pour traiter votre problème avec le demi-tour, puis utilisez le modèle de format pour la sortie requise.
Exemple:
DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
Double d = n.doubleValue();
System.out.println(df.format(d));
}
donne le résultat:
12
123.1235
0.23
0.1
2341234.2125
Autres conseils
En supposant que la valeur est un double , vous pouvez faire:
(double)Math.round(value * 100000d) / 100000d
C'est pour une précision de 5 chiffres. Le nombre de zéros indique le nombre de décimales.
new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);
vous obtiendrez un BigDecimal . Pour en extraire la chaîne, appelez simplement la méthode toString de BigDecimal , ou la méthode toPlainString pour Java 5+ pour un format brut chaîne.
Exemple de programme:
package trials;
import java.math.BigDecimal;
public class Trials {
public static void main(String[] args) {
int yourScale = 10;
System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
}
Vous pouvez également utiliser le
DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);
pour vous assurer que vous avez les derniers 0.
Comme d'autres l'ont noté, la bonne réponse consiste à utiliser DecimalFormat ou BigDecimal . Les virgules flottantes ne n'ont pas de décimales, vous ne pouvez donc pas forcément arrondir / tronquer à un nombre spécifique d'entre elles en premier lieu. Vous devez travailler dans une base décimale, et c’est ce que font ces deux classes.
Je publie le code suivant comme contre-exemple à toutes les réponses de ce fil de discussion et de tout le reste de StackOverflow (et ailleurs) qui recommandent une multiplication suivie d'une troncature suivie d'une division. Il incombe aux défenseurs de cette technique d’expliquer pourquoi le code suivant produit une sortie erronée dans plus de 92% des cas.
public class RoundingCounterExample
{
static float roundOff(float x, int position)
{
float a = x;
double temp = Math.pow(10.0, position);
a *= temp;
a = Math.round(a);
return (a / (float)temp);
}
public static void main(String[] args)
{
float a = roundOff(0.0009434f,3);
System.out.println("a="+a+" (a % .001)="+(a % 0.001));
int count = 0, errors = 0;
for (double x = 0.0; x < 1; x += 0.0001)
{
count++;
double d = x;
int scale = 2;
double factor = Math.pow(10, scale);
d = Math.round(d * factor) / factor;
if ((d % 0.01) != 0.0)
{
System.out.println(d + " " + (d % 0.01));
errors++;
}
}
System.out.println(count + " trials " + errors + " errors");
}
}
Sortie de ce programme:
10001 trials 9251 errors
EDIT: Pour adresser certains commentaires ci-dessous, j'ai refait la partie module de la boucle de test à l'aide de BigDecimal et de new MathContext (16) pour la opération de module comme suit:
public static void main(String[] args)
{
int count = 0, errors = 0;
int scale = 2;
double factor = Math.pow(10, scale);
MathContext mc = new MathContext(16, RoundingMode.DOWN);
for (double x = 0.0; x < 1; x += 0.0001)
{
count++;
double d = x;
d = Math.round(d * factor) / factor;
BigDecimal bd = new BigDecimal(d, mc);
bd = bd.remainder(new BigDecimal("0.01"), mc);
if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
{
System.out.println(d + " " + bd);
errors++;
}
}
System.out.println(count + " trials " + errors + " errors");
}
Résultat:
10001 trials 4401 errors
Supposons que vous ayez
double d = 9232.129394d;
vous pouvez utiliser BigDecimal
BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();
ou sans BigDecimal
d = Math.round(d*100)/100.0d;
avec les deux solutions d == 9232.13
Vous pouvez utiliser la classe DecimalFormat.
double d = 3.76628729;
DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal = Double.valueOf(newFormat.format(d));
Le guide Java de Real's publie cette solution, qui est également compatible avec versions antérieures à Java 1.6.
BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();
double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;
@Milhous: le format décimal pour l'arrondi est excellent:
Vous pouvez également utiliser le
DecimalFormat df = new DecimalFormat("#.00000"); df.format(0.912385);pour vous assurer que vous avez les derniers 0.
J'ajouterais que cette méthode est très efficace pour fournir un résultat réel. Mécanisme d'arrondi numérique - non seulement visuel, mais également lors du traitement.
Hypothétique: vous devez implémenter un mécanisme d'arrondi dans une interface graphique programme. Pour modifier simplement la précision d'un résultat obtenu changer le format de caret (c'est-à-dire entre crochets). Alors que:
DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);
renverrait en sortie: 0.912385
DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);
renverrait en sortie: 0.91239
DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);
renverrait en sortie: 0.9124
[EDIT: également si le format de caret est comme tel ("# 0. ############") et vous
entrez une décimale, par exemple 3.1415926, pour cause d'argument, DecimalFormat
ne produit pas de déchets (par exemple, des zéros à la fin) et renvoie:
3.1415926 .. si vous êtes incliné de cette façon. Certes, c'est un peu prolixe
pour le goût de certains développeurs - mais bon, il a une faible empreinte mémoire
lors du traitement et est très facile à mettre en œuvre.]
Donc, l'essentiel de DecimalFormat réside dans le fait qu'il gère simultanément la chaîne l'apparence - ainsi que le niveau de précision d'arrondi. Ergo: vous obtenir deux avantages pour le prix d'une implémentation d'un code. ;)
Vous pouvez utiliser la méthode de l'utilitaire suivante -
public static double round(double valueToRound, int numberOfDecimalPlaces)
{
double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
double interestedInZeroDPs = valueToRound * multipicationFactor;
return Math.round(interestedInZeroDPs) / multipicationFactor;
}
Voici un résumé de ce que vous pouvez utiliser si vous souhaitez obtenir le résultat sous forme de chaîne:
-
DecimalFormat # setRoundingMode () :
DecimalFormat df = new DecimalFormat("#.#####"); df.setRoundingMode(RoundingMode.HALF_UP); String str1 = df.format(0.912385)); // 0.91239 -
String str2 = new BigDecimal(0.912385) .setScale(5, BigDecimal.ROUND_HALF_UP) .toString();
Voici une suggestion sur les bibliothèques que vous pouvez utiliser si vous voulez double en conséquence. Je ne le recommanderais toutefois pas pour la conversion de chaînes, car double pourrait ne pas être en mesure de représenter exactement ce que vous voulez (voir par exemple ici ):
Une solution succincte:
public static double round(double value, int precision) {
int scale = (int) Math.pow(10, precision);
return (double) Math.round(value * scale) / scale;
}
Voir aussi, https://stackoverflow.com/a/22186845/212950 Merci à jpdymond pour cette offre.
Vous pouvez utiliser BigDecimal
BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);
Voir: http://www.javabeat.net/precise- arrondi-de-décimales-en-arrondissant-mode-énumération /
Essayez ceci: org.apache.commons.math3.util.Precision.round (double x, échelle int)
La page d'accueil de la bibliothèque de mathématiques Apache Commons est la suivante: http://commons.apache.org/proper/commons- math / index.html
L’implémentation interne de cette méthode est la suivante:
public static double round(double x, int scale) {
return round(x, scale, BigDecimal.ROUND_HALF_UP);
}
public static double round(double x, int scale, int roundingMethod) {
try {
return (new BigDecimal
(Double.toString(x))
.setScale(scale, roundingMethod))
.doubleValue();
} catch (NumberFormatException ex) {
if (Double.isInfinite(x)) {
return x;
} else {
return Double.NaN;
}
}
}
Si vous voulez vraiment des nombres décimaux pour le calcul (et pas seulement pour la sortie), n'utilisez pas un format à virgule flottante à base binaire comme double.
Use BigDecimal or any other decimal-based format.
J'utilise BigDecimal pour les calculs, mais gardez à l'esprit que cela dépend de la taille de chiffres que vous avez affaire. Dans la plupart de mes implémentations, je trouve l'analyse syntaxique de double ou entier à Long est suffisant pour les calculs de très grands nombres.
En fait, j'ai récemment utilisé analysé à long pour obtenir des représentations précises (par opposition aux résultats hexadécimaux) dans une interface graphique pour des nombres aussi grands que ################################## caractères (en tant que exemple).
Comme je n'ai trouvé aucune réponse complète sur ce thème, j'ai mis en place une classe qui devrait gérer cela correctement, avec prise en charge de:
- Mise en forme : formatez facilement une chaîne double en chaîne avec un certain nombre de décimales
- Analyse : doublez la valeur mise en forme de nouveau
- Paramètres régionaux : formatez et analysez à l'aide des paramètres régionaux par défaut
- Notation exponentielle : commencez à utiliser la notation exponentielle après un certain seuil
L'utilisation est assez simple :
(Pour les besoins de cet exemple, j'utilise des paramètres régionaux personnalisés)
public static final int DECIMAL_PLACES = 2;
NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);
String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"
double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345
Voici la classe :
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.util.Locale;
public class NumberFormatter {
private static final String SYMBOL_INFINITE = "\u221e";
private static final char SYMBOL_MINUS = '-';
private static final char SYMBOL_ZERO = '0';
private static final int DECIMAL_LEADING_GROUPS = 10;
private static final int EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation
private DecimalFormat decimalFormat;
private DecimalFormat decimalFormatLong;
private DecimalFormat exponentialFormat;
private char groupSeparator;
public NumberFormatter(int decimalPlaces) {
configureDecimalPlaces(decimalPlaces);
}
public void configureDecimalPlaces(int decimalPlaces) {
if (decimalPlaces <= 0) {
throw new IllegalArgumentException("Invalid decimal places");
}
DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
separators.setMinusSign(SYMBOL_MINUS);
separators.setZeroDigit(SYMBOL_ZERO);
groupSeparator = separators.getGroupingSeparator();
StringBuilder decimal = new StringBuilder();
StringBuilder exponential = new StringBuilder("0.");
for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
}
for (int i = 0; i < decimalPlaces; i++) {
decimal.append("#");
exponential.append("0");
}
exponential.append("E0");
decimalFormat = new DecimalFormat(decimal.toString(), separators);
decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
exponentialFormat = new DecimalFormat(exponential.toString(), separators);
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
}
public String format(double value) {
String result;
if (Double.isNaN(value)) {
result = "";
} else if (Double.isInfinite(value)) {
result = String.valueOf(SYMBOL_INFINITE);
} else {
double absValue = Math.abs(value);
if (absValue >= 1) {
if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
value = Math.floor(value);
result = exponentialFormat.format(value);
} else {
result = decimalFormat.format(value);
}
} else if (absValue < 1 && absValue > 0) {
if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
result = decimalFormat.format(value);
if (result.equalsIgnoreCase("0")) {
result = decimalFormatLong.format(value);
}
} else {
result = exponentialFormat.format(value);
}
} else {
result = "0";
}
}
return result;
}
public String formatWithoutGroupSeparators(double value) {
return removeGroupSeparators(format(value));
}
public double parse(String value, double defValue) {
try {
return decimalFormat.parse(value).doubleValue();
} catch (ParseException e) {
e.printStackTrace();
}
return defValue;
}
private String removeGroupSeparators(String number) {
return number.replace(String.valueOf(groupSeparator), "");
}
}
Juste au cas où quelqu'un aurait encore besoin d'aide pour cela. Cette solution fonctionne parfaitement pour moi.
private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();
}
renvoie une chaîne avec la sortie souhaitée.
L’extrait de code ci-dessous montre comment afficher n chiffres. L'astuce consiste à définir la variable pp sur 1 suivie de n zéros. Dans l'exemple ci-dessous, la valeur de la variable pp comporte 5 zéros. Cinq chiffres seront donc affichés.
double pp = 10000;
double myVal = 22.268699999999967;
String needVal = "22.2687";
double i = (5.0/pp);
String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();
Si vous utilisez DecimalFormat pour convertir double en String , c'est très simple:
DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);
double num = 1.234567;
return formatter.format(num);
Il existe plusieurs valeurs d’énumération RoundingMode à choisir, en fonction du comportement souhaité.
Je suis venu ici simplement pour une réponse simple sur la manière d'arrondir un nombre. C’est une réponse supplémentaire à fournir.
Comment arrondir un nombre en Java
Le cas le plus courant consiste à utiliser Math.round () .
Math.round(3.7) // 4
Les nombres sont arrondis au nombre entier le plus proche. Une valeur .5 est arrondie. Si vous avez besoin d'un comportement d'arrondi différent, vous pouvez utiliser l'un des autres Math fonctions. Voir la comparaison ci-dessous.
rond
Comme indiqué ci-dessus, ce nombre est arrondi au nombre entier le plus proche. Les chiffres .5 sont arrondis. Cette méthode retourne un int .
Math.round(3.0); // 3
Math.round(3.1); // 3
Math.round(3.5); // 4
Math.round(3.9); // 4
Math.round(-3.0); // -3
Math.round(-3.1); // -3
Math.round(-3.5); // -3 *** careful here ***
Math.round(-3.9); // -4
ceil
Toute valeur décimale est arrondie au nombre entier supérieur. Cela va au plafond . Cette méthode retourne un double .
Math.ceil(3.0); // 3.0
Math.ceil(3.1); // 4.0
Math.ceil(3.5); // 4.0
Math.ceil(3.9); // 4.0
Math.ceil(-3.0); // -3.0
Math.ceil(-3.1); // -3.0
Math.ceil(-3.5); // -3.0
Math.ceil(-3.9); // -3.0
sol
Toute valeur décimale est arrondie au nombre entier inférieur. Cette méthode retourne un double .
Math.floor(3.0); // 3.0
Math.floor(3.1); // 3.0
Math.floor(3.5); // 3.0
Math.floor(3.9); // 3.0
Math.floor(-3.0); // -3.0
Math.floor(-3.1); // -4.0
Math.floor(-3.5); // -4.0
Math.floor(-3.9); // -4.0
rint
Ceci est similaire à arrondir en ce que les valeurs décimales arrondies à l'entier le plus proche. Cependant, contrairement à round , les valeurs de .5 sont arrondies à l'entier pair. Cette méthode retourne un double .
Math.rint(3.0); // 3.0
Math.rint(3.1); // 3.0
Math.rint(3.5); // 4.0 ***
Math.rint(3.9); // 4.0
Math.rint(4.5); // 4.0 ***
Math.rint(5.5); // 6.0 ***
Math.rint(-3.0); // -3.0
Math.rint(-3.1); // -3.0
Math.rint(-3.5); // -4.0 ***
Math.rint(-3.9); // -4.0
Math.rint(-4.5); // -4.0 ***
Math.rint(-5.5); // -6.0 ***
Pour cela, nous pouvons utiliser ce formateur:
DecimalFormat df = new DecimalFormat("#.00");
String resultado = df.format(valor)
ou:
DecimalFormat df = new DecimalFormat("0.00"); :
Utilisez cette méthode pour obtenir toujours deux décimales:
private static String getTwoDecimals(double value){
DecimalFormat df = new DecimalFormat("0.00");
return df.format(value);
}
Définir ces valeurs:
91.32
5.22
11.5
1.2
2.6
En utilisant la méthode, nous pouvons obtenir les résultats suivants:
91.32
5.22
11.50
1.20
2.60
Je suis d'accord avec la réponse choisie d'utiliser DecimalFormat --- ou bien BigDecimal .
Veuillez tout d'abord lire la Mise à jour ci-dessous!
Toutefois, si vous voulez arrondir la valeur double et obtenir un résultat double , vous pouvez utiliser org.apache.commons.math3. .util.Precision.round (..) comme mentionné ci-dessus. L'implémentation utilise BigDecimal , est lente et crée des déchets.
Une méthode similaire mais rapide et sans faille est fournie par l'utilitaire DoubleRounder dans la bibliothèque decimal4j:
double a = DoubleRounder.round(2.0/3.0, 3);
double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
double c = DoubleRounder.round(1000.0d, 17);
double d = DoubleRounder.round(90080070060.1d, 9);
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
affichera
0.667
0.666
1000.0
9.00800700601E10
Voir https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility
Clause de non-responsabilité: je participe au projet decimal4j.
Mise à jour:
Comme @iaforek l'a souligné, DoubleRounder renvoie parfois des résultats contre-intuitifs. La raison en est qu'il effectue un arrondi mathématiquement correct. Par exemple, DoubleRounder.round (256.025d, 2) sera arrondi à 256.02 car la valeur double représentée par 256.025d est légèrement inférieure à la valeur rationnelle 256.025 et sera donc arrondie à la baisse.
Remarques:
- Ce comportement est très similaire à celui du constructeur
BigDecimal (double)(mais pas àvalueOf (double)qui utilise le constructeur de chaîne). - Le problème peut être contourné par un double arrondi vers une précision supérieure, mais c'est compliqué et je ne vais pas entrer dans les détails ici
Pour ces raisons et pour tout ce qui est mentionné ci-dessus dans ce message, je ne peux pas recommander l'utilisation de DoubleRounder .
Si vous utilisez une technologie comportant un kit JDK minimal. Voici une solution sans librairie Java:
double scale = 100000;
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;
DecimalFormat est le meilleur moyen de générer un résultat, mais je ne le préfère pas. Je fais toujours cela tout le temps, parce que ça retourne la double valeur. Je peux donc l'utiliser plus que la simple sortie.
Math.round(selfEvaluate*100000d.0)/100000d.0;
OU
Math.round(selfEvaluate*100000d.0)*0.00000d1;
Si vous avez besoin d'un nombre de décimales élevé, vous pouvez utiliser BigDecimal à la place. Quoi qu'il en soit, .0 est important. Sans cela, l’arrondi de 0.33333d5 renvoie 0.33333 et seulement 9 chiffres sont autorisés. La deuxième fonction sans .0 a des problèmes avec 0.30000 return 0.30000000000000004.
Où dp = position décimale souhaitée, et valeur est un double.
double p = Math.pow(10d, dp);
double result = Math.round(value * p)/p;
N'oubliez pas que String.format () et DecimalFormat produisent une chaîne à l'aide de l'option Locale par défaut. Ils peuvent donc écrire un nombre formaté avec un point ou une virgule comme séparateur entre les parties entières et décimales. Pour vous assurer que la chaîne arrondie a le format souhaité, utilisez java.text.NumberFormat comme suit:
Locale locale = Locale.ENGLISH;
NumberFormat nf = NumberFormat.getNumberInstance(locale);
// for trailing zeros:
nf.setMinimumFractionDigits(2);
// round to 2 digits:
nf.setMaximumFractionDigits(2);
System.out.println(nf.format(.99));
System.out.println(nf.format(123.567));
System.out.println(nf.format(123.0));
Imprimera dans les paramètres régionaux anglais (quel que soit le paramètre local): 0,99 123,57 123,00
L'exemple est tiré de Farenda - comment convertir en double en Chaîne correctement .
Si vous considérez 5 ou n nombre de décimales. Peut-être que cette réponse résoudra votre problème.
double a = 123.00449;
double roundOff1 = Math.round(a*10000)/10000.00;
double roundOff2 = Math.round(roundOff1*1000)/1000.00;
double roundOff = Math.round(roundOff2*100)/100.00;
System.out.println("result:"+roundOff);
Le résultat sera: 123.0 1
cela peut être résolu avec une boucle et une fonction récursive.
En général, l’arrondi se fait en mettant à l’échelle: round (num / p) * p
/**
* MidpointRounding away from zero ('arithmetic' rounding)
* Uses a half-epsilon for correction. (This offsets IEEE-754
* half-to-even rounding that was applied at the edge cases).
*/
double RoundCorrect(double num, int precision) {
double c = 0.5 * EPSILON * num;
// double p = Math.pow(10, precision); //slow
double p = 1; while (precision--> 0) p *= 10;
if (num < 0)
p *= -1;
return Math.round((num + c) * p) / p;
}
// testing edge cases
RoundCorrect(1.005, 2); // 1.01 correct
RoundCorrect(2.175, 2); // 2.18 correct
RoundCorrect(5.015, 2); // 5.02 correct
RoundCorrect(-1.005, 2); // -1.01 correct
RoundCorrect(-2.175, 2); // -2.18 correct
RoundCorrect(-5.015, 2); // -5.02 correct
