์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿ”ข ๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์˜ ์ •๋ฐ€๋„ ๋ฌธ์ œ์™€ ํ•ด๊ฒฐ ๋ฐฉ์•ˆ

๐Ÿ”ข ๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์˜ ์ •๋ฐ€๋„ ๋ฌธ์ œ์™€ ํ•ด๊ฒฐ ๋ฐฉ์•ˆ

์ปดํ“จํ„ฐ๊ฐ€ ์†Œ์ˆ˜๋ฅผ ๋‹ค๋ฃจ๋Š” ๋ฐฉ์‹์˜ ๋น„๋ฐ€์„ ํŒŒํ—ค์ณ๋ณด์ž!

๐ŸŽฏ ์‹œ์ž‘ํ•˜๊ธฐ ์ „์—

์•ˆ๋…•! ์˜ค๋Š˜์€ ์ •๋ง ํฅ๋ฏธ๋กœ์šด ์ฃผ์ œ๋ฅผ ๊ฐ€์ง€๊ณ  ์™”์–ด. ํ˜น์‹œ ๊ณ„์‚ฐ๊ธฐ๋กœ 0.1 + 0.2๋ฅผ ๊ณ„์‚ฐํ•ด๋ณธ ์  ์žˆ์–ด? ๋‹น์—ฐํžˆ 0.3์ด ๋‚˜์™€์•ผ ํ•˜๋Š”๋ฐ, ์ปดํ“จํ„ฐ๋Š” ๊ฐ€๋” 0.30000000000000004 ๊ฐ™์€ ์ด์ƒํ•œ ๊ฐ’์„ ๋ฑ‰์–ด๋‚ด๊ณค ํ•ด. ๐Ÿ˜…


์ด๊ฒŒ ๋ฐ”๋กœ ๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์˜ ์ •๋ฐ€๋„ ๋ฌธ์ œ์•ผ! ์˜ค๋Š˜ ์šฐ๋ฆฌ๋Š” ์ด ์‹ ๋น„๋กœ์šด ํ˜„์ƒ์˜ ์›์ธ์„ ํŒŒํ—ค์น˜๊ณ , ์–ด๋–ป๊ฒŒ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์•Œ์•„๋ณผ ๊ฑฐ์•ผ.

๐Ÿค” ๋ถ€๋™ ์†Œ์ˆ˜์ ์ด ๋ญ๊ธธ๋ž˜?

๋จผ์ € ๋ถ€๋™ ์†Œ์ˆ˜์ (Floating Point)์ด ๋ญ”์ง€๋ถ€ํ„ฐ ์•Œ์•„๋ณด์ž. ์ด๋ฆ„์ด ์ข€ ์–ด๋ ค์›Œ ๋ณด์ด์ง€๋งŒ, ์‚ฌ์‹ค ์šฐ๋ฆฌ๊ฐ€ ์ผ์ƒ์—์„œ ์“ฐ๋Š” ์†Œ์ˆ˜๋ฅผ ์ปดํ“จํ„ฐ๊ฐ€ ํ‘œํ˜„ํ•˜๋Š” ๋ฐฉ์‹์ด์•ผ.


์˜ˆ๋ฅผ ๋“ค์–ด, 123.456์ด๋ผ๋Š” ์ˆซ์ž๋ฅผ ์ƒ๊ฐํ•ด๋ณด์ž. ์ด๊ฑธ ๊ณผํ•™์  ํ‘œ๊ธฐ๋ฒ•์œผ๋กœ ์“ฐ๋ฉด 1.23456 ร— 10ยฒ๊ฐ€ ๋˜์ง€? ์ปดํ“จํ„ฐ๋„ ๋น„์Šทํ•œ ๋ฐฉ์‹์œผ๋กœ ์†Œ์ˆ˜๋ฅผ ์ €์žฅํ•ด. ๋‹ค๋งŒ 10์ง„๋ฒ• ๋Œ€์‹  2์ง„๋ฒ•์„ ์‚ฌ์šฉํ•œ๋‹ค๋Š” ๊ฒŒ ์ฐจ์ด์ ์ด์•ผ! ๐Ÿ”„

๐Ÿ’ก ๊ฐ„๋‹จํ•œ ์˜ˆ์‹œ

10์ง„์ˆ˜ 0.1์„ 2์ง„์ˆ˜๋กœ ๋ฐ”๊พธ๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ?


0.1 (10์ง„์ˆ˜) = 0.000110011001100... (2์ง„์ˆ˜)


์–ด? ๋ญ”๊ฐ€ ์ด์ƒํ•˜์ง€? 2์ง„์ˆ˜๋กœ ํ‘œํ˜„ํ•˜๋ฉด ๋ฌดํ•œํžˆ ๋ฐ˜๋ณต๋˜๋Š” ์†Œ์ˆ˜๊ฐ€ ๋˜์–ด๋ฒ„๋ ค! ๐Ÿ˜ฑ

10์ง„์ˆ˜ vs 2์ง„์ˆ˜ ๋ณ€ํ™˜ 10์ง„์ˆ˜ 0.1 ์ •ํ™•ํ•œ ํ‘œํ˜„ ๊ฐ€๋Šฅ โœ“ ๊ฐ„๋‹จํ•จ 2์ง„์ˆ˜ 0.000110011001100... ๋ฌดํ•œ ๋ฐ˜๋ณต! โœ— ์ •ํ™•ํ•œ ํ‘œํ˜„ ๋ถˆ๊ฐ€ ๋ฌธ์ œ ๋ฐœ์ƒ! ์ปดํ“จํ„ฐ๋Š” ๋ฉ”๋ชจ๋ฆฌ ํ•œ๊ณ„๋กœ ์ธํ•ด ๋ฌดํ•œ ์†Œ์ˆ˜๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์—†์Œ โ†’ ๊ทผ์‚ฌ๊ฐ’์œผ๋กœ ์ €์žฅ (๋ฐ˜์˜ฌ๋ฆผ ์˜ค์ฐจ ๋ฐœ์ƒ) โ†’ 0.1์ด ์‹ค์ œ๋กœ๋Š” 0.1000000000000000055511151... ๋กœ ์ €์žฅ๋จ ๊ฒฐ๊ณผ: 0.1 + 0.2 โ‰  0.3 ๐Ÿ˜ฑ

๐Ÿ” IEEE 754 ํ‘œ์ค€: ๋ถ€๋™ ์†Œ์ˆ˜์ ์˜ ๋น„๋ฐ€

์ปดํ“จํ„ฐ๊ฐ€ ๋ถ€๋™ ์†Œ์ˆ˜์ ์„ ์ €์žฅํ•˜๋Š” ๋ฐฉ์‹์—๋Š” ๊ตญ์ œ ํ‘œ์ค€์ด ์žˆ์–ด. ๋ฐ”๋กœ IEEE 754 ํ‘œ์ค€์ด์•ผ! ์ด ํ‘œ์ค€์€ 1985๋…„์— ๋งŒ๋“ค์–ด์ ธ์„œ ์ง€๊ธˆ๊นŒ์ง€๋„ ๊ฑฐ์˜ ๋ชจ๋“  ์ปดํ“จํ„ฐ์—์„œ ์‚ฌ์šฉ๋˜๊ณ  ์žˆ์–ด.

๐Ÿ“Š IEEE 754 ๋‹จ์ •๋ฐ€๋„ (32๋น„ํŠธ) ๊ตฌ์กฐ

32๋น„ํŠธ ๋ถ€๋™ ์†Œ์ˆ˜์ ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ตฌ์„ฑ๋ผ:


  1. ๋ถ€ํ˜ธ ๋น„ํŠธ (1๋น„ํŠธ): ์–‘์ˆ˜์ธ์ง€ ์Œ์ˆ˜์ธ์ง€ ํ‘œ์‹œ ๐Ÿ”„
  2. ์ง€์ˆ˜ ๋น„ํŠธ (8๋น„ํŠธ): ์†Œ์ˆ˜์ ์˜ ์œ„์น˜๋ฅผ ๋‚˜ํƒ€๋ƒ„ ๐Ÿ“
  3. ๊ฐ€์ˆ˜ ๋น„ํŠธ (23๋น„ํŠธ): ์‹ค์ œ ์ˆซ์ž ๊ฐ’์„ ์ €์žฅ ๐Ÿ’พ

