数学爱好者必看！对编程有用的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) 的元组。
    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;
}