數學愛好者必看！對程式設計有用的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>

// 為了將二維座標視為複數的型別別名
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 # 避免除以零
        
    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):
    """
    計算一維快速傅立葉變換 (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):
    """
    生成三次貝茲曲線上的座標串列。
    p0, p1, p2, p3 為 (x, y) 格式的元組 (tuple)。
    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):
    """針對單一值的 Sigmoid 計算"""
    # 為防止 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):
    """對陣列中的所有元素套用 Sigmoid 函數"""
    return [sigmoid(x) for x in array]

# 神經網路輸出層的原始資料（Logits）
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 座標的差（Delta）
    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;
}