์ด๋ ‡๊ฒŒ ์ œํ•œ๋œ ๋น„ํŠธ๋กœ ๋ฌดํ•œํ•œ ์‹ค์ˆ˜๋ฅผ ํ‘œํ˜„ํ•˜๋ ค๋‹ค ๋ณด๋‹ˆ ์ •๋ฐ€๋„ ์†์‹ค์ด ๋ฐœ์ƒํ•˜๋Š” ๊ฑฐ์•ผ. ๋งˆ์น˜ ํฐ ๊ทธ๋ฆผ์„ ์ž‘์€ ์•ก์ž์— ๋„ฃ์œผ๋ ค๊ณ  ํ•˜๋ฉด ์ผ๋ถ€๊ฐ€ ์ž˜๋ฆฌ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ง์ด์•ผ! ๐Ÿ–ผ๏ธ

๐Ÿ› ์‹ค์ œ๋กœ ์–ด๋–ค ๋ฌธ์ œ๋“ค์ด ๋ฐœ์ƒํ• ๊นŒ?

์ด๋ก ์ ์ธ ์–˜๊ธฐ๋งŒ ํ•˜๋ฉด ์žฌ๋ฏธ์—†์œผ๋‹ˆ๊นŒ, ์‹ค์ œ C ์–ธ์–ด์—์„œ ์–ด๋–ค ๋ฌธ์ œ๋“ค์ด ๋ฐœ์ƒํ•˜๋Š”์ง€ ์‚ดํŽด๋ณด์ž! ๐Ÿ’ป

๐Ÿ”ง ์˜ˆ์ œ 1: ๊ธฐ๋ณธ์ ์ธ ๋ง์…ˆ ๋ฌธ์ œ

#include <stdio.h>

int main() {
    float a = 0.1f;
    float b = 0.2f;
    float result = a + b;
    
    printf("0.1 + 0.2 = %.20f\n", result);
    
    if (result == 0.3f) {
        printf("๊ฐ™๋‹ค!\n");
    } else {
        printf("๋‹ค๋ฅด๋‹ค! ๐Ÿ˜ฑ\n");
    }
    
    return 0;
}

๊ฒฐ๊ณผ: 0.30000001192092895508 (๋‹ค๋ฅด๋‹ค! ๐Ÿ˜ฑ)

๐Ÿ”ง ์˜ˆ์ œ 2: ๋ฐ˜๋ณต ์—ฐ์‚ฐ์˜ ๋ˆ„์  ์˜ค์ฐจ

#include <stdio.h>

int main() {
    float sum = 0.0f;
    
    // 0.1์„ 10๋ฒˆ ๋”ํ•˜๊ธฐ
    for (int i = 0; i < 10; i++) {
        sum += 0.1f;
    }
    
    printf("0.1์„ 10๋ฒˆ ๋”ํ•œ ๊ฒฐ๊ณผ: %.20f\n", sum);
    printf("์˜ˆ์ƒ ๊ฒฐ๊ณผ: 1.0\n");
    
    if (sum == 1.0f) {
        printf("์ •ํ™•ํ•ด!\n");
    } else {
        printf("์˜ค์ฐจ ๋ฐœ์ƒ! ๐Ÿ˜ฐ\n");
    }
    
    return 0;
}

๊ฒฐ๊ณผ: 1.00000011920928955078 (์˜ค์ฐจ ๋ฐœ์ƒ! ๐Ÿ˜ฐ)

์ด๋Ÿฐ ๋ฌธ์ œ๋“ค์€ ํŠนํžˆ ๊ธˆ์œต ๊ณ„์‚ฐ์ด๋‚˜ ๊ณผํ•™ ๊ณ„์‚ฐ์—์„œ ์‹ฌ๊ฐํ•œ ๊ฒฐ๊ณผ๋ฅผ ์ดˆ๋ž˜ํ•  ์ˆ˜ ์žˆ์–ด. ์ƒ์ƒํ•ด๋ด, ์€ํ–‰ ์‹œ์Šคํ…œ์—์„œ ์ด๋Ÿฐ ์˜ค์ฐจ๊ฐ€ ๋ˆ„์ ๋˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ? ๐Ÿ’ฐ

๐Ÿ› ๏ธ ํ•ด๊ฒฐ ๋ฐฉ์•ˆ๋“ค

๋‹คํ–‰ํžˆ ์ด๋Ÿฐ ๋ฌธ์ œ๋“ค์„ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋Š” ์—ฌ๋Ÿฌ ๋ฐฉ๋ฒ•๋“ค์ด ์žˆ์–ด! ํ•˜๋‚˜์”ฉ ์‚ดํŽด๋ณด์ž. ๐Ÿ”ง

1๏ธโƒฃ ์—ก์‹ค๋ก (Epsilon) ๋น„๊ต๋ฒ•

๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ด๊ณ  ๋„๋ฆฌ ์‚ฌ์šฉ๋˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ. ๋‘ ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆ˜๊ฐ€ "๊ฑฐ์˜ ๊ฐ™์€์ง€" ํ™•์ธํ•˜๋Š” ๊ฑฐ์ง€! ๐ŸŽฏ

๐Ÿ’ก ์—ก์‹ค๋ก  ๋น„๊ต๋ฒ•์˜ ์›๋ฆฌ

๋‘ ์ˆ˜์˜ ์ฐจ์ด๊ฐ€ ์•„์ฃผ ์ž‘์€ ๊ฐ’(์—ก์‹ค๋ก ) ์ดํ•˜์ด๋ฉด "๊ฐ™๋‹ค"๊ณ  ํŒ๋‹จํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ.


#include <stdio.h>
#include <math.h>

#define EPSILON 1e-9

int float_equal(float a, float b) {
    return fabs(a - b) < EPSILON;
}

int main() {
    float a = 0.1f + 0.2f;
    float b = 0.3f;
    
    if (float_equal(a, b)) {
        printf("๊ฐ™๋‹ค! ๐ŸŽ‰\n");
    } else {
        printf("๋‹ค๋ฅด๋‹ค! ๐Ÿ˜ข\n");
    }
    
    return 0;
}

2๏ธโƒฃ ์ƒ๋Œ€์  ์—ก์‹ค๋ก  ๋น„๊ต๋ฒ•

์ ˆ๋Œ€์ ์ธ ์—ก์‹ค๋ก  ๊ฐ’ ๋Œ€์‹ , ๋น„๊ตํ•˜๋Š” ์ˆ˜์˜ ํฌ๊ธฐ์— ๋น„๋ก€ํ•œ ์—ก์‹ค๋ก ์„ ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ. ํฐ ์ˆ˜์™€ ์ž‘์€ ์ˆ˜๋ฅผ ๋ชจ๋‘ ์ •ํ™•ํ•˜๊ฒŒ ๋น„๊ตํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ“

#include <stdio.h>
#include <math.h>

int relative_equal(float a, float b, float relative_epsilon) {
    if (a == b) return 1; // ์ •ํ™•ํžˆ ๊ฐ™์€ ๊ฒฝ์šฐ
    
    float diff = fabs(a - b);
    float largest = fmax(fabs(a), fabs(b));
    
    return diff <= relative_epsilon * largest;
}

int main() {
    float a = 1000000.1f;
    float b = 1000000.2f;
    
    if (relative_equal(a, b, 1e-6)) {
        printf("์ƒ๋Œ€์ ์œผ๋กœ ๊ฐ™๋‹ค! โœจ\n");
    } else {
        printf("์ƒ๋Œ€์ ์œผ๋กœ ๋‹ค๋ฅด๋‹ค! ๐Ÿค”\n");
    }
    
    return 0;
}

3๏ธโƒฃ ์ •์ˆ˜ ์—ฐ์‚ฐ ํ™œ์šฉ๋ฒ•

์•„์˜ˆ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์„ ํ”ผํ•˜๊ณ  ์ •์ˆ˜๋กœ ๊ณ„์‚ฐํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ! ํŠนํžˆ ๊ธˆ์œต ๊ณ„์‚ฐ์—์„œ ๋งŽ์ด ์‚ฌ์šฉ๋ผ. ๐Ÿ’ณ

๐Ÿ’ฐ ๊ธˆ์œต ๊ณ„์‚ฐ ์˜ˆ์ œ

#include <stdio.h>

// ์†Œ์ˆ˜์  ๋‘˜์งธ ์ž๋ฆฌ๊นŒ์ง€ ์ •ํ™•ํ•˜๊ฒŒ ๊ณ„์‚ฐ
// ๋ชจ๋“  ๊ฐ’์„ 100๋ฐฐ๋กœ ํ™•๋Œ€ํ•ด์„œ ์ •์ˆ˜๋กœ ๊ณ„์‚ฐ
int main() {
    // 12.34 + 56.78์„ ๊ณ„์‚ฐ
    int a = 1234; // 12.34 * 100
    int b = 5678; // 56.78 * 100
    
    int result = a + b;
    
    printf("๊ฒฐ๊ณผ: %d.%02d\n", result / 100, result % 100);
    // ์ถœ๋ ฅ: 69.12 (์ •ํ™•ํ•จ!)
    
    return 0;
}

