用Scipy.Sparse实现GF(256)中稀疏矩阵的快速点乘

import numpy as np
from scipy.sparse import csr_matrix

# 定义 GF(256) 中的加法和乘法
def gf_add(a, b):
    return (a + b) % 256

def gf_mul(a, b):
    return (a * b) % 256

# 创建两个稀疏矩阵
data = np.array([1, 2, 3, 4])
row = np.array([0, 0, 1, 2])
col = np.array([0, 2, 2, 0])
A = csr_matrix((data, (row, col)), shape=(3, 3))

data = np.array([5, 6, 7])
row = np.array([0, 1, 2])
col = np.array([1, 1, 2])
B = csr_matrix((data, (row, col)), shape=(3, 3))

# 点乘函数
def sparse_matrix_gf256_multiply(A, B):
    # 获取矩阵的形状和非零元素位置
    rows, cols = A.shape
    data_A = A.data
    data_B = B.data
    indices_A = A.indices
    indptr_A = A.indptr
    indices_B = B.indices
    indptr_B = B.indptr
    
    # 结果矩阵的非零元素存储
    result_data = []
    result_indices = []
    result_indptr = [0]
    
    # 遍历 A 的每一行
    for i in range(rows):
        start_A = indptr_A[i]
        end_A = indptr_A[i + 1]
        for j in range(start_A, end_A):
            a_val = data_A[j]
            a_col = indices_A[j]
            
            # 遍历 B 的对应列
            start_B = indptr_B[a_col]
            end_B = indptr_B[a_col + 1]
            for k in range(start_B, end_B):
                b_val = data_B[k]
                b_row = indices_B[k]
                
                # 计算点乘结果并累加
                if i == b_row:
                    result_data.append(gf_mul(a_val, b_val))
                    result_indices.append(a_col)
        
        # 去重和模运算
        unique_indices = np.unique(result_indices)
        unique_data = np.zeros_like(unique_indices, dtype=np.uint8)
        for idx, val in zip(result_indices, result_data):
            unique_data[np.where(unique_indices == idx)[0][0]] = gf_add(unique_data[np.where(unique_indices == idx)[0][0]], val)
        
        result_data = unique_data.tolist()
        result_indptr.append(len(result_data))
    
    return csr_matrix((result_data, unique_indices, result_indptr), shape=(rows, cols))

# 进行点乘
C = sparse_matrix_gf256_multiply(A, B)
print(C.toarray())