书的作者

思维导图

使用到的函数

几何的介绍（略）

点线面和定义

等高线比较重要，应用多
曲线的切线使用极限和微积分工具来解

欧几里得几何原本的公理

正多边形

代码：如何绘制正多边形

import matplotlib.pyplot as plt
from matplotlib.patches import RegularPolygon, Circle
import numpy as np

for num_vertices in [3,4,5,6,7,8]:
    
    #创建几个子图
    fig, ax = plt.subplots()
    
    ax.set_aspect('equal')
    #使x和y的长度相同
    #规则正多边形使用。RegularPolygon创建具有指定顶点数的正六边形，并将其添加到坐标轴中。设置半径、不透明度和边缘颜色。
    hexagon_inner = RegularPolygon((0,0), numVertices=num_vertices, 
                                   radius=1, alpha=0.2, edgecolor='k')
    
    # RegularPolygon,matplotlib中还有Rectangle,Circle,Arrow等各种补丁对象
    #将补丁对象输出到对应的轴
    ax.add_patch(hexagon_inner)
    
    plt.axis('off')
    
    plt.xlim(-1.5,1.5)
    plt.ylim(-1.5,1.5)
    plt.show()

三维的几何体

柏拉图立体

几何变换

在函数变换、线性变换、多元高斯分布等话题中用到几何变换。

投影
这个概念可以进行一定的泛化。

角度和弧度

角度

弧度

正负角（相位）

三个角

勾股定理到三角函数

勾股定理

三角函数

反三角函数

余弦定理

代码：

三角函数

import math

# 输入角度（单位：度）
angle_deg = 45
# 将角度转换为弧度
angle_rad = math.radians(angle_deg)

# 计算三角函数
sin_val = math.sin(angle_rad)  # 正弦
cos_val = math.cos(angle_rad)  # 余弦
tan_val = math.tan(angle_rad)  # 正切

print(f"Sin({angle_deg}°) = {sin_val}")
print(f"Cos({angle_deg}°) = {cos_val}")
print(f"Tan({angle_deg}°) = {tan_val}")

反三角函数

# 已知正弦值
sin_val = 0.707

# 计算反三角函数
angle_rad_asin = math.asin(sin_val)  # 反正弦
angle_deg_asin = math.degrees(angle_rad_asin)  # 弧度转换为角度

print(f"Asin({sin_val}) = {angle_deg_asin}°")

使用numpy

import numpy as np

# 假设我们有一个数组表示正弦、余弦、正切值
sin_values = np.array([0.5, 0.707, 1.0])
cos_values = np.array([0.866, 0.707, 0.0])
tan_values = np.array([0.577, 1.0, np.inf])  # np.inf 表示正切值无穷大（90度）

# 反正弦
asin_values = np.degrees(np.arcsin(sin_values))  # 结果是弧度，转换为角度
print("Arcsin values (in degrees):", asin_values)

# 反余弦
acos_values = np.degrees(np.arccos(cos_values))  # 结果是弧度，转换为角度
print("Arccos values (in degrees):", acos_values)

# 反正切
atan_values = np.degrees(np.arctan(tan_values))  # 结果是弧度，转换为角度
print("Arctan values (in degrees):", atan_values)

在 numpy 中，你可以使用 numpy 模块来计算反三角函数。numpy 提供了与 math 模块类似的函数，支持数组操作和批量计算，非常适合处理大量数据。

Arcsin values (in degrees): [30.      45.00001764 90.     ]
Arccos values (in degrees): [ 30.      45.00001764  90.     ]
Arctan values (in degrees): [30.00000083 45.         90.        ]

• np.arcsin() 和 np.arccos() 的输入值必须在 [-1, 1] 之间，因为这些是正弦和余弦的值域。
• np.arctan() 没有这种限制，任何实数都可以作为输入。
• 结果默认是以弧度表示的，如果需要角度，可以使用 np.degrees() 将弧度转换为角度。

这样，你就可以使用 numpy 批量计算反三角函数，非常适合大规模数据处理。

余弦定理求边

$$c^2=a^2+b^2-2ab\cdot \cos (\theta )$$

def cosine_law(a, b, angle_deg):
    # 将角度转换为弧度
    angle_rad = math.radians(angle_deg)
    # 计算 c 的长度
    c = math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(angle_rad))
    return c

# 示例：已知 a=5, b=7, 夹角为60度，求 c
a = 5
b = 7
angle_deg = 60
c = cosine_law(a, b, angle_deg)

print(f"Using the cosine law, c = {c}")

余弦定理求角

$$\cos (\theta )=\frac{a^2+b^2-c^2}{2ab}$$