4๏ธโƒฃ ๊ณ ์ • ์†Œ์ˆ˜์  ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์‚ฌ์šฉ

C ์–ธ์–ด์—๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ ๊ณ ์ • ์†Œ์ˆ˜์  ํƒ€์ž…์ด ์—†์ง€๋งŒ, ์ง์ ‘ ๊ตฌํ˜„ํ•˜๊ฑฐ๋‚˜ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ“š

๐Ÿ”ง ๊ฐ„๋‹จํ•œ ๊ณ ์ • ์†Œ์ˆ˜์  ๊ตฌํ˜„

#include <stdio.h>

// 16.16 ๊ณ ์ • ์†Œ์ˆ˜์  (16๋น„ํŠธ ์ •์ˆ˜๋ถ€, 16๋น„ํŠธ ์†Œ์ˆ˜๋ถ€)
typedef int fixed_point;

#define FIXED_SCALE 65536 // 2^16

fixed_point float_to_fixed(float f) {
    return (fixed_point)(f * FIXED_SCALE);
}

float fixed_to_float(fixed_point fp) {
    return (float)fp / FIXED_SCALE;
}

fixed_point fixed_add(fixed_point a, fixed_point b) {
    return a + b;
}

int main() {
    fixed_point a = float_to_fixed(0.1f);
    fixed_point b = float_to_fixed(0.2f);
    fixed_point result = fixed_add(a, b);
    
    printf("0.1 + 0.2 = %.6f\n", fixed_to_float(result));
    // ํ›จ์”ฌ ๋” ์ •ํ™•ํ•œ ๊ฒฐ๊ณผ!
    
    return 0;
}
๋ถ€๋™ ์†Œ์ˆ˜์  ๋ฌธ์ œ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ• ๋น„๊ต ์—ก์‹ค๋ก  ๋น„๊ต๋ฒ• โœ“ ๊ตฌํ˜„ ๊ฐ„๋‹จ โœ“ ๋„๋ฆฌ ์‚ฌ์šฉ โœ— ์—ก์‹ค๋ก  ๊ฐ’ ์„ ํƒ ์–ด๋ ค์›€ ์ ํ•ฉ๋„: โญโญโญ ์ผ๋ฐ˜์  ์šฉ๋„ fabs(a-b) < ฮต ์ƒ๋Œ€์  ์—ก์‹ค๋ก  โœ“ ๋‹ค์–‘ํ•œ ํฌ๊ธฐ ๋Œ€์‘ โœ“ ๋” ์ •ํ™•ํ•จ โœ— ๋ณต์žกํ•จ ์ ํ•ฉ๋„: โญโญโญโญ ๊ณผํ•™ ๊ณ„์‚ฐ ํฌ๊ธฐ ๋น„๋ก€ ๋น„๊ต ์ •์ˆ˜ ์—ฐ์‚ฐ โœ“ ์™„์ „ํžˆ ์ •ํ™• โœ“ ๋น ๋ฆ„ โœ— ์ œํ•œ์  ๋ฒ”์œ„ ์ ํ•ฉ๋„: โญโญโญโญโญ ๊ธˆ์œต ๊ณ„์‚ฐ ์Šค์ผ€์ผ๋ง ํ™œ์šฉ ๊ณ ์ • ์†Œ์ˆ˜์  โœ“ ์˜ˆ์ธก ๊ฐ€๋Šฅ โœ“ ์ผ๊ด€์„ฑ โœ— ๊ตฌํ˜„ ๋ณต์žก ์ ํ•ฉ๋„: โญโญโญโญ ๊ฒŒ์ž„, ์ž„๋ฒ ๋””๋“œ ๊ณ ์ • ์ •๋ฐ€๋„ ์ƒํ™ฉ๋ณ„ ์ถ”์ฒœ ๋ฐฉ๋ฒ• ๐ŸŽฏ ๐Ÿ’ฐ ๊ธˆ์œต ๊ณ„์‚ฐ ์ •์ˆ˜ ์—ฐ์‚ฐ 100% ์ •ํ™•์„ฑ ํ•„์š” ๐ŸŽฎ ๊ฒŒ์ž„ ๊ฐœ๋ฐœ ๊ณ ์ • ์†Œ์ˆ˜์  ์„ฑ๋Šฅ + ์ผ๊ด€์„ฑ ๐Ÿ”ฌ ๊ณผํ•™ ๊ณ„์‚ฐ ์ƒ๋Œ€์  ์—ก์‹ค๋ก  ๋‹ค์–‘ํ•œ ํฌ๊ธฐ ๋Œ€์‘ ๐Ÿ“ฑ ์ผ๋ฐ˜ ์•ฑ ์—ก์‹ค๋ก  ๋น„๊ต ๊ฐ„๋‹จํ•˜๊ณ  ์‹ค์šฉ์  โš ๏ธ ์ฃผ์˜: ์ƒํ™ฉ์— ๋งž๋Š” ๋ฐฉ๋ฒ• ์„ ํƒ์ด ์ค‘์š”! ์ •ํ™•์„ฑ, ์„ฑ๋Šฅ, ๊ตฌํ˜„ ๋ณต์žก๋„๋ฅผ ๋ชจ๋‘ ๊ณ ๋ คํ•ด์•ผ ํ•จ ํ…Œ์ŠคํŠธ๋ฅผ ํ†ตํ•ด ๊ฒ€์ฆํ•˜๋Š” ๊ฒƒ์ด ํ•„์ˆ˜!

๐ŸŽฏ ์‹ค๋ฌด์—์„œ ์ž์ฃผ ๋งˆ์ฃผ์น˜๋Š” ์ƒํ™ฉ๋“ค

์ด๋ก ๋งŒ ์•Œ๋ฉด ๋ญํ•ด? ์‹ค์ œ๋กœ ๊ฐœ๋ฐœํ•˜๋‹ค ๋ณด๋ฉด ์–ด๋–ค ์ƒํ™ฉ์—์„œ ์ด๋Ÿฐ ๋ฌธ์ œ๋“ค์„ ๋งˆ์ฃผ์น˜๊ฒŒ ๋ ๊นŒ? ์‹ค๋ฌด ๊ฒฝํ—˜์„ ๋ฐ”ํƒ•์œผ๋กœ ๋ช‡ ๊ฐ€์ง€ ์ผ€์ด์Šค๋ฅผ ์†Œ๊ฐœํ•ด๋ณผ๊ฒŒ! ๐Ÿ’ผ

๐Ÿ’ธ ์ผ€์ด์Šค 1: ์ „์ž์ƒ๊ฑฐ๋ž˜ ๊ฒฐ์ œ ์‹œ์Šคํ…œ

์˜จ๋ผ์ธ ์‡ผํ•‘๋ชฐ์—์„œ ํ• ์ธ ๊ณ„์‚ฐ์„ ํ•  ๋•Œ ์ด๋Ÿฐ ์ผ์ด ๋ฒŒ์–ด์งˆ ์ˆ˜ ์žˆ์–ด:

๐Ÿ˜ฑ ๋ฌธ์ œ ์ƒํ™ฉ

// ๋ฌธ์ œ๊ฐ€ ์žˆ๋Š” ์ฝ”๋“œ
float price = 19.99f;
float discount = 0.15f; // 15% ํ• ์ธ
float discounted_price = price * (1.0f - discount);

printf("ํ• ์ธ ๊ฐ€๊ฒฉ: %.2f\n", discounted_price);
// ์˜ˆ์ƒ: 16.99, ์‹ค์ œ: 16.989999... ๐Ÿคฏ

โœ… ํ•ด๊ฒฐ์ฑ…

// ์ •์ˆ˜ ์—ฐ์‚ฐ์œผ๋กœ ํ•ด๊ฒฐ
int price_cents = 1999; // 19.99 * 100
int discount_percent = 15;
int discounted_cents = price_cents * (100 - discount_percent) / 100;

printf("ํ• ์ธ ๊ฐ€๊ฒฉ: %d.%02d\n", 
       discounted_cents / 100, 
       discounted_cents % 100);
// ์ •ํ™•ํžˆ 16.99 ์ถœ๋ ฅ! ๐ŸŽ‰

