信息安全管理作业I

def matrix_multiply(matrix1, matrix2):
    result = []
    for row1 in matrix1:
        new_row = []
        for row2 in zip(*matrix2):
            element = sum(a * b for a, b in zip(row1, row2))
            new_row.append(element)
        result.append(new_row)
    return result

def calculate_fuzzy_consistency(matrix):
    n = len(matrix)

    # 初始化三角形模糊数的和
    sum_fuzzy_number = [0, 0, 0]

    # 计算所有三角形模糊数的和
    for row in matrix:
        for fuzzy_number in row:
            for i in range(3):
                sum_fuzzy_number[i] += fuzzy_number[i]

    # 初始化行和矩阵
    sum_rows = []

    for row in matrix:
        sum_row = [0, 0, 0]
        for fuzzy_number in row:
            for i in range(3):
                sum_row[i] += fuzzy_number[i]
        sum_rows.append(sum_row)

    # 初始化归一化和
    normalized_sums = []

    for sum_row in sum_rows:
        normalized_sum = [sum_row[i] / sum_fuzzy_number[2 - i] for i in range(3)]
        normalized_sums.append(normalized_sum)

    # 建立可能性矩阵
    possibility_matrix = []

    for i in range(n):
        possibility_row = []
        for j in range(n):
            a = normalized_sums[i]
            b = normalized_sums[j]
            possibility = 0.5 * max(1 - max((b[1] - a[0]) / (a[1] - a[0] + b[1] - b[0]), 0), 0) + 0.5 * max(1 - max((b[2] - a[1]) / (a[2] - a[1] + b[2] - b[1]), 0), 0)
            possibility_row.append(possibility)
        possibility_matrix.append(possibility_row)

    # 计算模糊一致性矩阵
    consistency_matrix = []

    # 计算可能性矩阵的行和
    possibility_row_sums = [sum(row) for row in possibility_matrix]

    for i in range(n):
        rij = []
        for j in range(n):
            ri = possibility_row_sums[i]
            rj = possibility_row_sums[j]
            rij.append((ri - rj) / (2 * (n - 1)) + 0.5)
        consistency_matrix.append(rij)

    # 计算排序向量
    v = [(sum(row) + n / 2 - 1)/ (n * (n - 1)) for row in consistency_matrix]

    #for i in range(n):
        #print(format(v[i] + 0.0000001, '.5f'), end=' ')
    return v;
"""
# 示例用法
matrix = [[[0.1, 0.2, 0.3], [0.2, 0.3, 0.4], [0.3, 0.4, 0.5]],
          [[0.4, 0.5, 0.6], [0.5, 0.6, 0.7], [0.6, 0.7, 0.8]],
          [[0.7, 0.8, 0.9], [0.8, 0.9, 1.0], [0.9, 1.0, 1.1]]]

calculate_fuzzy_consistency(matrix)"""
#构造第一层的矩阵
rows_1= []
#构造第二层的矩阵
rows_2 =[]
while True:
    num = int(input())
    if num == 0:
        break
    matrix = []
    n = int(input().strip())
    # 读入数据
    for _ in range(n):
        row = list(map(lambda x: list(map(float, x.split(','))), input().strip().split()))
        matrix.append(row)
    if(num==1):
        rows_1.append(calculate_fuzzy_consistency(matrix))
    if(num==2):
        rows_2.append(calculate_fuzzy_consistency(matrix))

result_matrix = matrix_multiply(rows_1, rows_2)
# 打印出相乘后的结果，将所有结果在一行打印出来
for row in result_matrix:
    for elem in row:
        print(format(elem, '.5f'), end=' ')

"""
for row in rows_1:
    print(row)
for row in rows_2:
    print(row)
"""