Перетворіть float у double, не втрачаючи точності

У мене є примітивний поплавок, і мені це потрібно як примітивний двійник. Просто кидання поплавка вдвічі дає мені дивну додаткову точність. Наприклад:

float temp = 14009.35F;
System.out.println(Float.toString(temp)); // Prints 14009.35
System.out.println(Double.toString((double)temp)); // Prints 14009.349609375

Однак, якщо замість приведення, я вивожу float як рядок і аналізую рядок як подвійний, я отримую те, що хочу:

System.out.println(Double.toString(Double.parseDouble(Float.toString(temp))));
// Prints 14009.35

Чи є кращий спосіб, ніж поїхати до Стринга і назад?

Це не те, що ви насправді отримуєте додаткову точність - це те, що поплавок не точно відображав число, на яке ви прагнули спочатку. Двічі в точно представляє оригінальний поплавець; toStringпоказує "зайві" дані, які вже були в наявності.

Наприклад (а ці цифри неправильні, я просто все вигадую) припустимо, у вас було:

float f = 0.1F;
double d = f;

Тоді значення fможе бути рівно 0,100000234523. dматиме точно таке ж значення, але коли ви перетворите його на рядок, він буде "довіряти", що він є точним з більшою точністю, тому не буде округлятися так рано, і ви побачите "зайві цифри", які вже були там, але прихований від вас.

Коли ви перетворюєте на рядок і назад, ви отримуєте подвійне значення, яке ближче до значення рядка, ніж було оригінальним плаваючим, - але це добре, якщо ви дійсно вірите, що значення рядка - це те, що ви дійсно хотіли.

Ви впевнені, що float / double є відповідними типами для використання тут замість BigDecimal? Якщо ви намагаєтесь використовувати цифри з точними десятковими значеннями (наприклад, гроші), то BigDecimalце більш відповідний тип IMO.

Я вважаю, що перетворення в двійкове представлення легше зрозуміти цю проблему.

float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

Ви можете бачити, як поплавок розширюється до подвійного, додаючи 0s до кінця, але що подвійне представлення 0,27 є "більш точним", отже, проблема.

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

Це пов’язано з контрактом Float.toString(float), який частково говорить:

Скільки цифр потрібно надрукувати для дробової частини […]? Потрібно мати хоча б одну цифру, щоб представити дробову частину, а поза нею стільки, але лише стільки, скільки цифр потрібно, щоб однозначно відрізнити значення аргументу від суміжних значень типу float. Тобто, припустимо, що x - це точне математичне значення, представлене десятковим поданням, виробленим цим методом для скінченного ненульового аргументу f. Тоді f має бути плаваючою величиною, найближчою до x; або, якщо два плаваючі значення однаково близькі до x, тоді f має бути одним із них, а найменш значущий біт значення і f повинен бути 0.

Я зіткнувся з цією проблемою сьогодні і не міг використовувати рефактор для BigDecimal, оскільки проект справді величезний. Однак я знайшов рішення за допомогою

Float result = new Float(5623.23)
Double doubleResult = new FloatingDecimal(result.floatValue()).doubleValue()

І це працює.

Зверніть увагу, що виклик result.doubleValue () повертає 5623.22998046875

Але виклик doubleResult.doubleValue () повертає правильно 5623.23

Але я не зовсім впевнений, чи це правильне рішення.

Я знайшов таке рішення:

public static Double getFloatAsDouble(Float fValue) {
    return Double.valueOf(fValue.toString());
}

Якщо ви використовуєте float та double замість Float та Double, використовуйте наступне:

public static double getFloatAsDouble(float value) {
    return Double.valueOf(Float.valueOf(value).toString()).doubleValue();
}

Використовуйте BigDecimalзамість float/ double. Є багато чисел, які неможливо представити як двійкові числа з плаваючою комою (наприклад, 0.1). Отже, ви завжди повинні округляти результат до відомих точних результатів або використовувати BigDecimal.

Для отримання додаткової інформації див. Http://en.wikipedia.org/wiki/Floating_point .

Поплавки за своєю природою неточні і завжди мають акуратні округлі "проблеми". Якщо точність важлива, тоді ви можете розглянути можливість рефакторингу програми для використання десяткової або великої десяткової.

Так, плаваючі обчислювальні швидше, ніж десяткові, завдяки підтримці вбудованого процесора. Однак, ви хочете швидко або точно?

Для інформації це стосується пункту 48 - Уникайте плавання та подвоєння, коли потрібні точні значення, Ефективного Java 2-го видання Джошуа Блоха. Ця книга є варенням, упакованим гарними речами, і, безумовно, варто подивитися.

Це працює?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

Просте рішення, яке добре працює, - проаналізувати подвійне від представлення рядка поплавця:

double val = Double.valueOf(String.valueOf(yourFloat));

Не надто ефективно, але це працює!