Làm thế nào để bạn tính toán cơ sở log 2 trong Java cho các số nguyên?

Tôi sử dụng hàm sau để tính log cơ sở 2 cho số nguyên:

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

Liệu nó có hiệu suất tối ưu?

Có ai biết chức năng API J2SE sẵn sàng cho mục đích đó không?

CẬP NHẬT1 Đáng ngạc nhiên đối với tôi, mỹ phẩm điểm nổi dường như nhanh hơn so với mỹ phẩm số nguyên.

CẬP NHẬT2 Do ý kiến ​​tôi sẽ tiến hành điều tra chi tiết hơn.

CẬP NHẬT Hàm số học số nguyên của tôi nhanh hơn 10 lần so với Math.log (n) /Math.log (2).

Nếu bạn đang suy nghĩ về việc sử dụng dấu phẩy động để trợ giúp với số nguyên học, bạn phải cẩn thận.

Tôi thường cố gắng tránh tính toán FP bất cứ khi nào có thể.

Hoạt động dấu phẩy động không chính xác. Bạn không bao giờ có thể biết chắc chắn những gì sẽ (int)(Math.log(65536)/Math.log(2))đánh giá. Ví dụ: Math.ceil(Math.log(1<<29) / Math.log(2))là 30 trên PC của tôi về mặt toán học, nó phải chính xác là 29. Tôi không tìm thấy giá trị cho x khi (int)(Math.log(x)/Math.log(2))thất bại (chỉ vì chỉ có 32 giá trị "nguy hiểm"), nhưng điều đó không có nghĩa là nó sẽ hoạt động cùng một cách trên bất kỳ PC nào.

Thủ thuật thông thường ở đây là sử dụng "epsilon" khi làm tròn. Giống như (int)(Math.log(x)/Math.log(2)+1e-10)không bao giờ nên thất bại. Sự lựa chọn của "epsilon" này không phải là một nhiệm vụ tầm thường.

Trình diễn nhiều hơn, sử dụng một nhiệm vụ tổng quát hơn - cố gắng thực hiện int log(int x, int base):

Mã kiểm tra:

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);
        }
    }
}

Nếu chúng ta sử dụng logarit đơn giản nhất,

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

bản in này:

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
...

Để hoàn toàn thoát khỏi lỗi, tôi đã phải thêm epsilon trong khoảng từ 1e-11 đến 1e-14. Bạn có thể nói điều này trước khi thử nghiệm? Tôi chắc chắn không thể.

Đây là hàm mà tôi sử dụng cho tính toán này:

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 );
}

Nó nhanh hơn một chút so với Integer.numberOfLeadZeros () (20-30%) và nhanh hơn gần 10 lần (jdk 1.6 x64) so ​​với triển khai dựa trên Math.log () như thế này:

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 );
}

Cả hai hàm trả về cùng một kết quả cho tất cả các giá trị đầu vào có thể.

Cập nhật: JIT máy chủ Java 1.7 có thể thay thế một vài hàm toán học tĩnh bằng các triển khai thay thế dựa trên nội tại của CPU. Một trong những chức năng đó là Integer.numberOfLeadZeros (). Vì vậy, với máy chủ VM 1.7 hoặc mới hơn, việc triển khai như câu hỏi trong câu hỏi thực sự nhanh hơn một chút so với binlogở trên. Thật không may, khách hàng JIT dường như không có tối ưu hóa này.

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

Việc triển khai này cũng trả về kết quả tương tự cho tất cả 2 ^ 32 giá trị đầu vào có thể như hai triển khai khác mà tôi đã đăng ở trên.

Dưới đây là thời gian chạy thực tế trên PC của tôi (Sandy Bridge i7):

Máy khách VM JDK 1.7 32 Bits:

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

Máy chủ JDK 1.7 x64 VM:

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

Đây là mã kiểm tra:

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 );

Thử Math.log(x) / Math.log(2)

bạn có thể sử dụng danh tính

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

vì vậy điều này sẽ được áp dụng cho log2.

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

chỉ cần cắm cái này vào phương thức java Math log10 ....

http://mathforum.org/l Library / drmath / view /55565.html

Tại sao không:

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

Có chức năng trong thư viện ổi:

LongMath.log2()

Vì vậy, tôi đề nghị sử dụng nó.

Để thêm vào câu trả lời x4u, cung cấp cho bạn sàn của nhật ký nhị phân của một số, hàm này trả về trần của nhật ký nhị phân của một số:

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);
}

Một số trường hợp chỉ hoạt động khi tôi sử dụng Math.log10:

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

hãy thêm:

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;
        }
    }
}

Nguồn: https://github.com/pochuan/cs166/blob/master/ps1/rmq/SparseTableRMQ.java

Để tính toán cơ sở log 2 của n, có thể sử dụng biểu thức sau:

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