BigDecimal 的对数
Posted
技术标签:
【中文标题】BigDecimal 的对数【英文标题】：Logarithm of a BigDecimal 【发布时间】：2010-10-18 21:07:01 【问题描述】：如何计算 ？有谁知道我可以使用的任何算法？
到目前为止，我的谷歌搜索提出了一个（无用的）想法，即转换为双精度并使用 Math.log。
我将提供所需答案的精确度。
编辑：任何基础都可以。如果在 base x 中更容易，我会这样做。
【问题讨论】：
以什么为底的对数？ 2、10、e? 任何基地。一旦我有了一个实现，基数之间的转换就很简单了 我已经给出了解决方案***.com/questions/11848887/… 我需要这个。有没有人测试给出的答案的性能？ 另见***.com/questions/6827516/logarithm-for-biginteger/… 【参考方案1】：Java Number Cruncher: The Java Programmer's Guide to Numerical Computing 提供了一个使用Newton's Method 的解决方案。本书的源代码可在here 获取。以下内容摘自第 12.5 章大十进制函数（p330 和 p331）：
/**
* Compute the natural logarithm of x to a given scale, x > 0.
*/
public static BigDecimal ln(BigDecimal x, int scale)
// Check that x > 0.
if (x.signum() <= 0)
throw new IllegalArgumentException("x <= 0");
// The number of digits to the left of the decimal point.
int magnitude = x.toString().length() - x.scale() - 1;
if (magnitude < 3)
return lnNewton(x, scale);
// Compute magnitude*ln(x^(1/magnitude)).
else
// x^(1/magnitude)
BigDecimal root = intRoot(x, magnitude, scale);
// ln(x^(1/magnitude))
BigDecimal lnRoot = lnNewton(root, scale);
// magnitude*ln(x^(1/magnitude))
return BigDecimal.valueOf(magnitude).multiply(lnRoot)
.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
/**
* Compute the natural logarithm of x to a given scale, x > 0.
* Use Newton's algorithm.
*/
private static BigDecimal lnNewton(BigDecimal x, int scale)
int sp1 = scale + 1;
BigDecimal n = x;
BigDecimal term;
// Convergence tolerance = 5*(10^-(scale+1))
BigDecimal tolerance = BigDecimal.valueOf(5)
.movePointLeft(sp1);
// Loop until the approximations converge
// (two successive approximations are within the tolerance).
do
// e^x
BigDecimal eToX = exp(x, sp1);
// (e^x - n)/e^x
term = eToX.subtract(n)
.divide(eToX, sp1, BigDecimal.ROUND_DOWN);
// x - (e^x - n)/e^x
x = x.subtract(term);
Thread.yield();
while (term.compareTo(tolerance) > 0);
return x.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
/**
* Compute the integral root of x to a given scale, x >= 0.
* Use Newton's algorithm.
* @param x the value of x
* @param index the integral root value
* @param scale the desired scale of the result
* @return the result value
*/
public static BigDecimal intRoot(BigDecimal x, long index,
int scale)
// Check that x >= 0.
if (x.signum() < 0)
throw new IllegalArgumentException("x < 0");
int sp1 = scale + 1;
BigDecimal n = x;
BigDecimal i = BigDecimal.valueOf(index);
BigDecimal im1 = BigDecimal.valueOf(index-1);
BigDecimal tolerance = BigDecimal.valueOf(5)
.movePointLeft(sp1);
BigDecimal xPrev;
// The initial approximation is x/index.
x = x.divide(i, scale, BigDecimal.ROUND_HALF_EVEN);
// Loop until the approximations converge
// (two successive approximations are equal after rounding).
do
// x^(index-1)
BigDecimal xToIm1 = intPower(x, index-1, sp1);
// x^index
BigDecimal xToI =
x.multiply(xToIm1)
.setScale(sp1, BigDecimal.ROUND_HALF_EVEN);
// n + (index-1)*(x^index)
BigDecimal numerator =
n.add(im1.multiply(xToI))
.setScale(sp1, BigDecimal.ROUND_HALF_EVEN);
// (index*(x^(index-1))
BigDecimal denominator =
i.multiply(xToIm1)
.setScale(sp1, BigDecimal.ROUND_HALF_EVEN);
// x = (n + (index-1)*(x^index)) / (index*(x^(index-1)))
xPrev = x;
x = numerator
.divide(denominator, sp1, BigDecimal.ROUND_DOWN);
Thread.yield();
while (x.subtract(xPrev).abs().compareTo(tolerance) > 0);
return x;
/**
* Compute e^x to a given scale.
* Break x into its whole and fraction parts and
* compute (e^(1 + fraction/whole))^whole using Taylor's formula.
* @param x the value of x
* @param scale the desired scale of the result
* @return the result value
*/
public static BigDecimal exp(BigDecimal x, int scale)
// e^0 = 1
if (x.signum() == 0)
return BigDecimal.valueOf(1);
// If x is negative, return 1/(e^-x).
else if (x.signum() == -1)
return BigDecimal.valueOf(1)
.divide(exp(x.negate(), scale), scale,
BigDecimal.ROUND_HALF_EVEN);
// Compute the whole part of x.
BigDecimal xWhole = x.setScale(0, BigDecimal.ROUND_DOWN);
// If there isn't a whole part, compute and return e^x.
if (xWhole.signum() == 0) return expTaylor(x, scale);
// Compute the fraction part of x.
BigDecimal xFraction = x.subtract(xWhole);
// z = 1 + fraction/whole
BigDecimal z = BigDecimal.valueOf(1)
.add(xFraction.divide(
xWhole, scale,
BigDecimal.ROUND_HALF_EVEN));
// t = e^z
BigDecimal t = expTaylor(z, scale);
BigDecimal maxLong = BigDecimal.valueOf(Long.MAX_VALUE);
BigDecimal result = BigDecimal.valueOf(1);
// Compute and return t^whole using intPower().
// If whole > Long.MAX_VALUE, then first compute products
// of e^Long.MAX_VALUE.
while (xWhole.compareTo(maxLong) >= 0)
result = result.multiply(
intPower(t, Long.MAX_VALUE, scale))
.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
xWhole = xWhole.subtract(maxLong);
Thread.yield();
return result.multiply(intPower(t, xWhole.longValue(), scale))
.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
【讨论】：
为什么不使用 Math.log() 作为第一个近似值？ 不应出现对Thread.yield() 的调用。如果您的目标是使计算密集型线程成为“好公民”，那么您可以用一些代码替换它来测试线程的“中断”标志并退出。但是对Thread.yield() 的调用会干扰正常的线程调度，并可能使方法运行非常缓慢 ...取决于其他情况。
请注意，这个答案并不完整，exp() 和 intRoot() 的代码丢失了。
你可以用 .precision() 代替 toString().length()
@MaartenBodewes exp() 和 intRoot() github.com/javadev/calc/blob/master/src/main/java/com/github/…【参考方案2】：
一种适用于大数的 hacky 小算法使用关系 log(AB) = log(A) + log(B)。以下是以 10 为底的方法（您可以轻松地将其转换为任何其他对数底）：
计算答案中的小数位数。这是对数的组成部分，加一。示例：floor(log10(123456)) + 1 是 6，因为 123456 有 6 位。
如果您只需要对数的整数部分，您可以在这里停下来：只需从第 1 步的结果中减去 1。
1234563将其添加到整数部分。示例：获取log10(123456)的小数部分，计算math.log10(0.123456) = -0.908...，并将其添加到步骤1的结果中：6 + -0.908 = 5.092，即log10(123456)。请注意，您基本上只是在大数前面加上小数点；在你的用例中可能有一个很好的方法来优化它，对于非常大的数字，你甚至不需要费心去抓取所有的数字——log10(0.123) 是log10(0.123456789) 的一个很好的近似值。
【讨论】：
这种方法如何不适用于任意精度？你给我一个数字和一个容差，我可以用那个算法来计算它的对数，绝对误差保证小于你的容差。我想说这意味着它适用于任意精度。 我对 BigInteger 的简单非优化实现，与此答案一致，并可推广到 BigDecimal，此处为 ***.com/questions/6827516/logarithm-for-biginteger/…【参考方案3】：这个超级快，因为：
没有toString()
否 BigInteger 数学（牛顿/连分数）
甚至没有实例化一个新的BigInteger
只使用固定数量的非常快速的操作
一个调用大约需要 20 微秒（每秒大约 50k 个调用）
但是：
仅适用于BigInteger
BigDecimal 的解决方法（未测试速度）：
toBigInteger()（内部使用一个div）
该算法利用了对数可以计算为指数和尾数对数之和的事实。例如：
12345 有 5 位数字，因此以 10 为底的日志介于 4 和 5 之间。 log(12345) = 4 + log(1.2345) = 4.09149...（以 10 为基数）
此函数计算以 2 为底的对数，因为查找占用位数很简单。
public double log(BigInteger val)
// Get the minimum number of bits necessary to hold this value.
int n = val.bitLength();
// Calculate the double-precision fraction of this number; as if the
// binary point was left of the most significant '1' bit.
// (Get the most significant 53 bits and divide by 2^53)
long mask = 1L << 52; // mantissa is 53 bits (including hidden bit)
long mantissa = 0;
int j = 0;
for (int i = 1; i < 54; i++)
j = n - i;
if (j < 0) break;
if (val.testBit(j)) mantissa |= mask;
mask >>>= 1;
// Round up if next bit is 1.
if (j > 0 && val.testBit(j - 1)) mantissa++;
double f = mantissa / (double)(1L << 52);
// Add the logarithm to the number of bits, and subtract 1 because the
// number of bits is always higher than necessary for a number
// (ie. log2(val)<n for every val).
return (n - 1 + Math.log(f) * 1.44269504088896340735992468100189213742664595415298D);
// Magic number converts from base e to base 2 before adding. For other
// bases, correct the result, NOT this number!
【讨论】：
出于好奇，为什么1.44269504088896340735992468100189213742664595415298D 这么长？ Java 的浮点数只有 16 的精度，所以在 Java 中1.44269504088896340735992468100189213742664595415298D == 1.4426950408889634（以及大多数具有浮点精度的语言）。不过，仍然可以确认它运行良好，所以请向我 +1。
这是windows计算器给我的，我很懒
@KevinCruijssen 这是十进制数字的整数精度。当谈论分数精度时，这是一个完全不同的球赛，因为使用以 2 为底的分数，其中一些转换为重复。小数精度没有单个数字，因为基本上没有小数。【参考方案4】：
你可以使用分解它
log(a * 10^b) = log(a) + b * log(10)
基本上b+1 将是数字中的位数，a 将是一个介于 0 和 1 之间的值，您可以使用常规的 double 算法计算其对数。
或者您可以使用一些数学技巧 - 例如，可以通过级数展开计算接近 1 的数字的对数
ln(x + 1) = x - x^2/2 + x^3/3 - x^4/4 + ...
根据您尝试取对数的类型，您可能可以使用类似的数字。
编辑：要获得以 10 为底的对数，您可以将自然对数除以 ln(10)，或以类似方式除以任何其他底数。
【讨论】：
我找到了一种算法，它适用于你给出的第一个 equn，但第二个给出的是自然对数。 哎呀，是的，我应该提到 - 该系列是自然日志。我会进行编辑。【参考方案5】：这是我想出的：
//http://everything2.com/index.pl?node_id=946812
public BigDecimal log10(BigDecimal b, int dp)
final int NUM_OF_DIGITS = dp+2; // need to add one to get the right number of dp
// and then add one again to get the next number
// so I can round it correctly.
MathContext mc = new MathContext(NUM_OF_DIGITS, RoundingMode.HALF_EVEN);
//special conditions:
// log(-x) -> exception
// log(1) == 0 exactly;
// log of a number lessthan one = -log(1/x)
if(b.signum() <= 0)
throw new ArithmeticException("log of a negative number! (or zero)");
else if(b.compareTo(BigDecimal.ONE) == 0)
return BigDecimal.ZERO;
else if(b.compareTo(BigDecimal.ONE) < 0)
return (log10((BigDecimal.ONE).divide(b,mc),dp)).negate();
StringBuffer sb = new StringBuffer();
//number of digits on the left of the decimal point
int leftDigits = b.precision() - b.scale();
//so, the first digits of the log10 are:
sb.append(leftDigits - 1).append(".");
//this is the algorithm outlined in the webpage
int n = 0;
while(n < NUM_OF_DIGITS)
b = (b.movePointLeft(leftDigits - 1)).pow(10, mc);
leftDigits = b.precision() - b.scale();
sb.append(leftDigits - 1);
n++;
BigDecimal ans = new BigDecimal(sb.toString());
//Round the number to the correct number of decimal places.
ans = ans.round(new MathContext(ans.precision() - ans.scale() + dp, RoundingMode.HALF_EVEN));
return ans;
【讨论】：
【参考方案6】：如果您只需要在可以使用的数字中找到 10 的幂：
public int calculatePowersOf10(BigDecimal value)
return value.round(new MathContext(1)).scale() * -1;
【讨论】：
【参考方案7】：我用几个数字测试过的 Meower68 伪代码的 Java 实现：
public static BigDecimal log(int base_int, BigDecimal x)
BigDecimal result = BigDecimal.ZERO;
BigDecimal input = new BigDecimal(x.toString());
int decimalPlaces = 100;
int scale = input.precision() + decimalPlaces;
int maxite = 10000;
int ite = 0;
BigDecimal maxError_BigDecimal = new BigDecimal(BigInteger.ONE,decimalPlaces + 1);
System.out.println("maxError_BigDecimal " + maxError_BigDecimal);
System.out.println("scale " + scale);
RoundingMode a_RoundingMode = RoundingMode.UP;
BigDecimal two_BigDecimal = new BigDecimal("2");
BigDecimal base_BigDecimal = new BigDecimal(base_int);
while (input.compareTo(base_BigDecimal) == 1)
result = result.add(BigDecimal.ONE);
input = input.divide(base_BigDecimal, scale, a_RoundingMode);
BigDecimal fraction = new BigDecimal("0.5");
input = input.multiply(input);
BigDecimal resultplusfraction = result.add(fraction);
while (((resultplusfraction).compareTo(result) == 1)
&& (input.compareTo(BigDecimal.ONE) == 1))
if (input.compareTo(base_BigDecimal) == 1)
input = input.divide(base_BigDecimal, scale, a_RoundingMode);
result = result.add(fraction);
input = input.multiply(input);
fraction = fraction.divide(two_BigDecimal, scale, a_RoundingMode);
resultplusfraction = result.add(fraction);
if (fraction.abs().compareTo(maxError_BigDecimal) == -1)
break;
if (maxite == ite)
break;
ite ++;
MathContext a_MathContext = new MathContext(((decimalPlaces - 1) + (result.precision() - result.scale())),RoundingMode.HALF_UP);
BigDecimal roundedResult = result.round(a_MathContext);
BigDecimal strippedRoundedResult = roundedResult.stripTrailingZeros();
//return result;
//return result.round(a_MathContext);
return strippedRoundedResult;
【讨论】：
【参考方案8】：做对数的伪代码算法。
假设我们想要 x 的 log_n
double fraction, input;
int base;
double result;
result = 0;
base = n;
input = x;
while (input > base)
result++;
input /= base;
fraction = 1/2;
input *= input;
while (((result + fraction) > result) && (input > 1))
if (input > base)
input /= base;
result += fraction;
input *= input;
fraction /= 2.0;
大的while循环可能看起来有点混乱。
每次通过时，您可以对输入进行平方，也可以取基数的平方根；无论哪种方式，您都必须将分数除以 2。我发现对输入进行平方，而不考虑基数，这样会更准确。
如果输入变为 1，我们就完成了。 1的log，对于任何base，都是0，这意味着我们不需要再添加了。
如果 (result + fraction) 不大于 result，那么我们已经达到了编号系统的精度极限。我们可以停下来了。
显然，如果您正在使用具有任意多位精度的系统，您将需要在其中放置其他东西来限制循环。
【讨论】：
【参考方案9】：我一直在寻找这个确切的东西，最终采用了连分数方法。连分数可以在here 或here 找到
代码：
import java.math.BigDecimal;
import java.math.MathContext;
public static long ITER = 1000;
public static MathContext context = new MathContext( 100 );
public static BigDecimal ln(BigDecimal x)
if (x.equals(BigDecimal.ONE))
return BigDecimal.ZERO;
x = x.subtract(BigDecimal.ONE);
BigDecimal ret = new BigDecimal(ITER + 1);
for (long i = ITER; i >= 0; i--)
BigDecimal N = new BigDecimal(i / 2 + 1).pow(2);
N = N.multiply(x, context);
ret = N.divide(ret, context);
N = new BigDecimal(i + 1);
ret = ret.add(N, context);
ret = x.divide(ret, context);
return ret;
【讨论】：
【参考方案10】：老问题，但我实际上认为这个答案更可取。它具有良好的精度并支持几乎任何大小的参数。
private static final double LOG10 = Math.log(10.0);
/**
* Computes the natural logarithm of a BigDecimal
*
* @param val Argument: a positive BigDecimal
* @return Natural logarithm, as in Math.log()
*/
public static double logBigDecimal(BigDecimal val)
return logBigInteger(val.unscaledValue()) + val.scale() * Math.log(10.0);
private static final double LOG2 = Math.log(2.0);
/**
* Computes the natural logarithm of a BigInteger. Works for really big
* integers (practically unlimited)
*
* @param val Argument, positive integer
* @return Natural logarithm, as in <tt>Math.log()</tt>
*/
public static double logBigInteger(BigInteger val)
int blex = val.bitLength() - 1022; // any value in 60..1023 is ok
if (blex > 0)
val = val.shiftRight(blex);
double res = Math.log(val.doubleValue());
return blex > 0 ? res + blex * LOG2 : res;
核心逻辑（logBigInteger 方法）复制自我的this other answer。
【讨论】：
【参考方案11】：我为 BigInteger 创建了一个函数，但它可以很容易地修改为 BigDecimal。分解日志并使用日志的某些属性是我所做的，但我只得到双精度。但它适用于任何基地。 :)
public double BigIntLog(BigInteger bi, double base)
// Convert the BigInteger to BigDecimal
BigDecimal bd = new BigDecimal(bi);
// Calculate the exponent 10^exp
BigDecimal diviser = new BigDecimal(10);
diviser = diviser.pow(bi.toString().length()-1);
// Convert the BigDecimal from Integer to a decimal value
bd = bd.divide(diviser);
// Convert the BigDecimal to double
double bd_dbl = bd.doubleValue();
// return the log value
return (Math.log10(bd_dbl)+bi.toString().length()-1)/Math.log10(base);
【讨论】：
以上是关于BigDecimal 的对数的主要内容，如果未能解决你的问题，请参考以下文章