수학을 좋아하는 사람이라면 필독! 프로그래밍에 유용한 아름다운 수식 10선

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <iostream>
#include <complex>
#include <cmath>

// 2차원 좌표를 복소수로 다루기 위한 타입 에일리어스
using Point2D = std::complex<double>;

// 점을 원점을 중심으로 theta (라디안) 회전시키는 함수
Point2D rotatePoint(const Point2D& point, double theta) {
    // 오일러의 공식에 기반하여, 회전용 복소수 e^{i*theta} 를 생성
    // 내부적으로는 cos(theta) + i*sin(theta) 가 됨
    Point2D rotation(std::cos(theta), std::sin(theta));
    
    // 복소수 곱셈을 통해 회전을 적용
    return point * rotation;
}

int main() {
    // 초기 좌표 (x=1.0, y=0.0)
    Point2D p(1.0, 0.0);
    
    // 90도(π/2 라디안) 회전
    double theta = M_PI / 2.0;
    Point2D rotated_p = rotatePoint(p, theta);
    
    std::cout << "Original Point: (" << p.real() << ", " << p.imag() << ")\n";
    // 기대되는 출력은 약 (0, 1)
    std::cout << "Rotated Point: (" << rotated_p.real() << ", " << rotated_p.imag() << ")\n";
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import math

def taylor_sin(x, terms=10):
    """
    테일러 전개(매클로린 전개)를 사용하여 sin(x)를 근사 계산한다.
    
    :param x: 각도 (라디안)
    :param terms: 계산할 항의 수 (많을수록 고정밀도)
    :return: 근사된 sin(x)의 값
    """
    # 주기성을 이용하여 x를 -π에서 π 범위로 정규화 (정밀도 향상을 위함)
    x = (x + math.pi) % (2 * math.pi) - math.pi
    
    result = 0.0
    for n in range(terms):
        # 홀수 번째 항만 사용: 2n + 1
        power = 2 * n + 1
        
        # 부호는 항마다 반전: (-1)^n
        sign = (-1) ** n
        
        # 팩토리얼 계산
        fact = math.factorial(power)
        
        # 식의 평가와 덧셈
        term = sign * (x ** power) / fact
        result += term
        
    return result

# 테스트
angle = math.radians(45) # 45도 = π/4
print(f"Math library sin: {math.sin(angle)}")
print(f"Taylor series sin: {taylor_sin(angle, terms=5)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

def calculate_spam_probability(
    prob_spam, 
    prob_word_given_spam, 
    prob_word_given_ham
):
    """
    어떤 단어가 포함된 메일이 스팸일 확률을 베이즈 정리로 계산한다.
    
    :param prob_spam: P(Spam) - 메일이 스팸일 사전 확률
    :param prob_word_given_spam: P(Word|Spam) - 스팸 메일에 그 단어가 포함될 확률
    :param prob_word_given_ham: P(Word|Ham) - 정상 메일에 그 단어가 포함될 확률
    :return: P(Spam|Word) - 그 단어가 포함되어 있을 경우 스팸일 확률
    """
    # 정상 메일의 사전 확률 P(Ham) = 1 - P(Spam)
    prob_ham = 1.0 - prob_spam
    
    # 전체 메일에서 그 단어의 출현 확률 P(Word) = P(Word|Spam)P(Spam) + P(Word|Ham)P(Ham)
    # 이는 전체 확률의 법칙에 따름
    prob_word = (prob_word_given_spam * prob_spam) + (prob_word_given_ham * prob_ham)
    
    # 베이즈 정리 P(Spam|Word) = P(Word|Spam) * P(Spam) / P(Word)
    if prob_word == 0:
        return 0.0 # 0으로 나누기 방지
        
    prob_spam_given_word = (prob_word_given_spam * prob_spam) / prob_word
    return prob_spam_given_word

# 예: '당첨'이라는 단어의 확률
# 과거 데이터: 전체 메일의 20%가 스팸
p_spam = 0.2
# 스팸의 80%에 '당첨'이 포함됨
p_win_given_spam = 0.8
# 정상 메일의 1%에 '당첨'이 포함됨
p_win_given_ham = 0.01

result = calculate_spam_probability(p_spam, p_win_given_spam, p_win_given_ham)
print(f"'당첨'이 포함된 메일이 스팸일 확률: {result:.2%}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import math
from collections import Counter

def calculate_entropy(data):
    """
    주어진 데이터 세트(문자열이나 리스트)의 섀넌 엔트로피를 계산한다.
    """
    if not data:
        return 0.0
        
    # 각 요소의 출현 횟수를 카운트
    counts = Counter(data)
    total_len = len(data)
    
    entropy = 0.0
    for element, count in counts.items():
        # 출현 확률 P(x_i)
        probability = count / total_len
        
        # - P(x_i) * log2(P(x_i))
        entropy -= probability * math.log2(probability)
        
    return entropy

# 테스트
# 모두 같은 문자인 경우, 불확실성은 0
data_deterministic = "AAAAAAAAAA" 
# 무작위 문자인 경우, 불확실성이 높음
data_random = "ABACBCBACB"

print(f"Entropy of '{data_deterministic}': {calculate_entropy(data_deterministic)}")
print(f"Entropy of '{data_random}': {calculate_entropy(data_random)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import cmath

def fft(x):
    """
    1차원 고속 푸리에 변환(FFT)을 계산한다 (Cooley-Tukey 방법).
    입력 리스트의 길이 N은 2의 거듭제곱이어야 한다.
    """
    N = len(x)
    
    # 베이스 케이스
    if N <= 1:
        return x
        
    # 짝수 번째와 홀수 번째 요소로 분할 (Divide)
    even = fft(x[0::2])
    odd = fft(x[1::2])
    
    # 결과를 결합 (Conquer)
    T = [cmath.exp(-2j * cmath.pi * k / N) * odd[k] for k in range(N // 2)]
    
    # 대칭성을 이용하여 계산량 감소
    return [even[k] + T[k] for k in range(N // 2)] + \
           [even[k] - T[k] for k in range(N // 2)]

# 테스트: 단순한 신호
signal = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
spectrum = fft(signal)

print("Frequency Spectrum (Magnitude):")
for k, val in enumerate(spectrum):
    # 절댓값(진폭)을 계산
    print(f"Freq {k}: {abs(val):.3f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import math

def haversine_distance(lat1, lon1, lat2, lon2):
    """
    하버사인 공식을 사용하여 두 점 사이의 대원 거리를 계산한다.
    """
    # 지구의 평균 반지름 (킬로미터)
    R = 6371.0 
    
    # 위도·경도를 도수법에서 라디안으로 변환
    phi1, phi2 = math.radians(lat1), math.radians(lat2)
    delta_phi = math.radians(lat2 - lat1)
    delta_lambda = math.radians(lon2 - lon1)
    
    # 하버사인 계산
    a = math.sin(delta_phi / 2.0)**2 + \
        math.cos(phi1) * math.cos(phi2) * \
        math.sin(delta_lambda / 2.0)**2
        
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    
    # 거리 산출
    distance = R * c
    return distance

# 도쿄 타워 (35.6586, 139.7454)에서 자유의 여신상 (40.6892, -74.0445)까지의 거리
tokyo = (35.6586, 139.7454)
ny = (40.6892, -74.0445)

dist = haversine_distance(tokyo[0], tokyo[1], ny[0], ny[1])
print(f"도쿄 타워에서 자유의 여신상까지의 거리: 약 {dist:.2f} km")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
#include <cmath>

double newton_sqrt(double N, double tolerance = 1e-7) {
    if (N < 0) return NAN; // 음수의 제곱근은 NaN
    if (N == 0) return 0;
    
    // 초기 추정값 (N 자신부터 시작)
    double x = N; 
    
    while (true) {
        // 다음 추정값을 계산: x_new = x - (x^2 - N) / (2x) = (x + N/x) / 2
        double x_new = 0.5 * (x + N / x);
        
        // 변화량이 허용 오차 (tolerance) 미만이면 수렴한 것으로 간주
        if (std::abs(x - x_new) < tolerance) {
            break;
        }
        x = x_new;
    }
    
    return x;
}

int main() {
    double number = 612.0;
    std::cout << "Square root of " << number << " is: " << newton_sqrt(number) << "\n";
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

def cubic_bezier(p0, p1, p2, p3, steps=10):
    """
    3차 베지에 곡선 상의 좌표 리스트를 생성한다.
    p0, p1, p2, p3 는 (x, y) 튜플이다.
    steps 는 곡선을 몇 개의 선분으로 분할할지 결정한다.
    """
    curve_points = []
    
    for i in range(steps + 1):
        # 매개변수 t 는 0.0 에서 1.0 사이를 변화
        t = i / steps
        
        # 식을 구성하는 계수 계산
        u = 1 - t
        tt = t * t
        uu = u * u
        uuu = uu * u
        ttt = tt * t
        
        # x좌표와 y좌표를 각각의 점에 대해 계산
        x = (uuu * p0[0]) + \
            (3 * uu * t * p1[0]) + \
            (3 * u * tt * p2[0]) + \
            (ttt * p3[0])
            
        y = (uuu * p0[1]) + \
            (3 * uu * t * p1[1]) + \
            (3 * u * tt * p2[1]) + \
            (ttt * p3[1])
            
        curve_points.append((x, y))
        
    return curve_points

# 시작점, 제어점1, 제어점2, 끝점
p0 = (0, 0)
p1 = (5, 10)
p2 = (15, 10)
p3 = (20, 0)

points = cubic_bezier(p0, p1, p2, p3, steps=5)
for i, pt in enumerate(points):
    print(f"t={i/5:.1f} -> Point({pt[0]:.2f}, {pt[1]:.2f})")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import math

def sigmoid(x):
    """단일 값에 대한 시그모이드 계산"""
    # math.exp(-x) 가 오버플로되는 것을 방지하기 위해 입력값을 제한하는 경우가 많음
    # 간략화를 위한 표준적인 구현
    if x >= 0:
        return 1.0 / (1.0 + math.exp(-x))
    else:
        # x가 음수의 큰 값일 때의 오버플로 대책
        return math.exp(x) / (1.0 + math.exp(x))

def apply_sigmoid(array):
    """배열 내의 모든 요소에 시그모이드 함수를 적용한다"""
    return [sigmoid(x) for x in array]

# 신경망 출력층의 원시 데이터 (로짓)
logits = [-5.0, -1.0, 0.0, 1.0, 5.0]
probabilities = apply_sigmoid(logits)

for val, prob in zip(logits, probabilities):
    print(f"Input: {val:4.1f} -> Probability: {prob:.4f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
#include <cmath>

struct Circle {
    double x, y; // 중심 좌표
    double radius; // 반지름
};

// 두 원이 충돌했는지 판정하는 함수
bool isColliding(const Circle& a, const Circle& b) {
    // x좌표와 y좌표의 차이 (델타)
    double dx = b.x - a.x;
    double dy = b.y - a.y;
    
    // 거리의 '제곱'을 계산한다
    double distanceSquared = (dx * dx) + (dy * dy);
    
    // 반지름 합의 '제곱'을 계산한다
    double radiiSum = a.radius + b.radius;
    double radiiSumSquared = radiiSum * radiiSum;
    
    // 거리의 제곱과 반지름 합의 제곱을 비교한다
    return distanceSquared <= radiiSumSquared;
}

int main() {
    Circle player = {0.0, 0.0, 5.0};
    Circle enemy1 = {8.0, 0.0, 4.0}; // 거리 8, 반지름 합 9 -> 충돌
    Circle enemy2 = {10.0, 10.0, 2.0}; // 거리 약 14.1, 반지름 합 7 -> 충돌 안 함
    
    std::cout << "Collision with enemy1: " << (isColliding(player, enemy1) ? "Yes" : "No") << "\n";
    std::cout << "Collision with enemy2: " << (isColliding(player, enemy2) ? "Yes" : "No") << "\n";
    
    return 0;
}