三角函数基础

import random
import unittest
import numpy as np
import sympy as sy
class SinXFeaturesTestCase(unittest.TestCase):
    def test_periodicity(self):
        """
        周期性：以 2π 为一个周期，Repeats every 2π
        """
        x = random.randint(-100000 , 10000)
        self.assertEqual(sy.sin(x + 2 * sy.pi) , sy.sin(x))
        self.assertEqual(sy.sin(x - 2 * sy.pi) , sy.sin(x))
        self.assertNotEqual(sy.sin(x + sy.pi) , sy.sin(x))
        self.assertNotEqual(sy.sin(x - sy.pi) , sy.sin(x))
    
    def test_parity(self):
        """
        奇偶性（Odd/Even Nature）：sin(x) = -sin(-x), sin(x) + sin(-x) == 0
        sin(x) 是奇函数(Odd Function)
        关于原点对称（Symmetric about the origin）
        在 x=0 处为奇对称（Odd symmetry at x=0）
        """
        x = random.randint(0 , int(10000 * sy.pi))
        self.assertEqual(sy.sin(x) , -sy.sin(0 - x))
        self.assertEqual(sy.sin(x) + sy.sin(0 - x) , 0)
    
    def test_boundedness(self):
        """
        有界性：正弦函数的值域为[-1, 1]，即 |sin(x)| ≤ 1
        The range of sine is bounded between -1 and 1, i.e., |sin(x)| ≤ 1.
        """
        for _ in range(1000):
            x = random.randint(0 , int(10000 * sy.pi))
            self.assertTrue(sy.sin(x) <= 1)
            self.assertTrue(sy.sin(x) >= -1)
    
    def test_monotonicity(self):
        """
        单调性：在区间 [-π/2, π/2] 上单调递增，[π/2, 3π/2] 上单调递减
        It is increasing on [-π/2, π/2] and decreasing on [π/2, 3π/2].
        """
        r = random.randint(-100000 , 100000)
        # 确保随机数 r 一定是偶数，因为 sin(x) 一定是以 2π 为周期的
        if r % 2 != 0:
            r = r + 1
        # 单调递增
        data_1 = np.linspace(0 - sy.pi / 2 + r * sy.pi , sy.pi / 2 + r * sy.pi , 100)
        for i in range(len(data_1)):
            if i < len(data_1) - 1:
                self.assertTrue(sy.sin(data_1[ i ]) < sy.sin(data_1[ i + 1 ]))
        # 单调递减
        data_2 = np.linspace(sy.pi / 2 + r * sy.pi , 3 * sy.pi / 2 + r * sy.pi , 1000)
        for i in range(len(data_2)):
            if i < len(data_2) - 1:
                self.assertTrue(sy.sin(data_2[ i ]) > sy.sin(data_2[ i + 1 ]))
    
    def test_zeros(self):
        """
        零点值：当x = kπ（k为整数）时，sin(x) = 0
        sin(x) = 0 at x = kπ, where k is any integer.
        """
        self.assertEqual(sy.sin(0) , 0)
        r = random.randint(-100000 , 100000)
        self.assertTrue(sy.sin(r * sy.pi) == 0)
    
    def test_extrema(self):
        """
        极值点：sin(x)在x = (2k+1)π/2处取得极值±1
        It attains maxima ±1 at x = (2k+1)π/2.
        当x=π/2 +2πk，其中k为任意整数时，sin(x)=1；
        当x=3π/2 +2πk，其中k为任意整数时，sin(x)=-1。
        """
        r = random.randint(-100000 , 100000)
        self.assertTrue(sy.sin(2 * r * sy.pi + sy.pi / 2) == 1)
        self.assertTrue(sy.sin(2 * r * sy.pi + 3 * sy.pi / 2) == -1)
    
    def test_sine_wave(self):
        """
        For Asin(Bx+C)+D:
            A sine wave with amplitude A, period 2π/B,  a phase shift of -C/B, and a vertical shift of D
        Amplitude: Vertical stretch/compression (peak value).
        Period: Horizontal stretch/compression (cycle length).
        Phase Shift: Horizontal translation (left/right shift).
        Vertical Shift: Vertical translation (up/down shift)
        
        Example for 3sin(2x−π)+4:
            Amplitude: 3.
            Period: 2π/2=π
            Phase Shift: −(-π)/2 = π/2
            Vertical Shift: 4, midline at y=4.
        
        ∣A∣ 决定波峰高度和波谷深度。若 A>0，波形向上；若 A<0，波形向下翻转，但振幅不变
        B 控制水平缩放：∣B∣>1：波形压缩，周期缩短；∣B∣<1：波形拉伸，周期延长
        相位位移=-B/C：若结果为正，波形向左平移；若结果为负，波形向右平移
        中线位置=y=D：所有点的纵坐标增加 D，波形整体上移或下移
        极大值点（波峰）：y=D+|A|, x=(π/2+2nπ-C)/B
        极小值点（波谷）：y=D-|A|, x=(3π/2+2nπ-C)/B
        极值点间的水平间距为半个周期：π/B
        零点存在的条件：
            方程 Asin(Bx+C)+D=0 可化简为：sin(Bx+C)=-D/A
            由于正弦函数的值域为 [−1,1]，因此方程有解的条件为：
                |-D/A| <= 1
            若 ∣D∣>∣A∣：无解，函数图像完全在 y=0 的上方或下方，无零点
            若 ∣D∣≤∣A∣：方程有解，零点存在：
                Bx+C=arcsin(-D/A)+2nπ
                    => x=(arcsin(-D/A)+2nπ-C)/B
                或
                Bx+C=π-arcsin(-D/A)+2nπ
                    => x=(π-arcsin(-D/A)+2nπ-C)/B
        """
        A = random.randint(2 , 10)
        D = random.randint(2 , A)
        B = random.randint(2 , 10)
        C = random.randint(2 , 10)
        random_n = random.randint(1 , 10)
        assert D <= A , f'D={D} > A={A}， 方程{A}sin({B}x+{C})+{D}无解'
        print(f'方程式为：{A}sin({B}x+{C})+{D}, D<=A: {D <= A}, random_n={random_n}')
        # 极大值点: y = D + | A | , x = (π / 2 + 2nπ-C) / B
        x = (sy.pi / 2 + 2 * random_n * sy.pi - C) / B
        self.assertAlmostEqual(A * sy.sin(B * x + C) + D , D + A , delta = 1e-10)
        # 极小值点: y=D-|A|, x=(3π/2+2nπ-C)/B
        x = (3 * sy.pi / 2 + 2 * random_n * sy.pi - C) / B
        self.assertAlmostEqual(A * sy.sin(B * x + C) + D , D - A , delta = 1e-10)
        # 零点值（这里需要注意误差问题）
        # 科学计数法中的 e→代表 10 的幂次(例如：1e−5=10^−5)
        # 自然常数 e→是一个固定数值≈2.71828(例如：e^2≈7.389)
        # delta 直接比较绝对误差，不会放大浮点误差的问题
        # x=(arcsin(-D/A)+2nπ-C)/B
        x = (sy.asin((0 - D) / A) + 2 * sy.pi * random_n - C) / B
        self.assertAlmostEqual(A * sy.sin(B * x + C) + D , 0 , delta = 1e-10)
        # x=(π-arcsin(-D/A)+2nπ-C)/B
        x = (sy.pi - sy.asin((0 - D) / A) + 2 * sy.pi * random_n - C) / B
        self.assertAlmostEqual(A * sy.sin(B * x + C) + D , 0 , delta = 1e-10)
        # 无论 x 如何取值，y 的取值区间总是在[D-A, D+A]之间
        for x in np.linspace(sy.pi , B * sy.pi , 1000):
            self.assertTrue(A * sy.sin(B * x + C) + D <= D + A)
            self.assertTrue(A * sy.sin(B * x + C) + D >= D - A)

