Le calcul des puissances d'entiers

Entiers sont uniquement en 32 bits. Cela signifie que sa valeur max est 2^31 -1. Comme vous le voyez, pour de très petits nombres, vous disposez rapidement à un résultat qui ne peut pas être représentée par un nombre entier plus. C'est pourquoi Math.pow utilise double.

Si vous voulez entière arbitraire de précision, utilisez BigInteger.pow. Mais bien sûr, c'est moins efficace.

Non, il n'est pas quelque chose d'aussi court que a**b

Ici est une simple boucle, si vous voulez éviter les doubles:

long result = 1;
for (int i = 1; i <= b; i++) {
   result *= a;
}

Si vous souhaitez utiliser pow et convertir le résultat en entier, cast le résultat comme suit:

int result = (int)Math.pow(a, b);

Google Guava a de maths utilitaires pour les entiers.
IntMath

Goyave, les mathématiques, les bibliothèques offrent deux méthodes sont utiles lors du calcul exact des puissances entières:

pow(int b, int k) calcule b pour la kième le pouvoir, et s'enroule sur le dépassement

checkedPow(int b, int k) est identique, sauf qu'il jette ArithmeticException sur le dépassement

Personnellement checkedPow() répond à la plupart de mes besoins pour l'entier exponentiation et est plus propre et safter que d'utiliser les versions doubles et arrondi, etc. Dans presque tous les endroits que je veux une fonction de puissance, le dépassement est une erreur (ou impossible, mais je veux être dit que si l'impossible devient possible).

Si vous voulez obtenir un long conséquent, vous pouvez simplement utiliser le correspondant LongMath méthodes et passer int arguments.

Un simple (pas de vérification de débordement ou de la validité des arguments) de la mise en œuvre de la répétition-la quadrature algorithme pour le calcul de la puissance:

/** Compute a**p, assume result fits in a 32-bit signed integer */ 
int pow(int a, int p)
{
    int res = 1;
    int i1 = 31 - Integer.numberOfLeadingZeros(p); //highest bit index
    for (int i = i1; i >= 0; --i) {
        res *= res;
        if ((p & (1<<i)) > 0)
            res *= a;
    }
    return res;
}

La complexité du temps est logarithmique en exposant de p (c'est à dire linéaire en le nombre de bits nécessaires à la représentation de p).

Contrairement à Python (où des pouvoirs peut être calculé par un**b) , JAVA n'a pas de raccourci pour le résultat de la puissance de deux nombres.
Java a une fonction nommée pow dans la classe de Mathématiques, qui retourne une valeur de type Double

double pow(double base, double exponent)

Mais vous pouvez également calculer les puissances d'entiers en utilisant la même fonction. Dans le programme suivant, j'ai fait de même et je suis enfin à convertir le résultat en un entier (typecasting). Suivez l'exemple:

import java.util.*;
import java.lang.*; //CONTAINS THE Math library
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n= sc.nextInt(); //Accept integer n
        int m = sc.nextInt(); //Accept integer m
        int ans = (int) Math.pow(n,m); //Calculates n ^ m
        System.out.println(ans); //prints answers
    }
}

Sinon,
Le java.math.BigInteger.pow(int exponent) retourne un BigInteger dont la valeur est (ce^exposant). L'exposant est un entier plutôt qu'un BigInteger. Exemple:

import java.math.*;
public class BigIntegerDemo {
public static void main(String[] args) {
      BigInteger bi1, bi2; //create 2 BigInteger objects          
      int exponent = 2; //create and assign value to exponent
      //assign value to bi1
      bi1 = new BigInteger("6");
      //perform pow operation on bi1 using exponent
      bi2 = bi1.pow(exponent);
      String str = "Result is " + bi1 + "^" +exponent+ " = " +bi2;
      //print bi2 value
      System.out.println( str );
   }
}

de base est le nombre que vous voulez pour pouvoir, n est le pouvoir, nous renvoie 1 si n est égal à 0, et l'on retourne à la base si le n est 1, si les conditions ne sont pas remplies, nous utilisons la formule de base*(powerN(de base,n-1)) par exemple: 2 soulevée à l'aide de cette formule est : 2(base)*2(powerN(de base,n-1)).

public int power(int base, int n){
   return n == 0 ? 1 : (n == 1 ? base : base*(power(base,n-1)));
}