CodeGym /Java Blog /๋ฌด์ž‘์œ„์˜ /Java์—์„œ Math.pow() ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ
John Squirrels
๋ ˆ๋ฒจ 41
San Francisco

Java์—์„œ Math.pow() ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ

๋ฌด์ž‘์œ„์˜ ๊ทธ๋ฃน์— ๊ฒŒ์‹œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค
Java ์–ธ์–ด๋Š” ์ˆ˜ํ•™ ํ•จ์ˆ˜ ๋ฐ ์—ฐ์‚ฐ์„ ์œ„ํ•œ ํฌ๊ด„์ ์ธ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ๊ฐ–์ถ”๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. "Math" ํด๋ž˜์Šค๋ผ๊ณ  ํ•˜๋ฉฐ java.lang ํŒจํ‚ค์ง€ ์— ์žˆ์Šต๋‹ˆ๋‹ค . ์ˆ˜ํ•™ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์—๋Š” ๊ธฐ๋ณธ ์ˆ˜์น˜ ์—ฐ์‚ฐ, ์‚ผ๊ฐ๋ฒ•, ์ตœ์†Œ-์ตœ๋Œ€ ์ฐพ๊ธฐ, ๋‚œ์ˆ˜ ์ƒ์„ฑ ๋ฐ ๋กœ๊ทธ ์—ฐ์‚ฐ์„ ์œ„ํ•œ ๋ฐฉ๋ฒ•์ด ํฌํ•จ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ค๋Š˜ ํŠœํ† ๋ฆฌ์–ผ์—์„œ๋Š” ๋ฐ‘์ˆ˜์™€ ์ง€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ˆซ์ž์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์„ ๊ณ„์‚ฐํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋Š” Math.pow() ๋ฉ”์„œ๋“œ์— ์ค‘์ ์„ ๋‘˜ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์‹œ์ž‘ํ•˜์ž. 'a์˜ n์Šน'์ด๋ผ๋Š” ํ‘œํ˜„์€ ์ˆ˜ํ•™์ ์œผ๋กœ n ์œผ๋กœ ์“ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.. ์‹์—์„œ ์šฉ์–ด๋ฅผ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ •์˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. a - ๋ฐ‘์ˆ˜ n - ์ง€์ˆ˜ ์ง€์ˆ˜๋ฅผ ์ƒ๊ฐํ•ด ๋ด…์‹œ๋‹ค. ๊ณฑ์…ˆ ์—ฐ์‚ฐ์ด ๋ฐ˜๋ณต๋˜๋Š” ํšŸ์ˆ˜๋กœ ์‹๋ณ„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐ‘์€ ์ž์‹ ์„ ๊ณฑํ•œ ์ˆ˜์ž…๋‹ˆ๋‹ค. Java์—์„œ Math.pow() ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ - 1์ด์ œ ์ˆซ์ž์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์„ ๊ณ„์‚ฐํ•˜๋Š” ๊ฐ„๋‹จํ•œ 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 ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ์—ผ๋‘์— ๋‘์–ด์•ผ ํ•  ๋ช‡ ๊ฐ€์ง€ ์‚ฌํ•ญ์ด ์žˆ์Šต๋‹ˆ๋‹ค.
  1. ์ง€์ˆ˜ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ 0์ด๋ฉด ์ถœ๋ ฅ์€ 1.0์ด ๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋ชจ๋“  ์ˆซ์ž์— ๋Œ€ํ•œ 0์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์ด 1๋กœ ์ •์˜๋˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.
  2. ์ง€์ˆ˜ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ 1์ด๋ฉด ์ถœ๋ ฅ์€ ๊ธฐ๋ณธ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ์ˆซ์ž๋ฅผ 1์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์œผ๋กœ ์˜ฌ๋ฆฌ๋ฉด ๊ฒฐ๊ณผ๊ฐ€ ๋ฐ‘๊ณผ ๊ฐ™๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.
  3. ๋ฐ‘์ด ์Œ์ˆ˜/์–‘์ˆ˜ 0์ด๊ณ  ์ง€์ˆ˜ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์Œ์ˆ˜์ด๋ฉด ๊ฒฐ๊ณผ๋Š” ๋ฌดํ•œ๋Œ€์ž…๋‹ˆ๋‹ค. (์Œ์ˆ˜ 0์€ 0๊ณผ 0์ด ์•„๋‹Œ ๊ฐ€์žฅ ์ž‘์€ ํ‘œํ˜„ ๊ฐ€๋Šฅํ•œ ์Œ์ˆ˜ ์‚ฌ์ด์˜ ๋ฐ˜์˜ฌ๋ฆผ์œผ๋กœ ์ธํ•ด ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.)
  4. ์ง€์ˆ˜ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ 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()๋ฅผ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์— ์‚ฌ์šฉํ•  ์ค€๋น„๊ฐ€ ๋ชจ๋‘ ๋๋‚ฌ๋‹ค๊ณ  ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค .

๊ฒฐ๋ก 

java.lang.Math.pow () ๋ฉ”์„œ๋“œ๋Š” ์ •์ˆ˜์™€ ์†Œ์ˆ˜ ๊ฐ’ ๋ชจ๋‘์—์„œ ๋‹ค์–‘ํ•œ ์ˆซ์ž์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์„ ์‰ฝ๊ฒŒ ์ฐพ์„ ์ˆ˜ ์žˆ๋Š” ์ข‹์€ ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. ์ง์ ‘ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•๊ณผ ๋‹ฌ๋ฆฌ ๊ณ ๋„๋กœ ์ตœ์ ํ™”๋˜์–ด ์žˆ์œผ๋ฉฐ ์‹œ๊ฐ„์ด ์ค‘์š”ํ•œ ๋‹ค์–‘ํ•œ ์‘์šฉ ํ”„๋กœ๊ทธ๋žจ์— ๋งค์šฐ ์ ํ•ฉํ•ฉ๋‹ˆ๋‹ค. ๋ชจ๋“  ๊ฒฐ๊ณผ๋ฅผ double๋กœ ์ถœ๋ ฅํ•˜์ง€๋งŒ ์˜ˆ์ œ์—์„œ์™€ ๊ฐ™์ด ํ•ญ์ƒ ๊ฐ’์„ ์ •์ˆ˜๋กœ ์บ์ŠคํŠธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋˜ํ•œ ํŽธ์˜์ƒ java.lang.Math ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ๊ฒฐ๊ณผ๋ฅผ ์›ํ•˜๋Š” ์†Œ์ˆ˜ ์ž๋ฆฟ์ˆ˜๋กœ ๋ฐ˜์˜ฌ๋ฆผํ•˜๋Š” ๋ฉ”์„œ๋“œ๋ฅผ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.
์ฝ”๋ฉ˜ํŠธ
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION