Question

我使用以下函数计算整数的log base 2：

public static int log2(int n){
    if(n <= 0) throw new IllegalArgumentException();
    return 31 - Integer.numberOfLeadingZeros(n);
}

它是否具有最佳性能？

有人知道为此目的准备好了J2SE API函数吗？

UPD1 令我惊讶的是，浮点运算似乎比整数算术更快。

UPD2 由于评论，我会进行更详细的调查。

UPD3 我的整数算术函数比Math.log（n）/Math.log（2）快10倍。

Answer 1

这是我用于此计算的函数：

public static int binlog( int bits ) // returns 0 for bits=0
{
    int log = 0;
    if( ( bits & 0xffff0000 ) != 0 ) { bits >>>= 16; log = 16; }
    if( bits >= 256 ) { bits >>>= 8; log += 8; }
    if( bits >= 16  ) { bits >>>= 4; log += 4; }
    if( bits >= 4   ) { bits >>>= 2; log += 2; }
    return log + ( bits >>> 1 );
}

它比Integer.numberOfLeadingZeros（）（20-30％）略快，比基于Math.log（）的实现快几十倍（jdk 1.6 x64）：

private static final double log2div = 1.000000000001 / Math.log( 2 );
public static int log2fp0( int bits )
{
    if( bits == 0 )
        return 0; // or throw exception
    return (int) ( Math.log( bits & 0xffffffffL ) * log2div );
}

两个函数都为所有可能的输入值返回相同的结果。

<强>更新 Java 1.7服务器JIT能够用基于CPU内在函数的替代实现替换一些静态数学函数。其中一个函数是Integer.numberOfLeadingZeros（）。因此，对于1.7或更新的服务器VM，问题中的实现实际上比上面的binlog略快。不幸的是，客户端JIT似乎没有这种优化。

public static int log2nlz( int bits )
{
    if( bits == 0 )
        return 0; // or throw exception
    return 31 - Integer.numberOfLeadingZeros( bits );
}

此实现也为所有2 ^ 32个可能的输入值返回与上面发布的其他两个实现相同的结果。

以下是我的电脑上的实际运行时间（Sandy Bridge i7）：

JDK 1.7 32位客户端虚拟机：

binlog:         11.5s
log2nlz:        16.5s
log2fp:        118.1s
log(x)/log(2): 165.0s

JDK 1.7 x64服务器VM：

binlog:          5.8s
log2nlz:         5.1s
log2fp:         89.5s
log(x)/log(2): 108.1s

这是测试代码：

int sum = 0, x = 0;
long time = System.nanoTime();
do sum += log2nlz( x ); while( ++x != 0 );
time = System.nanoTime() - time;
System.out.println( "time=" + time / 1000000L / 1000.0 + "s -> " + sum );

Answer 2

如果你正在考虑使用浮点来帮助整数算术，你必须要小心。

我通常尽可能避免计算FP。

浮点运算并不准确。你永远无法确定(int)(Math.log(65536)/Math.log(2))评估的内容。例如，Math.ceil(Math.log(1<<29) / Math.log(2))在我的PC上是30，在数学上它应该是29。我没有找到x (int)(Math.log(x)/Math.log(2))失败的值（因为只有32个“危险”值），但这并不意味着它在任何PC上的工作方式都相同。

这里通常的技巧是在舍入时使用“epsilon”。像(int)(Math.log(x)/Math.log(2)+1e-10)一样永远不会失败。选择这个“epsilon”并非易事。

使用更一般的任务进行更多演示 - 尝试实施int log(int x, int base)：

测试代码：

static int pow(int base, int power) {
    int result = 1;
    for (int i = 0; i < power; i++)
        result *= base;
    return result;
}

private static void test(int base, int pow) {
    int x = pow(base, pow);
    if (pow != log(x, base))
        System.out.println(String.format("error at %d^%d", base, pow));
    if(pow!=0 && (pow-1) != log(x-1, base))
        System.out.println(String.format("error at %d^%d-1", base, pow));
}

public static void main(String[] args) {
    for (int base = 2; base < 500; base++) {
        int maxPow = (int) (Math.log(Integer.MAX_VALUE) / Math.log(base));
        for (int pow = 0; pow <= maxPow; pow++) {
            test(base, pow);
        }
    }
}

如果我们使用最直接的对数实现，

static int log(int x, int base)
{
    return (int) (Math.log(x) / Math.log(base));
}

打印：

error at 3^5
error at 3^10
error at 3^13
error at 3^15
error at 3^17
error at 9^5
error at 10^3
error at 10^6
error at 10^9
error at 11^7
error at 12^7
...

为了完全消除错误，我必须添加介于1e-11和1e-14之间的epsilon。你能在测试之前告诉过这个吗？我绝对不能。

Answer 3

尝试Math.log(x) / Math.log(2)

Answer 4

您可以使用身份

            log[a]x
 log[b]x = ---------
            log[a]b

所以这适用于log2。

            log[10]x
 log[2]x = ----------
            log[10]2

只需将其插入java Math log10方法....

http://mathforum.org/library/drmath/view/55565.html

Answer 5

为什么不：

public static double log2(int n)
{
    return (Math.log(n) / Math.log(2));
}

Answer 6

番石榴库中有功能：

LongMath.log2()

所以我建议使用它。

Answer 7

要添加到x4u的答案，它给出了一个数字的二进制日志的底层，这个函数返回一个数字的二进制日志的ceil：

public static int ceilbinlog(int number) // returns 0 for bits=0
{
    int log = 0;
    int bits = number;
    if ((bits & 0xffff0000) != 0) {
        bits >>>= 16;
        log = 16;
    }
    if (bits >= 256) {
        bits >>>= 8;
        log += 8;
    }
    if (bits >= 16) {
        bits >>>= 4;
        log += 4;
    }
    if (bits >= 4) {
        bits >>>= 2;
        log += 2;
    }
    if (1 << log < number)
        log++;
    return log + (bits >>> 1);
}

Answer 8

当我使用Math.log10时，某些情况才起作用：

public static double log2(int n)
{
    return (Math.log10(n) / Math.log10(2));
}

Answer 9

让我们添加：

int[] fastLogs;

private void populateFastLogs(int length) {
    fastLogs = new int[length + 1];
    int counter = 0;
    int log = 0;
    int num = 1;
    fastLogs[0] = 0;
    for (int i = 1; i < fastLogs.length; i++) {
        counter++;
        fastLogs[i] = log;
        if (counter == num) {
            log++;
            num *= 2;
            counter = 0;
        }
    }
}

来源：https://github.com/pochuan/cs166/blob/master/ps1/rmq/SparseTableRMQ.java

Answer 10

要计算n的对数以2为底，可以使用以下表达式：

double res = log10(n)/log10(2);

如何用Java计算整数中的log base 2？

10 个答案: