Java ์ธ์ด๋ ์ํ ํจ์ ๋ฐ ์ฐ์ฐ์ ์ํ ํฌ๊ด์ ์ธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ์ถ๊ณ ์์ต๋๋ค. "Math" ํด๋์ค๋ผ๊ณ ํ๋ฉฐ java.lang ํจํค์ง ์ ์์ต๋๋ค . ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ ๊ธฐ๋ณธ ์์น ์ฐ์ฐ, ์ผ๊ฐ๋ฒ, ์ต์-์ต๋ ์ฐพ๊ธฐ, ๋์ ์์ฑ ๋ฐ ๋ก๊ทธ ์ฐ์ฐ์ ์ํ ๋ฐฉ๋ฒ์ด ํฌํจ๋์ด ์์ต๋๋ค. ์ค๋ ํํ ๋ฆฌ์ผ์์๋ ๋ฐ์์ ์ง์๋ฅผ ์ฌ์ฉํ์ฌ ์ซ์์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ณ์ฐํ๋ ๋ฐ ์ฌ์ฉ๋๋ Math.pow() ๋ฉ์๋์ ์ค์ ์ ๋ ๊ฒ์
๋๋ค. ์์ํ์. 'a์ n์น'์ด๋ผ๋ ํํ์ ์ํ์ ์ผ๋ก n ์ผ๋ก ์ธ ์ ์์ต๋๋ค.. ์์์ ์ฉ์ด๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์ ์ํ ์ ์์ต๋๋ค. a - ๋ฐ์ n - ์ง์ ์ง์๋ฅผ ์๊ฐํด ๋ด
์๋ค. ๊ณฑ์
์ฐ์ฐ์ด ๋ฐ๋ณต๋๋ ํ์๋ก ์๋ณํ ์ ์์ต๋๋ค. ๋ฐ์ ์์ ์ ๊ณฑํ ์์
๋๋ค.
์ด์ ์ซ์์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ณ์ฐํ๋ ๊ฐ๋จํ Java ๋ฉ์๋๋ฅผ ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค. ๋ค์ ์์ ์์๋ powerFunction() ๋ฉ์๋์ ๊ฐ๊ฐ ๋ฐ๊ณผ ์ง์์ธ ๋ ๊ฐ์ ์ธ์๋ฅผ ์ ๋ฌํ๋ค๋ ์ ์ ์ ์ํ์ญ์์ค .

