I’m wondering what the best way to fix precision errors is in Java. As you can see in the following example, there are precision errors:
class FloatTest
{
public static void main(String[] args)
{
Float number1 = 1.89f;
for(int i = 11; i < 800; i*=2)
{
System.out.println("loop value: " + i);
System.out.println(i*number1);
System.out.println("");
}
}
}
The result displayed is:
loop value: 11
20.789999
loop value: 22
41.579998
loop value: 44
83.159996
loop value: 88
166.31999
loop value: 176
332.63998
loop value: 352
665.27997
loop value: 704
1330.5599
Also, if someone can explain why it only does it starting at 11 and doubling the value every time. I think all other values (or many of them at least) displayed the correct result.
Problems like this have caused me headache in the past and I usually use number formatters or put them into a String.
Edit: As people have mentioned, I could use a double, but after trying it, it seems that 1.89 as a double times 792 still outputs an error (the output is 1496.8799999999999).
I guess I’ll try the other solutions such as BigDecimal
asked Jul 15, 2011 at 22:06
2
answered Jul 15, 2011 at 22:13
Jarek PotiukJarek Potiuk
19.1k2 gold badges59 silver badges60 bronze badges
0
The problem is not with Java but with the good standard float’s (http://en.wikipedia.org/wiki/IEEE_floating-point_standard).
You can either:
-
use Double and have a bit more precision (but not perfect of course, it also has limited precision)
-
use a arbitrary-precision-library
-
use numerically stable algorithms and truncate/round digits of which you are not sure they are correct (you can calculate numeric precision of operations)
answered Jul 15, 2011 at 22:12
Bernd ElkemannBernd Elkemann
23.2k4 gold badges37 silver badges65 bronze badges
When you print the result of a double operation you need to use appropriate rounding.
System.out.printf("%.2f%n", 1.89 * 792);
prints
1496.88
If you want to round the result to a precision, you can use rounding.
double d = 1.89 * 792;
d = Math.round(d * 100) / 100.0;
System.out.println(d);
prints
1496.88
However if you see below, this prints as expected, as there is a small amount of implied rounding.
It worth nothing that (double) 1.89 is not exactly 1.89 It is a close approximation.
new BigDecimal(double) converts the exact value of double without any implied rounding. It can be useful in finding the exact value of a double.
System.out.println(new BigDecimal(1.89));
System.out.println(new BigDecimal(1496.88));
prints
1.8899999999999999023003738329862244427204132080078125
1496.8800000000001091393642127513885498046875
answered Jul 15, 2011 at 22:30
Peter LawreyPeter Lawrey
524k77 gold badges749 silver badges1130 bronze badges
5
Most of your question has been pretty well covered, though you might still benefit from reading the [floating-point] tag wiki to understand why the other answers work.
However, nobody has addressed «why it only does it starting at 11 and doubling the value every time,» so here’s the answer to that:
for(int i = 11; i < 800; i*=2)
╚═══╤════╝ ╚╤═╝
│ └───── "double the value every time"
│
└───── "start at 11"
answered Nov 10, 2011 at 17:26
PopsPops
30k37 gold badges134 silver badges151 bronze badges
2
You could use doubles instead of floats
answered Jul 15, 2011 at 22:08
PaulPaul
139k27 gold badges274 silver badges264 bronze badges
3
If you really need arbitrary precision, use BigDecimal.
answered Jul 15, 2011 at 22:13
JacobJacob
41.4k6 gold badges79 silver badges81 bronze badges
first of Float is the wrapper class for the primitive float
and doubles have more precision
but if you only want to calculate down to the second digit (for monetary purposes for example) use an integer (as if you are using cents as unit) and add some scaling logic when you are multiplying/dividing
or if you need arbitrary precision use BigDecimal
answered Jul 15, 2011 at 22:14
ratchet freakratchet freak
47.1k5 gold badges67 silver badges106 bronze badges
1
If precision is vital, you should use BigDecimal to make sure that the required precision remains. When you instantiate the calculation, remember to use strings to instantiate the values instead of doubles.
answered Jul 15, 2011 at 22:18
I never had a problem with simple arithmetic precision in either Basic, Visual Basic, FORTRAN, ALGOL or other «primitive» languages. It is beyond comprehension that JAVA can’t do simple arithmetic without introducing errors. I need just two digits to the right of the decimal point for doing some accounting. Using Float subtracting 1000 from 1355.65 I get 355.650002! In order to get around this ridiculous error I have implemented a simple solution. I process my input by separating the values on each side of the decimal point as character, convert each to integers, multiply each by 1000 and add the two back together as integers. Ridiculous but there are no errors introduced by the poor JAVA algorithms.
answered Dec 19, 2020 at 3:57
Помогаю со студенческими работами здесь
Ошибка при компиляции
Здравствуйте!
Дан код:
int a = 5;
int b = 2;
int c = a * b;
System.out.print("Result: ");…
Ошибка при компиляции
Почему при компиляции через жабу ц возникает ошибка ?) Я думаю что дело в кодировке, пробовал…
Ошибка при компиляции
Не могу понять почему компилятор выдает ошибку.
class Circle {
public double x; // абсцисса…
Ошибка при компиляции
Пытаюсь запустить Java программу из консоли — выдает вот это (на картинке).
Переменные Path,…
Искать еще темы с ответами
Или воспользуйтесь поиском по форуму:
I’m using a float constant and setting a objects private float variable to the float constant below, but when the object outputs the value it was set to, it’s rounding up the last digit in the float.
private final float RF_FREQUENCY = 956.35625f;
Object o = new Object();
o.setRFFrequency(RF_FREQUENCY);
System.out.println(o.getRFFrequency);
Output: 956.35626
The variable in the object is declared as protected float rfFrequency; and below are the getters and setters.
public float getRFFrequency() {
return rfFrequency;
}
public void setRFFrequency(float value) {
this.rfFrequency = value;
}
Any idea why this is happening?
mskfisher
3,2714 gold badges35 silver badges48 bronze badges
asked Feb 17, 2012 at 14:09
5
Because single precision IEEE754 floating point numbers only have 23 bits of precision (24 including the implicit 1 bit at the start).
That equates to roughly seven decimal digits and you can see that your number has eight digits in it.
All that’s happening is that the computer is choosing the closest number to what you asked for that it can represent.
If you need more precision, use a double. That gives you 52/53 bits which equates to about 15 decimal digits.
answered Feb 17, 2012 at 14:13
paxdiablopaxdiablo
848k233 gold badges1569 silver badges1944 bronze badges
5
Floats can’t represent every number, so numbers are rounded. Doubles are the same, but with a higher precision. If you use Double your output will be 956.35625 (in this special case).
answered Feb 17, 2012 at 14:14
AlexSAlexS
5,2853 gold badges38 silver badges54 bronze badges
After some testing, I got this result:
final float RF_FREQUENCY = 956.35625f;
System.out.println(String.format("%.5f", RF_FREQUENCY));
final BigDecimal xRF_FREQUENCY = new BigDecimal(956.35625);
System.out.println(String.format("%.5f", xRF_FREQUENCY));
And the output was:
956,35626
956,35625
So, as its explained in more details from coderanch and in this blog post, I recommend you to change to BigDecimal.
EDIT: I’ve found another post about same problem in stackoverflow Double vs. BigDecimal? Hope it helps you.
answered Feb 17, 2012 at 14:25
Luiggi MendozaLuiggi Mendoza
84.9k16 gold badges153 silver badges328 bronze badges
1
Время на прочтение
8 мин
Количество просмотров 146K
Несколько дней назад мне на глаза попался занимательный такой вопрос, касающийся того, каков будет результат выполнения данного кода:
double a = 2.0 - 1.1;
или такого:
double f = 0.0;
for (int i=1; i <= 10; i++) {
f += 0.1;
}
Вопреки всем моим ожиданиям, ответ: 0.89999999999999991 в первом случае и 0.99999999999999989 во втором.
Для тех, кто хочет узнать почему, а так же еще несколько занимательных фактов про этот тип данных, милости просим.
В общем виде ответ на поставленный выше вопрос будет звучать примерно так: «Подобные ошибки связанны с внутренним двоичным (binary) представлением чисел. Подобно тому, как в десятичной системе нельзя точно представить результат деления 1/3, так и в двоичной системе невозможно точно представить 1/10. Если вам нужно исключить ошибки округления, следует использовать класс BigDecimal».
Существует важное различие между абстрактными вещественными числами, такими как π или 0.2, и типом данных double в Java. Во-первых, платонически-идеальное представление вещественных чисел является бесконечным, в то время как представление в Java ограничено числом бит. Однако точность вычислений является еще более насущной проблемой, чем ограничение на размер чисел. Еще больше «интригует» совершенно оригинальный способ округления чисел, но обо всем по порядку.
Начать, пожалуй, стоит с двоичного представления целых чисел. Этот абзац нам пригодится чуть позже. Итак. Самым простым вариантом представления целых чисел считается так называемый «Прямой код», в котором старший бит используется для записи знака числа (0 — положительное, 1 — отрицательное), а оставшиеся биты используются непосредственно для записи самого значения. Таким образом, число «-9» в восьмиразрядном представлении будет выглядеть как 10001001. Недостатком такого подхода считается наличие двух нулей («+0» и «-0») и усложнение арифметических операций с отрицательными числами. Другим вариантом, интересующим нас, является «Код со сдвигом», в котором, говоря простым языком, мы прибавляем к нашему числу некое константное для данного типа представления число, равное 2^(n-1), где n — число разрядов (бит). В нашем случае, пример с числом «-9» в восьмиразрядном представлении будет выглядеть так:
-9 + 2^(8-1) = -9 + 128 = 119. В двоичном виде получим 01110111. Этот вариант удобен тем, что ноль у нас всего один, однако при арифметических операциях необходимо будет учитывать смещение.
Здесь стоит упомянуть вот о чем. Одной из заявленных целей языка Java является машинная независимость. Вычисления должны приводить к одинаковому результату, независимо от того, какая виртуальная машина их выполняет. Для арифметических вычислений над числами с плавающей точкой это неожиданно оказалось трудной задачей. Тип double использует для хранения числовых значений 64 бита, однако некоторые процессоры применяют 80-разрядные регистры с плавающей точкой. Эти регистры обеспечивают дополнительную точность на промежуточных этапах вычисления, т.е. промежуточный результат вычислений храниться в 80-разрядном регистре, после чего ответ округляется до 64 бит. Однако этот результат может оказаться иным, если в процессе всех вычислений используется 64-разрядный процессор. По этой причине в первоначальном описании JVM указывалось, что все промежуточные вычисления должны округляться. Это вызвало протест многих специалистов, поскольку подобное округление не только может привести к переполнению, но и сами вычисления происходят медленнее. Это привело к тому, что в JDK 1.2 появилась поддержка ключевого слова strictfp, гарантирующая воспроизводимость результатов всех вычислений, производимых внутри этого метода, класса или интерфейса (вернее его реализации). Иными словами, ключевое слово strictfp гарантирует, что на каждой платформе вычисления с плавающей точкой будут вести себя одинаково и с определенной точностью, даже если некоторые платформы могут производить вычисления с большей точностью. Интересно, что для процессоров семейства x86 модуль операций с плавающей точкой был выделен в отдельную микросхему, называемую математическим сопроцессором (floating point unit (FPU)). Начиная с процессоров Pentium модели MMX модуль операций с плавающей точкой интегрирован в центральный процессор. Подробнее.
Далее. Стандарт IEEE 754 говорит нам, что представление действительных чисел должно записываться в экспоненциальном виде. Это значит, что часть битов кодирует собой так называемую мантиссу числа, другая часть — показатель порядка (степени), и ещё один бит используется для указания знака числа (0 — если число положительное, 1 — если число отрицательное). Математически это записывается так:
(-1)^s × M × 2^E, где s — знак, M — мантисса, а E — экспонента. Экспонента записывается со сдвигом, который можно получить по формуле, приведенной выше.
Что такое мантисса и экспонента? Мантисса – это целое число фиксированной длины, которое представляет старшие разряды действительного числа. Допустим наша мантисса состоит из четырех бит (|M|=4). Возьмем, например, число «9», которое в двоичной системе будет равно 1001.
Экспонента (ее еще называют «порядком» или «показателем степени») – это степень базы (двойки) старшего разряда. Можно рассматривать ее как количество цифр перед точкой, отделяющей дробную часть числа. Если экспонента переменная, записываемая в регистр и неизвестная при компиляции, то число называют «числом с плавающей точкой». Если экспонента известна заранее, то число называют «числом с фиксированной точкой». Числа с фиксированной точкой могут записываться в обыкновенные целочисленные переменные (регистры) путем сохранения только мантиссы. В случае же записи чисел с плавающей точкой, записываются и мантиса и экспонента в так называемом стандартном виде, например «1.001e+3». Сразу видно, что мантисса состоит из четырех знаков, а экспонента равна трем.
Допустим мы хотим получить дробное число, используя те же 3 бита мантиссы. Мы можем это сделать, если возьмем, скажем, E=1. Тогда наше число будет равно
1.001e+1 = 1×2^2 + 0×2^1 + 0×2^0 + 1×2^(-1) = 4 + 0,5 = 4,5
Одной из проблем такого подхода может стать различное представление одного и того же числа в рамках одной длины мантиссы. Нашу «9-ку», при длине мантиссы равной 5, можно представить и как 1.00100e+3 и как 0.10010e+4 и как 0.01001e+5. Это не удобно для оборудования, т.к. нужно учитывать множественность представления при сравнении чисел и при выполнении над ними арифметических операций. Кроме того, это не экономично, поскольку число представлений — конечное, а повторения уменьшают множество чисел, которые вообще могут быть представлены. Однако тут есть маленькая хитрость. Оказывается, что для вычисления значения первого бита можно использовать экспоненту. Если все биты экспоненты равны 0, то первый бит мантиссы также считается равным нулю, в противном случае он равен единице. Числа с плавающей точкой, в которых первый бит мантиссы равен единице, являются нормализованными. Числа с плавающей точкой, первый бит мантиссы в которых равен нулю, называются денормализованными. С их помощью можно представлять значительно меньшие величины. Поскольку первый бит всегда может быть вычислен, нет необходимости хранить его явным образом. Это экономит один бит, так как неявную единицу не нужно хранить в памяти, и обеспечивает уникальность представления числа. В нашем примере с «9» нормализованным представлением будет 1.00100e+3, а мантисса будет храниться в памяти как «00100», т.к. старшая единица подразумевается неявно. Проблемой такого подхода является невозможность представления нуля, о которой я скажу чуть позже. Подробнее об этом и многом другом можно почитать тут и тут.
К слову, в JDK 1.5 допустимо задавать числа с плавающей точкой в шестнадцатеричном формате. Например, 0.125 можно представить как 0x1.0p-3. В шестнадцатеричной записи для указания экспоненты используется знак «p» вместо «е».
Вещи, о которых стоит помнить, работая с Double:
- Целочисленное деление на 0 генерирует исключение, в то время как результатом деления на 0 чисел с плавающей точкой является бесконечность (или NaN в случае деления 0.0/0). Кстати мне было интересно узнать, что разработчики JVM, согласно все тому же стандарту IEEE 754 ввели также и значения Double.NEGATIVE_INFINITY и Double.POSITIVE_INFINITY, равные -1.0 / 0.0 и 1.0 / 0.0 соответственно.
- Double.MIN_VALUE на самом деле не самое маленькое число, которое можно записать в double. Помните, мы говорили о том, что согласно стандарту IEEE 754, старшая единица мантиссы указывается неявно? Так вот. Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль, поскольку нет такой степени двойки, которая равнялась бы нулю. И разработчики JVM специально для решения этой проблемы ввели переменную Double.MIN_VALUE, которая, по сути, является максимально близким значением к нулю. Самым маленьким значением, которое вы можете сохранить в double является «-Double.MAX_VALUE».
System.out.println(0.0 > Double.MIN_VALUE); // возвращает false - Развивая предыдущую тему, можно привести еще один интересный пример, показывающий нам, что не все так очевидно, как может показаться на первый взгляд. Double.MAX_VALUE возвращает нам 1.7976931348623157E308, но что будет если мы преобразуем строку, содержащую число с плавающей запятой в double?
System.out.println(Double.parseDouble("1.7976931348623157E308")); // (...7E308) = 1.7976931348623157E308 max value System.out.println(Double.parseDouble("1.7976931348623158E308")); // (...8E308) = 1.7976931348623157E308 same??? System.out.println(Double.parseDouble("1.7976931348623159E308")); // (...9E308) = InfinityОказывается, между Double.MAX_VALUE и Double.POSITIVE_INFINITY есть еще некоторые значения, которые при вычислении округляются в одну или другую сторону. Тут стоит остановиться подробнее.
Множество вещественных чисел является бесконечно плотным (dense). Не существует такого понятия, как следующее вещественное число. Для любых двух вещественных чисел существует вещественное число в промежутке между ними. Это свойство не выполняется для чисел с плавающей точкой. Для каждого числа типа float или double существует следующее число. Кроме того, существует минимальное конечное расстояние между двумя последовательными числами типа float или double. Метод Math.nextUp() возвращает следующее число с плавающей точкой, превышающее заданный параметр. Например, данный код печатает все числа типа float между 1.0 и 2.0 включительно.
float x = 1.0F; int numFloats = 0; while (x <= 2.0) { numFloats++; System.out.println(x); x = Math.nextUp(x); } System.out.println(numFloats);Оказывается, что в промежутке от 1.0 до 2.0 включительно лежит ровно 8,388,609 чисел типа float. Это немало, но намного меньше, чем бесконечное множество вещественных чисел, которые находятся в том же диапазоне. Каждая пара последовательных чисел типа float находится на расстоянии примерно 0.0000001 друг от друга. Это расстояние называется единицей наименьшей точности (unit of least precision – ULP). Для типа double ситуация совершенно идентичная, за исключением того факта, что кол-во чисел после запятой значительно выше.
Пожалуй, на этом все. Желающим «копнуть поглубже» может пригодится следующий код:
// Возвращает представление заданного значения с плавающей точкой в соответствии с IEEE 754
long lbits = Double.doubleToLongBits(-0.06);
long lsign = lbits >>> 63; // знак
long lexp = (lbits >>> 52 & ((1 << 11) - 1)) - ((1 << 10) - 1); // порядок
long lmantissa = lbits & ((1L << 52) - 1); // мантисса
System.out.println(lsign + " " + lexp + " " + lmantissa);
System.out.println(Double.longBitsToDouble((lsign << 63) | (lexp + ((1 << 10) - 1)) << 52 | lmantissa));
Спасибо всем осилившим. Буду рад конструктивной критике и дополнениям.
Материалы по теме:
Новые математические возможности Java: Часть 2. Числа с плавающей точкой
IEEE Standard 754 Floating Point Numbers
Java Language and Virtual Machine Specifications
Представление вещественных чисел
Что нужно знать про арифметику с плавающей запятой
Арифметические операции над числами с плавающей точкой
The NumberFormatException is the frequently occurred exception in Java applications like NullPointerException.
NumberFormatException is an unchecked exception that occurred we try to convert a String to a number type.
Many Java methods convert String to numeric type e.g. Integer.parseInt() which convert String to int, Double.parseDoble() which convert String to double, and Long.parseLong() which convert String to long throws NumberFormatException to inform that the input String is not numeric.
In this article, we will see how the NumberFormatException exception occurred and ways to avoid NumberFormatExcpetion in Java.
Null String
Some times we see the Exception in thread «main» java.lang.NumberFormatException: «null». In the first case, In this, we have a «null» String i.e. an initialized String object whose value is «null». Since this is also not numeric, parseInt(), or parseFloat() will throw the NumberFormat exception as shown below.
Converting Float to String
In this case «1.0» is perfectly valid String i.e. it doesn’t contain any alphanumeric String. If you try to convert it into integer values using parseInt(), parseShort(), or parseByte() it will throw NumberFormatException because «1.0» is a floating-point value and cannot be converted into integral one.
These methods don’t cast they just do the conversion.
Convert String to Out of range values
Suppose we have string «130» to a byte, It throws NumberFormatException as the given type byte has rage is 128, which is exceeded by us.
Leading and Trailing space in String
This is a common error when we read values from the properties files and there are leading and trailing spaces present in the string.
If we want to convert » 128″ into an integer, it will throw exception java.lang.NumberFormatException.
For Trailing Spaces
Alphanumeric Input
This is a common mistake by the programmer for the alphanumeric input. No non-numeric letter other than + and — is not permitted in the input string.
It will throw an exception.
Empty String
This is the most common mistakes that happened from the programmer to convert an empty string to numeric or float values.
The parseInt(),parseFloat() …etc will throw NumberFormatException.
null values
This will happens when we pass null to a method like parseInt or parseFloat.It mostly occurs when we expect return values from some other methods and forgot to put a null check before converting it to our required type.
characters e.g 1 and l
This is another mistake by the programmer. Consider or typo «1» as «l».
Best Practices to avoid java.lang.NumberFormatException
1). Don’t try to convert alphabetic or special characters into numbers – the Java Number
API cannot do that.
2). We may want to validate an input string using regular expressions and throw the exception for
the invalid characters.
3). We can sanitize input against foreseeable known issues with methods like trim() and replaceAll().
4). In some cases, special characters in input may be valid. So, we do special processing for
that, using NumberFormat.
5). validate the input before converting it to antother data types.
6). Checks whether the String a valid Java number.
7). Determine if a string is Int or Float and to represent in longer format.
Post/Questions related to Java lang number format exception
How to resolve number format exception in java?
How to resolve class cast exception in java?
How to fix «Error: Could not find or load main class» in Eclipse?
Ways to avoid ConcurrentModificationException in Java?
How to solve «could not create the Java virtual machine» error in Java?
How to fix «illegal start of expression» compile-time error in Java?
Cause and solution of «class, interface, or enum expected» compiler error in Java?
How to solve java.lang.ClassNotFoundException: com.mysql.jdbc.Driver error?
How to solve java.lang.classnotfoundexception oracle.jdbc.driver.oracledriver?
Common reasons of java.lang.ArrayIndexOutOfBoundsException in Java?
java.lang.ClassNotFoundException : org.Springframework.Web.Context.ContextLoaderListener
How to solve «variable might not have initialized» compile-time error in Java?
How to fix ‘javac’ is not recognized as an internal or external command
How to solve java.lang.OutOfMemoryError: Java Heap Space in Eclipse, Tomcat?
Best Practices to Handle Exceptions in Java
In this article, we have seen the Java lang number format exception with examples. All source code in the tutorial can be found in the GitHub repository.