Как округлить число до n знаков после запятой в Java

Question

Что мне нужно - это метод преобразования двойника в строку, которая округляется с использованием метода полураспада - то есть, если десятичное число округляется до 5, оно всегда округляется до предыдущего номера. Это стандартный метод округления большинства людей в большинстве ситуаций.

Я также хотел бы отображать только значимые цифры, т. Е. Не должно быть никаких конечных нулей.

Я знаю один способ сделать это состоит в использовании String.format метода:

String.format("%.5g%n", 0.912385); 

возвращается:

0.91239 

который является большим, однако он всегда отображает числа с 5 знаками после запятой, даже если они не являются существенными:

String.format("%.5g%n", 0.912300); 

возвращение:

0.91230 

Другой способ заключается в использовании DecimalFormatter:

DecimalFormat df = new DecimalFormat("#.#####"); 
df.format(0.912385); 

возвращается:

0.91238 

Однако, как вы можете видеть это использует половину даже округления. То есть он округляется, если предыдущая цифра четная. Что бы я хотел:

0.912385 -> 0.91239 
0.912300 -> 0.9123 

Каков наилучший способ достичь этого в Java?

Answer 1

Использование setRoundingMode, установите RoundingMode явно обрабатывать вашу проблему с половинной даже раунде, а затем использовать шаблон формата для требуемой мощности.

Пример:

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)); 
} 

дает выход:

12 
123.1235 
0.23 
0.1 
2341234.2125 

Answer 2

Предполагая value является double, вы можете сделать:

(double)Math.round(value * 100000d)/100000d 

Это для точности 5 цифр. Число нулей указывает количество десятичных знаков.

Answer 3

double myNum = .912385; 
int precision = 10000; //keep 4 digits 
myNum= Math.floor(myNum * precision +.5)/precision; 

Answer 4

Вы также можете использовать

DecimalFormat df = new DecimalFormat("#.00000"); 
df.format(0.912385); 

, чтобы убедиться, что вы задн 0-х.

Answer 5

new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP); 

предоставит вам BigDecimal. Чтобы получить строку из нее, просто позвоните по этому методу или toPlainString для Java 5+ для строки простого формата.

Пример программы:

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)); 
    } 

Answer 6

Реала Java Как к posts это решение, которое также совместим для версий до Java 1.6.

BigDecimal bd = new BigDecimal(Double.toString(d)); 
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP); 
return bd.doubleValue(); 

Answer 7

Предположим, у вас есть

double d = 9232.129394d; 

вы можете использовать BigDecimal

BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN); 
d = bd.doubleValue(); 

или без BigDecimal

d = Math.round(d*100)/100.0d; 

с обоими решениями d == 9232.13

Answer 8

Вы можете использовать следующую утилиту ме-

public static double round(double valueToRound, int numberOfDecimalPlaces) 
{ 
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces); 
    double interestedInZeroDPs = valueToRound * multipicationFactor; 
    return Math.round(interestedInZeroDPs)/multipicationFactor; 
} 

Answer 9

@Milhous: десятичный формат для закругления превосходен:

Вы также можете использовать

DecimalFormat df = new DecimalFormat("#.00000"); 
df.format(0.912385); 

сделать конечно, у вас есть задние 0.

Я хотел бы добавить, что этот метод очень хорош при обеспечении фактической числового, округлением механизма - не только визуально, но и при обработке.

Гипотетика: вам необходимо реализовать механизм округления в программе GUI . Чтобы изменить точность/точность результата, просто измените формат каретки (т. Е. В скобках). Так что:

DecimalFormat df = new DecimalFormat("#0.######"); 
df.format(0.912385); 

вернется в качестве выходного сигнала: 0.912385

DecimalFormat df = new DecimalFormat("#0.#####"); 
df.format(0.912385); 

вернется в качестве выходного сигнала: 0.91239

DecimalFormat df = new DecimalFormat("#0.####"); 
df.format(0.912385); 

вернется в качестве выходного сигнала: 0.9124

[EDIT: также если формат каретки выглядит так ("# 0. ########## ## "), а вы введите десятичное число, например. 3.1415926, для аргументации, DecimalFormat не производит никакого мусора (например, конечных нулей) и вернет: 3.1415926 .. если вы так наклонены. Конечно, это немного многословным по вкусу некоторые Дэв. - но эй, это есть след низкой памяти во время обработки и очень легко осуществить]

Так по существу, красота DecimalFormat является то, что она одновременно обрабатывает строка внешний вид - а также уровень точности округления. Ergo: вы получаете двух преимуществ по цене одной реализации кода.;)

Answer 10

Если вы действительно хотите использовать десятичные числа для вычисления (и не только для вывода), не используйте бинарный формат с плавающей запятой, такой как double. Используйте BigDecimal или любой другой десятичный формат. - PAULO Эберманн

---