๐ŸŽฎ ์ผ€์ด์Šค 2: ๊ฒŒ์ž„ ๋ฌผ๋ฆฌ ์—”์ง„

๊ฒŒ์ž„์—์„œ ์บ๋ฆญํ„ฐ์˜ ์œ„์น˜๋ฅผ ๊ณ„์‚ฐํ•  ๋•Œ๋„ ์ด๋Ÿฐ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์–ด. ํŠนํžˆ ๋งค ํ”„๋ ˆ์ž„๋งˆ๋‹ค ์ž‘์€ ๊ฐ’์„ ๋ˆ„์ ํ•˜๋Š” ๊ฒฝ์šฐ์— ๋ง์ด์•ผ! ๐Ÿƒโ€โ™‚๏ธ

๐ŸŽฏ ๊ฒŒ์ž„ ๋ฃจํ”„์—์„œ์˜ ๋ˆ„์  ์˜ค์ฐจ

// ๋ฌธ์ œ๊ฐ€ ์žˆ๋Š” ์ฝ”๋“œ
float player_x = 0.0f;
float velocity = 0.1f; // ์ดˆ๋‹น 0.1 ํ”ฝ์…€ ์ด๋™
float delta_time = 0.016f; // 60 FPS (1/60์ดˆ)

// 1์ดˆ ๋™์•ˆ ์ด๋™ (60ํ”„๋ ˆ์ž„)
for (int frame = 0; frame < 60; frame++) {
    player_x += velocity * delta_time;
}

printf("1์ดˆ ํ›„ ์œ„์น˜: %.10f\n", player_x);
// ์˜ˆ์ƒ: 0.096, ์‹ค์ œ: 0.0959999... ๐Ÿ˜ต

โœ… ๊ณ ์ • ์†Œ์ˆ˜์ ์œผ๋กœ ํ•ด๊ฒฐ

// ๊ณ ์ • ์†Œ์ˆ˜์  ์‚ฌ์šฉ (16.16 ํ˜•์‹)
typedef int fixed_t;
#define FIXED_SCALE 65536

fixed_t float_to_fixed(float f) {
    return (fixed_t)(f * FIXED_SCALE);
}

float fixed_to_float(fixed_t f) {
    return (float)f / FIXED_SCALE;
}

fixed_t player_x = 0;
fixed_t velocity = float_to_fixed(0.1f);
fixed_t delta_time = float_to_fixed(0.016f);

for (int frame = 0; frame < 60; frame++) {
    player_x += (velocity * delta_time) / FIXED_SCALE;
}

printf("1์ดˆ ํ›„ ์œ„์น˜: %.10f\n", fixed_to_float(player_x));
// ํ›จ์”ฌ ๋” ์ •ํ™•ํ•œ ๊ฒฐ๊ณผ! ๐ŸŽฏ

๐Ÿ“Š ์ผ€์ด์Šค 3: ๋ฐ์ดํ„ฐ ๋ถ„์„ ๋ฐ ํ†ต๊ณ„

๋Œ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ ์ž‘์€ ์˜ค์ฐจ๊ฐ€ ๋ˆ„์ ๋˜์–ด ํฐ ๋ฌธ์ œ๊ฐ€ ๋  ์ˆ˜ ์žˆ์–ด. ํŠนํžˆ ํ‰๊ท ๊ฐ’ ๊ณ„์‚ฐ์—์„œ ์ž์ฃผ ๋ฐœ์ƒํ•˜์ง€! ๐Ÿ“ˆ

๐Ÿ“‰ ํฐ ์ˆ˜์™€ ์ž‘์€ ์ˆ˜์˜ ํ˜ผ์žฌ ๋ฌธ์ œ

// ๋ฌธ์ œ๊ฐ€ ์žˆ๋Š” ํ‰๊ท  ๊ณ„์‚ฐ
float data[] = {1000000.0f, 1000000.1f, 1000000.2f, 1000000.3f};
int count = 4;

float sum = 0.0f;
for (int i = 0; i < count; i++) {
    sum += data[i];
}

float average = sum / count;
printf("ํ‰๊ท : %.10f\n", average);
// ์ •๋ฐ€๋„ ์†์‹ค๋กœ ์ธํ•œ ๋ถ€์ •ํ™•ํ•œ ๊ฒฐ๊ณผ

โœ… Kahan ํ•ฉ์‚ฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ ํ•ด๊ฒฐ

// Kahan ํ•ฉ์‚ฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜ (์˜ค์ฐจ ๋ณด์ •)
float kahan_sum(float data[], int count) {
    float sum = 0.0f;
    float compensation = 0.0f; // ์˜ค์ฐจ ๋ณด์ •๊ฐ’
    
    for (int i = 0; i < count; i++) {
        float y = data[i] - compensation;
        float temp = sum + y;
        compensation = (temp - sum) - y;
        sum = temp;
    }
    
    return sum;
}

float data[] = {1000000.0f, 1000000.1f, 1000000.2f, 1000000.3f};
float sum = kahan_sum(data, 4);
float average = sum / 4;

printf("์ •ํ™•ํ•œ ํ‰๊ท : %.10f\n", average);
// ํ›จ์”ฌ ๋” ์ •ํ™•ํ•œ ๊ฒฐ๊ณผ! ๐ŸŽฏ

์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ๋„ ์ด๋Ÿฐ ์ •๋ฐ€ํ•œ ๊ณ„์‚ฐ์ด ์ค‘์š”ํ•ด. ํŠนํžˆ ์ˆ˜์ˆ˜๋ฃŒ ๊ณ„์‚ฐ์ด๋‚˜ ํฌ์ธํŠธ ์ ๋ฆฝ ์‹œ์Šคํ…œ์—์„œ ๋ง์ด์•ผ! ์ •ํ™•ํ•œ ๊ณ„์‚ฐ์€ ์‚ฌ์šฉ์ž ์‹ ๋ขฐ๋„์™€ ์ง๊ฒฐ๋˜๊ฑฐ๋“ . ๐Ÿ’ฏ

๐Ÿ”ฌ ๊ณ ๊ธ‰ ํ•ด๊ฒฐ ๊ธฐ๋ฒ•๋“ค

๊ธฐ๋ณธ์ ์ธ ํ•ด๊ฒฐ์ฑ…๋“ค์„ ์•Œ์•„๋ดค์œผ๋‹ˆ, ์ด์ œ ์ข€ ๋” ๊ณ ๊ธ‰ ๊ธฐ๋ฒ•๋“ค์„ ์‚ดํŽด๋ณด์ž! ์ด๋Ÿฐ ๊ธฐ๋ฒ•๋“ค์€ ํŠน๋ณ„ํ•œ ์ƒํ™ฉ์—์„œ ์ •๋ง ์œ ์šฉํ•ด. ๐Ÿš€

๐Ÿงฎ ๋‹ค์ค‘ ์ •๋ฐ€๋„ ์—ฐ์‚ฐ (Multiple Precision Arithmetic)

์•„์˜ˆ ๋” ๋†’์€ ์ •๋ฐ€๋„๋กœ ๊ณ„์‚ฐํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ. C ์–ธ์–ด์—์„œ๋Š” long double์„ ์‚ฌ์šฉํ•˜๊ฑฐ๋‚˜, ์™ธ๋ถ€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด!

๐Ÿ”ข long double ํ™œ์šฉ

#include <stdio.h>

int main() {
    // float vs long double ๋น„๊ต
    float f_result = 0.1f + 0.2f;
    long double ld_result = 0.1L + 0.2L;
    
    printf("float ๊ฒฐ๊ณผ:       %.20f\n", f_result);
    printf("long double ๊ฒฐ๊ณผ: %.20Lf\n", ld_result);
    
    // long double์ด ๋” ์ •ํ™•ํ•จ!
    return 0;
}

๐ŸŽฒ ํ™•๋ฅ ์  ๋ฐ˜์˜ฌ๋ฆผ (Stochastic Rounding)

์ผ๋ฐ˜์ ์ธ ๋ฐ˜์˜ฌ๋ฆผ ๋Œ€์‹  ํ™•๋ฅ ์ ์œผ๋กœ ๋ฐ˜์˜ฌ๋ฆผํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ. ๋จธ์‹ ๋Ÿฌ๋‹์—์„œ ํŠนํžˆ ์œ ์šฉํ•ด! ๐Ÿค–

๐ŸŽฏ ํ™•๋ฅ ์  ๋ฐ˜์˜ฌ๋ฆผ ๊ตฌํ˜„

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