def cosine_law_angle(a, b, c):
    # 计算夹角的余弦值
    cos_theta = (a**2 + b**2 - c**2) / (2 * a * b)
    # 计算角度（弧度）
    angle_rad = math.acos(cos_theta)
    # 将弧度转换为角度
    angle_deg = math.degrees(angle_rad)
    return angle_deg

# 示例：已知 a=5, b=7, c=8，求夹角
a = 5
b = 7
c = 8
theta_deg = cosine_law_angle(a, b, c)

print(f"Angle between a and b is {theta_deg}°")

圆周率割圆术

内接和外切正多边形的圆形逼近

import matplotlib.pyplot as plt
from matplotlib.patches import RegularPolygon, Circle
import numpy as np

# 循环遍历num_vertices的值
for num_vertices in [6,8,10,12,14,16]:
    
    # 创建一个图形和坐标轴
    fig, ax = plt.subplots()
    ax.set_aspect('equal')
    
    # 创建一个内六边形，num_vertices为边数，radius为半径，alpha为透明度，edgecolor为边框颜色
    hexagon_inner = RegularPolygon((0,0), numVertices=num_vertices, 
                                   radius=1, alpha=0.2, edgecolor='k')
    #Patch是多边形对象
    ax.add_patch(hexagon_inner)
    
    # 创建一个外六边形，num_vertices为边数，radius为半径，alpha为透明度，edgecolor为边框颜色
    hexagon_outer = RegularPolygon((0,0), numVertices=num_vertices, 
                                   radius=1/np.cos(np.pi/num_vertices), 
                                   alpha=0.2, edgecolor='k')
    ax.add_patch(hexagon_outer)
    
    # 创建一个圆形，radius为半径，facecolor为填充颜色，edgecolor为边框颜色
    circle = Circle((0,0), radius=1, facecolor = 'none', edgecolor='k')
    ax.add_patch(circle)
    
    # 关闭坐标轴
    plt.axis('off')
    
    # 设置坐标轴范围
    plt.xlim(-1.5,1.5)
    plt.ylim(-1.5,1.5)
    
    # 显示图形
    plt.show()

关键代码：内切多边形和外切多边形的R怎么计算的


此处类似于三角函数的那个基础等价代换的推导和逼近。
不等式，在无穷处逼近
周长的逼近

import numpy as np
import matplotlib.pyplot as plt
#生成x
n_start = 6
n_stop  = 50
n_array = np.linspace(n_start,n_stop,n_stop-n_start + 1)
#两个估计的边界，此处直接使用向量的乘法
pi_lower_b = np.sin(np.pi/n_array)*n_array
pi_upper_b = np.tan(np.pi/n_array)*n_array

fig, ax = plt.subplots()
#平行于x的线
plt.axhline(y=np.pi, color='r', linestyle='-')
#两个曲线
plt.plot(n_array,pi_lower_b, color = 'b')
plt.plot(n_array,pi_upper_b, color = 'g')
#填充
plt.fill_between(n_array, pi_lower_b, pi_upper_b, color = '#DEEAF6')
plt.tight_layout()
plt.xlabel('Number of sides, n')
plt.ylabel('Estimate of $\pi$')

阿基米德的方法

$$tan(\alpha /2)=sin\alpha /(1+cos\alpha )=(1-cos\alpha )/sin\alpha$$
可证明下式成立

import numpy as np
import matplotlib.pyplot as plt

n_start = 6

B_6 = np.sin(np.pi/n_start)*n_start
A_6 = np.tan(np.pi/n_start)*n_start
#列表
B_array = []
A_array = []
n_array = [6,12,24,48,96]

B_i = B_6
A_i = A_6
n_i = n_start

for i in n_array:
    
    B_array.append(B_i)
    A_array.append(A_i)
    
    # updating
    A_i = 2*A_i*B_i/(A_i + B_i)
    B_i = np.sqrt(A_i*B_i)
#转换为np数组
B_array = np.array(B_array)
A_array = np.array(A_array)
n_array = np.array(n_array)

fig, ax = plt.subplots()

plt.axhline(y=np.pi, color='r', linestyle='-')
plt.plot(n_array,B_array, color = 'b', marker = 'x')
plt.plot(n_array,A_array, color = 'g', marker = 'x')
plt.fill_between(n_array, B_array, A_array, color = '#DEEAF6')
plt.tight_layout()
plt.xticks([6,12,24,48,96])
plt.xlim((6,96))
plt.xlabel('Number of sides, n')
plt.ylabel('Estimate of $\pi$')
plt.show()