Я использую BigDecimal для вычислений, но иметь в виду, что это зависит от размера цифры, которые вы имеете дело с. В большинстве моих реализаций я нахожу парсинг из двойного или целых чисел в Long достаточно для вычисления очень большого числа. На самом деле, у меня недавно использовалось синтаксический анализ для получения точных представлений (в отличие от результатов шестнадцатеричного) в гиях для чисел, больших как ################ ################# символов (в качестве примера ).

Answer 11

В приведенном ниже фрагменте кода показано, как отображать n цифр. Фокус в том, чтобы установить переменную pp в 1, за которой следуют n нулей. В приведенном ниже примере переменное значение pp имеет 5 нулей, поэтому будет отображаться 5 цифр.

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(); 

Answer 12

Вы можете использовать класс DecimalFormat.

double d = 3.76628729; 

DecimalFormat newFormat = new DecimalFormat("#.##"); 
double twoDecimal = Double.valueOf(newFormat.format(d)); 

Answer 13

Как отметили некоторые другие, правильный ответ должен использовать либо DecimalFormat или BigDecimal. Плавающая точка не имеет десятичных знаков, поэтому вы не можете округлить или усечь их до определенного числа. Вы должны работать в десятичной системе, и это то, что делают эти два класса.

Я размещаю следующий код в качестве встречного примера для всех ответов в этом потоке и даже по всему StackOverflow (и в другом месте), которые рекомендуют умножение с последующим усечением, за которым следует разделение. На адвокатов этой методики должно объясняться, почему следующий код производит неправильный вывод в более чем 92% случаев.

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"); 
    } 
} 

Вывод этой программы:

10001 trials 9251 errors 

EDIT: Для того, чтобы решить некоторые комментарии ниже я переделал модуль часть цикла испытаний с использованием BigDecimal и new MathContext(16) для работы модуля следующим образом:

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"); 
} 

10001 trials 4401 errors 

Answer 14

Попробуйте это: org.apache.commons.math3.util.Precision.round (двойные х, внутр шкала)

См: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html

домашнюю страницу Apache Commons Математика Библиотека: http://commons.apache.org/proper/commons-math/index.html

внутренняя реализация этого метода является:

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; 
     } 
    } 
} 

Answer 15

Где дп = десятичное место, которое вы хотите, и значение - это двойной.

double p = Math.pow(10d, dp); 

    double result = Math.round(value * p)/p; 

Answer 16

Вы можете использовать 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); 

См: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/

Answer 17

Если вы используете DecimalFormat конвертировать double в String, это очень просто:

DecimalFormat formatter = new DecimalFormat("0.0##"); 
formatter.setRoundingMode(RoundingMode.HALF_UP); 

double num = 1.234567; 
return formatter.format(num); 

Есть несколько RoundingMode значения перечисления для выбора, в зависимости от требуемого поведения.

Answer 18

Вот краткое изложение того, что вы можете использовать, если вы хотите, чтобы результат в виде строки:

1. DecimalFormat#setRoundingMode():

   DecimalFormat df = new DecimalFormat("#.#####"); 
   df.setRoundingMode(RoundingMode.HALF_UP); 
   String str1 = df.format(0.912385)); // 0.91239 
   

2. BigDecimal#setScale()

   String str2 = new BigDecimal(0.912385) 
       .setScale(5, BigDecimal.ROUND_HALF_UP) 
       .toString(); 
   

Вот предложение о том, какие библиотеки вы можете использовать, если хотите double. Я бы не рекомендовал его для преобразования строки, хотя, как дважды не может быть в состоянии представить, что вы хотите точно (смотри, например, here):

1. Precision из Apache Commons Math

   double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP); 
   

2. Functions из кольта

   double rounded = Functions.round(0.00001).apply(0.912385) 
   

3. Utils из Weka

   double rounded = Utils.roundDouble(0.912385, 5) 
   

Answer 19

Я согласен с выбранным ответом использовать DecimalFormat --- или в качестве альтернативы BigDecimal.

Пожалуйста, прочтите Обновить ниже.

Однако если вы сделать округлить двойное значение и получить результат в double значение, вы можете использовать org.apache.commons.math3.util.Precision.round(..), как указано выше. Реализация использует BigDecimal, медленная и создает мусор.

Аналогичный, но быстро и мусора свободный метод обеспечивается DoubleRounder утилитой в библиотеке 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); 

будет выводить

0.667 
0.666 
1000.0 
9.00800700601E10 

См https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility

Отказ от ответственности : Я участвую в проект decimal4j.

Обновление: Как отметил @iaforek, DoubleRounder иногда возвращает встречные результаты. Причина в том, что он выполняет математически правильное округление. Например, DoubleRounder.round(256.025d, 2) будет округлено до 256,02, потому что двойное значение, представленное как 256.025d, несколько меньше, чем рациональное значение 256.025 и, следовательно, будет округлено.

Примечания:

• Такое поведение очень похож на что из BigDecimal(double) конструктора (но не valueOf(double), который использует строку конструктора).
• Проблема может быть преодолена с двойным шагом округления к более высокой точности первого, но это сложно, и я не вдаваясь в подробности здесь