import matplotlib.pyplot as plt
import numpy as np

# ==================== 1. 数据生成 ====================
# 生成 x 轴数据（示例：从 0 到 2π，均匀取 200 个点）
x_begin = -2 * np.pi
x_end = 2 * np.pi
numbers_count = 1000
y_begin = -1.1
y_end = 4.1
title = 'Sin(x)'
curve_name = 'sin(x)'
x_label = 'x-axis'
y_label = 'y-axis'
x = np.linspace(x_begin , x_end , numbers_count)

# 生成多个 y 函数（可根据需要添加/修改）
# 同时定义每个函数曲线的绘图风格
y_functions = {
    curve_name:    {
        'data': np.sin(x) ,
        'style':{ 'color':'blue' , 'linestyle':'-' , 'linewidth':1 } ,
        } ,
    '2sin(3x+6)+2':{
        # y：[0, 4]
        'data': 2 * np.sin(3 * x + 6) + 2 ,
        'style':{ 'color':'red' , 'linestyle':'-' , 'linewidth':1 } ,
        } ,
    }

# ==================== 2. 创建画布和坐标系 ====================
# 参数说明:
# fig-size: (宽, 高) 英寸
# dpi: 分辨率
fig , ax = plt.subplots(figsize = (10 , 6) , dpi = 100)