public class Main {
public static void main(String[] args) {
int result = powerFunction(2, 5);
System.out.println("2 raised to the power of 5 = " + result);
}
static int powerFunction(int base, int exponent) {
int result = 1;
for (int i = 0; i < exponent; i++) {
result = base * result;
}
return result;
}
}
์์ ์์ ์ฝ๋๋ฅผ ์คํํ๋ฉด 32๊ฐ ๋ฐํ๋ฉ๋๋ค. ๋จ์ํ base^exponent๋ฅผ ์ธ ์ ์๋ ์ด์ ๋ฅผ ์์ํ ์ ์์ต๋๋ค. Java์๋ ํ ์ค์ ์ฝ๋์์ ์ฌ์ฉํ ์ ์๋ ์ง์ ์ฐ์ฐ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๊ฒ ํ ์ ์์ต๋๋ค. ์์ ์ฝ๋๋ฅผ ๊ณ ๋ คํ๋ฉด ์ด ๋ฉ์๋๋ฅผ ์์ฑํ๋ ๋ฐ ๊ฝค ๋ง์ ์๊ฐ์ ์๋นํด์ผ ํ๋ค๋ ๊ฒ์ด ๋ถ๋ช
ํฉ๋๋ค. ๋ํ ๋์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ณ์ฐํ๋ ค๋ ๊ฒฝ์ฐ for ๋ฃจํ๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋ฉ์๋์์ ์ด๋ฌํ ๊ณ์ฐ์ ์๋ฃํ๋ ๋ฐ ์๋นํ ์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค. ๊ทธ ์ธ์๋ ๋ฃจํ๋ ๋ถ์ ์ง์๋ก ์ ๋ ฅ ๊ณ์ฐ์ ์ํํ๋ ๊ฒ์ ๋ฐฉ์งํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ๋ฐฉ๋ฒ์ ์ต์ ํ๋ฅผ ์ํ ๋ ๋ง์ ๊ณต๊ฐ์ด ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ค์ง ์ ๋ฆฌํ์ง ์๊ธฐ ๋๋ฌธ์ ๊ณ์ฐ ๋ณต์ก์ฑ์ด ์ข์ง ์์ต๋๋ค. ํ๋ก๊ทธ๋๋จธ๊ฐ ๊ฑฐ๋ญ์ ๊ณฑ ๋ฐ ๊ธฐํ ์ํ ์ฐ์ฐ์ ์ผ๋ง๋ ์์ฃผ ์ฌ์ฉํ๋์ง ๊ณ ๋ คํ์ฌ ์์ ์ Java ๊ฐ๋ฐ์๋ค์ ์ํ์ ์ฐ์ฐ์ ์ฉ์ดํ๊ฒ ํ๋ ๋ฐ ์ ๋
ํ๋ 'Math'๋ผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ง๋ค์์ต๋๋ค. ๋ฐ๋ผ์ ์ ์ ํจ์๋ฅผ ์ฒ์๋ถํฐ ์์ฑํ๋ ๋์ Java Lang ํจํค์ง์ ํฌํจ๋ ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํ ์ ์์ต๋๋ค.
Math.pow ๋ฉ์๋๋ ๋ฌด์์ด๋ฉฐ ์ด๋ป๊ฒ ์ฌ์ฉํฉ๋๊น?
Math.pow๋ java.lang ํจํค์ง์์ Math ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฉ์๋๋ก ์ฐพ์ ์ ์์ต๋๋ค. ์ ์์ ๋ณต์ ๋ชจ๋ ์ซ์์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ณ์ฐํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๊ตฌ๋ฌธ์ ๊ณ ๋ คํด ๋ด ์๋ค.
public static double pow(double base, double exponent)
๊ตฌ๋ฌธ์์ ๋ณผ ์ ์๋ฏ์ด java.lang.Math.pow() ๋ฉ์๋๋ ๋ ๊ฐ์ ์ธ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฒซ ๋ฒ์งธ๋ ๋ฐ์ด๊ณ ๋ ๋ฒ์งธ๋ ์ง์์
๋๋ค. ๊ธฐ๋ณธ ์ง์๋ฅผ ์ถ๋ ฅ์ผ๋ก ๋ฐํํฉ๋๋ค . ์ด๋ป๊ฒ ๋ถ๋ฅผ ์ ์๋์ง ๋ด
์๋ค.
Math.pow๋ฅผ ์ฌ์ฉํ์ฌ Java์์ ์ซ์๋ฅผ ๊ฑฐ๋ญ์ ๊ณฑํ๊ธฐ
Math.pow๋ฅผ ์ฌ์ฉํ์ฌ 5 4 ์ ๊ฐ์ ์ฐพ์๋ด ์๋ค .
import java.lang.Math;
public class MyClass{
public static void main(String []args){
double answer = Math.pow(5, 4);
// java.lang.Math.pow() method
System.out.println("5 raised to the power of 4 = " + answer);
}
}
์ถ๋ ฅ์ 625.0์
๋๋ค. ๋ณด์๋ค์ํผ ์ด์ค ๊ฐ์
๋๋ค. ์์์ ์ด ๊ท์ฐฎ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ซ์๋ฅผ ์ ์๋ก ๋ณํํ์ฌ ์ฝ๊ฒ ์ ๊ฑฐํ ์ ์์ต๋๋ค. ์ฐ๋ฆฌ๋ ๋ฉ์ธ ๋ฉ์๋ ๋ด๋ถ์ ์ฒซ ๋ฒ์งธ ์ค์ ๋ณ๊ฒฝํ๊ณ ์์์ ์ ์ํ์ญ์์ค.
int answer = (int) Math.pow(5, 4);
์ด์ ๊ฒฐ๊ณผ๋ 625์
๋๋ค. ๋ฐ์์ ์ง์ ๋ชจ๋์ ๋ถ์๋ฅผ ์ฌ์ฉํ๊ณ ๋ต์ ๊ตฌํด ๋ด
์๋ค. 1.25 4.5 ์ ๊ฐ์ด ๋ฌด์์ธ์ง ๋ด
์๋ค .
import java.lang.Math;
public class MyClass {
public static void main(String[] args) {
double answer = Math.pow(1.25, 4.5);
// java.lang.Math.pow() method
System.out.println("1.25 raised to the power of 4.5 = " + answer);
}
}
๊ทธ๋ฌ๋ฉด 2.729575167846423์ด ์ถ๋ ฅ๋ฉ๋๋ค. ๊ณ์ฐ๊ธฐ๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ผํ ๋ต์ ๋ฐํํ๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ๋ค์ ์น์
์ผ๋ก ์ด๋ํ๊ธฐ ์ ์ ํ ๊ฐ์ง ์๋ฅผ ๋ ์ดํด๋ณด๊ฒ ์ต๋๋ค. ์ซ์๋ฅผ ์์ ๊ฑฐ๋ญ์ ๊ณฑ์ผ๋ก ์ฌ๋ฆฌ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋น๊ตํ ๊ฒ์
๋๋ค. ์ด ์์์๋ ๊ธฐ๋ณธ์ผ๋ก 4๋ฅผ ์ ํํ๊ณ ์ง์๋ก -2๋ฅผ ์ ํํฉ๋๋ค.
import java.lang.Math;
public class MyClass{
public static void main(String []args){
double answer = Math.pow(4, -2);
// java.lang.Math.pow() method
System.out.println(answer);
}
}
์ถ๋ ฅ์ 0.0625์
๋๋ค.
๋น ๋ฅธ ์: ๋ต์ ๋ฐ์ฌ๋ฆผํ๋ ๋ฐฉ๋ฒ
์๋ฅผ ๋ค์ด 1.25 4.5 ์ ๊ฐ์ ์ฐพ์์ผ ํฉ๋๋ค . ๋ต์ 2.729575167846423์ ๋๋ค. ๊ฝค ์์ฃผ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ฌ๋ฆผํด์ผ ํฉ๋๋ค. ์์์ ์ดํ ๋ค ๋ฒ์งธ ์๋ฆฌ๊น์ง ์ ํํ ๋ต์ ๊ตฌํด ๋ด ์๋ค. ๊ทธ๊ฒ์ํ๋ ๋ฐฉ๋ฒ? ์์์ ์ดํ 4์๋ฆฌ๋ง ์๊ตฌํ๋ค๋ฉด? ์ด๋ฅผ ์ํด java.lang.Math.round ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค . ๊ทธ๋ฌ๋ Math.round๋ ๊ฐ์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ ์๋ก ๋ฐ์ฌ๋ฆผํ๋ฏ๋ก ์์์ ์ดํ ์๋ฆฟ์๋ก ๊ณฑํ ๋ค์ ๋ฐ์ฌ๋ฆผํ๊ณ ๋ค์ ๋๋์ด์ผ ํฉ๋๋ค.
import java.lang.Math;
public class MyClass{
public static void main(String []args){
double answer = Math.pow(1.25, 4.5);
answer = Math.round(answer*100.0)/100.0;
System.out.println(answer);
}
}
์ถ๋ ฅ์ 2.73์
๋๋ค.
Math.pow๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
java.lang.Math.pow ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋ ์ผ๋์ ๋์ด์ผ ํ ๋ช ๊ฐ์ง ์ฌํญ์ด ์์ต๋๋ค.- ์ง์ ๋งค๊ฐ๋ณ์๊ฐ 0์ด๋ฉด ์ถ๋ ฅ์ 1.0์ด ๋ฉ๋๋ค. ์ด๋ ๋ชจ๋ ์ซ์์ ๋ํ 0์ ๊ฑฐ๋ญ์ ๊ณฑ์ด 1๋ก ์ ์๋๊ธฐ ๋๋ฌธ์ ๋๋ค.
- ์ง์ ๋งค๊ฐ๋ณ์๊ฐ 1์ด๋ฉด ์ถ๋ ฅ์ ๊ธฐ๋ณธ ๋งค๊ฐ๋ณ์๊ฐ ๋ฉ๋๋ค. ์ซ์๋ฅผ 1์ ๊ฑฐ๋ญ์ ๊ณฑ์ผ๋ก ์ฌ๋ฆฌ๋ฉด ๊ฒฐ๊ณผ๊ฐ ๋ฐ๊ณผ ๊ฐ๊ธฐ ๋๋ฌธ์ ๋๋ค.
- ๋ฐ์ด ์์/์์ 0์ด๊ณ ์ง์ ๋งค๊ฐ๋ณ์๊ฐ ์์์ด๋ฉด ๊ฒฐ๊ณผ๋ ๋ฌดํ๋์ ๋๋ค. (์์ 0์ 0๊ณผ 0์ด ์๋ ๊ฐ์ฅ ์์ ํํ ๊ฐ๋ฅํ ์์ ์ฌ์ด์ ๋ฐ์ฌ๋ฆผ์ผ๋ก ์ธํด ๋ฐ์ํ ์ ์์ต๋๋ค.)
- ์ง์ ๋งค๊ฐ๋ณ์๊ฐ NaN์ด๋ฉด ์ถ๋ ฅ๋ NaN์ด ๋ฉ๋๋ค.
import java.lang.Math;
public class MyClass{
public static void main(String []args){
double base = 5;
double exponent = Double.NaN;
double answer = Math.pow(base, exponent);
System.out.println(answer);
}
}
๊ทธ๋ฌ๋ฉด NaN์ด ์ถ๋ ฅ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์ฝ๋ ๊ฒฐ๊ณผ๊ฐ NaN์ด๋ฉด ์ง์ ์ธ์๊ฐ NaN์ธ์ง ํ์ธํ๋ ๊ฒ์ด ์ข์ต๋๋ค. NaN์ด ๋ฌด์์ธ์ง ๊ถ๊ธํ๋ค๋ฉด '์ซ์๊ฐ ์๋'์ ์๋ฏธํ๋ฉฐ ๊ฐ์ด ์ ์๋์ง ์์์์ ๋ํ๋
๋๋ค. ์ด์ lang.Math.pow()๋ฅผ ์ ํ๋ฆฌ์ผ์ด์
์ ์ฌ์ฉํ ์ค๋น๊ฐ ๋ชจ๋ ๋๋ฌ๋ค๊ณ ์๊ฐํฉ๋๋ค .
GO TO FULL VERSION