## how to get exponents without using the math.pow for java

java program to find power of a number using for loop
java exponents without math pow
math.pow java
write a program to find the value of one number raised to the power of another in java
exponents in java
power in java
c++ exponent without using pow
java math pow equivalent

This is my program

```// ************************************************************
// PowersOf2.java
//
// Print out as many powers of 2 as the user requests
//
// ************************************************************

import java.util.Scanner;

public class PowersOf2 {

public static void main(String[] args)

{
int numPowersOf2; //How many powers of 2 to compute
int nextPowerOf2 = 1; //Current power of 2
int exponent= 1;
double x;

//Exponent for current power of 2 -- this
//also serves as a counter for the loop Scanner

Scanner scan = new Scanner(System.in);
System.out.println("How many powers of 2 would you like printed?");
numPowersOf2 = scan.nextInt();
System.out.println ("There will be " + numPowersOf2 + " powers of 2 printed");
//initialize exponent -- the first thing printed is 2 to the what?

while( exponent <= numPowersOf2)
{
double x1 = Math.pow(2, exponent);
System.out.println("2^" + exponent + " = " + x1);
exponent++;
}
//print out current power of 2
//find next power of 2 -- how do you get this from the last one?
//increment exponent

}
}
```

The thing is that I am not allowed to use the math.pow method, I need to find another way to get the correct answer in the while loop.

Powers of 2 can simply be computed by Bit Shift Operators

```int exponent = ...
int powerOf2 = 1 << exponent;
```

Even for the more general form, you should not compute an exponent by "multiplying `n` times". Instead, you could do Exponentiation by squaring

Java Program to Calculate the Power of a Number, In this program, you'll learn to calculate the power of a number with and without using pow() Both programs above doesn't work if you have a negative exponent. In this program, we use Java's Math.pow() function to calculate the power of  Is there any way to take a number to a power of itself without using the Math.pow?? I realized that by using this statement, {CODE} whenS = (44 * (initialDep * (1 + interest))); {CODE}, I am not getting the correct answer, because after 44 years the compounded interest isn't calculated that way, but I cannot use the pow statement.

You could implement your own `power` function.

The complexity of the `power` function depends on your requirements and constraints. For example, you may constraint exponents to be only positive integer.

Here's an example of `power` function:

```public static double power(double base, int exponent) {
double ans = 1;
if (exponent != 0) {
int absExponent = exponent > 0 ? exponent : (-1) * exponent;
for (int i = 1; i <= absExponent; i++) {
ans *= base;
}

if (exponent < 0) {
// For negative exponent, must invert
ans = 1.0 / ans;
}
} else {
// exponent is 0
ans = 1;
}

return ans;
}
```

Calculating Exponent Without Math.pow, Calculating exponent without Math.pow: Problem is I now need to avoyd using Math.sqrt too, so i wanted to use that code to get: x^(1/2). Java exponent method math pow can do calculate exponent. Math pow method is not the only way do it, With your own code logic, you can do number exponent. You use the Math.pow(a, b) to calculate a^b. Where “b” is Exponent and it says how many times to use the “a” number in a multiplication.

You can try to do this based on this explanation:

``` public double myPow(double x, int n) {

if(n < 0) {
if(n == Integer.MIN_VALUE) {
n = (n+1)*(-1);
return 1.0/(myPow(x*x, n));
}
n = n*(-1);
return (double)1.0/myPow(x, n);
}
double y = 1;
while(n > 0) {
if(n%2 == 0) {
x = x*x;
}
else {
y = y*x;
x = x*x;
}
n = n/2;
}
return y;
}
```

What is an alternative to Math.pow in Java?, This is because the return data type for the function Math.pow is double. Here , there are no compulsions for using a specific data type as no functions are used for the arithmetic operation. Hope this was But you can only get the powers of positive integers. If you want to vary the exponent, you can do it in a loop:. Double result = Math.pow(4,2) i.e. This results is 16, or 4^2. There are some special cases to consider when using the Pow () method in Java. If the second number is zero either positive or negative then the output would be 1.0. If the second number is one then the value would be the same as of the first number.

