numpy库中的dot函数来计算矩阵和向量的点积
python
def matrix_vector_dot_product(a, b):
import numpy as np
if (len(a[0]) != len(b)):
return -1
# 使用tolist()将结果转换为列表
return np.dot(a, b).tolist()原始方法
python
def matrix_vector_dot_product(matrix, vector):
if len(matrix[0]) != len(vector):
return -1
l = []
for i in matrix:
num = 0
for j in range(len(i)):
num += (i[j]*vector[j])
l.append(num)
return l
# 主程序
if __name__ == "__main__":
# 输入矩阵和向量
matrix_input = input()
vector_input = input()
# 处理输入
import ast
matrix = ast.literal_eval(matrix_input)
vector = ast.literal_eval(vector_input)
# 调用函数计算点积
output = matrix_vector_dot_product(matrix, vector)
# 输出结果
print(output)numpy库中给定的矩阵 A，其转置矩阵表示为 A^T
python
def transpose_matrix(a: List[List[Union[int, float]]]) -> List[List[Union[int, float]]]:
import numpy as np
return np.array(a).T.tolist()使用numpy库的reshape方法矩阵重塑
矩阵重塑是将一个矩阵转换为另一个形状的过程，前提是新形状的元素总数与原矩阵相同
python
def reshape_matrix(a: List[List[Union[int, float]]], new_shape: Tuple[int, int]) -> List[List[Union[int, float]]]:
import numpy as np
if len(a) * len(a[0]) != new_shape[0] * new_shape[1]:
return -1
return np.array(a).reshape(new_shape).tolist()使用numpy库的mean方法按行或列计算平均值
python
def calculate_matrix_mean(matrix: List[List[Union[int, float]]], mode: str) -> List[float]:
import numpy as np
if mode == 'column':
return np.mean(matrix, axis=0).tolist()
elif mode == 'row':
return np.mean(matrix, axis=1).tolist()
else:
raise ValueError("Mode must be 'row' or 'column'")使用python的广播机制进行标量的矩阵乘法
python
def scalar_multiply(matrix: List[List[Union[int, float]]], scalar: Union[int, float]) -> List[List[Union[int, float]]]:
import numpy as np
return (np.array(matrix) * scalar).tolist()使用numpy库的cov方法计算协方差矩阵
协方差矩阵是一种描述两个随机变量之间关系的矩阵，其计算公式为：
python
import numpy as np
def jia(vectors, a):
return [i + a for i in vectors]
def dianji(a,b):
if len(a) != len(b):
return -1
s = 0
for j in range(len(a)):
s += a[j] * b[j]
return s
def cov(x,y):
return dianji(jia(x, -sum(x)/len(x)),jia(y, -sum(y)/len(y))) / (len(x)-1)
def calculate_covariance_matrix(vectors):
# 补全代码
return [[cov(x,y) for x in vectors] for y in vectors]
# 主程序
if __name__ == "__main__":
# 输入
ndarrayA = input()
# 处理输入
import ast
A = ast.literal_eval(ndarrayA)
# 调用函数计算
output = calculate_covariance_matrix(A)
# 输出结果
print(output)原始方法
python
import numpy as np
def calculate_covariance_matrix(vectors):
n_features = len(vectors)
n_observations = len(vectors[0])
covariance_matrix = np.zeros([n_features, n_features])
means = [sum(feature) / n_observations for feature in vectors]
for i in range(n_features):
for j in range(i, n_features):
covariance = sum(
(vectors[i][k] - means[i]) * (vectors[j][k] - means[j])
for k in range(n_observations)
) / (n_observations - 1)
covariance_matrix[i][j] = covariance_matrix[j][i] = covariance
return covariance_matrix.tolist()
# 主程序
if __name__ == "__main__":
# 输入
ndarrayA = input()
# 处理输入
import ast
A = ast.literal_eval(ndarrayA)
# 调用函数计算
output = calculate_covariance_matrix(A)
# 输出结果
print(output)基向量变换矩阵
基向量变换矩阵（Basis Vector Transformation Matrix）是一种常用的矩阵，用于将基向量变换为另一个基向量。
python
import numpy as np
def transform_basis(B, C):
B = np.array(B)
C = np.array(C)
C = np.linalg.inv(C)
P = B@C
return P.tolist()
if __name__ == "__main__":
B = np.array(eval(input()))
C = np.array(eval(input()))
print(transform_basis(B, C))将向量转换为对角矩阵
python
def make_diagonal(x):
identity_matrix = np.identity(np.size(x))
return (identity_matrix*x)原始方法
python
def make_diagonal(x):
x = np.array(x)
zeros = np.zeros((len(x),len(x)),dtype=np.float16)
for i in range(len(x)):
zeros[i,i]=x[i]
return zeros
if __name__ == "__main__":
x = np.array(eval(input()))
print(make_diagonal(x))实现压缩行稀疏矩阵（CSR）格式转换
压缩行稀疏矩阵（CSR）格式是一种特殊的矩阵存储格式，其特点是只存储非零元素的值、行号和列指针。本质上是一种三元组表示法。
输入
[[1, 0, 0], [2, 3, 0], [0, 4, 5]]
输出
**[1, 2, 3, 4, 5]
0, 0, 1, 1, 2
0, 1, 3, 5\]** ```python def compressed_row_sparse_matrix(dense_matrix): vals = [] col_idx = [] row_ptr=[0] for x in dense_matrix: for i,y in enumerate(x): if y!=0: vals.append(y) col_idx.append(i) row_ptr.append(len(vals)) return vals, col_idx, row_ptr if __name__ == "__main__": dense_matrix = eval(input()) vals, col_idx, row_ptr = compressed_row_sparse_matrix(dense_matrix) print(vals) print(col_idx) print(row_ptr) ``` ## 实现向量到直线的正交投影  ```python def orthogonal_projection(v, L): import numpy as np v = np.array(v) L = np.array(L) a = (((v@L)/np.dot(L,L))*L) a = a.tolist() return a if __name__ == "__main__": v = eval(input()) L = eval(input()) print(orthogonal_projection(v, L)) ``` ## 实现压缩列稀疏矩阵 ```python def compressed_col_sparse_matrix(dense_matrix): from scipy.sparse import csc_matrix sparse = csc_matrix(dense_matrix) return sparse.data.tolist(), sparse.indices.tolist(), sparse.indptr.tolist() ``` 原始方法 ```python def compressed_col_sparse_matrix(dense_matrix): vals, row_idx, col_ptr = [],[],[0] import numpy as np dense_matrix = np.array(dense_matrix) dense_matrix = dense_matrix.T for i in dense_matrix: for j,x in enumerate(i): if x!=0: vals.append(x) row_idx.append(j) col_ptr.append(len(vals)) return vals, row_idx, col_ptr if __name__ == "__main__": dense_matrix = eval(input()) vals, row_idx, col_ptr = compressed_col_sparse_matrix(dense_matrix) print(vals) print(row_idx) print(col_ptr) ``` ## 计算向量之间的余弦相似度 ```python import numpy as np def cosine_similarity(v1, v2): # Implement your code here if v1.shape != v2.shape: raise ValueError("Arrays must have the same shape") if v1.size == 0: raise ValueError("Arrays cannot be empty") v1 = v1.flatten() v2 = v2.flatten() val= (v1@v2)/(np.sqrt(np.dot(v1,v1))*np.sqrt(np.dot(v2,v2))) return round(val, 3) if __name__ == "__main__": v1 = np.array(eval(input())) v2 = np.array(eval(input())) print(cosine_similarity(v1, v2)) ``` ## 泊松分布概率计算器 泊松分布是一种描述随机事件发生次数的概率分布，其计算公式为：  ```python import math def poisson_probability(k, lam): # Your code here o=(math.exp(-lam))*(lam**k) u=math.factorial(k) val=o/u return round(val, 5) if __name__ == "__main__": k, lam = map(int, input().split()) print(poisson_probability(k, lam)) ```