# ==================== 3. 绘制多条曲线 ====================
# 循环绘制所有曲线
for curve_func in y_functions:
    label = curve_func
    y = y_functions[ curve_func ][ 'data' ]
    style = y_functions[ curve_func ][ 'style' ]
    ax.plot(x , y ,
            label = label ,  # 图例标签
            **style ,  # 解包样式字典
            )

# ==================== 4. 添加图表元素 ====================
ax.legend(loc = 'upper right')  # 显示图例
ax.set_title(title , fontsize = 14 , pad = 20)  # 标题
ax.set_xlabel(x_label , fontsize = 12)  # x轴标签
ax.set_ylabel(y_label , fontsize = 12)  # y轴标签

# ==================== 5. 自定义样式 ====================
ax.grid(True , linestyle = '--' , alpha = 0.6)  # 显示网格线
ax.set_xlim(x_begin , x_end)  # 设置x轴范围
ax.set_ylim(y_begin , y_end)  # 设置y轴范围
ax.tick_params(axis = 'both' , labelsize = 10)  # 刻度标签大小

# ==================== 6. 显示/保存 ====================
plt.tight_layout()  # 自动调整子图间距
plt.show()

import random
import unittest
import numpy as np
import sympy as sy
class CosXFeaturesTestCase(unittest.TestCase):
    def test_periodicity(self):
        """
        周期性：以 2π 为一个周期，Repeats every 2π
        """
        x = random.randint(-100000 , 10000)
        # 加减完整周期后函数值应保持不变
        self.assertEqual(sy.cos(x + 2 * sy.pi) , sy.cos(x))
        self.assertEqual(sy.cos(x - 2 * sy.pi) , sy.cos(x))
        # 加减半周期（π）后函数值应为相反数，不等于原值
        self.assertNotEqual(sy.cos(x + sy.pi) , sy.cos(x))
        self.assertNotEqual(sy.cos(x - sy.pi) , sy.cos(x))
    
    def test_parity(self):
        """
        奇偶性（Odd/Even Nature）：cos(x) = cos(-x)，是偶函数
        关于Y轴对称（Symmetric about the y-axis）
        在 x=0 处为偶对称（Even symmetry at x=0）
        """
        x = random.randint(0 , int(10000 * sy.pi))
        # 验证偶函数性质
        self.assertEqual(sy.cos(x) , sy.cos(-x))
        # 两者的差应为0
        self.assertEqual(sy.cos(x) - sy.cos(-x) , 0)
    
    def test_boundedness(self):
        """
        有界性：余弦函数的值域为[-1, 1]，即 |cos(x)| ≤ 1
        The range of cosine is bounded between -1 and 1, i.e., |cos(x)| ≤ 1.
        """
        for _ in range(1000):
            x = random.randint(0 , int(10000 * sy.pi))
            self.assertTrue(sy.cos(x) <= 1)
            self.assertTrue(sy.cos(x) >= -1)
    
    def test_monotonicity(self):
        """
        单调性：在区间 [0, π] 上单调递减，[π, 2π] 上单调递增
        Decreasing on [0, π], increasing on [π, 2π].
        """
        r = random.randint(-100000 , 100000)
        # 生成2π整数倍的基准点，确保区间正确
        base = r * 2 * sy.pi
        # 单调递减区间 [0 + base, π + base]
        data_dec = np.linspace(base , base + sy.pi , 100)
        for i in range(len(data_dec) - 1):
            self.assertTrue(sy.cos(data_dec[ i ]) > sy.cos(data_dec[ i + 1 ]))
        # 单调递增区间 [π + base, 2π + base]
        data_inc = np.linspace(base + sy.pi , base + 2 * sy.pi , 100)
        for i in range(len(data_inc) - 1):
            self.assertTrue(sy.cos(data_inc[ i ]) < sy.cos(data_inc[ i + 1 ]))
    
    def test_zeros(self):
        """
        零点值：当x = π/2 + kπ（k为整数）时，cos(x) = 0
        cos(x) = 0 at x = π/2 + kπ, where k is any integer.
        """
        # 验证k=0时零点
        self.assertEqual(sy.cos(sy.pi / 2) , 0)
        # 随机整数k测试
        k = random.randint(-100000 , 100000)
        self.assertEqual(sy.cos(k * sy.pi + sy.pi / 2) , 0)
    
    def test_extrema(self):
        """
        极值点：cos(x)在x = 2kπ处取得极大值1，在x = (2k+1)π处取得极小值-1
        Maxima 1 at x = 2kπ, minima -1 at x = (2k+1)π.
        """
        k = random.randint(-100000 , 100000)
        # 极大值点测试
        self.assertEqual(sy.cos(2 * k * sy.pi) , 1)
        # 极小值点测试
        self.assertEqual(sy.cos((2 * k + 1) * sy.pi) , -1)
    
    def test_cosine_wave(self):
        """
        For Acos(Bx+C)+D:
            A cosine wave with amplitude |A|, period 2π/B,
            phase shift of -C/B, and vertical shift D.
        Amplitude: Vertical stretch/compression (peak value).
        Period: Horizontal stretch/compression (cycle length).
        Phase Shift: Horizontal translation (shift along x-axis).
        Vertical Shift: Vertical translation (shift along y-axis).

        Example for 3cos(2x−π)+4:
            Amplitude: 3.
            Period: 2π/2 = π.
            Phase Shift: π/2 (solved as -(-π)/2).
            Vertical Shift: 4 (midline y=4).

        Key Points:
        - Maxima: y = D + |A| at x = (2kπ - C)/B
        - Minima: y = D - |A| at x = ((2k+1)π - C)/B
        - Zeros exist when |D| ≤ |A|, solved from Acos(Bx+C)+D = 0
        """
        A = random.randint(2 , 10)
        D = random.randint(2 , A)  # Ensure |D| ≤ A for zero existence
        B = random.randint(2 , 10)
        C = random.randint(2 , 10)
        n = random.randint(1 , 10)
        print(f'Testing wave: {A}cos({B}x+{C})+{D}')
        
        # 极大值点验证
        x_max = (2 * n * sy.pi - C) / B
        self.assertAlmostEqual(A * sy.cos(B * x_max + C) + D , D + A , delta = 1e-10)
        
        # 极小值点验证
        x_min = ((2 * n + 1) * sy.pi - C) / B
        self.assertAlmostEqual(A * sy.cos(B * x_min + C) + D , D - A , delta = 1e-10)
        
        # 零点存在条件 |D| ≤ |A|
        if D <= A:
            # 零点解1: Bx + C = arccos(-D/A) + 2kπ
            x_zero1 = (sy.acos(-D / A) + 2 * n * sy.pi - C) / B
            self.assertAlmostEqual(A * sy.cos(B * x_zero1 + C) + D , 0 , delta = 1e-10)
            # 零点解2: Bx + C = -arccos(-D/A) + 2kπ
            x_zero2 = (-sy.acos(-D / A) + 2 * n * sy.pi - C) / B
            self.assertAlmostEqual(A * sy.cos(B * x_zero2 + C) + D , 0 , delta = 1e-10)
        
        # 值域边界验证
        for x in np.linspace(0 , 10 * sy.pi , 1000):
            y = A * sy.cos(B * x + C) + D
            self.assertTrue(y <= D + A)
            self.assertTrue(y >= D - A)