Here is a post that allows both negative/positive power calculations.

https://stackoverflow.com/a/23003962/3538289

Function to handle +/- exponents with O(log(n)) complexity.

```double power(double x, int n){
if(n==0)
return 1;

if(n<0){
x = 1.0/x;
n = -n;
}
double ret = power(x,n/2);
ret = ret * ret;
if(n%2!=0)
ret = ret * x;
return ret;
}
```

Write you own Power without using multiplication(*) and division , Write you own Power without using multiplication(*) and division(/) operators. Method 1 get 3125 (5^5) 5) Then 5 times add 3125, we get 15625 (5^6) int pow ( int a, int b) Java. filter_none. edit close. play_arrow. link brightness_4 code  The output is the expected result 51185893014090757L.As a rule of thumb, the Math.pow method usage should be avoided when the exponent is an integer. First, the result is an approximation, and second it is more costly to compute.

It's unclear whether your comment about using a loop is a desire or a requirement. If it's just a desire there is a math identity you can use that doesn't rely on `Math.Pow`.

`xy = ey∙ln(x)`

In Java this would look like

```public static double myPow(double x, double y){
return Math.exp(y*Math.log(x));
}
```

If you really need a loop, you can use something like the following

```public static double myPow(double b, int e) {
if (e < 0) {
b = 1 / b;
e = -e;
}

double pow = 1.0;
double intermediate = b;
boolean fin = false;

while (e != 0) {
if (e % 2 == 0) {
intermediate *= intermediate;
fin = true;
} else {
pow *= intermediate;
intermediate = b;
fin = false;
}
e >>= 1;
}

return pow * (fin ? intermediate : 1.0);
}
```

[Java] Exponents without using Math.pow? : learnprogramming, My roommate, a 4th year math major, says that the epsilon equation is simply 1 -​10 I'm unsure of how to handle the exponent without being able to use the Math.pow method. How do I get from learning a new language to actually using it? Math pow() method in Java with Example The java.lang.Math .pow() is used to calculate a number raise to the power of some other number. This function accepts two parameters and returns the value of first parameter raised to the second parameter.

Powers without Math.pow, I am having trouble with this, finding powers without math.pow does not really make sense. any help Using the comments as a guide, complete the program so that it Also, your while loop checks the value of exponent. The java.lang.Math.pow (double a, double b) returns the value of the first argument raised to the power of the second argument. If the second argument is positive or negative zero, then the result is 1.0. If the second argument is 1.0, then the result is the same as the first argument. If the second argument is NaN, then the result is NaN.

Calculate the Power of Any Number in the Java Program, Fibonacci Series · Java Program to Swapping Two Numbers without Using a Temporary In Java, three techniques are used primarily to find the power of any number. Using While Loop we keep multiplying temp by besanumber until the Math.pow() function and it's also capable of working with a negative exponent. Do not use the following code to replace Math.pow because the following code will always be slower than Math.pow because Math.pow is implemented natively by the browser. Thus, although the intention of the code below is to demonstate the efficient binary algorithim likely in use under the hood, the code below itself is intented to be educational but not efficient.

How to use the Math.pow() method in Java, The Math.pow() is an built-in method in Java Math class and is used to calculate the power of a given number. The method takes the base and exponent parameters of type double . Using the pow() method let's calculate the following:. You can import that math class and use the Math.pow() function, or you can multiply the variable or value to itself the number of times the exponent says. For example: [math]9^5 = [/math] [code]double result = 0.0; result = Math.pow(9,5); [/cod

• Multiply maybe ?!? After all `next power = previous power * 2`..eg `2^1=2` `2^2 = 4`, `2^3 = 4*2 = 8`
• to get exponents you use `log`, not `pow`. `pow` is used to get the powers
• There are performance constraints on this one. Will be `O(n)`. It can be done in `O(1)` time.