float stochastic_round(float value, int decimal_places) {
    float scale = 1.0f;
    for (int i = 0; i < decimal_places; i++) {
        scale *= 10.0f;
    }
    
    float scaled = value * scale;
    float fractional = scaled - (int)scaled;
    
    // ํ™•๋ฅ ์  ๋ฐ˜์˜ฌ๋ฆผ
    float random_val = (float)rand() / RAND_MAX;
    if (random_val < fractional) {
        scaled = (int)scaled + 1.0f;
    } else {
        scaled = (int)scaled;
    }
    
    return scaled / scale;
}

int main() {
    srand(time(NULL));
    
    float value = 1.2345f;
    printf("์›๋ž˜ ๊ฐ’: %.4f\n", value);
    
    // ์—ฌ๋Ÿฌ ๋ฒˆ ํ™•๋ฅ ์  ๋ฐ˜์˜ฌ๋ฆผ ์ˆ˜ํ–‰
    for (int i = 0; i < 5; i++) {
        printf("๋ฐ˜์˜ฌ๋ฆผ %d: %.2f\n", i+1, stochastic_round(value, 2));
    }
    
    return 0;
}

โšก SIMD๋ฅผ ํ™œ์šฉํ•œ ๋ณ‘๋ ฌ ์—ฐ์‚ฐ

๋Œ€๋Ÿ‰์˜ ๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์„ ๋น ๋ฅด๊ฒŒ ์ฒ˜๋ฆฌํ•˜๋ฉด์„œ๋„ ์ •๋ฐ€๋„๋ฅผ ์œ ์ง€ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ! ๐Ÿ’จ

๐Ÿš€ AVX๋ฅผ ํ™œ์šฉํ•œ ๋ฒกํ„ฐ ์—ฐ์‚ฐ

#include <immintrin.h>
#include <stdio.h>

// 8๊ฐœ์˜ float๋ฅผ ๋™์‹œ์— ๋”ํ•˜๊ธฐ (AVX ์‚ฌ์šฉ)
void vector_add(float* a, float* b, float* result, int count) {
    for (int i = 0; i < count; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vresult = _mm256_add_ps(va, vb);
        _mm256_store_ps(&result[i], vresult);
    }
}

// ์ปดํŒŒ์ผ ์‹œ: gcc -mavx -O2 your_program.c

๐Ÿ’ก ์ฃผ์˜: SIMD๋Š” ๋น ๋ฅด์ง€๋งŒ ์—ฌ์ „ํžˆ ๋ถ€๋™ ์†Œ์ˆ˜์  ์ •๋ฐ€๋„ ๋ฌธ์ œ๋Š” ๋‚จ์•„์žˆ์–ด. ๋‹ค๋ฅธ ๊ธฐ๋ฒ•๊ณผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•ด์•ผ ํ•ด!

๐Ÿงช ์‹ค์ „ ํ…Œ์ŠคํŠธ์™€ ๊ฒ€์ฆ ๋ฐฉ๋ฒ•

์ด๋ก ๊ณผ ์ฝ”๋“œ๋งŒ์œผ๋กœ๋Š” ๋ถ€์กฑํ•ด! ์‹ค์ œ๋กœ ์šฐ๋ฆฌ๊ฐ€ ๊ตฌํ˜„ํ•œ ํ•ด๊ฒฐ์ฑ…์ด ์ œ๋Œ€๋กœ ์ž‘๋™ํ•˜๋Š”์ง€ ํ™•์ธํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์•Œ์•„๋ณด์ž. ๐Ÿ”

๐Ÿ“‹ ๋‹จ์œ„ ํ…Œ์ŠคํŠธ ์ž‘์„ฑํ•˜๊ธฐ

๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์˜ ์ •ํ™•์„ฑ์„ ๊ฒ€์ฆํ•˜๋Š” ํ…Œ์ŠคํŠธ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด์ž!

๐Ÿงช ํฌ๊ด„์ ์ธ ํ…Œ์ŠคํŠธ ํ•จ์ˆ˜

#include <stdio.h>
#include <math.h>
#include <assert.h>

#define EPSILON 1e-9
#define TEST_PASSED 1
#define TEST_FAILED 0

// ํ…Œ์ŠคํŠธ ๊ฒฐ๊ณผ ๊ตฌ์กฐ์ฒด
typedef struct {
    int total_tests;
    int passed_tests;
    int failed_tests;
} TestResult;

TestResult test_result = {0, 0, 0};

// ๋ถ€๋™ ์†Œ์ˆ˜์  ๋น„๊ต ํ•จ์ˆ˜
int float_equal(float a, float b) {
    return fabs(a - b) < EPSILON;
}

// ํ…Œ์ŠคํŠธ ๋งคํฌ๋กœ
#define RUN_TEST(test_name, condition) \
    do { \
        test_result.total_tests++; \
        if (condition) { \
            printf("โœ… %s: PASSED\n", test_name); \
            test_result.passed_tests++; \
        } else { \
            printf("โŒ %s: FAILED\n", test_name); \
            test_result.failed_tests++; \
        } \
    } while(0)

// ๊ธฐ๋ณธ ์—ฐ์‚ฐ ํ…Œ์ŠคํŠธ
void test_basic_operations() {
    printf("\n๐Ÿ”ข ๊ธฐ๋ณธ ์—ฐ์‚ฐ ํ…Œ์ŠคํŠธ\n");
    printf("==================\n");
    
    RUN_TEST("0.1 + 0.2 โ‰ˆ 0.3", float_equal(0.1f + 0.2f, 0.3f));
    RUN_TEST("0.1 * 3 โ‰ˆ 0.3", float_equal(0.1f * 3.0f, 0.3f));
    RUN_TEST("1.0 / 3.0 * 3.0 โ‰ˆ 1.0", float_equal((1.0f / 3.0f) * 3.0f, 1.0f));
}

// ๋ˆ„์  ์—ฐ์‚ฐ ํ…Œ์ŠคํŠธ
void test_accumulation() {
    printf("\n๐Ÿ“Š ๋ˆ„์  ์—ฐ์‚ฐ ํ…Œ์ŠคํŠธ\n");
    printf("==================\n");
    
    float sum = 0.0f;
    for (int i = 0; i < 10; i++) {
        sum += 0.1f;
    }
    
    RUN_TEST("0.1์„ 10๋ฒˆ ๋”ํ•˜๊ธฐ โ‰ˆ 1.0", float_equal(sum, 1.0f));
    
    // Kahan ํ•ฉ์‚ฐ๊ณผ ๋น„๊ต
    float kahan_sum = 0.0f;
    float compensation = 0.0f;
    
    for (int i = 0; i < 10; i++) {
        float y = 0.1f - compensation;
        float temp = kahan_sum + y;
        compensation = (temp - kahan_sum) - y;
        kahan_sum = temp;
    }
    
    RUN_TEST("Kahan ํ•ฉ์‚ฐ โ‰ˆ 1.0", float_equal(kahan_sum, 1.0f));
    
    printf("์ผ๋ฐ˜ ํ•ฉ์‚ฐ: %.15f\n", sum);
    printf("Kahan ํ•ฉ์‚ฐ: %.15f\n", kahan_sum);
}

// ๊ฒฝ๊ณ„๊ฐ’ ํ…Œ์ŠคํŠธ
void test_edge_cases() {
    printf("\nโš ๏ธ  ๊ฒฝ๊ณ„๊ฐ’ ํ…Œ์ŠคํŠธ\n");
    printf("================\n");
    
    RUN_TEST("๋งค์šฐ ์ž‘์€ ์ˆ˜ ๋”ํ•˜๊ธฐ", float_equal(1e-10f + 1e-10f, 2e-10f));
    RUN_TEST("๋งค์šฐ ํฐ ์ˆ˜ ๋”ํ•˜๊ธฐ", float_equal(1e10f + 1.0f, 1e10f + 1.0f));
    RUN_TEST("0์œผ๋กœ ๋‚˜๋ˆ„๊ธฐ ์ฒดํฌ", isinf(1.0f / 0.0f));
    RUN_TEST("NaN ์ฒดํฌ", isnan(0.0f / 0.0f));
}

int main() {
    printf("๐Ÿงช ๋ถ€๋™ ์†Œ์ˆ˜์  ์ •๋ฐ€๋„ ํ…Œ์ŠคํŠธ ์‹œ์ž‘\n");
    printf("===================================\n");
    
    test_basic_operations();
    test_accumulation();
    test_edge_cases();
    
    printf("\n๐Ÿ“Š ํ…Œ์ŠคํŠธ ๊ฒฐ๊ณผ ์š”์•ฝ\n");
    printf("==================\n");
    printf("์ด ํ…Œ์ŠคํŠธ: %d\n", test_result.total_tests);
    printf("์„ฑ๊ณต: %d โœ…\n", test_result.passed_tests);
    printf("์‹คํŒจ: %d โŒ\n", test_result.failed_tests);
    printf("์„ฑ๊ณต๋ฅ : %.1f%%\n", 
           (float)test_result.passed_tests / test_result.total_tests * 100);
    
    return test_result.failed_tests == 0 ? 0 : 1;
}