import matplotlib.pyplot as plt
import numpy as np

# ==================== 1. 数据生成 ====================
# 生成 x 轴数据（示例：从 0 到 2π，均匀取 200 个点）
x_begin = -2 * np.pi
x_end = 2 * np.pi
numbers_count = 1000
y_begin = -1.1
y_end = 4.1
title = 'Cos(x)'
curve_name = 'cos(x)'
x_label = 'x-axis'
y_label = 'y-axis'
x = np.linspace(x_begin , x_end , numbers_count)

# 生成多个 y 函数（可根据需要添加/修改）
# 同时定义每个函数曲线的绘图风格
y_functions = {
    curve_name:    {
        'data': np.cos(x) ,
        'style':{ 'color':'blue' , 'linestyle':'-' , 'linewidth':1 } ,
        } ,
    '2cos(3x+6)+2':{
        'data': 2 * np.cos(3 * x + 6) + 2 ,
        'style':{ 'color':'red' , 'linestyle':'-' , 'linewidth':1 } ,
        } ,
    }

# ==================== 2. 创建画布和坐标系 ====================
# 参数说明:
# fig-size: (宽, 高) 英寸
# dpi: 分辨率
fig , ax = plt.subplots(figsize = (10 , 6) , dpi = 100)

# ==================== 3. 绘制多条曲线 ====================
# 循环绘制所有曲线
for curve_func in y_functions:
    label = curve_func
    y = y_functions[ curve_func ][ 'data' ]
    style = y_functions[ curve_func ][ 'style' ]
    ax.plot(x , y ,
            label = label ,  # 图例标签
            **style ,  # 解包样式字典
            )

