Можно ли вычислить квадратный корень из BigDecimal в Java, используя только Java API, а не собственный 100-строчный алгоритм?
Квадратный корень BigDecimal в Java
Ответ 1
Я использовал это, и он работает очень хорошо. Вот пример того, как алгоритм работает на высоком уровне.
Изменить: Мне было любопытно посмотреть, насколько это было точно, как указано ниже. Вот sqrt (2) из официального источника :
(first 200 digits) 1.41421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147
и здесь он использует описанный ниже подход с SQRT_DIG равным 150:
(first 200 digits) 1.41421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206086685
Первое отклонение происходит после 195 цифр точности. Используйте на свой страх и риск, если вам нужен такой высокий уровень точности, как это.
Изменение SQRT_DIG до 1000 дало 1570 цифр точности.
private static final BigDecimal SQRT_DIG = new BigDecimal(150);
private static final BigDecimal SQRT_PRE = new BigDecimal(10).pow(SQRT_DIG.intValue());
/**
* Private utility method used to compute the square root of a BigDecimal.
*
* @author Luciano Culacciatti
* @url http://www.codeproject.com/Tips/257031/Implementing-SqrtRoot-in-BigDecimal
*/
private static BigDecimal sqrtNewtonRaphson (BigDecimal c, BigDecimal xn, BigDecimal precision){
BigDecimal fx = xn.pow(2).add(c.negate());
BigDecimal fpx = xn.multiply(new BigDecimal(2));
BigDecimal xn1 = fx.divide(fpx,2*SQRT_DIG.intValue(),RoundingMode.HALF_DOWN);
xn1 = xn.add(xn1.negate());
BigDecimal currentSquare = xn1.pow(2);
BigDecimal currentPrecision = currentSquare.subtract(c);
currentPrecision = currentPrecision.abs();
if (currentPrecision.compareTo(precision) <= -1){
return xn1;
}
return sqrtNewtonRaphson(c, xn1, precision);
}
/**
* Uses Newton Raphson to compute the square root of a BigDecimal.
*
* @author Luciano Culacciatti
* @url http://www.codeproject.com/Tips/257031/Implementing-SqrtRoot-in-BigDecimal
*/
public static BigDecimal bigSqrt(BigDecimal c){
return sqrtNewtonRaphson(c,new BigDecimal(1),new BigDecimal(1).divide(SQRT_PRE));
}
Обязательно проверьте ответ barwnikk. он более кратким и, по-видимому, предлагает такую же хорошую или лучшую точность.
Ответ 2
public static BigDecimal sqrt(BigDecimal A, final int SCALE) {
BigDecimal x0 = new BigDecimal("0");
BigDecimal x1 = new BigDecimal(Math.sqrt(A.doubleValue()));
while (!x0.equals(x1)) {
x0 = x1;
x1 = A.divide(x0, SCALE, ROUND_HALF_UP);
x1 = x1.add(x0);
x1 = x1.divide(TWO, SCALE, ROUND_HALF_UP);
}
return x1;
}
Эта работа прекрасна! Очень быстро для более чем 65536 цифр!
Ответ 3
С Java 9 вы можете! Смотрите BigDecimal.sqrt().
Ответ 4
Используя Karp Tricks, это может быть реализовано без цикла только в двух строках с точностью до 32 цифр:
public static BigDecimal sqrt(BigDecimal value) {
BigDecimal x = new BigDecimal(Math.sqrt(value.doubleValue()));
return x.add(new BigDecimal(value.subtract(x.multiply(x)).doubleValue() / (x.doubleValue() * 2.0)));
}
Ответ 5
Если вам нужно найти только целочисленные квадратные корни - это два метода, которые можно использовать.
Метод Ньютона - очень быстрый даже для 1000 цифр BigInteger:
public static BigInteger sqrtN(BigInteger in) {
final BigInteger TWO = BigInteger.valueOf(2);
int c;
// Significantly speed-up algorithm by proper select of initial approximation
// As square root has 2 times less digits as original value
// we can start with 2^(length of N1 / 2)
BigInteger n0 = TWO.pow(in.bitLength() / 2);
// Value of approximate value on previous step
BigInteger np = in;
do {
// next approximation step: n0 = (n0 + in/n0) / 2
n0 = n0.add(in.divide(n0)).divide(TWO);
// compare current approximation with previous step
c = np.compareTo(n0);
// save value as previous approximation
np = n0;
// finish when previous step is equal to current
} while (c != 0);
return n0;
}
Метод деления пополам - в 50 раз медленнее, чем Ньютон - использовать только в образовательных целях:
public static BigInteger sqrtD(final BigInteger in) {
final BigInteger TWO = BigInteger.valueOf(2);
BigInteger n0, n1, m, m2, l;
int c;
// Init segment
n0 = BigInteger.ZERO;
n1 = in;
do {
// length of segment
l = n1.subtract(n0);
// middle of segment
m = l.divide(TWO).add(n0);
// compare m^2 with in
c = m.pow(2).compareTo(in);
if (c == 0) {
// exact value is found
break;
} else if (c > 0) {
// m^2 is bigger than in - choose left half of segment
n1 = m;
} else {
// m^2 is smaller than in - choose right half of segment
n0 = m;
}
// finish if length of segment is 1, i.e. approximate value is found
} while (l.compareTo(BigInteger.ONE) > 0);
return m;
}
Ответ 6
Если вы хотите вычислить квадратные корни для чисел с большим количеством цифр, чем в двойном (BigDecimal с большим масштабом):
В Википедии есть статья для вычисления квадратных корней: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
Это моя реализация:
public static BigDecimal sqrt(BigDecimal in, int scale){
BigDecimal sqrt = new BigDecimal(1);
sqrt.setScale(scale + 3, RoundingMode.FLOOR);
BigDecimal store = new BigDecimal(in.toString());
boolean first = true;
do{
if (!first){
store = new BigDecimal(sqrt.toString());
}
else first = false;
store.setScale(scale + 3, RoundingMode.FLOOR);
sqrt = in.divide(store, scale + 3, RoundingMode.FLOOR).add(store).divide(
BigDecimal.valueOf(2), scale + 3, RoundingMode.FLOOR);
}while (!store.equals(sqrt));
return sqrt.setScale(scale, RoundingMode.FLOOR);
}
setScale(scale + 3, RoundingMode.Floor), потому что вычисление дает большую точность. RoundingMode.Floor обрезает число, RoundingMode.HALF_UP выполняет нормальное округление.
Ответ 7
Здесь очень точное и быстрое решение, основанное на моем решении BigIntSqRoot и следующее наблюдение: Квадратный корень A ^ 2B - умножается корень B. Используя этот метод, я могу легко вычислить первые 1000 цифр квадратного корня из 2.
1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927557999505011527820605714701095599716059702745345968620147285174186408891986095523292304843087143214508397626036279952514079896872533965463318088296406206152583523950547457502877599617298355752203375318570113543746034084988471603868999706990048150305440277903164542478230684929369186215805784631115966687130130156185689872372352885092648612494977154218334204285686060146824720771435854874155657069677653720226485447015858801620758474922657226002085584466521458398893944370926591800311388246468157082630100594858704003186480342194897278290641045072636881313739855256117322040245091227700226941127573627280495738108967504018369868368450725799364729060762996941380475654823728997180326802474420629269124859052181004459842150591120249441341728531478105803603371077309182869314710171111683916581726889419758716582152128229518488472
Итак, вот исходный код
public class BigIntSqRoot {
private static final int PRECISION = 10000;
private static BigInteger multiplier = BigInteger.valueOf(10).pow(PRECISION * 2);
private static BigDecimal root = BigDecimal.valueOf(10).pow(PRECISION);
private static BigInteger two = BigInteger.valueOf(2L);
public static BigDecimal bigDecimalSqRootFloor(BigInteger x)
throws IllegalArgumentException {
BigInteger result = bigIntSqRootFloor(x.multiply(multiplier));
//noinspection BigDecimalMethodWithoutRoundingCalled
return new BigDecimal(result).divide(root);
}
public static BigInteger bigIntSqRootFloor(BigInteger x)
throws IllegalArgumentException {
if (checkTrivial(x)) {
return x;
}
if (x.bitLength() < 64) { // Can be cast to long
double sqrt = Math.sqrt(x.longValue());
return BigInteger.valueOf(Math.round(sqrt));
}
// starting with y = x / 2 avoids magnitude issues with x squared
BigInteger y = x.divide(two);
BigInteger value = x.divide(y);
while (y.compareTo(value) > 0) {
y = value.add(y).divide(two);
value = x.divide(y);
}
return y;
}
public static BigInteger bigIntSqRootCeil(BigInteger x)
throws IllegalArgumentException {
BigInteger y = bigIntSqRootFloor(x);
if (x.compareTo(y.multiply(y)) == 0) {
return y;
}
return y.add(BigInteger.ONE);
}
private static boolean checkTrivial(BigInteger x) {
if (x == null) {
throw new NullPointerException("x can't be null");
}
if (x.compareTo(BigInteger.ZERO) < 0) {
throw new IllegalArgumentException("Negative argument.");
}
return x.equals(BigInteger.ZERO) || x.equals(BigInteger.ONE);
}
}
Ответ 8
В java api нет ничего, поэтому, если double недостаточно точен (если нет, зачем вообще использовать BigDecimal?), вам нужно что-то вроде приведенного ниже кода.)
import java.math.BigDecimal;
public class BigDSqrt {
public static BigDecimal sqrt(BigDecimal n, int s) {
BigDecimal TWO = BigDecimal.valueOf(2);
// Obtain the first approximation
BigDecimal x = n
.divide(BigDecimal.valueOf(3), s, BigDecimal.ROUND_DOWN);
BigDecimal lastX = BigDecimal.valueOf(0);
// Proceed through 50 iterations
for (int i = 0; i < 50; i++) {
x = n.add(x.multiply(x)).divide(x.multiply(TWO), s,
BigDecimal.ROUND_DOWN);
if (x.compareTo(lastX) == 0)
break;
lastX = x;
}
return x;
}
}
Ответ 9
public static BigDecimal sqrt( final BigDecimal value )
{
BigDecimal guess = value.multiply( DECIMAL_HALF );
BigDecimal previousGuess;
do
{
previousGuess = guess;
guess = sqrtGuess( guess, value );
} while ( guess.subtract( previousGuess ).abs().compareTo( EPSILON ) == 1 );
return guess;
}
private static BigDecimal sqrtGuess( final BigDecimal guess,
final BigDecimal value )
{
return guess.subtract( guess.multiply( guess ).subtract( value ).divide( DECIMAL_TWO.multiply( guess ), SCALE, RoundingMode.HALF_UP ) );
}
private static BigDecimal epsilon()
{
final StringBuilder builder = new StringBuilder( "0." );
for ( int i = 0; i < SCALE - 1; ++i )
{
builder.append( "0" );
}
builder.append( "1" );
return new BigDecimal( builder.toString() );
}
private static final int SCALE = 1024;
private static final BigDecimal EPSILON = epsilon();
public static final BigDecimal DECIMAL_HALF = new BigDecimal( "0.5" );
public static final BigDecimal DECIMAL_TWO = new BigDecimal( "2" );
Ответ 10
Как уже было сказано: если вы не возражаете против точности вашего ответа, но хотите генерировать случайные цифры после 15-го по-прежнему действительного, то почему вы вообще используете BigDecimal?
Вот код для метода, который должен делать трюк с помощью BigDecimals с плавающей запятой:
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
public BigDecimal bigSqrt(BigDecimal d, MathContext mc) {
// 1. Make sure argument is non-negative and treat Argument 0
int sign = d.signum();
if(sign == -1)
throw new ArithmeticException("Invalid (negative) argument of sqrt: "+d);
else if(sign == 0)
return BigDecimal.ZERO;
// 2. Scaling:
// factorize d = scaledD * scaleFactorD
// = scaledD * (sqrtApproxD * sqrtApproxD)
// such that scalefactorD is easy to take the square root
// you use scale and bitlength for this, and if odd add or subtract a one
BigInteger bigI=d.unscaledValue();
int bigS=d.scale();
int bigL = bigI.bitLength();
BigInteger scaleFactorI;
BigInteger sqrtApproxI;
if ((bigL%2==0)){
scaleFactorI=BigInteger.ONE.shiftLeft(bigL);
sqrtApproxI=BigInteger.ONE.shiftLeft(bigL/2);
}else{
scaleFactorI=BigInteger.ONE.shiftLeft(bigL-1);
sqrtApproxI=BigInteger.ONE.shiftLeft((bigL-1)/2 );
}
BigDecimal scaleFactorD;
BigDecimal sqrtApproxD;
if ((bigS%2==0)){
scaleFactorD=new BigDecimal(scaleFactorI,bigS);
sqrtApproxD=new BigDecimal(sqrtApproxI,bigS/2);
}else{
scaleFactorD=new BigDecimal(scaleFactorI,bigS+1);
sqrtApproxD=new BigDecimal(sqrtApproxI,(bigS+1)/2);
}
BigDecimal scaledD=d.divide(scaleFactorD);
// 3. This is the core algorithm:
// Newton-Ralpson for scaledD : In case of f(x)=sqrt(x),
// Heron Method or Babylonian Method are other names for the same thing.
// Since this is scaled we can be sure that scaledD.doubleValue() works
// for the start value of the iteration without overflow or underflow
System.out.println("ScaledD="+scaledD);
double dbl = scaledD.doubleValue();
double sqrtDbl = Math.sqrt(dbl);
BigDecimal a = new BigDecimal(sqrtDbl, mc);
BigDecimal HALF=BigDecimal.ONE.divide(BigDecimal.ONE.add(BigDecimal.ONE));
BigDecimal h = new BigDecimal("0", mc);
// when to stop iterating? You start with ~15 digits of precision, and Newton-Ralphson is quadratic
// in approximation speed, so in roundabout doubles the number of valid digits with each step.
// This fmay be safer than testing a BigDecifmal against zero.
int prec = mc.getPrecision();
int start = 15;
do {
h = scaledD.divide(a, mc);
a = a.add(h).multiply(HALF);
start *= 2;
} while (start <= prec);
// 3. Return rescaled answer. sqrt(d)= sqrt(scaledD)*sqrtApproxD :
return (a.multiply(sqrtApproxD));
}
В качестве теста попробуйте несколько раз квадрат числа пару раз, чем повторение квадратного корня, и посмотрите, насколько вы близки к тому, с чего вы начали.
Ответ 11
Я придумал алгоритм, который не просто берет квадратный корень, но делает каждый корень ниже целого числа каждого BigDecimal. С большим преимуществом в том, что он не выполняет алгоритм поиска, поэтому он довольно быстрый с временем выполнения 0,1 мс - 1 мс.
Но что вы получаете в скорости и универсальности, ему не хватает точности, в среднем 5 правильных цифр с отклонением 3 на пятой цифре. (Проверено с миллионом случайных чисел и корней), хотя тест проходил с очень высокими корнями, поэтому вы можете ожидать немного большей точности, если держите корни ниже 10.
Результат содержит только 64 бита точности, а остальное число равно нулю, поэтому, если вам нужен очень высокий уровень точности, не используйте эту функцию.
Это сделано для обработки очень больших чисел и очень больших корней, а не очень маленьких чисел.
public static BigDecimal nrt(BigDecimal bd,int root) {
//if number is smaller then double_max_value it faster to use the usual math
//library
if(bd.compareTo(BigDecimal.valueOf(Double.MAX_VALUE)) < 0)
return new BigDecimal( Math.pow(bd.doubleValue(), 1D / (double)root ));
BigDecimal in = bd;
int digits = bd.precision() - bd.scale() -1; //take digits to get the numbers power of ten
in = in.scaleByPowerOfTen (- (digits - digits%root) ); //scale down to the lowest number with it power of ten mod root is the same as initial number
if(in.compareTo(BigDecimal.valueOf( Double.MAX_VALUE) ) > 0) { //if down scaled value is bigger then double_max_value, we find the answer by splitting the roots into factors and calculate them seperately and find the final result by multiplying the subresults
int highestDenominator = highestDenominator(root);
if(highestDenominator != 1) {
return nrt( nrt(bd, root / highestDenominator),highestDenominator); // for example turns 1^(1/25) 1^(1/5)^1(1/5)
}
//hitting this point makes the runtime about 5-10 times higher,
//but the alternative is crashing
else return nrt(bd,root+1) //+1 to make the root even so it can be broken further down into factors
.add(nrt(bd,root-1),MathContext.DECIMAL128) //add the -1 root and take the average to deal with the inaccuracy created by this
.divide(BigDecimal.valueOf(2),MathContext.DECIMAL128);
}
double downScaledResult = Math.pow(in.doubleValue(), 1D /root); //do the calculation on the downscaled value
BigDecimal BDResult =new BigDecimal(downScaledResult) // scale back up by the downscaled value divided by root
.scaleByPowerOfTen( (digits - digits % root) / root );
return BDResult;
}
private static int highestDenominator(int n) {
for(int i = n-1; i>1;i--) {
if(n % i == 0) {
return i;
}
}
return 1;
}
Он работает с использованием математического свойства, которое в основном говорит, что когда вы делаете квадратные корни, вы можете изменить x ^ 0,5 на (x/100) ^ 0,5 * 10, поэтому разделите основание на 100, возьмите мощность и умножьте на 10.
Обобщенный это становится x ^ (1/n) = (x/10 ^ n) ^ (1/n) * 10.
Таким образом, для корней куба вам нужно разделить основание на 10 ^ 3, а для корней квадратов - 10 ^ 4 и так далее.
Алгоритм использует эти функции для масштабирования входных данных до того, что может обработать математическая библиотека, а затем снова увеличит масштаб, основываясь на том, насколько масштабировался ввод.
Он также обрабатывает несколько крайних случаев, когда входные данные не могут быть достаточно уменьшены, и это те крайние случаи, которые добавляют много проблем точности.
Ответ 12
Предположим, вы не хотите иметь дело только с тривиальным случаем небольших больших десятичных знаков, и вы хотите управлять точностью, тогда ответ будет отрицательным: это невозможно сделать в нескольких LOC без внешних библиотек, но Этот связанный вопрос содержит список хороших.
Ответ 13
BigDecimal.valueOf(Math.sqrt(myBigDecimal.doubleValue()));