Я переношу программу с С# на java. Я столкнулся с тем, что
Ява
Math.pow(0.392156862745098,1./3.) = 0.7319587495200227
C#
Math.Pow( 0.392156862745098, 1.0 / 3.0) =0.73195874952002271
эта последняя цифра приводит к значительным различиям в дальнейших расчетах. Есть ли способ эмулировать pow С#?
спасибо
Просто чтобы подтвердить то, что написал Крис Шейн, я получаю те же двоичные значения:
// Java
public class Test
{
public static void main(String[] args)
{
double input = 0.392156862745098;
double pow = Math.pow(input, 1.0/3.0);
System.out.println(Double.doubleToLongBits(pow));
}
}
// C#
using System;
public class Test
{
static void Main()
{
double input = 0.392156862745098;
double pow = Math.Pow(input, 1.0/3.0);
Console.WriteLine(BitConverter.DoubleToInt64Bits(pow));
}
}
Вывод обоих: 4604768117848454313
Другими словами, двойные значения представляют собой точно один и тот же битовый шаблон, и любые различия, которые вы видите (при условии, что вы получите одинаковые результаты), скорее связаны с форматированием чем разница в стоимости. Кстати, точное значение этого двойника равно
0.73195874952002271118800535987247712910175323486328125
Теперь стоит отметить, что в арифметике с плавающей запятой могут происходить явно странные вещи, особенно когда оптимизации допускают 80-битную арифметику в одних ситуациях, но не в других и т. д.
Как говорит Хенк, если разница в последних двух битах вызывает у вас проблемы, значит, ваш дизайн неисправен.
Если ваши расчеты чувствительны к такой разнице, вам потребуются другие меры (редизайн).
эта последняя цифра приводит к достаточным различиям в дальнейших расчетах
Это невозможно, потому что это одно и то же число. У double недостаточно точности, чтобы отличить 0.7319587495200227 от 0.73195874952002271; они оба представлены как
0.73195874952002271118800535987247712910175323486328125.
Разница заключается в округлении: в Java используется 16 значащих цифр, а в C# — 17. Но это всего лишь проблема с отображением.
И Java, и C# возвращают число с плавающей запятой IEEE (в частности, двойное число) из Math.Pow. Разница, которую вы видите, почти наверняка связана с форматированием, когда вы отображаете число как десятичное. Базовое (двоичное) значение, вероятно, то же самое, и ваши математические проблемы заключаются в другом.
Арифметика с плавающей запятой по своей сути неточна. Вы утверждаете, что ответ С# «лучше», но ни один из них не точен. Например, Wolfram Alpha (который действительно намного точнее) дает следующие значения:
http://www.wolframalpha.com/input/?i=Pow%280.392156862745098%2C+1.0+%2F+3.0%29
Если разница единиц в 17-й цифре приводит к тому, что последующие вычисления идут неправильно, то я думаю, что есть проблема с вашей математикой, а не с реализацией Java pow. Вам нужно подумать о том, как реструктурировать ваши вычисления, чтобы они не зависели от таких незначительных различий.
Точность в семнадцать цифр — это лучшее, что может сделать любое число с плавающей запятой IEEE, независимо от языка:
http://en.wikipedia.org/wiki/Double-precision_format_floating-point