По этим причинам и все упомянутые выше в этом посте я не может рекомендовать использовать DoubleRounder.

Answer 20

На всякий случай кому-то еще нужна помощь. Это решение отлично работает для меня.

private String withNoTrailingZeros(final double value, final int nrOfDecimals) { 
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString(); 

} 

возвращает String с требуемым выходом.

Answer 21

В основном, метод round() возвращает ближайший long или int, как указано тип возвращаемого значения метода, в аргументу:

public class Test{ 
    public static void main(String args[]){ 
    double d = 100.675; 
    double e = 100.500; 
    float f = 100; 
    float g = 90f; 
    System.out.println (Math.round(d)); 
    System.out.println (Math.round(e)); 
    System.out.println (Math.round(f)); 
    System.out.println (Math.round(g)); 
    } 
} 

И это дает результат:

101 
101 
100 
90 

Answer 22

Поскольку I не нашел полного ответа на эту тему. Я собрал класс, который должен правильно его обрабатывать, с поддержкой:

• Форматирование: Легко форматировать двойной строки с определенным количеством знаков после запятой
• Синтаксический: Разбираем отформатированный значение обратно в два раза
• Locale: Формат и анализировать с использованием локали по умолчанию
• экспоненциальной записи: Начало работы с экспоненциальной нотации после определенного порога

Использование довольно просто:

(Ради этого примера я использую пользовательский языковой стандарт)

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 

Вот класс:

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), ""); 
    } 

} 

Answer 23

Имейте в виду, что String.format() и DecimalFormat производят строку, используя стандартный язык Locale. Таким образом, они могут писать форматированное число с точкой или запятой в качестве разделителя между целыми и десятичными частями. Для того, чтобы убедиться, что закругленная строка в формате, который вы хотите использовать java.text.NumberFormat, как так:

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)); 

Будет печатать на английском языке локали (независимо от того, что ваша локаль): 0,99 123,57 123,00

Пример взяты из Farenda - how to convert double to String correctly.

Answer 24

Если вы считаете 5 или n числом десятичных знаков. Может быть, этот ответ решает вашу проблему.

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); 

Выход будет: 123,0
это можно решить с помощью цикла и рекурсивной функции.

Answer 25

DecimalFormat - это лучший способ вывода, но я не люблю его. Я всегда делаю это все время, потому что он возвращает двойное значение. Поэтому я могу использовать его больше, чем просто вывод.

Math.round(selfEvaluate*100000d.0)/100000d.0; 

ИЛИ

Math.round(selfEvaluate*100000d.0)*0.00000d1; 

Если вам нужно большое значение знаков после запятой, вы можете использовать вместо BigDecimal. Anyways .0 важен. Без него округление 0,333333d5 возвращает 0,33333 и допускается только 9 цифр. Вторая функция без .0 имеет проблемы с возвратом 0.30000 0.30000000000000004.

Answer 26

Я пришел сюда просто для того, чтобы получить простой ответ о том, как округлить число. Это дополнительный ответ, чтобы обеспечить это.

Как округлить число в Java

Наиболее распространенный случай является использование Math.round().

Math.round(3.7) // 4 

Номера округлены до ближайшего целого числа. Значение A .5 округляется. Если вам нужно другое поведение округления, то вы можете использовать одну из других функций Math. См. Сравнение ниже.

round

Как уже говорилось выше, это округление до ближайшего целого числа. .5 десятичные знаки округляют вверх. Этот метод возвращает 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

Любое десятичное значение округляется до следующего целого числа. Он идет к ceil ing. Этот метод возвращает 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 

floor

Любое десятичное значение округляется до следующего целого числа. Этот метод возвращает 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

Это аналогично округлить в том, что десятичные значения круглых до ближайшего целого числа. Однако, в отличие от round, .5 значения округляются до четного целого. Этот метод возвращает 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 *** 

Answer 27

DecimalFormat myFormatter = new DecimalFormat("0.000"); 
String output = myFormatter.format(2.34d); 

Answer 28

Вот основное решение, предложенное jpdymond:

public static double round(double value, int precision) { 
     int scale = (int) Math.pow(10, precision); 
     return (double) Math.round(value * scale)/scale; 
    } 

https://stackoverflow.com/a/22186845/212950

Answer 29

Если вы используете технологию, которая имеет минимальную JDK.Вот способ без каких-либо Java LIBS:

double scale = 100000;  
double myVal = 0.912385; 
double rounded = (int)((myVal * scale) + 0.5d)/scale; 

Answer 30

В общем, округление производится путем масштабирования: 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) { 
 
\t double c = 0.5 * EPSILON * num; 
 
// \t double p = Math.pow(10, precision); //slow 
 
\t double p = 1; while (precision--> 0) p *= 10; 
 
\t if (num < 0) 
 
\t \t p *= -1; 
 
\t 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