Java résultats diffèrent for (int)Math.pow(2,x) et 1<<x

Pourquoi les deux opérations suivantes aboutissent à des résultats différents en Java pour x = 31 ou 32 mais les mêmes résultats pour x=3?

int x=3;
int b = (int) Math.pow(2,x);
int c = 1<<x;

Résultats:

x=32: b=2147483647; c=1;
x=31: b=2147483647; c=-2147483648;
x=3:  b=8         ; c=8
Une subtile différence, c'est que pow() est beaucoup plus lent, même si la réponse est la même. pow() a erreur d'arrondi, tandis que int a débordement. Vous pouvez essayer de 1L << 32 ce qui équivaut à 2147483648

OriginalL'auteur kasavbere | 2012-05-02

  1. 18

    Il y a plusieurs questions à jouer:

    Ce que cette question de l'entrevue n'est de montrer que (int)Math.pow(2, x) et 1 << x ne sont pas équivalentes pour les valeurs de x à l'extérieur de la 0...30 gamme.

    P. S. C'est peut-être intéressant de noter que l'utilisation long en place de int (et 1L en place de 1) donnerait encore un autre ensemble de résultats différent des deux autres. Ceci est valable même si les résultats finaux sont convertis à int.

    Le dernier point qui est très important.

    OriginalL'auteur NPE

  2. 3

    Selon la documentation Math.pow permettra de promouvoir à la fois de ses arguments de double et de double. Évidemment, quand le résultat retourné est double et vous jeter aux int vous obtiendrez seulement la plus haute de 32 bits et le reste sera tronqué par conséquent, vous obtenez toujours la (int) Math.pow(2,x); valeur. Lorsque vous ne bitshift vous de toujours travailler avec les services de renseignements et, par conséquent, un débordement se produit.

    Je devine la plus haute de 32 bits de la mantisse. Je peux me tromper, cependant.
    Hm, d'accord, cela pourrait être vrai. Je viens de me rappeler qu'il retourne toujours 2^31-1. Supprimé le commentaire 🙂

    OriginalL'auteur asenovm

  3. 2

    De considérer les limites de type int. La façon dont un grand nombre peut-il tenir?

    La question est à propos de la différence entre décalage à gauche et explicite des puissances de 2.
    Et d'ajouter, à la limite de int le fait que c'est un type signé.

    OriginalL'auteur erikxiv

  4. 0

    int de 32 bits et depuis il est signé (par défaut), le premier bit est utilisé pour le signe. Lorsque vous déplacez de gauche 31 bits, vous obtenez le Deux Compliment, qui est -(2^32). Lorsque vous déplacez à gauche 32 bits, c'est juste des boucles de tout le chemin du retour autour de 1. Si vous décidez de faire ce changement à longs au lieu de l'ints, vous obtenez les réponses que vous attendez (c'est-à jusqu'à ce que vous maj 63+ bits).

    OriginalL'auteur mrketchup

  5. 0

    Voici un micro-benchmark pour le cas d'un long. Sur mon portable (2.8 GHz), en utilisant la touche maj au lieu de Math.pow est plus de 7 fois plus rapides.

    int limit = 50_000_000;
@Test
public void testPower() {
    Random r = new Random(7);
    long t = System.currentTimeMillis();
    for (int i = 0; i < limit; i++) {
        int p = r.nextInt(63);
        long l = (long)Math.pow(2,p);
    }
    long t1 = System.currentTimeMillis();
    System.out.println((t1-t)/1000.0); //3.758 s
}
@Test
public void testShift() {
    Random r = new Random(7);
    long t = System.currentTimeMillis();
    for (int i = 0; i < limit; i++) {
        int p = r.nextInt(63);
        long l = 1L << p;
    }
    long t1 = System.currentTimeMillis();
    System.out.println((t1-t)/1000.0); //0.523 s
}

    OriginalL'auteur denine99