在量化金融分析中，扎实的数学工具是建模和分析的基础。虽然Python生态已有NumPy、SciPy等成熟库，但深入理解这些工具背后的数学原理对量化分析师至关重要。本项目旨在让学习者通过构建自己的数学工具库，掌握量化分析中常用的数学操作原理。
通过本项目，学习者将:
project1/
├── matrix.py # 矩阵运算模块
├── calculus.py # 微积分模块
└── statistics.py # 统计分析模块学习者需要实现以下功能:
class Calculus:
"""
数值计算工具类，提供微分、积分和优化方法的实现
"""
@staticmethod
def forward_difference(func, x, h=1e-5):
"""
使用前向差分法计算函数在给定点的一阶导数
Parameters:
-----------
func : callable
要计算导数的函数
x : float
计算导数的点
h : float, optional
步长，默认为1e-5
Returns:
--------
float
函数在x点的一阶导数近似值
"""
# TODO: 实现前向差分法计算一阶导数
pass
@staticmethod
def backward_difference(func, x, h=1e-5):
"""
使用后向差分法计算函数在给定点的一阶导数
Parameters:
-----------
func : callable
要计算导数的函数
x : float
计算导数的点
h : float, optional
步长，默认为1e-5
Returns:
--------
float
函数在x点的一阶导数近似值
"""
# TODO: 实现后向差分法计算一阶导数
pass
@staticmethod
def central_difference(func, x, h=1e-5):
"""
使用中心差分法计算函数在给定点的一阶导数
Parameters:
-----------
func : callable
要计算导数的函数
x : float
计算导数的点
h : float, optional
步长，默认为1e-5
Returns:
--------
float
函数在x点的一阶导数近似值
"""
# TODO: 实现中心差分法计算一阶导数
pass
@staticmethod
def second_derivative(func, x, h=1e-5, method='central'):
"""
计算函数在给定点的二阶导数
Parameters:
-----------
func : callable
要计算导数的函数
x : float
计算导数的点
h : float, optional
步长，默认为1e-5
method : str, optional
差分方法，可选'forward', 'backward', 'central'，默认为'central'
Returns:
--------
float
函数在x点的二阶导数近似值
"""
# TODO: 实现二阶导数计算
pass
@staticmethod
def partial_derivative(func, point, variable_index, h=1e-5, method='central'):
"""
计算多变量函数在给定点的偏导数
Parameters:
-----------
func : callable
多变量函数，接受向量输入
point : list or numpy.ndarray
计算偏导数的点，如[x, y, z]
variable_index : int
对哪个变量求偏导数（0表示第一个变量）
h : float, optional
步长，默认为1e-5
method : str, optional
差分方法，可选'forward', 'backward', 'central'，默认为'central'
Returns:
--------
float
函数在给定点关于指定变量的偏导数
"""
# TODO: 实现偏导数计算
pass
@staticmethod
def gradient(func, point, h=1e-5):
"""
计算多变量函数在给定点的梯度向量
Parameters:
-----------
func : callable
多变量函数，接受向量输入
point : list or numpy.ndarray
计算梯度的点，如[x, y, z]
h : float, optional
步长，默认为1e-5
Returns:
--------
numpy.ndarray
函数在给定点的梯度向量
"""
# TODO: 实现梯度计算
pass
@staticmethod
def trapezoidal_rule(func, a, b, n=100):
"""
使用复合梯形法则计算函数在区间[a,b]上的定积分
Parameters:
-----------
func : callable
要积分的函数
a : float
积分下限
b : float
积分上限
n : int, optional
区间划分数量，默认为100
Returns:
--------
float
定积分的近似值
"""
# TODO: 实现复合梯形法则
pass
@staticmethod
def simpson_rule(func, a, b, n=100):
"""
使用辛普森法则计算函数在区间[a,b]上的定积分
Parameters:
-----------
func : callable
要积分的函数
a : float
积分下限
b : float
积分上限
n : int, optional
区间划分数量，默认为100（必须为偶数）
Returns:
--------
float
定积分的近似值
"""
# TODO: 实现辛普森法则
pass
@staticmethod
def adaptive_quadrature(func, a, b, tol=1e-6, max_recursion=20):
"""
使用自适应积分算法计算函数在区间[a,b]上的定积分
Parameters:
-----------
func : callable
要积分的函数
a : float
积分下限
b : float
积分上限
tol : float, optional
容差，默认为1e-6
max_recursion : int, optional
最大递归深度，默认为20
Returns:
--------
float
定积分的近似值
"""
# TODO: 实现自适应积分算法（可选）
pass
@staticmethod
def double_integral(func, x_range, y_range, nx=20, ny=20):
"""
计算二重积分
Parameters:
-----------
func : callable
二元函数 f(x, y)
x_range : tuple
x的积分范围 (x_min, x_max)
y_range : tuple
y的积分范围 (y_min, y_max)
nx : int, optional
x方向的划分数量，默认为20
ny : int, optional
y方向的划分数量，默认为20
Returns:
--------
float
二重积分的近似值
"""
# TODO: 实现二重积分（可选）
pass
@staticmethod
def gradient_descent(func, grad_func, initial_point, learning_rate=0.01, max_iterations=1000, tol=1e-6):
"""
使用梯度下降法寻找函数的局部最小值
Parameters:
-----------
func : callable
目标函数
grad_func : callable
目标函数的梯度函数
initial_point : list or numpy.ndarray
初始点
learning_rate : float, optional
学习率，默认为0.01
max_iterations : int, optional
最大迭代次数，默认为1000
tol : float, optional
收敛容差，默认为1e-6
Returns:
--------
tuple
(最优点, 最优值, 迭代次数)
"""
# TODO: 实现梯度下降法
pass
@staticmethod
def newton_method(func, grad_func, hessian_func, initial_point, max_iterations=100, tol=1e-6):
"""
使用牛顿法寻找函数的局部最小值
Parameters:
-----------
func : callable
目标函数
grad_func : callable
目标函数的梯度函数
hessian_func : callable
目标函数的海森矩阵
initial_point : list or numpy.ndarray
初始点
max_iterations : int, optional
最大迭代次数，默认为100
tol : float, optional
收敛容差，默认为1e-6
Returns:
--------
tuple
(最优点, 最优值, 迭代次数)
"""
# TODO: 实现牛顿法（可选）
pass学习者需要实现以下功能:
class Matrix:
"""
矩阵类，用于存储和操作二维数值数据
实现基本矩阵操作、高级矩阵计算和矩阵分解功能
"""
def __init__(self, data):
"""
初始化矩阵对象
Parameters:
-----------
data : list of lists or numpy.ndarray
矩阵数据，每个内部列表代表一行
"""
# TODO: 实现矩阵初始化逻辑
# 存储矩阵数据
# 验证输入数据的有效性（所有行具有相同长度）
# 计算并存储矩阵的维度（行数和列数）
pass
def __str__(self):
"""返回矩阵的字符串表示，便于打印和显示"""
# TODO: 实现矩阵的字符串表示
pass
def __repr__(self):
"""返回矩阵的官方字符串表示"""
# TODO: 实现矩阵的官方字符串表示
pass
# ===== 基本矩阵操作 =====
def __add__(self, other):
"""
矩阵加法运算
Parameters:
-----------
other : Matrix
要相加的另一个矩阵
Returns:
--------
Matrix
两个矩阵相加的结果
Raises:
-------
ValueError
如果两个矩阵的维度不匹配
"""
# TODO: 实现矩阵加法
pass
def __sub__(self, other):
"""
矩阵减法运算
Parameters:
-----------
other : Matrix
要相减的另一个矩阵
Returns:
--------
Matrix
两个矩阵相减的结果
Raises:
-------
ValueError
如果两个矩阵的维度不匹配
"""
# TODO: 实现矩阵减法
pass
def __mul__(self, other):
"""
矩阵乘法或标量乘法
Parameters:
-----------
other : Matrix or scalar (int, float)
如果是Matrix，执行矩阵乘法
如果是标量，执行标量乘法
Returns:
--------
Matrix
乘法结果
Raises:
-------
ValueError
矩阵乘法时，如果维度不兼容
TypeError
如果other既不是Matrix也不是标量
"""
# TODO: 实现矩阵乘法或标量乘法
pass
def __rmul__(self, scalar):
"""
右侧标量乘法，处理 scalar * matrix 情况
Parameters:
-----------
scalar : int or float
与矩阵相乘的标量
Returns:
--------
Matrix
标量乘法结果
"""
# TODO: 实现右侧标量乘法
pass
def __matmul__(self, other):
"""
矩阵乘法运算（使用 @ 运算符）
Parameters:
-----------
other : Matrix
右侧矩阵
Returns:
--------
Matrix
矩阵乘法结果
Raises:
-------
ValueError
如果维度不兼容
"""
# TODO: 实现矩阵乘法
pass
def transpose(self):
"""
返回矩阵的转置
Returns:
--------
Matrix
转置后的矩阵
"""
# TODO: 实现矩阵转置
pass
# ===== 高级矩阵计算 =====
def determinant(self):
"""
计算矩阵的行列式
Returns:
--------
float
矩阵的行列式值
Raises:
-------
ValueError
如果矩阵不是方阵
"""
# TODO: 实现行列式计算
pass
def inverse(self):
"""
计算矩阵的逆（如果存在）
Returns:
--------
Matrix
矩阵的逆
Raises:
-------
ValueError
如果矩阵不是方阵或者矩阵是奇异的（行列式为0）
"""
# TODO: 实现矩阵求逆
pass
def lu_decomposition(self):
"""
LU分解 - 可选实现
将矩阵分解为下三角矩阵L和上三角矩阵U的乘积
Returns:
--------
tuple of Matrix
(L, U) 下三角矩阵L和上三角矩阵U
Raises:
-------
ValueError
如果矩阵不是方阵或不能进行LU分解
"""
# TODO: 实现LU分解
pass
def solve(self, b):
"""
求解线性方程组 Ax = b
Parameters:
-----------
b : Matrix or list
等式右侧的向量或矩阵
Returns:
--------
Matrix
方程的解 x
Raises:
-------
ValueError
如果方程无解或有无穷多解
"""
# TODO: 实现线性方程组求解
pass
def eigenvalues(self):
"""
计算矩阵的特征值
Returns:
--------
list
矩阵的特征值列表
Raises:
-------
ValueError
如果矩阵不是方阵
"""
# TODO: 实现特征值计算
pass
def eigenvectors(self):
"""
计算矩阵的特征向量
Returns:
--------
dict
键为特征值，值为对应的特征向量列表
Raises:
-------
ValueError
如果矩阵不是方阵
"""
# TODO: 实现特征向量计算
pass
def svd(self):
"""
奇异值分解 - 可选实现
将矩阵分解为 U·Σ·V^T 的形式
Returns:
--------
tuple
(U, S, V)，其中U和V是正交矩阵，S是奇异值向量
"""
# TODO: 实现奇异值分解
pass
# ===== 矩阵分解 =====
def qr_decomposition(self):
"""
QR分解
将矩阵分解为正交矩阵Q和上三角矩阵R的乘积
Returns:
--------
tuple of Matrix
(Q, R) 正交矩阵Q和上三角矩阵R
"""
# TODO: 实现QR分解
pass
def cholesky_decomposition(self):
"""
Cholesky分解 - 可选实现
将对称正定矩阵分解为下三角矩阵L和其转置的乘积
Returns:
--------
Matrix
下三角矩阵L，满足A = L·L^T
Raises:
-------
ValueError
如果矩阵不是对称正定的
"""
# TODO: 实现Cholesky分解
pass
# ===== 辅助方法 =====
def is_square(self):
"""
检查矩阵是否为方阵
Returns:
--------
bool
如果矩阵是方阵返回True，否则返回False
"""
# TODO: 实现方阵检查
pass
def rank(self):
"""
计算矩阵的秩
Returns:
--------
int
矩阵的秩
"""
# TODO: 实现矩阵秩的计算
pass
def trace(self):
"""
计算矩阵的迹（对角线元素之和）
Returns:
--------
float
矩阵的迹
Raises:
-------
ValueError
如果矩阵不是方阵
"""
# TODO: 实现矩阵迹的计算
pass
def copy(self):
"""
创建矩阵的深拷贝
Returns:
--------
Matrix
新的矩阵实例，与原矩阵有相同的数据
"""
# TODO: 实现矩阵的深拷贝
pass学习者需要实现以下功能:
class Stats:
"""
统计分析类，提供各种统计计算功能
实现描述性统计、相关性分析和回归分析
"""
def __init__(self, data=None):
"""
初始化统计对象
Parameters:
-----------
data : list, numpy.ndarray, pandas.DataFrame, or None
要分析的数据，可以是一维或多维数据
如果为None，则创建一个空的统计对象，可以后续添加数据
"""
# TODO: 实现统计对象初始化
# 存储和验证输入数据
# 可能需要区分一维数据和多维数据的处理方式
pass
def set_data(self, data):
"""
设置或更新要分析的数据
Parameters:
-----------
data : list, numpy.ndarray, or pandas.DataFrame
要分析的数据
Returns:
--------
self
返回自身以支持链式调用
"""
# TODO: 实现数据设置
pass
# ===== 描述性统计 =====
def mean(self, axis=None):
"""
计算数据的算术平均值
Parameters:
-----------
axis : int or None
计算平均值的轴。如果为None，计算整个数据集的平均值
Returns:
--------
float or numpy.ndarray
数据的平均值。如果指定了axis，返回沿该轴的平均值数组
"""
# TODO: 实现均值计算
pass
def median(self, axis=None):
"""
计算数据的中位数
Parameters:
-----------
axis : int or None
计算中位数的轴。如果为None，计算整个数据集的中位数
Returns:
--------
float or numpy.ndarray
数据的中位数。如果指定了axis，返回沿该轴的中位数数组
"""
# TODO: 实现中位数计算
pass
def mode(self, axis=None):
"""
计算数据的众数
Parameters:
-----------
axis : int or None
计算众数的轴。如果为None，计算整个数据集的众数
Returns:
--------
float, list, or numpy.ndarray
数据的众数。可能返回多个值（如果有多个众数）
"""
# TODO: 实现众数计算
pass
def variance(self, axis=None, ddof=1):
"""
计算数据的方差
Parameters:
-----------
axis : int or None
计算方差的轴。如果为None，计算整个数据集的方差
ddof : int
自由度delta。默认为1（样本方差）
Returns:
--------
float or numpy.ndarray
数据的方差。如果指定了axis，返回沿该轴的方差数组
"""
# TODO: 实现方差计算
pass
def std(self, axis=None, ddof=1):
"""
计算数据的标准差
Parameters:
-----------
axis : int or None
计算标准差的轴。如果为None，计算整个数据集的标准差
ddof : int
自由度delta。默认为1（样本标准差）
Returns:
--------
float or numpy.ndarray
数据的标准差。如果指定了axis，返回沿该轴的标准差数组
"""
# TODO: 实现标准差计算
pass
def skewness(self, axis=None):
"""
计算数据的偏度（分布不对称性的度量）
Parameters:
-----------
axis : int or None
计算偏度的轴。如果为None，计算整个数据集的偏度
Returns:
--------
float or numpy.ndarray
数据的偏度。如果指定了axis，返回沿该轴的偏度数组
"""
# TODO: 实现偏度计算
pass
def kurtosis(self, axis=None, fisher=True):
"""
计算数据的峰度（分布尖峰或平坦程度的度量）
Parameters:
-----------
axis : int or None
计算峰度的轴。如果为None，计算整个数据集的峰度
fisher : bool
是否使用Fisher's定义（减去3）。默认为True
Returns:
--------
float or numpy.ndarray
数据的峰度。如果指定了axis，返回沿该轴的峰度数组
"""
# TODO: 实现峰度计算
pass
def quantile(self, q, axis=None):
"""
计算数据的分位数
Parameters:
-----------
q : float or array-like
要计算的分位数，范围为[0, 1]
axis : int or None
计算分位数的轴。如果为None，计算整个数据集的分位数
Returns:
--------
float or numpy.ndarray
指定分位数对应的值
"""
# TODO: 实现分位数计算
pass
def describe(self):
"""
生成数据的描述性统计摘要
Returns:
--------
dict or pandas.DataFrame
包含统计摘要的数据结构，通常包括计数、均值、标准差、最小值、
25%分位数、中位数、75%分位数、最大值等
"""
# TODO: 实现描述性统计摘要
pass
# ===== 相关性分析 =====
def covariance(self, x=None, y=None, ddof=1):
"""
计算两组数据之间的协方差
Parameters:
-----------
x : array-like or None
第一组数据。如果为None，使用对象中存储的数据
y : array-like or None
第二组数据。如果为None且x不为None，则计算x中各列之间的协方差
ddof : int
自由度delta。默认为1
Returns:
--------
float or numpy.ndarray
协方差值或协方差矩阵
"""
# TODO: 实现协方差计算
pass
def correlation(self, x=None, y=None, method='pearson'):
"""
计算两组数据之间的相关系数
Parameters:
-----------
x : array-like or None
第一组数据。如果为None，使用对象中存储的数据
y : array-like or None
第二组数据。如果为None且x不为None，则计算x中各列之间的相关系数
method : str
相关系数的计算方法，可选值为'pearson'或'spearman'
Returns:
--------
float or numpy.ndarray
相关系数值或相关系数矩阵
"""
# TODO: 实现相关系数计算
pass
def pearson_correlation(self, x=None, y=None):
"""
计算Pearson相关系数
Parameters:
-----------
x : array-like or None
第一组数据。如果为None，使用对象中存储的数据
y : array-like or None
第二组数据。如果为None且x不为None，则计算x中各列之间的Pearson相关系数
Returns:
--------
float or numpy.ndarray
Pearson相关系数值或相关系数矩阵
"""
# TODO: 实现Pearson相关系数计算
pass
def spearman_correlation(self, x=None, y=None):
"""
计算Spearman等级相关系数
Parameters:
-----------
x : array-like or None
第一组数据。如果为None，使用对象中存储的数据
y : array-like or None
第二组数据。如果为None且x不为None，则计算x中各列之间的Spearman相关系数
Returns:
--------
float or numpy.ndarray
Spearman相关系数值或相关系数矩阵
"""
# TODO: 实现Spearman相关系数计算
pass
def cov_matrix(self, data=None, ddof=1):
"""
构建协方差矩阵
Parameters:
-----------
data : array-like or None
要计算协方差矩阵的数据。如果为None，使用对象中存储的数据
ddof : int
自由度delta。默认为1
Returns:
--------
numpy.ndarray
协方差矩阵
"""
# TODO: 实现协方差矩阵构建
pass
# ===== 回归分析 =====
def simple_linear_regression(self, x=None, y=None):
"""
执行简单线性回归分析 (y = a + bx)
Parameters:
-----------
x : array-like or None
自变量数据。如果为None，使用对象中存储的第一列数据
y : array-like or None
因变量数据。如果为None，使用对象中存储的第二列数据
Returns:
--------
dict
包含回归结果的字典，通常包括斜率、截距、R方值、p值等
"""
# TODO: 实现简单线性回归
pass
def multiple_linear_regression(self, X=None, y=None):
"""
执行多元线性回归分析
Parameters:
-----------
X : array-like or None
自变量数据矩阵，每列是一个自变量。如果为None，使用对象中存储的除最后一列外的所有数据
y : array-like or None
因变量数据。如果为None，使用对象中存储的最后一列数据
Returns:
--------
dict
包含回归结果的字典，通常包括系数、截距、R方值、p值等
"""
# TODO: 实现多元线性回归
pass
def goodness_of_fit(self, y_true, y_pred):
"""
评估回归模型的拟合优度
Parameters:
-----------
y_true : array-like
实际观测值
y_pred : array-like
模型预测值
Returns:
--------
dict
包含各种拟合优度指标的字典，通常包括R方值、调整后的R方值、均方误差、
平均绝对误差、均方根误差等
"""
# TODO: 实现拟合优度评估
pass
def r_squared(self, y_true, y_pred):
"""
计算决定系数(R²)，衡量回归模型解释因变量变异性的比例
Parameters:
-----------
y_true : array-like
实际观测值
y_pred : array-like
模型预测值
Returns:
--------
float
R²值，范围为[0, 1]，越接近1表示拟合越好
"""
# TODO: 实现R²计算
pass
def adjusted_r_squared(self, y_true, y_pred, n_predictors):
"""
计算调整后的决定系数，考虑了模型中自变量数量的影响
Parameters:
-----------
y_true : array-like
实际观测值
y_pred : array-like
模型预测值
n_predictors : int
模型中自变量的数量
Returns:
--------
float
调整后的R²值，可能为负值
"""
# TODO: 实现调整后的R²计算
pass
def mse(self, y_true, y_pred):
"""
计算均方误差
Parameters:
-----------
y_true : array-like
实际观测值
y_pred : array-like
模型预测值
Returns:
--------
float
均方误差值，非负数，越小越好
"""
# TODO: 实现均方误差计算
pass
def predict(self, model, X):
"""
使用回归模型进行预测
Parameters:
-----------
model : dict
回归模型，通常是simple_linear_regression或multiple_linear_regression的返回值
X : array-like
要预测的自变量数据
Returns:
--------
numpy.ndarray
预测的因变量值
"""
# TODO: 实现预测功能
pass
# ===== 辅助方法 =====
def _validate_data(self, data):
"""
验证输入数据的有效性
Parameters:
-----------
data : object
要验证的数据
Returns:
--------
bool
数据是否有效
"""
# TODO: 实现数据验证
pass
def _convert_to_numpy(self, data):
"""
将输入数据转换为numpy数组格式
Parameters:
-----------
data : object
要转换的数据
Returns:
--------
numpy.ndarray
转换后的数据
"""
# TODO: 实现数据转换
pass以下是三个最常用的数值计算例子，涵盖矩阵计算、微积分和概率统计领域：
函数 GAUSSIAN_ELIMINATION(A):
n = A的行数
创建增广矩阵 [A|I]，其中I是n阶单位矩阵
# 前向消元
对于 i = 0 到 n-1:
# 找最大主元以增强数值稳定性（部分主元选择）
maxIndex = i
对于 k = i+1 到 n-1:
如果 |A[k,i]| > |A[maxIndex,i]|:
maxIndex = k
# 如果需要，交换行
如果 maxIndex ≠ i:
交换第i行和第maxIndex行
# 检查是否可逆
如果 A[i,i] 接近于0:
报错："矩阵接近奇异，不能求逆"
# 归一化第i行
除数 = A[i,i]
对于 j = 0 到 2n-1: # 增广矩阵的所有列
A[i,j] = A[i,j] / 除数
# 消元其他行
对于 j = 0 到 n-1:
如果 j ≠ i:
系数 = A[j,i]
对于 k = 0 到 2n-1:
A[j,k] = A[j,k] - 系数 * A[i,k]
# 提取逆矩阵
逆矩阵 = 增广矩阵的右半部分[0:n, n:2n]
返回 逆矩阵
函数 SIMPSON_RULE(f, a, b, n):
# f是要积分的函数，a和b是积分区间，n是区间分割数（必须是偶数）
# 检查n是否为偶数
如果 n % 2 ≠ 0:
n = n + 1 # 确保n为偶数
h = (b - a) / n # 步长
积分值 = f(a) + f(b) # 首尾两项
# 处理偶数位置的点（系数为2）
对于 i = 2 到 n-2, 步长为2:
x = a + i*h
积分值 += 2 * f(x)
# 处理奇数位置的点（系数为4）
对于 i = 1 到 n-1, 步长为2:
x = a + i*h
积分值 += 4 * f(x)
# 应用辛普森公式
积分值 = 积分值 * h/3
返回 积分值
函数 MULTIPLE_LINEAR_REGRESSION(X, y):
# X是设计矩阵（n个样本，p个特征），y是目标向量（n个值）
# 步骤1: 添加截距项（如果需要）
X = 在X的第一列前添加全1列
# 步骤2: 计算回归系数 β = (X^T·X)^(-1)·X^T·y
X_T = X的转置
XTX = X_T 乘以 X
# 检查XTX是否可逆
如果 XTX行列式接近0:
报错："特征之间可能存在高度相关性，考虑使用正则化方法"
XTX_inv = XTX的逆矩阵 # 可以调用高斯消元函数
XTy = X_T 乘以 y
beta = XTX_inv 乘以 XTy
# 步骤3: 计算拟合值和残差
y_pred = X 乘以 beta
残差 = y - y_pred
# 步骤4: 计算模型评估指标
y_mean = y的平均值
SST = 求和((y - y_mean)的平方) # 总离差平方和
SSR = 求和((y_pred - y_mean)的平方) # 回归平方和
SSE = 求和(残差的平方) # 残差平方和
# 计算决定系数R^2
R_squared = 1 - SSE/SST # 或者等价于 SSR/SST
# 计算调整R^2（考虑自由度）
n = X的行数
p = X的列数 - 1 # 减去截距项
adjusted_R_squared = 1 - (SSE/(n-p-1))/(SST/(n-1))
返回 {
"系数": beta,
"预测值": y_pred,
"残差": 残差,
"R方": R_squared,
"调整R方": adjusted_R_squared
}
if A.shape[1] != B.shape[0]: raise ValueError("矩阵维度不匹配")assert A.shape[1] == B.shape[0], "第一个矩阵的列数必须等于第二个矩阵的行数"print(f"尝试将{A.shape}矩阵与{B.shape}矩阵相乘")if np.linalg.cond(A) > 1e15: print("警告：矩阵条件数过大，结果可能不准确")# 替换这种循环:
result = 0
for i in range(len(a)):
result += a[i] * b[i]
# 使用向量化操作:
result = np.dot(a, b)
def block_matrix_multiply(A, B, block_size=1000):
"""使用分块策略计算大矩阵乘法，减少内存使用"""
import numpy as np
n, m = A.shape
m2, p = B.shape
if m != m2:
raise ValueError("矩阵维度不兼容")
# 创建结果矩阵
C = np.zeros((n, p))
# 分块计算
for i in range(0, n, block_size):
i_end = min(i + block_size, n)
for j in range(0, p, block_size):
j_end = min(j + block_size, p)
# 初始化当前块
C_block = np.zeros((i_end - i, j_end - j))
for k in range(0, m, block_size):
k_end = min(k + block_size, m)
# 只加载内存中需要的块
A_block = A[i:i_end, k:k_end]
B_block = B[k:k_end, j:j_end]
# 累加到结果
C_block += np.dot(A_block, B_block)
C[i:i_end, j:j_end] = C_block
return C
def parallel_monte_carlo_integration(f, a, b, n_samples=1000000, n_processes=4):
"""使用多进程并行计算蒙特卡洛积分"""
from multiprocessing import Pool
import numpy as np
def sample_function(n):
"""在每个进程中抽样并计算"""
# 生成随机点
x = np.random.uniform(a, b, n)
# 计算函数值
y = np.vectorize(f)(x)
# 返回平均值
return np.mean(y) * (b - a)
# 分配样本量
samples_per_process = n_samples // n_processes
# 并行处理
with Pool(processes=n_processes) as pool:
results = pool.map(sample_function, [samples_per_process] * n_processes)
# 取平均值作为最终结果
return np.mean(results)
@functools.lru_cache装饰器缓存函数结果from functools import lru_cache
@lru_cache(maxsize=None)
def binomial_coefficient(n, k):
"""计算组合数C(n,k)，使用缓存加速递归"""
if k == 0 or k == n:
return 1
return binomial_coefficient(n-1, k-1) + binomial_coefficient(n-1, k)通过这些实现指引，初学者可以更好地理解和应用量化分析中的数值计算方法，并避免常见陷阱和性能问题。
算法与数学基础
Python实现参考
在线工具
上一篇