# ==================== 4. 添加图表元素 ====================
ax.legend(loc = 'upper right')  # 显示图例
ax.set_title(title , fontsize = 14 , pad = 20)  # 标题
ax.set_xlabel(x_label , fontsize = 12)  # x轴标签
ax.set_ylabel(y_label , fontsize = 12)  # y轴标签

# ==================== 5. 自定义样式 ====================
ax.grid(True , linestyle = '--' , alpha = 0.6)  # 显示网格线
ax.set_xlim(x_begin , x_end)  # 设置x轴范围
ax.set_ylim(y_begin , y_end)  # 设置y轴范围
ax.tick_params(axis = 'both' , labelsize = 10)  # 刻度标签大小

# ==================== 6. 显示/保存 ====================
plt.tight_layout()  # 自动调整子图间距
plt.show()

import random
import unittest
import numpy as np
import sympy as sy
class TanXFeaturesTestCase(unittest.TestCase):
    def test_periodicity(self):
        """
        周期性：以 π 为一个周期，Repeats every π
        tan(x + π) = tan(x), tan(x - π) = tan(x)
        半周期特性：tan(k * π/2) 无定义（垂直渐近线）
        """
        x = random.randint(-1000 , 1000)  # 避开奇点
        # 完整周期验证
        self.assertEqual(sy.tan(x + sy.pi) , sy.tan(x))
        self.assertEqual(sy.tan(x - sy.pi) , sy.tan(x))
        k = random.randint(-1000 , 1000)
        self.assertEqual(sy.tan(k * sy.pi) , 0)
        # 半周期行为（导致函数无定义）
        
        if k % 2 == 0:
            k = k + 1
        self.assertEqual(sy.tan(k * sy.pi / 2) , sy.zoo)
    
    def test_parity(self):
        """
        奇偶性（Odd/Even Nature）：tan(-x) = -tan(x)，是奇函数
        关于原点对称（Symmetric about the origin）
        """
        x = random.uniform(-10 * sy.pi , 10 * sy.pi)
        # 验证奇函数性质
        self.assertEqual(sy.tan(-x) , -sy.tan(x))
        self.assertEqual(sy.tan(x) + sy.tan(-x) , 0)
    
    def test_unboundedness(self):
        """
        无界性：正切函数在渐近线附近趋近±∞
        验证在接近 π/2 +kπ 时绝对值大于1e6（模拟无界）
        """
        k = random.randint(-100 , 100)
        if k % 2 == 0:
            k = k + 1
        asymptote = k * sy.pi / 2  # 渐近线位置
        # 从左侧逼近渐近线（趋近+∞）
        x_left = asymptote - 1e-6
        self.assertAlmostEqual(sy.tan(asymptote) - sy.tan(x_left) , sy.zoo , delta = 1e-10)
        # 从右侧逼近渐近线（趋近-∞）
        x_right = asymptote + 1e-6
        self.assertAlmostEqual(sy.tan(asymptote) - sy.tan(x_right) , sy.zoo , delta = 1e-10)
    
    def test_monotonicity(self):
        """
        单调性：在区间 (-π/2, π/2) 内严格单调递增
        验证相邻点的增长性（避开渐近线）
        """
        base = random.randint(-100 , 100) * sy.pi  # 选择周期基准点
        # 生成严格在 (-π/2 + base, π/2 + base) 内的测试点
        start = base - sy.pi / 2 + 0.1  # 左边界+0.1防溢出
        end = base + sy.pi / 2 - 0.1  # 右边界-0.1防溢出
        test_points = np.linspace(start , end , 100)
        for i in range(len(test_points) - 1):
            self.assertLess(sy.tan(test_points[ i ]) , sy.tan(test_points[ i + 1 ]))
    
    def test_zeros(self):
        """
        零点值：当x = kπ（k为整数）时，tan(x) = 0
        """
        self.assertEqual(sy.tan(0) , 0)
        k = random.randint(-1000 , 1000)
        self.assertEqual(sy.tan(k * sy.pi).expand() , 0)
    
    def test_tangent_wave(self):
        """
        波形变换测试：Atan(Bx + C) + D
        验证相位位移、垂直平移、周期变化等特性
        - 周期：π/B
        - 垂直平移：中线从y=0变为y=D
        - 零点位移：函数值为的位置，即解方程 A⋅tan(Bx+C)+D=0, x=(arctan((0-D)/A))+k*π-C)/B
                   如果 D=0，则x=(k*π-C)/B
        """
        A = random.randint(1 , 10)  # 振幅（影响陡峭度）
        B = random.randint(1 , 10)  # 周期参数
        C = random.randint(1 , 10)  # 相位位移参数
        D = random.randint(1 , 10)  # 垂直平移
        n = random.randint(-10 , 10)  # 随机周期数
        
        # 周期验证（周期应为π/|B|）
        x = random.randint(-10 , 10)
        self.assertAlmostEqual(
                A * sy.tan(B * (x + sy.pi / B) + C) + D ,
                A * sy.tan(B * x + C + sy.pi) + D ,
                delta = 1e-10 ,
                )
        
        # 垂直平移验证
        # 当 Bx+C=kπ 时，tan(Bx+C)=0，此时函数值应等于 D，x = (k*π - C)/B
        x_zero = (n * sy.pi - C) / B  # 零点位置
        self.assertAlmostEqual(
                A * sy.tan(B * x_zero + C) + D ,
                D ,  # 零点处应等于垂直平移值
                delta = 1e-10 ,
                )
        
        # 相位位移验证（-C/B）
        # 当 x=−C/B 时，Bx+C=0，此时 tan(0)=0，函数值应等于 D
        x_shifted = -C / B  # 相位位移后的零点
        self.assertAlmostEqual(
                A * sy.tan(B * x_shifted + C) + D ,
                D ,  # tan(0)=0
                delta = 1e-10 ,
                )
        
        # 渐近线位置验证
        # 当 x = (π / 2 - C) / B 时，Bx+C=π/2，此时 tan(π/2) 为无穷
        asymptote = (sy.pi / 2 - C) / B  # 理论渐近线位置
        self.assertAlmostEqual(sy.tan(sy.pi / 2) , A * sy.tan(B * asymptote + C) + D , delta = 1e-10)

