编程中的数学知识：从逻辑到算法的基石

# 基本的布尔运算
def access_control(user_role, is_authenticated):
    # 使用布尔逻辑进行权限控制
    can_access_admin = (user_role == "admin") and is_authenticated
    can_view_content = (user_role in ["user", "admin"]) and is_authenticated
    
    return {
        "admin_panel": can_access_admin,
        "content": can_view_content
    }

# 德摩根定律的应用
def validate_input(username, email, age):
    # 原始逻辑
    is_valid = (username != "" and email != "" and age >= 18)
    
    # 使用德摩根定律的等价形式
    is_invalid = (username == "" or email == "" or age < 18)
    
    return not is_invalid  # 两种表达等价

# 使用集合操作处理数据
def analyze_user_behavior(active_users, premium_users, new_users):
    # 并集：所有涉及的用户
    all_affected_users = active_users | premium_users | new_users
    
    # 交集：既是活跃又是付费的用户
    loyal_users = active_users & premium_users
    
    # 差集：活跃但非付费用户
    active_free_users = active_users - premium_users
    
    # 对称差集：只在其中一个集合中的用户
    exclusive_users = active_users ^ premium_users
    
    return {
        "loyal_count": len(loyal_users),
        "conversion_candidates": active_free_users
    }

# 实际示例
active_users = {"user1", "user2", "user3", "user4"}
premium_users = {"user2", "user4", "user5"}
new_users = {"user6", "user7"}

result = analyze_user_behavior(active_users, premium_users, new_users)
print(result)

from collections import defaultdict, deque

class SocialNetwork:
    def __init__(self):
        self.graph = defaultdict(list)
    
    def add_friendship(self, user1, user2):
        self.graph[user1].append(user2)
        self.graph[user2].append(user1)
    
    def find_shortest_path(self, start, end):
        """使用BFS找到最短连接路径"""
        if start == end:
            return [start]
        
        visited = {start}
        queue = deque([(start, [start])])
        
        while queue:
            current, path = queue.popleft()
            
            for neighbor in self.graph[current]:
                if neighbor == end:
                    return path + [neighbor]
                
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append((neighbor, path + [neighbor]))
        
        return None  # 没有路径

# 使用示例
network = SocialNetwork()
network.add_friendship("Alice", "Bob")
network.add_friendship("Bob", "Charlie")
network.add_friendship("Charlie", "David")

path = network.find_shortest_path("Alice", "David")
print(f"最短路径: {' -> '.join(path)}")

import numpy as np

class VectorOperations:
    @staticmethod
    def cosine_similarity(vec1, vec2):
        """计算余弦相似度 - 用于推荐系统和文本相似度"""
        dot_product = np.dot(vec1, vec2)
        norm1 = np.linalg.norm(vec1)
        norm2 = np.linalg.norm(vec2)
        
        if norm1 == 0 or norm2 == 0:
            return 0
        
        return dot_product / (norm1 * norm2)
    
    @staticmethod
    def transform_coordinates(point, transformation_matrix):
        """应用矩阵变换 - 用于图形变换"""
        return np.dot(transformation_matrix, point)

# 推荐系统示例
def recommend_items(user_preferences, item_features):
    """
    user_preferences: 用户偏好向量
    item_features: 物品特征矩阵
    """
    recommendations = []
    
    for item_id, features in item_features.items():
        similarity = VectorOperations.cosine_similarity(
            user_preferences, features
        )
        recommendations.append((item_id, similarity))
    
    # 按相似度排序
    recommendations.sort(key=lambda x: x[1], reverse=True)
    return recommendations[:5]  # 返回前5个推荐

# 使用示例
user_pref = np.array([0.8, 0.2, 0.5])
items = {
    "item1": np.array([0.7, 0.3, 0.6]),
    "item2": np.array([0.9, 0.1, 0.4]),
    "item3": np.array([0.3, 0.8, 0.1])
}

top_recommendations = recommend_items(user_pref, items)
print("推荐物品:", top_recommendations)

import random
from collections import Counter
import matplotlib.pyplot as plt

class ProbabilityApplications:
    @staticmethod
    def monte_carlo_pi(num_samples=100000):
        """使用蒙特卡洛方法估算π值"""
        inside_circle = 0
        
        for _ in range(num_samples):
            x = random.uniform(-1, 1)
            y = random.uniform(-1, 1)
            
            # 检查点是否在单位圆内
            if x**2 + y**2 <= 1:
                inside_circle += 1
        
        # 面积比：π/4 = 圆内点数 / 总点数
        return 4 * inside_circle / num_samples
    
    @staticmethod
    def load_balancing(servers, requests):
        """使用随机算法进行负载均衡"""
        # 简单的随机分配
        assignments = {}
        for request in requests:
            server = random.choice(servers)
            if server not in assignments:
                assignments[server] = []
            assignments[server].append(request)
        
        return assignments

