Come si calcola la base di registro 2 in Java per numeri interi?

Uso la seguente funzione per calcolare la base di registro 2 per gli interi:

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

Ha prestazioni ottimali?

Qualcuno conosce la funzione API J2SE pronta a tale scopo?

UPD1 Sorprendentemente per me, l'aritmetica in virgola mobile sembra essere più veloce dell'aritmetica intera.

UPD2 A causa di commenti, effettuerò indagini più dettagliate.

UPD3 La mia funzione aritmetica intera è 10 volte più veloce di Math.log (n) /Math.log (2).

Se stai pensando di utilizzare il virgola mobile per aiutare con l'aritmetica dei numeri interi, devi fare attenzione.

Di solito cerco di evitare i calcoli FP quando possibile.

Le operazioni in virgola mobile non sono esatte. Non puoi mai sapere con certezza cosa (int)(Math.log(65536)/Math.log(2))valuterà. Ad esempio, Math.ceil(Math.log(1<<29) / Math.log(2))è 30 sul mio PC dove matematicamente dovrebbe essere esattamente 29. Non ho trovato un valore per x dove (int)(Math.log(x)/Math.log(2))fallisce (solo perché ci sono solo 32 valori "pericolosi"), ma ciò non significa che funzionerà allo stesso modo su qualsiasi PC.

Il solito trucco qui è usare "epsilon" quando si arrotondano. Come (int)(Math.log(x)/Math.log(2)+1e-10)non dovrebbe mai fallire. La scelta di questo "epsilon" non è un compito banale.

Altre dimostrazioni, utilizzando un'attività più generale, cercando di implementare int log(int x, int base):

Il codice di test:

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

Se utilizziamo l'implementazione più diretta del logaritmo,

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

questo stampa:

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

Per eliminare completamente gli errori ho dovuto aggiungere epsilon tra 1e-11 e 1e-14. Avresti potuto dirlo prima del test? Non potrei assolutamente.

Questa è la funzione che uso per questo calcolo:

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

È leggermente più veloce di Integer.numberOfLeadingZeros () (20-30%) e quasi 10 volte più veloce (jdk 1.6 x64) di un'implementazione basata su Math.log () come questa:

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

Entrambe le funzioni restituiscono gli stessi risultati per tutti i possibili valori di input.

Aggiornamento: JIT del server Java 1.7 è in grado di sostituire alcune funzioni matematiche statiche con implementazioni alternative basate su intrinseci della CPU. Una di queste funzioni è Integer.numberOfLeadingZeros (). Quindi, con una VM server 1.7 o più recente, un'implementazione come quella nella domanda è in realtà leggermente più veloce di quella binlogsopra. Sfortunatamente il client JIT non sembra avere questa ottimizzazione.

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

Questa implementazione restituisce anche gli stessi risultati per tutti i 2 ^ 32 possibili valori di input delle altre due implementazioni che ho pubblicato sopra.

Ecco i runtime effettivi sul mio PC (Sandy Bridge i7):

VM client JDK 1.7 a 32 bit:

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

VM del server JDK 1.7 x64:

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

Questo è il codice di prova:

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

Provare Math.log(x) / Math.log(2)

puoi usare l'identità

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

quindi questo sarebbe applicabile per log2.

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

basta collegarlo al metodo java Math log10 ....

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

Perchè no:

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

C'è la funzione nelle librerie guava:

LongMath.log2()

Quindi suggerisco di usarlo.

Per aggiungere alla risposta x4u, che fornisce il piano del registro binario di un numero, questa funzione restituisce il ceil del registro binario di un numero:

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

Alcuni casi hanno funzionato solo quando ho usato Math.log10:

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

aggiungiamo:

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

Fonte: https://github.com/pochuan/cs166/blob/master/ps1/rmq/SparseTableRMQ.java

Per calcolare la base di registro 2 di n, è possibile utilizzare la seguente espressione:

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