1. ์๋ฐ ์ผ๊ฐํจ์
Math
์ด์ ์ ๋ฐ์ฌ๋ฆผ ์ซ์๋ฅผ ๊ณต๋ถํ์ ๋ ํด๋์ค์ ๊ทธ ๋ฐฉ๋ฒ ์ค ์ผ๋ถ์ ๋ํด ์๊ฒ ๋์์ต๋๋ค . ์ด์ ์ด ํด๋์ค์ ๋ํด ์์ธํ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์ด๋ฆ์์ ์ ์ ์๋ฏ์ด ์ด Math
ํด๋์ค์๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ๊ฐ์ฅ ์์ฃผ ์ฌ์ฉํ๋ ์ํ ์ฐ์ฐ์ ๋ํ ๋ฉ์๋๊ฐ ํฌํจ๋์ด ์์ต๋๋ค. ๋ค์์ ๊ฐ์ฅ ํฅ๋ฏธ๋ก์ด ๊ฒ์
๋๋ค.
๋ฐฉ๋ฒ | ์ค๋ช | |
---|---|---|
|
๊ฐ๋์ ์ฌ์ธ์ d ๋ผ๋์์ผ๋ก ๋ฐํํฉ๋๋ค. |
|
|
๊ฐ๋์ ์ฝ์ฌ์ธ ๊ฐ์ d ๋ผ๋์์ผ๋ก ๋ฐํํฉ๋๋ค. |
|
|
๊ฐ๋์ ํ์ ํธ๋ฅผ d ๋ผ๋์์ผ๋ก ๋ฐํํฉ๋๋ค. |
|
|
์ํฌ์ฌ์ธ์ ๋ฐํํฉ๋๋ค. | |
|
์ํฌ์ฝ์ฌ์ธ์ ๋ฐํํฉ๋๋ค. | |
|
์ํฌํ์ ํธ๋ฅผ ๋ฐํํฉ๋๋ค. | |
|
ํ์ดํผ๋ณผ๋ฆญ ์ฌ์ธ์ ๋ฐํํฉ๋๋ค. | |
|
ํ์ดํผ๋ณผ๋ฆญ ์ฝ์ฌ์ธ์ ๋ฐํํฉ๋๋ค. | |
|
ํ์ดํผ๋ณผ๋ฆญ ํ์ ํธ๋ฅผ ๋ฐํํฉ๋๋ค. |
, ๋ฐ ๋ฉ์๋๋ ๋ผ๋์ ์ผ๋ก ํ์๋๋ ๊ฐ๋๋ฅผ ์ทจํฉ๋๋ค. ๊ฐ๋๋ฅผ ๋์์ ๋ผ๋์์ผ๋ก ๋๋ ๊ทธ ๋ฐ๋๋ก ๋ณํํ๊ธฐ ์ํด ์ด ํด๋์ค๋ ๋ ๊ฐ์ง ํน์ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค.Math.sin()
Math.cos()
Math.tan()
Math
๋ฐฉ๋ฒ | ์ค๋ช |
---|---|
|
๊ฐ๋๋ฅผ ๋์์ ๋ผ๋์์ผ๋ก ๋ณํ |
|
๊ฐ๋๋ฅผ ๋ผ๋์์์ ๋๋ก ๋ณํํฉ๋๋ค. |
๊ทธ๋ฐ๋ฐ ํด๋์ค์๋ ๋ฉ์๋ ์ธ์๋ ๋ ๊ฐ์ ์์ ๋ณ์ (ํด๋์ค์ ์ ์ ํ๋) Math
๊ฐ ์์ต๋๋ค .
๋์์๋ | ์ค๋ช |
---|---|
|
"Pi" ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.3.141592653589793 |
|
"E" ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.2.718281828459045 |
์ด ๋ชจ๋ ๊ธฐ๋ฅ์ ์์ ๋ง์ ๊ฒ์์ ์์ฑํ๊ฑฐ๋, ๊ทธ๋ํฝ ์์ ์ ํ๊ฑฐ๋, ๋จ์ํ ์ง๋์์ ๊ฒฝ๋ก์ ๊ธธ์ด๋ฅผ ๊ณ์ฐํ๊ธฐ๋ก ๊ฒฐ์ ํ ๊ฒฝ์ฐ ๋งค์ฐ ์ ์ฉํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋ฅผ ๊ณ์ฐํ๋ ค๋ฉด sin(45ยฐ)
๋ค์๊ณผ ๊ฐ์ด ํ์ญ์์ค.
Math.sin( Math.toRadians(45) )
์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
public class Main
{
public static int N = 10;
public static void drawValue(double y)
{
int value = (int) (y * N) + N;
for (int i = 0; i < 2 * N; i++)
{
char c = i == N ? '|': '.';
if (i == value)
c = '*';
System.out.print(c);
}
System.out.println();
}
public static void main(String[] args)
{
for (int i = 0; i < 10 * N; i++)
{
double x = i * 1.0 / N;
double y = Math.sin(x);
drawValue(y);
}
}
}
2. Java์ ๋์ ํจ์
๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๊ณ ๋ฑํ๊ต ์ํ์ ํ๋ก๊ทธ๋๋จธ์๊ฒ ์ถฉ๋ถํฉ๋๋ค. ์ฌ์ธ๊ณผ ์ฝ์ฌ์ธ์กฐ์ฐจ๋ ์ฝ๋์์ ๊ฑฐ์ ๋ฐ๊ฒฌ๋์ง ์์ต๋๋ค. ๋๋ถ๋ถ ๊ฒ์, ์ง๋ ๋๋ ๊ฒ์ ์์ง์ผ๋ก ์์ ํ ๋ ํ์ํฉ๋๋ค. ํ๋ก๊ทธ๋๋จธ์ 90%๋ ์ด๋ฐ ์ผ์ ๊ฒช์ง ์์ต๋๋ค.
๊ทธ๋ฌ๋ ๊ธฐํํ ์ธ์๋ ํ๋ก๊ทธ๋๋จธ๋ ๋๋๋ก ๋์ ํจ์๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ๋ฌผ๋ก Math
ํด๋์ค์๋ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ํด๋์ค๊ฐ ํฌํจ๋์ด ์์ต๋๋ค.
๋ฐฉ๋ฒ | ์ค๋ช |
---|---|
|
์ ์ ๊ณฑ๊ทผa |
|
์ ์ธ์ ๊ณฑ๊ทผa |
|
์ง์:ab |
|
์ง์(์ค์ผ๋ฌ ์์ ๊ฑฐ๋ญ์ ๊ณฑ):ea |
|
๋ค์์ ์์ฐ ๋ก๊ทธ a :ln(a) |
|
๋ฐ์ด 10์ธ ๋ก๊ทธ a :log10(a) |
|
๋ค์์ ์์ฐ ๋ก๊ทธ x + 1 :ln(x + 1) |
|
ex-1 |
์ซ์์ ์ ๊ณฑ๊ทผ ๋๋ ์ธ์ ๊ณฑ๊ทผ์ ์ํ๋ ๊ฒฝ์ฐ sqrt(a)
๋ฐ cbrt(a)
๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ ๊ณฑ๊ทผ์ ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐํ ์ ์์ต๋๋ค.
Math.sqrt(2)
๋ ๋์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ทผ์ ์ป์ผ๋ ค๋ฉด ๊ฑฐ๋ญ์ ๊ณฑ ๋ฐฉ๋ฒ์ ์ฌ์ฉ a
ํ์ญ์์ค ยผ
.
Math.pow(2, 0.25)
log(a)
๋ก๊ทธ ๋ฐ ์ง์์ ๊ฒฝ์ฐ (์์ฐ ๋ก๊ทธ) ๋ฐ exp(x)
(์ง์) ๋ฐฉ๋ฒ์ด ์์ต๋๋ค . ๋ฐ์ด 10์ธ ๋ก๊ทธ๋ฅผ ๊ณ์ฐํ๋ ค๋ฉด log10(a)
.
์ซ์์ ๋ก๊ทธ๋ฅผ b
๋ฐ์ผ๋ก ํ๋ ค๋ฉด a
๋ค์ ๊ฐ๋จํ ๊ณต์์ ์ฌ์ฉํ์ญ์์ค.loga(b) = ln(b) / ln(a)
์ ์ฉํ ๋ฐฉ๋ฒ
์ ๋งค์ฐ ์์ ๊ฐ์ ํฌํจํ๋ ๊ณ์ฐ์ ์ํํ๋ ๊ฒฝ์ฐ x
๋ง์ง๋ง ๋ ํจ์ โ log1p()
and expm1()
โ๊ฐ ์ ์ฉํ ์ ์์ต๋๋ค.
๋งค์ฐ ์์ ๋ณ์์ ๋งค์ฐ ํฐ ๋ณ์๋ฅผ ์ถ๊ฐํ ๋ double
๋งค์ฐ ์์ ๊ฐ์ด ์ค์ํ์ง ์์ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋์ด ๋ฌด์(๋ฒ๋ ค์ง)๋๋ ๊ฒฝ์ฐ๊ฐ ์ข
์ข
์์ต๋๋ค. ์ฌ์ค ์ด๊ฒ์ log()
and exp()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์ ๋ฐ์ํฉ๋๋ค. ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํ๋ก๊ทธ๋๋จธ๋ค์ "์๊ณ ์ค์ํ ๋ถ๋ถ"๋ง ๋ฐํํ๋ ํจ์๋ฅผ ๊ณ ์ํ์ต๋๋ค.
์:
์ ์์ฐ ๋ก๊ทธ๋ฅผ ๊ณ์ฐํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค 1 + x
. ์ฌ๊ธฐ์ ๋ x
์
๋๋ค . ์ ๋ฅผ ๋ํ๋ฉด ์ ์ป๊ฒ ๋๋ฏ๋ก ๋จ์ํ ์ด ์ซ์๋ฅผ ๋ฉ์๋์ ์ ๋ฌํ ์ ์์ต๋๋ค . ์ซ์๊ฐ ๋ํด์ง๋ฉด ์์ ํ ๋ฒ๋ ค์ง ์ ๋๋ก ์์ ์ซ์์
๋๋ค.10-20
log()
1
10-20
1
10-20
log()
์ํ์ ์ข
์ข
์ ๊ฐ๊น์ด ์ซ์์ ๊ณ์ฐ์ ํฌํจํ๊ธฐ ๋๋ฌธ์ 1
ํ๋ก๊ทธ๋๋จธ๋ ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํด ๋์ต๋๋ค. ์ซ์ ์์ฒด๋ฅผ ๋ฉ์๋์ ์ ๋ฌํ๋ ๋์ ์์ ์ฐจ์ด๋ง ์ ๋ฌํ๋ ๊ฒ์
๋๋ค 1
.
3. ์ต์ ๋ฐ ์ต๋
๋ ๊ฐ์ง ๋ ์ ์ฉํ ๊ธฐ๋ฅ์ min(a, b)
๋ฐ ์
๋๋ค max(a, b)
. ์ด๋ฏธ ์ง์ํ์
จ๊ฒ ์ง๋ง ์ฒซ ๋ฒ์งธ๋ ๋ ์ซ์ ์ค ์ต์๊ฐ์ ๋ฐํํฉ๋๋ค.
Math.min(a, b)
๋ ๋ฒ์งธ๋ ์ต๋ ๋ ์ซ์๋ฅผ ๋ฐํํฉ๋๋ค.
Math.max(a, b)
if
ํญ์ ์ฐ๊ฑฐ๋ ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ์ ์๋๋ฐ ์ ์ด๋ฌํ ํจ์๊ฐ ํ์ํ๊ฐ์ (a < b ? a: b)
?
์ฝ๋์ ๊ฐ๋
์ฑ์ ๊ดํ ๊ฒ์
๋๋ค. ๋๋ก๋ ์ฝ๋๊ฐ ๋ฌธ์ผ๋ก ์ค๋ฒ๋ก๋๋์ด if
๋ ๊ฐ๊ฒฐํ ํ๊ธฐ๋ฒ์ ์ฌ์ฉํ๊ณ ์ ํ ์ ์์ต๋๋ค. ๋น๊ตํด๋ณด์:
์ํธ | ์ค๋ช |
---|---|
|
๋ฌธ ์ฌ์ฉ if-else (๊ฐ์ฅ ๊ธด ์์ฑ ๋ฐฉ๋ฒ) |
|
์ผํญ ์ฐ์ฐ์ ์ฌ์ฉ ๋จ์ : - ๋ถํผ๊ฐ ํฐ ์ฝ๋ - ๊ณ์ฐ์ด ๋ ๋ฒ ์ํ๋จ |
|
์ด๊ฒ์ ์ฐ๊ธฐ ์ข์ ๋ฐฉ๋ฒ์ด์ง๋ง ์ฝ๊ฐ ์ค๋ณต๋ฉ๋๋ค. |
|
๋ฐ๋ก ๐ |
4. ์ฌ๋ฌ ์ซ์์ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ
min()
and ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ ๋ค๋ฅธ ์ข์ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค max()
.
์ฌ๋ฌ ์ซ์๋ ๋ณ์์ ์ต์๊ฐ(๋๋ ์ต๋๊ฐ)์ ๊ณ์ฐํฉ๋๋ค. ์ด๋ฌํ ๋ฉ์๋๋ฅผ ์ค์ฒฉ ํธ์ถํ๋ ๊ฒ์ด ๋งค์ฐ ํธ๋ฆฌํฉ๋๋ค.
์ต์ 3๊ฐ์ ์ซ์๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
Math.min(a, Math.min(b, c))
๊ทธ๋์ ๋ญ? ๋งค์ฐ ํธ๋ฆฌํฉ๋๋ค. ๋ ์ซ์์ ์ต์๊ฐ์ ๊ณ์ฐํ ๋ค์ ์ด ์ซ์์ ์ต์๊ฐ๊ณผ ์ธ ๋ฒ์งธ ์ซ์๋ฅผ ๋ฐํํฉ๋๋ค.
์ต์ 4๊ฐ์ ์ซ์๋ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ป์ต๋๋ค.
Math.min(a, Math.min(b, Math.min(ั, d)))
์ฆ, ์ด ๊ณต์์ ์ข ๋ ๋ช ํํ๊ฒ ์์ฑํ ์ ์์ต๋๋ค.
Math.min(Math.min(a, b), Math.min(c, d))
๋ฐฉ๋ฒ ์ ๋ํด ๋ชจ๋ ๋์ผํ๊ฒ ์๋ํฉ๋๋ค max()
.
if-else
์ฐ์ฐ์ ๋๋ ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฌํ ์ฝ๋ ์ค๋ํซ์ด ์กฐ๊ธ ๋ ๋ณต์กํด์ง๋๋ค. ๊ทธ๋ฌ๋ min()
๋ฐ max()
๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ ๊ฒ์ ์๋ฒฝํฉ๋๋ค.
GO TO FULL VERSION