๐Ÿ“ˆ ์„ฑ๋Šฅ ๋ฒค์น˜๋งˆํฌ

์ •ํ™•์„ฑ๋„ ์ค‘์š”ํ•˜์ง€๋งŒ ์„ฑ๋Šฅ๋„ ๋ฌด์‹œํ•  ์ˆ˜ ์—†์–ด! ๊ฐ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์˜ ์„ฑ๋Šฅ์„ ๋น„๊ตํ•ด๋ณด์ž. โฑ๏ธ

โšก ์„ฑ๋Šฅ ์ธก์ • ์ฝ”๋“œ

#include <stdio.h>
#include <time.h>
#include <math.h>

#define ITERATIONS 10000000

// ์‹œ๊ฐ„ ์ธก์ • ๋งคํฌ๋กœ
#define MEASURE_TIME(name, code) \
    do { \
        clock_t start = clock(); \
        code; \
        clock_t end = clock(); \
        double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC; \
        printf("%s: %.6f์ดˆ (%.2f ์—ฐ์‚ฐ/์ดˆ)\n", name, time_taken, \
               ITERATIONS / time_taken); \
    } while(0)

int main() {
    printf("๐Ÿš€ ์„ฑ๋Šฅ ๋ฒค์น˜๋งˆํฌ (%.0e ์—ฐ์‚ฐ)\n", (double)ITERATIONS);
    printf("=====================================\n");
    
    volatile float result; // ์ตœ์ ํ™” ๋ฐฉ์ง€
    
    // 1. ์ผ๋ฐ˜ float ์—ฐ์‚ฐ
    MEASURE_TIME("์ผ๋ฐ˜ float ์—ฐ์‚ฐ", {
        for (int i = 0; i < ITERATIONS; i++) {
            result = 0.1f + 0.2f;
        }
    });
    
    // 2. ์—ก์‹ค๋ก  ๋น„๊ต
    MEASURE_TIME("์—ก์‹ค๋ก  ๋น„๊ต", {
        for (int i = 0; i < ITERATIONS; i++) {
            result = fabs(0.3f - (0.1f + 0.2f)) < 1e-9f ? 1.0f : 0.0f;
        }
    });
    
    // 3. ์ •์ˆ˜ ์—ฐ์‚ฐ (์Šค์ผ€์ผ๋ง)
    MEASURE_TIME("์ •์ˆ˜ ์—ฐ์‚ฐ", {
        for (int i = 0; i < ITERATIONS; i++) {
            int a = 10; // 0.1 * 100
            int b = 20; // 0.2 * 100
            result = (float)(a + b) / 100.0f;
        }
    });
    
    // 4. long double ์—ฐ์‚ฐ
    MEASURE_TIME("long double ์—ฐ์‚ฐ", {
        volatile long double ld_result;
        for (int i = 0; i < ITERATIONS; i++) {
            ld_result = 0.1L + 0.2L;
        }
        result = (float)ld_result;
    });
    
    printf("\n๐Ÿ’ก ๊ฒฐ๊ณผ ๋ถ„์„:\n");
    printf("- ์ผ๋ฐ˜ float: ๊ฐ€์žฅ ๋น ๋ฅด์ง€๋งŒ ์ •๋ฐ€๋„ ๋ฌธ์ œ\n");
    printf("- ์—ก์‹ค๋ก  ๋น„๊ต: ์•ฝ๊ฐ„ ๋А๋ฆฌ์ง€๋งŒ ์‹ค์šฉ์ \n");
    printf("- ์ •์ˆ˜ ์—ฐ์‚ฐ: ๋น ๋ฅด๊ณ  ์ •ํ™•ํ•˜์ง€๋งŒ ๋ฒ”์œ„ ์ œํ•œ\n");
    printf("- long double: ๋А๋ฆฌ์ง€๋งŒ ๋†’์€ ์ •๋ฐ€๋„\n");
    
    return 0;
}

๐ŸŒŸ ์‹ค๋ฌด ์ ์šฉ ๊ฐ€์ด๋“œ๋ผ์ธ

์ด์ œ ์ด๋ก ๊ณผ ์‹ค์Šต์„ ๋ชจ๋‘ ์•Œ์•„๋ดค์œผ๋‹ˆ, ์‹ค์ œ ํ”„๋กœ์ ํŠธ์—์„œ ์–ด๋–ป๊ฒŒ ์ ์šฉํ• ์ง€ ์ •๋ฆฌํ•ด๋ณด์ž! ๐Ÿ“

๐Ÿ“‹ ์ฒดํฌ๋ฆฌ์ŠคํŠธ

โœ… ํ”„๋กœ์ ํŠธ ์‹œ์ž‘ ์ „ ํ™•์ธ์‚ฌํ•ญ

  1. ์ •๋ฐ€๋„ ์š”๊ตฌ์‚ฌํ•ญ ํŒŒ์•… ๐ŸŽฏ
    - ๊ธˆ์œต: ์ ˆ๋Œ€์  ์ •ํ™•์„ฑ ํ•„์š”
    - ๊ฒŒ์ž„: ์ผ๊ด€์„ฑ์ด ๋” ์ค‘์š”
    - ๊ณผํ•™: ์ƒ๋Œ€์  ์ •ํ™•์„ฑ ์ค‘์š”

  2. ์„ฑ๋Šฅ ์š”๊ตฌ์‚ฌํ•ญ ํ™•์ธ โšก
    - ์‹ค์‹œ๊ฐ„ ์ฒ˜๋ฆฌ ํ•„์š” ์—ฌ๋ถ€
    - ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰ ์ œํ•œ
    - ๋ฐฐํ„ฐ๋ฆฌ ์ˆ˜๋ช… ๊ณ ๋ ค (๋ชจ๋ฐ”์ผ)

  3. ๋ฐ์ดํ„ฐ ๋ฒ”์œ„ ๋ถ„์„ ๐Ÿ“Š
    - ์ตœ๋Œ€/์ตœ์†Œ๊ฐ’ ํ™•์ธ
    - ์†Œ์ˆ˜์  ์ž๋ฆฟ์ˆ˜ ์š”๊ตฌ์‚ฌํ•ญ
    - ์—ฐ์‚ฐ ํšŸ์ˆ˜ ์˜ˆ์ƒ

๐ŸŽฏ ์ƒํ™ฉ๋ณ„ ๊ถŒ์žฅ์‚ฌํ•ญ

๐Ÿ’ฐ ๊ธˆ์œต/ํšŒ๊ณ„ ์‹œ์Šคํ…œ

๊ถŒ์žฅ ๋ฐฉ๋ฒ•: ์ •์ˆ˜ ์—ฐ์‚ฐ + ๊ณ ์ • ์†Œ์ˆ˜์ 


์ด์œ :

  1. ๋ฒ•์  ์š”๊ตฌ์‚ฌํ•ญ (์ •ํ™•ํ•œ ๊ณ„์‚ฐ)
  2. ๊ฐ์‚ฌ ์ถ”์  ๊ฐ€๋Šฅ์„ฑ
  3. ์žฌํ˜„ ๊ฐ€๋Šฅํ•œ ๊ฒฐ๊ณผ

๊ตฌํ˜„ ์˜ˆ์‹œ:

// ์†Œ์ˆ˜์  4์ž๋ฆฌ๊นŒ์ง€ ์ •ํ™•ํ•œ ๊ณ„์‚ฐ
typedef long long money_t;
#define MONEY_SCALE 10000

money_t dollars_to_money(double dollars) {
    return (money_t)(dollars * MONEY_SCALE + 0.5);
}

๐ŸŽฎ ๊ฒŒ์ž„ ๊ฐœ๋ฐœ

๊ถŒ์žฅ ๋ฐฉ๋ฒ•: ๊ณ ์ • ์†Œ์ˆ˜์  + ์—ก์‹ค๋ก  ๋น„๊ต