# A/B测试统计分析
def analyze_ab_test(control_group, treatment_group):
    """分析A/B测试结果"""
    control_conversion = sum(control_group) / len(control_group)
    treatment_conversion = sum(treatment_group) / len(treatment_group)
    
    # 计算提升
    lift = (treatment_conversion - control_conversion) / control_conversion
    
    # 简单的显著性检验（实际中应使用更严谨的统计检验）
    control_std = np.std(control_group)
    treatment_std = np.std(treatment_group)
    
    return {
        "control_rate": control_conversion,
        "treatment_rate": treatment_conversion,
        "lift": lift,
        "significant": abs(lift) > 0.05  # 简化判断
    }

# 使用示例
pi_estimate = ProbabilityApplications.monte_carlo_pi()
print(f"π的估计值: {pi_estimate}")

# A/B测试示例
control = [1, 0, 1, 0, 1, 0, 0, 1]  # 1表示转化
treatment = [1, 1, 0, 1, 1, 0, 1, 1]
result = analyze_ab_test(control, treatment)
print("A/B测试结果:", result)

import hashlib
import secrets

class CryptographyBasics:
    @staticmethod
    def gcd(a, b):
        """欧几里得算法 - 计算最大公约数"""
        while b != 0:
            a, b = b, a % b
        return a
    
    @staticmethod
    def modular_exponentiation(base, exponent, modulus):
        """快速模幂运算 - RSA算法基础"""
        result = 1
        base = base % modulus
        
        while exponent > 0:
            if exponent % 2 == 1:
                result = (result * base) % modulus
            exponent = exponent >> 1
            base = (base * base) % modulus
        
        return result
    
    @staticmethod
    def generate_secure_password(length=16):
        """生成加密安全的随机密码"""
        alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*"
        return ''.join(secrets.choice(alphabet) for _ in range(length))

# 简单的哈希应用
def password_hashing(password, salt=None):
    """密码哈希与加盐"""
    if salt is None:
        salt = secrets.token_hex(16)
    
    # 组合密码和盐值
    salted_password = password + salt
    
    # 计算哈希值
    hash_object = hashlib.sha256(salted_password.encode())
    hashed_password = hash_object.hexdigest()
    
    return hashed_password, salt

# 使用示例
password = "my_secure_password"
hashed, salt = password_hashing(password)
print(f"原始密码: {password}")
print(f"加盐哈希: {hashed}")
print(f"盐值: {salt}")

# 验证密码
def verify_password(input_password, stored_hash, salt):
    test_hash, _ = password_hashing(input_password, salt)
    return test_hash == stored_hash

is_valid = verify_password("my_secure_password", hashed, salt)
print(f"密码验证: {is_valid}")

class Optimization:
    @staticmethod
    def numerical_gradient(f, x, h=1e-5):
        """数值计算梯度 - 用于优化算法"""
        grad = np.zeros_like(x)
        
        for i in range(len(x)):
            x_plus = x.copy()
            x_minus = x.copy()
            
            x_plus[i] += h
            x_minus[i] -= h
            
            grad[i] = (f(x_plus) - f(x_minus)) / (2 * h)
        
        return grad
    
    @staticmethod
    def gradient_descent(f, initial_x, learning_rate=0.01, max_iter=1000):
        """梯度下降优化"""
        x = initial_x.copy()
        history = [x.copy()]
        
        for i in range(max_iter):
            grad = Optimization.numerical_gradient(f, x)
            x = x - learning_rate * grad
            history.append(x.copy())
            
            # 检查收敛
            if np.linalg.norm(grad) < 1e-6:
                break
        
        return x, history

# 示例：最小化二次函数
def quadratic_function(x):
    return x[0]**2 + 3*x[1]**2 + 2*x[0]*x[1] + 4*x[0] + 5*x[1] + 6

# 使用梯度下降找到最小值
initial_point = np.array([0.0, 0.0])
minimum, history = Optimization.gradient_descent(quadratic_function, initial_point)

print(f"函数最小值点: {minimum}")
print(f"最小值: {quadratic_function(minimum)}")