数学好き必見！プログラミングに役立つ美しい数式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 # ゼロ除算の回避
        
    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):
    """
    ハーベサインの公式を用いて2点間の大円距離を計算する。
    """
    # 地球の平均半径 (キロメートル)
    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; // 半径
};

// 2つの円が衝突しているかを判定する関数
bool isColliding(const Circle& a, const Circle& b) {
    // x座標とy座標の差（デルタ）
    double dx = b.x - a.x;
    double dy = b.y - a.y;
    
    // 距離の「2乗」を計算する
    double distanceSquared = (dx * dx) + (dy * dy);
    
    // 半径の合計の「2乗」を計算する
    double radiiSum = a.radius + b.radius;
    double radiiSumSquared = radiiSum * radiiSum;
    
    // 距離の2乗と半径の合計の2乗を比較する
    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;
}