์ด์œ :

  1. ์ผ๊ด€๋œ ๊ฒฐ๊ณผ (๋ฉ€ํ‹ฐํ”Œ๋ ˆ์ด์–ด)
  2. ์˜ˆ์ธก ๊ฐ€๋Šฅํ•œ ์„ฑ๋Šฅ
  3. ํ”Œ๋žซํผ ๋…๋ฆฝ์„ฑ

์ฃผ์˜์‚ฌํ•ญ:

โ€ข ๋ฌผ๋ฆฌ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์—์„œ๋Š” ๋ˆ„์  ์˜ค์ฐจ ์ฃผ์˜
โ€ข ๋„คํŠธ์›Œํฌ ๋™๊ธฐํ™” ์‹œ ์ •๋ฐ€๋„ ํ†ต์ผ ํ•„์š”

๐Ÿ”ฌ ๊ณผํ•™/๊ณตํ•™ ๊ณ„์‚ฐ

๊ถŒ์žฅ ๋ฐฉ๋ฒ•: ์ƒ๋Œ€์  ์—ก์‹ค๋ก  + ๊ณ ์ •๋ฐ€๋„ ํƒ€์ž…


์ด์œ :

  1. ๋‹ค์–‘ํ•œ ํฌ๊ธฐ์˜ ์ˆ˜ ์ฒ˜๋ฆฌ
  2. ์ˆ˜์น˜ ์•ˆ์ •์„ฑ ์ค‘์š”
  3. ์—ฐ๊ตฌ ์žฌํ˜„์„ฑ

์ถ”๊ฐ€ ๊ณ ๋ ค์‚ฌํ•ญ:

โ€ข Kahan ํ•ฉ์‚ฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ํ™œ์šฉ
โ€ข ์กฐ๊ฑด์ˆ˜(Condition Number) ํ™•์ธ
โ€ข ์ˆ˜์น˜ ๋ฏธ๋ถ„ ์‹œ ์Šคํ… ํฌ๊ธฐ ์ตœ์ ํ™”

๐Ÿšจ ์ฃผ์˜ํ•ด์•ผ ํ•  ํ•จ์ •๋“ค

๋งˆ์ง€๋ง‰์œผ๋กœ, ๋ถ€๋™ ์†Œ์ˆ˜์ ์„ ๋‹ค๋ฃฐ ๋•Œ ์ž์ฃผ ๋น ์ง€๋Š” ํ•จ์ •๋“ค์„ ์•Œ์•„๋ณด์ž! ์ด๊ฑธ ์•Œ๋ฉด ๋งŽ์€ ๋ฒ„๊ทธ๋ฅผ ๋ฏธ๋ฆฌ ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿ•ณ๏ธ

โš ๏ธ ํ”ํ•œ ์‹ค์ˆ˜๋“ค

1. ์ง์ ‘์ ์ธ ๋“ฑํ˜ธ ๋น„๊ต
// ์ž˜๋ชป๋œ ๋ฐฉ๋ฒ• โŒ
if (result == 0.3f) { ... }

// ์˜ฌ๋ฐ”๋ฅธ ๋ฐฉ๋ฒ• โœ…
if (fabs(result - 0.3f) < EPSILON) { ... }
2. ๋ฐ˜๋ณต๋ฌธ์—์„œ ๋ถ€๋™ ์†Œ์ˆ˜์  ์นด์šดํ„ฐ ์‚ฌ์šฉ
// ์ž˜๋ชป๋œ ๋ฐฉ๋ฒ• โŒ
for (float i = 0.0f; i < 1.0f; i += 0.1f) { ... }

// ์˜ฌ๋ฐ”๋ฅธ ๋ฐฉ๋ฒ• โœ…
for (int i = 0; i < 10; i++) {
    float value = i * 0.1f;
    ...
}
3. ํฐ ์ˆ˜์™€ ์ž‘์€ ์ˆ˜์˜ ์—ฐ์‚ฐ
// ๋ฌธ์ œ๊ฐ€ ๋  ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ โš ๏ธ
float big = 1e20f;
float small = 1.0f;
float result = big + small - big; // 0์ด ์•„๋‹ ์ˆ˜ ์žˆ์Œ!
๋ถ€๋™ ์†Œ์ˆ˜์  ๋ฌธ์ œ ํ•ด๊ฒฐ ๋กœ๋“œ๋งต ๐Ÿ—บ๏ธ 1๋‹จ๊ณ„: ๋ฌธ์ œ ์ธ์‹ โ€ข ์ •๋ฐ€๋„ ์š”๊ตฌ์‚ฌํ•ญ โ€ข ๋ฐ์ดํ„ฐ ๋ฒ”์œ„ ๋ถ„์„ โ€ข ์„ฑ๋Šฅ ์š”๊ตฌ์‚ฌํ•ญ โ€ข ํ˜„์žฌ ๋ฌธ์ œ์  ํŒŒ์•… 2๋‹จ๊ณ„: ๋ฐฉ๋ฒ• ์„ ํƒ โ€ข ์—ก์‹ค๋ก  ๋น„๊ต โ€ข ์ •์ˆ˜ ์—ฐ์‚ฐ โ€ข ๊ณ ์ • ์†Œ์ˆ˜์  โ€ข ๊ณ ์ •๋ฐ€๋„ ํƒ€์ž… 3๋‹จ๊ณ„: ๊ตฌํ˜„ โ€ข ํ•จ์ˆ˜ ์ž‘์„ฑ โ€ข ๋งคํฌ๋กœ ์ •์˜ โ€ข ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ํ™œ์šฉ โ€ข ์ฝ”๋“œ ์ตœ์ ํ™” 4๋‹จ๊ณ„: ๊ฒ€์ฆ โ€ข ๋‹จ์œ„ ํ…Œ์ŠคํŠธ โ€ข ์„ฑ๋Šฅ ํ…Œ์ŠคํŠธ โ€ข ๊ฒฝ๊ณ„๊ฐ’ ํ…Œ์ŠคํŠธ โ€ข ํšŒ๊ท€ ํ…Œ์ŠคํŠธ ์š”๊ตฌ์‚ฌํ•ญ ๋งŒ์กฑ? Yes ๐ŸŽ‰ ๋ฐฐํฌ ์ค€๋น„ ์™„๋ฃŒ! โ€ข ๋ฌธ์„œํ™” โ€ข ๋ชจ๋‹ˆํ„ฐ๋ง ์„ค์ • No ๋ฐฉ๋ฒ• ์žฌ๊ฒ€ํ†  ๋‹ค๋ฅธ ํ•ด๊ฒฐ์ฑ… ์‹œ๋„ ๐Ÿ’ก ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค โ€ข ํ•ญ์ƒ ํ…Œ์ŠคํŠธ ์ฝ”๋“œ ์ž‘์„ฑ โ€ข ๋ฌธ์„œํ™” ์ฒ ์ €ํžˆ โ€ข ์„ฑ๋Šฅ๊ณผ ์ •ํ™•์„ฑ์˜ ๊ท ํ˜• ๊ณ ๋ ค โ€ข ์ฝ”๋“œ ๋ฆฌ๋ทฐ ํ•„์ˆ˜ โ€ข ์ง€์†์ ์ธ ๋ชจ๋‹ˆํ„ฐ๋ง โ€ข ์—…๊ณ„ ํ‘œ์ค€ ์ค€์ˆ˜

๐Ÿš€ ๋ฏธ๋ž˜์˜ ๋ฐœ์ „ ๋ฐฉํ–ฅ

๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์˜ ๋ฏธ๋ž˜๋Š” ์–ด๋–ป๊ฒŒ ๋ ๊นŒ? ํ˜„์žฌ ์ง„ํ–‰ ์ค‘์ธ ์—ฐ๊ตฌ์™€ ์ƒˆ๋กœ์šด ๊ธฐ์ˆ ๋“ค์„ ์‚ดํŽด๋ณด์ž! ๐Ÿ”ฎ

๐Ÿง  AI/ML์„ ์œ„ํ•œ ์ƒˆ๋กœ์šด ๋ฐ์ดํ„ฐ ํƒ€์ž…

๋จธ์‹ ๋Ÿฌ๋‹์˜ ๋ฐœ์ „๊ณผ ํ•จ๊ป˜ ์ƒˆ๋กœ์šด ๋ถ€๋™ ์†Œ์ˆ˜์  ํ˜•์‹๋“ค์ด ๋“ฑ์žฅํ•˜๊ณ  ์žˆ์–ด!