import matplotlib.pyplot as plt
import numpy as np

# ==================== 1. 数据生成 ====================
# 生成 x 轴数据（示例：从 0 到 2π，均匀取 200 个点）
x_begin = -2 * np.pi
x_end = 2 * np.pi
numbers_count = 1000
y_begin = -100
y_end = 100
title = 'Tan(x)'
curve_name = 'tan(x)'
x_label = 'x-axis'
y_label = 'y-axis'
x = np.linspace(x_begin , x_end , numbers_count)

# 生成多个 y 函数（可根据需要添加/修改）
# 同时定义每个函数曲线的绘图风格
y_functions = {
    curve_name:    {
        'data': np.tan(x) ,
        'style':{ 'color':'blue' , 'linestyle':'-' , 'linewidth':1 } ,
        } ,
    '2tan(2x+1)+1':{
        'data': 2 * np.tan(2 * x + 1) + 1 ,
        'style':{ 'color':'red' , 'linestyle':'-' , 'linewidth':1 } ,
        } ,
    }

# ==================== 2. 创建画布和坐标系 ====================
# 参数说明:
# fig-size: (宽, 高) 英寸
# dpi: 分辨率
fig , ax = plt.subplots(figsize = (10 , 6) , dpi = 100)

# ==================== 3. 绘制多条曲线 ====================
# 循环绘制所有曲线
for curve_func in y_functions:
    label = curve_func
    y = y_functions[ curve_func ][ 'data' ]
    style = y_functions[ curve_func ][ 'style' ]
    ax.plot(x , y ,
            label = label ,  # 图例标签
            **style ,  # 解包样式字典
            )