๐Ÿค– ์ƒˆ๋กœ์šด ํ˜•์‹๋“ค

  1. bfloat16 (Brain Floating Point)
    Google์ด ๊ฐœ๋ฐœํ•œ 16๋น„ํŠธ ํ˜•์‹์œผ๋กœ, ๋จธ์‹ ๋Ÿฌ๋‹์— ์ตœ์ ํ™”๋จ

  2. TensorFloat-32 (TF32)
    NVIDIA๊ฐ€ ๊ฐœ๋ฐœํ•œ ํ˜•์‹์œผ๋กœ, AI ํ›ˆ๋ จ ์†๋„๋ฅผ ํฌ๊ฒŒ ํ–ฅ์ƒ์‹œํ‚ด

  3. Posit (Universal Number)
    IEEE 754๋ฅผ ๋Œ€์ฒดํ•  ์ˆ˜ ์žˆ๋Š” ์ƒˆ๋กœ์šด ํ‘œ์ค€ ํ›„๋ณด

โšก ํ•˜๋“œ์›จ์–ด ๊ฐ€์†

CPU์™€ GPU์˜ ๋ฐœ์ „์œผ๋กœ ๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์ด ๋”์šฑ ๋นจ๋ผ์ง€๊ณ  ์ •ํ™•ํ•ด์ง€๊ณ  ์žˆ์–ด!

๐Ÿ”ง ํ•˜๋“œ์›จ์–ด ๋ฐœ์ „

โ€ข AVX-512: 512๋น„ํŠธ ๋ฒกํ„ฐ ์—ฐ์‚ฐ์œผ๋กœ ๋Œ€๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
โ€ข GPU ํ…์„œ ์ฝ”์–ด: AI ์—ฐ์‚ฐ์— ํŠนํ™”๋œ ํ•˜๋“œ์›จ์–ด
โ€ข ์–‘์ž ์ปดํ“จํŒ…: ์™„์ „ํžˆ ๋‹ค๋ฅธ ๋ฐฉ์‹์˜ ์ˆ˜์น˜ ๊ณ„์‚ฐ

๐Ÿ“š ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€! ์ •๋ง ๊ธด ์—ฌํ–‰์ด์—ˆ์ง€? ๐Ÿ˜… ๋ถ€๋™ ์†Œ์ˆ˜์  ์—ฐ์‚ฐ์˜ ์ •๋ฐ€๋„ ๋ฌธ์ œ๋ถ€ํ„ฐ ํ•ด๊ฒฐ ๋ฐฉ์•ˆ๊นŒ์ง€ ๋ชจ๋“  ๊ฑธ ๋‹ค๋ค„๋ดค์–ด.

๐ŸŽฏ ํ•ต์‹ฌ ์š”์•ฝ

๐Ÿ” ๋ฌธ์ œ์˜ ๋ณธ์งˆ

โ€ข 2์ง„๋ฒ•์œผ๋กœ 10์ง„ ์†Œ์ˆ˜๋ฅผ ์ •ํ™•ํžˆ ํ‘œํ˜„ํ•  ์ˆ˜ ์—†์Œ
โ€ข IEEE 754 ํ‘œ์ค€์˜ ํ•œ๊ณ„
โ€ข ๋ˆ„์  ์˜ค์ฐจ์˜ ์œ„ํ—˜์„ฑ

๐Ÿ› ๏ธ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•๋“ค

โ€ข ์—ก์‹ค๋ก  ๋น„๊ต๋ฒ•: ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ด๊ณ  ์‹ค์šฉ์ 
โ€ข ์ •์ˆ˜ ์—ฐ์‚ฐ: ๊ธˆ์œต ๊ณ„์‚ฐ์— ์ตœ์ 
โ€ข ๊ณ ์ • ์†Œ์ˆ˜์ : ๊ฒŒ์ž„๊ณผ ์ž„๋ฒ ๋””๋“œ์— ์œ ์šฉ
โ€ข ๊ณ ์ •๋ฐ€๋„ ํƒ€์ž…: ๊ณผํ•™ ๊ณ„์‚ฐ์— ํ•„์ˆ˜

๐Ÿ’ก ์‹ค๋ฌด ์ ์šฉ

โ€ข ์š”๊ตฌ์‚ฌํ•ญ์— ๋งž๋Š” ๋ฐฉ๋ฒ• ์„ ํƒ
โ€ข ์ฒ ์ €ํ•œ ํ…Œ์ŠคํŠธ์™€ ๊ฒ€์ฆ
โ€ข ์„ฑ๋Šฅ๊ณผ ์ •ํ™•์„ฑ์˜ ๊ท ํ˜•

์ด์ œ ์—ฌ๋Ÿฌ๋ถ„๋„ ๋ถ€๋™ ์†Œ์ˆ˜์ ์˜ ํ•จ์ •์— ๋น ์ง€์ง€ ์•Š๊ณ  ์ •ํ™•ํ•œ ๊ณ„์‚ฐ์„ ํ•  ์ˆ˜ ์žˆ์„ ๊ฑฐ์•ผ! ๐Ÿ’ช


ํŠนํžˆ ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ด€๋ จ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•  ๋•Œ, ์ด๋Ÿฐ ๊นŠ์ด ์žˆ๋Š” ์ง€์‹์ด ์žˆ๋‹ค๋ฉด ์ •๋ง ํฐ ๋„์›€์ด ๋  ๊ฑฐ์•ผ. ๋‹จ์ˆœํžˆ ์ฝ”๋“œ๋ฅผ ์งœ๋Š” ๊ฒƒ์„ ๋„˜์–ด์„œ ์™œ ๊ทธ๋ ‡๊ฒŒ ํ•ด์•ผ ํ•˜๋Š”์ง€๋ฅผ ์„ค๋ช…ํ•  ์ˆ˜ ์žˆ๋‹ค๋ฉด, ์—ฌ๋Ÿฌ๋ถ„์˜ ๊ฐ€์น˜๋Š” ํ›จ์”ฌ ๋†’์•„์งˆ ๊ฑฐ์•ผ! โœจ

๐ŸŽ‰ ๋งˆ์ง€๋ง‰ ์กฐ์–ธ

๋ถ€๋™ ์†Œ์ˆ˜์  ๋ฌธ์ œ๋Š” ๋ชจ๋“  ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ํ•œ ๋ฒˆ์€ ๋งˆ์ฃผ์น˜๊ฒŒ ๋˜๋Š” ๋ฌธ์ œ์•ผ. ํ•˜์ง€๋งŒ ์ด์ œ ์—ฌ๋Ÿฌ๋ถ„์€ ์ค€๋น„๊ฐ€ ๋˜์—ˆ์–ด! ๐Ÿš€


๊ธฐ์–ตํ•ด: "์™„๋ฒฝํ•œ ํ•ด๊ฒฐ์ฑ…์€ ์—†๋‹ค. ์ƒํ™ฉ์— ๋งž๋Š” ์ตœ์„ ์˜ ์„ ํƒ๋งŒ ์žˆ์„ ๋ฟ์ด๋‹ค."


๊ณ„์† ํ•™์Šตํ•˜๊ณ , ์‹คํ—˜ํ•˜๊ณ , ๊ณต์œ ํ•˜์ž! ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ์„ธ๊ณ„๋Š” ๋ฌด๊ถ๋ฌด์ง„ํ•ด. ๐ŸŒŸ

์˜ค๋Š˜ ๋ฐฐ์šด ๋‚ด์šฉ์ด ์—ฌ๋Ÿฌ๋ถ„์˜ ์ฝ”๋”ฉ ์—ฌ์ •์— ๋„์›€์ด ๋˜๊ธธ ๋ฐ”๋ผ! ๊ถ๊ธˆํ•œ ์ ์ด ์žˆ๋‹ค๋ฉด ์–ธ์ œ๋“ ์ง€ ์žฌ๋Šฅ๋„ท์—์„œ ๊ด€๋ จ ์ „๋ฌธ๊ฐ€๋“ค๊ณผ ์†Œํ†ตํ•ด๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ํ•จ๊ป˜ ์„ฑ์žฅํ•˜๋Š” ๊ฐœ๋ฐœ์ž ์ปค๋ฎค๋‹ˆํ‹ฐ, ๊ทธ๊ฒŒ ๋ฐ”๋กœ ์šฐ๋ฆฌ๊ฐ€ ์ถ”๊ตฌํ•˜๋Š” ๊ฐ€์น˜๋‹ˆ๊นŒ! ๐Ÿค

๊ทธ๋Ÿผ ๋‹ค์Œ์— ๋˜ ์žฌ๋ฏธ์žˆ๋Š” ์ฃผ์ œ๋กœ ๋งŒ๋‚˜์ž! ํ•ดํ”ผ ์ฝ”๋”ฉ! ๐ŸŽŠ

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.