# ==================== 4. 添加图表元素 ====================
ax.legend(loc = 'upper right')  # 显示图例
ax.set_title(title , fontsize = 14 , pad = 20)  # 标题
ax.set_xlabel(x_label , fontsize = 12)  # x轴标签
ax.set_ylabel(y_label , fontsize = 12)  # y轴标签

# ==================== 5. 自定义样式 ====================
ax.grid(True , linestyle = '--' , alpha = 0.6)  # 显示网格线
ax.set_xlim(x_begin , x_end)  # 设置x轴范围
ax.set_ylim(y_begin , y_end)  # 设置y轴范围
ax.tick_params(axis = 'both' , labelsize = 10)  # 刻度标签大小

# ==================== 6. 显示/保存 ====================
plt.tight_layout()  # 自动调整子图间距
plt.show()

import random
import unittest
import numpy as np
import sympy as sy
from sympy import sqrt
class TrigonometricIdentitiesTestCase(unittest.TestCase):
    """
    三角恒等式
    """
    
    def test_fundamental_identities(self):
        """
        基本恒等式：
            倒数关系（Reciprocal Identities）：
                csc(x) = 1/sin(x)
                sec(x) = 1/cos(x)
                cot(x) = 1/tan(x)
            商数关系 (Quotient Identities)：
                tan(x) = sin(x)/cos(x)
                cot(x) = cos(x)/sin(x)
        """
        x = random.randint(-100 , 100)
        self.assertAlmostEqual(sy.csc(x) , 1 / sy.sin(x) , delta = 1e-10)
        self.assertAlmostEqual(sy.sec(x) , 1 / sy.cos(x) , delta = 1e-10)
        self.assertAlmostEqual(sy.cot(x) , 1 / sy.tan(x) , delta = 1e-10)
        self.assertAlmostEqual(sy.tan(x) , sy.sin(x) / sy.cos(x) , delta = 1e-10)
        self.assertAlmostEqual(sy.cot(x) , sy.cos(x) / sy.sin(x) , delta = 1e-10)
    
    def test_pythagorean_identities(self):
        """
        毕达哥拉斯恒等式
        sin(x)^2 + cos(x)^2 = 1
        1 + tan(x)^2 = sec(x)^2
        1 + cot(x)^2 = csc(x)^2
        """
        x = random.randint(-100 , 100)
        self.assertAlmostEqual((sy.sin(x)) ** 2 + (sy.cos(x)) ** 2 , 1 , delta = 1e-10)
        self.assertAlmostEqual(1 + (sy.tan(x)) ** 2 , (sy.sec(x)) ** 2 , delta = 1e-10)
        self.assertAlmostEqual(1 + (sy.cot(x)) ** 2 , (sy.csc(x)) ** 2 , delta = 1e-10)
    
    def test_sum_and_difference_formulas(self):
        """
        和差公式：
        sin(A+B)=sin(A)cos(B)+sin(B)cos(A)
        sin(A-B)=sin(A)cos(B)-sin(B)cos(A)
        
        cos(A+B)=cos(A)cos(B)-sin(A)sin(B)
        cos(A-B)=cos(A)cos(B)+sin(A)sin(B)
        
        tan(A+B)=(tan(A)+tan(B))/(1-tan(A)tan(B))
        tan(A-B)=(tan(A)-tan(B))/(1+tan(A)tan(B))
        """
        A = random.randint(-100 , 100)
        B = random.randint(-100 , 100)
        self.assertAlmostEqual(sy.sin(A + B) , sy.sin(A) * sy.cos(B) + sy.sin(B) * sy.cos(A) , delta = 1e-10)
        self.assertAlmostEqual(sy.sin(A - B) , sy.sin(A) * sy.cos(B) - sy.sin(B) * sy.cos(A) , delta = 1e-10)
        self.assertAlmostEqual(sy.cos(A + B) , sy.cos(A) * sy.cos(B) - sy.sin(A) * sy.sin(B) , delta = 1e-10)
        self.assertAlmostEqual(sy.cos(A - B) , sy.cos(A) * sy.cos(B) + sy.sin(A) * sy.sin(B) , delta = 1e-10)
        self.assertAlmostEqual(sy.tan(A + B) , (sy.tan(A) + sy.tan(B)) / (1 - sy.tan(A) * sy.tan(B)) , delta = 1e-10)
        self.assertAlmostEqual(sy.tan(A - B) , (sy.tan(A) - sy.tan(B)) / (1 + sy.tan(A) * sy.tan(B)) , delta = 1e-10)
    
    def test_double_and_half_angle_formulas(self):
        """
        倍角公式:
        sin(2x) = 2sin(x)cos(x)
        cos(2x) = cos(x)^2 - sin(x)^2 = 2cos(x)^2-1 = 1-2sin(x)^2
        tan(2x) = 2tan(x)/(1-tan(x)^2)
        
        半角公式:
        |sin(x/2)| = sqrt((1-cos(x))/2)
        |cos(x/2)| = sqrt((1+cos(x))/2)
        |tan(x/2)| = sqrt((1-cos(x))/(1+cos(x)))=sin(x)/(1+cos(x))
        """
        x = random.randint(-100 , 100)
        
        # 倍角公式
        self.assertAlmostEqual(sy.sin(2 * x) , 2 * sy.sin(x) * sy.cos(x) , delta = 1e-10)
        self.assertAlmostEqual(sy.cos(2 * x) , sy.cos(x) ** 2 - sy.sin(x) ** 2 , delta = 1e-10)
        self.assertAlmostEqual(sy.cos(2 * x) , 1 - 2 * (sy.sin(x) ** 2) , delta = 1e-10)
        self.assertAlmostEqual(sy.tan(2 * x) , 2 * sy.tan(x) / (1 - (sy.tan(x) ** 2)) , delta = 1e-10)
        # 半角公式
        self.assertAlmostEqual(abs(sy.sin(x / 2)) , sqrt((1 - sy.cos(x)) / 2) , delta = 1e-10)
        self.assertAlmostEqual(abs(sy.cos(x / 2)) , sqrt((1 + sy.cos(x)) / 2) , delta = 1e-10)
        self.assertAlmostEqual(abs(sy.tan(x / 2)) , sqrt((1 - sy.cos(x)) / (1 + sy.cos(x))) , delta = 1e-10)
    
    def test_product_to_sum_formulas(self):
        """
        积化和差公式:
        sin(A)sin(B) = (1/2)(cos(A-B)-cos(A+B))
        cos(A)cos(B) = (1/2)(cos(A-B)+cos(A+B))
        sin(A)cos(B) = (1/2)(sin(A+B)+sin(A-B))
        """
        A = random.randint(-100 , 100)
        B = random.randint(-100 , 100)
        self.assertAlmostEqual(sy.sin(A) * sy.sin(B) , (1 / 2) * (sy.cos(A - B) - sy.cos(A + B)) , delta = 1e-10)
        self.assertAlmostEqual(sy.cos(A) * sy.cos(B) , (1 / 2) * (sy.cos(A - B) + sy.cos(A + B)) , delta = 1e-10)
        self.assertAlmostEqual(sy.sin(A) * sy.cos(B) , (1 / 2) * (sy.sin(A + B) + sy.sin(A - B)) , delta = 1e-10)