2022-2023国科大李保滨老师矩阵分析期末大作业

最新推荐文章于 2024-01-23 09:21:04 发布
最新推荐文章于 2024-01-23 09:21:04 发布
阅读量747 收藏 5
点赞数
文章标签： 矩阵 python numpy 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43700556/article/details/129501139
版权

要求完成课堂上讲的关于矩阵分解的LU、QR（Gram-Schmidt）、Orthogonal Reduction (Householder reduction 和Givens reduction)和 URV程序实现，要求如下：

    1、一个综合程序，根据选择参数的不同，实现不同的矩阵分解；在此基础上，实现Ax=b方程组的求解，以及计算A的行列式；

     2、可以用matlab、Python等编写程序，需附上简单的程序说明，比如参数代表什么意思，输入什么，输出什么等等，附上相应的例子；

     3、一定是可执行文件，例如 .m文件等,不能是word或者txt文档。附上源代码，不能为直接调用matlab等函数库;

import numpy as np
import copy

#LU分解函数
def LU_Factorization(A):
    #输入：N * N的方阵A
    #输出：对角元全为1的下三角矩阵L与对角元素不为0的上三角元素U
    A = np.array(A)
    B = copy.deepcopy(A)
    n = B.shape[0]
    L = np.identity(n, dtype=int)
    U = np.zeros_like(A)
    for i in range(n):
        for j in range(i+1, n):
            L[j][i] = B[j][i] / B[i][i]
            B[j] = B[j] - L[j][i]*B[i]
        U[i] = B[i]
    return L, U

#LU分解函数
def LU_Factorization2(A):
    #输入：N * N的方阵A
    #输出：对角元全为1的下三角矩阵L与对角元素不为0的上三角元素U
    n = len(A[0])
    L = [[0] * n for i in range(n)]
    U = [[0] * n for i in range(n)]
    B = copy.deepcopy(A)
    for i in range(n):
        L[i][i] = 1
        U[i][i] = B[i][i]
        for j in range(i+1, n):
            L[j][i] = B[j][i] / B[i][i]
            for k in range(n):
                B[j][k] = B[j][k] - L[j][i]*B[i][k]
            U[i][j] = B[i][j]
    return L, U

#QR分解的函数
def QR_Factorization(A):
    #输入：N * N的方阵A
    #方法：使用Gram-Schmidt正交化方法 A = QR
    #输出：单位正交矩阵Q与对角元素不为0的上三角元素R
    A = np.array(A, dtype=float)
    n = A.shape[0]
    Q = copy.deepcopy(A)
    R = np.zeros_like(A)
    for i in range(n):
        for j in range(i):
            temp = np.sum(Q[:, j]*A[:, i])
            R[j][i] = temp
            Q[:, i] -= temp*Q[:, j]
        num = 0
        for k in range(n):
            num += Q[k][i]**2
        num = np.sqrt(num)
        Q[:, i] = Q[:, i] / num
        R[i][i] = num
        # R[i][i] = np.linalg.norm(Q[:, i])
        # Q[:, i] = Q[:, i] / np.linalg.norm(Q[:, i])
    return Q, R

#利用Householder reduction进行Orthogonal Reduction
def HouseHolder(A):
    #输入：N * N的方阵A
    #方法：使用Householder变换正交化方法,PA=T
    #输出：P为正交矩阵 T为上三角矩阵
    A = np.mat(A, dtype=float)
    n = A.shape[0]
    T = copy.deepcopy(A)
    P = np.eye(n)
    for i in range(n-1):
        sub_A = T[i:, i:]
        R = np.eye(n)
        e = np.zeros_like(sub_A[:, 0])
        e[0] = 1.0
        u = sub_A[:, 0] - np.linalg.norm(sub_A[:, 0]) * e
        R_ = np.eye((n-i)) - 2*u.dot(u.T) / (u.T.dot(u))
        R[i:, i:] = R_
        T = R.dot(T)
        P = R.dot(P)
    return P, T

#利用Givens reduction进行Orthogonal Reduction
def Givens(A):
    #输入：N * N的方阵A
    #方法：使用Givens变换正交化方法,PA=T
    #输出：P为正交矩阵 T为上三角矩阵
    A = np.array(A, dtype=float)
    n = A.shape[0]
    T = copy.deepcopy(A)
    P = np.eye(n)
    for i in range(n):
        for j in range(i+1, n):
            P_ = np.eye(n)
            c, s = T[i, i], T[j, i]
            c, s = c/np.sqrt(c**2+s**2), s/np.sqrt(c**2+s**2)
            P_[i, i] = c
            P_[i, j] = s
            P_[j, i] = -s
            P_[j, j] = c
            P = P_.dot(P)
            T = P_.dot(T)
    return P, T

#利用URV分解
def URV_Factorization(A):
    #输入：N * N的方阵A
    #方法：
    # U的前r列为R(A)的标准正交基
    # U的后m-r列为N(A.T)的标准正交基
    # V的前r列为R(A.T)的标准正交基
    # V的后n-r列为N(A)的标准正交基
    # 可以利用Householder或者Givens reduction方法来获得标准正交基P满足PA=(B|0).T
    # 对B.T再使用一次Householder或者Givens reduction方法得到标准正交基Q和非奇异上三角矩阵T
    #输出：P为正交矩阵 T为上三角矩阵
    A = np.array(A, dtype=float)
    U, B = HouseHolder(A)

    rank_A = np.linalg.matrix_rank(A)
    P = B[:rank_A, :]

    Q, T = HouseHolder(B.T)
    rank_B = np.linalg.matrix_rank(B.T)

    V = Q.T
    T = T[:rank_B, :]
    R = np.zeros_like(A, dtype=float)
    R[: rank_B, :rank_B] = T.T

    U = P

    return U, R, V

if __name__ == "__main__":
    '''该程序将会对给定的矩阵A进行LU、QR（Gram-Schmidt）
    Orthogonal Reduction (Householder reduction 和Givens reduction)和URV分解
    运行程序时需要numpy的环境 如果未安装则需要在python环境中进行pip install numpy的操作
    运行时需要输入1-5的数字进行分解的选择，输入其他字符程序无法运行
    输入完毕后可以输入1或0自己选择是使用程序给定的样例A与b进行运行或者自己输入A和b进行运算
    最后会对矩阵A进行相应的分解操作获得分解后的矩阵并对Ax=b进行求解同时计算出A的行列式
    '''
    num = int(input('请输入1-5来选择进行何种分解\n'
                    '1:LU\n'
                    '2:QR\n'
                    '3:HouseHolder\n'
                    '4:Givens\n'
                    '5:URV\n'))
    if num not in [i for i in range(1, 6)]:
        print('请输入1-5的数字')
        exit()
    print('将在给定的A矩阵进行相应的分解操作，并求得AX=b的解与A的行列式')
    mode = ['LU', 'QR', 'HouseHolder', 'Givens', 'URV'][num-1]
    flag = int(input('输入1将使用程序给定的A和b\n'
                     '输入0用户可以自己输入一个矩阵A和b\n'))
    if flag == 1:
        b = np.array([12, 24, 12], dtype=float)
        if mode == 'LU':
            A = [[2, 2, 2],
                 [4, 7, 7],
                 [6, 18, 22]]
            print("A矩阵:\n", A)
            L, U = LU_Factorization(A)
            print("矩阵A经过LU分解后得到的结果：")
            print("L矩阵:\n", L)
            print("U矩阵:\n", U)
            n = len(A[0])
            x = np.zeros_like(A[0])
            y = np.zeros_like(A[0])
            for i in range(n):
                y[i] = b[i]
                for j in range(i):
                    y[i] = y[i] - y[j] * L[i][j]
            for i in range(n):
                x[n - i - 1] = y[n - i - 1]
                for j in range(i):
                    x[n - i - 1] = x[n - i - 1] - x[n - j - 1] * U[n - i - 1][n - j - 1]
                x[n - i - 1] /= U[n - i - 1][n - i - 1]
            print("AX=B的解如下：")
            print("X:", x)
            det_L, det_U = 1, 1
            for i in range(n):
                det_L = det_L * L[i][i]
                det_U = det_U * U[i][i]
            det_A = det_L * det_U
            print("A的行列式为：", det_A)

        elif mode == 'QR':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            print("A矩阵:\n", A)
            Q, R = QR_Factorization(A)
            print("矩阵A经过QR分解后得到的结果：")
            print("Q矩阵:\n", Q)
            print("R矩阵:\n", R)
            n = len(A[0])
            x = np.zeros_like(A[0])
            b = Q.dot(b.T)
            for i in range(n):
                x[i] = b[i]
                for j in range(i):
                    x[i] = x[i] - x[j] * R[i][j]
            print("AX=B的解如下：")
            print("X:", x)
            det_R = 1
            for i in range(n):
                det_R = det_R * R[i][i]
            det_A = det_R
            print("A的行列式为：", det_A)

        elif mode == 'HouseHolder':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            print("A矩阵:\n", A)
            P, T = HouseHolder(A)
            print("矩阵A经过HousHolder变换后得到的结果：")
            print("P矩阵:\n", P)
            print("T矩阵:\n", T)
            n = len(A[0])
            x = np.zeros_like(A[0])
            b = P.dot(b.T)
            for i in range(n):
                x[i] = b[i]
                for j in range(i):
                    x[i] = x[i] - x[j] * T[i, j]
            print("AX=B的解如下：")
            print("X:", x)
            det_T = 1
            for i in range(n):
                det_T = det_T * T[i, i]
            det_A = det_T
            print("A的行列式为：", det_A)

        elif mode == 'Givens':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            P, T = Givens(A)
            print("A矩阵:\n", A)
            print("矩阵A经过Givens变换后得到的结果：")
            print("P矩阵:\n", P)
            print("T矩阵:\n", T)
            n = len(A[0])
            x = np.zeros_like(A[0])
            b = P.dot(b.T)
            for i in range(n):
                x[i] = b[i]
                for j in range(i):
                    x[i] = x[i] - x[j] * T[i, j]
            print("AX=B的解如下：")
            print("X:", x)
            det_T = 1
            for i in range(n):
                det_T = det_T * T[i, i]
            det_A = det_T
            print("A的行列式为：", det_A)

        elif mode == 'URV':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            U, R, V = URV_Factorization(A)
            n = len(A[0])
            x = np.zeros_like(A[0])
            y = np.zeros_like(A[0])
            b = U.dot(b.T)
            for i in range(n):
                y[i] = b[0, i]
                for j in range(i):
                    y[i] = y[i] - y[j] * R[i, j]
            print(y)
            x = V.dot(y.T)
            print("AX=B的解如下：")
            print("X:", x)
            det_A = 1
            for i in range(n):
                if R[i, i] == 0:
                    break
                det_A = det_A * R[i, i]
            print("A的行列式为：", det_A)

        else:
            print('无法选择其他方法！')

    elif flag == 0:
        n = int(input('请输入矩阵A的大小\n'))
        b_input = input('请输入'+str(n)+'个数\n')
        A_input = input('请输入'+str(n*n)+'个数\n')
        b = [int(temp) for temp in b_input.split(' ')]
        b = np.array(b, dtype=float)
        A = [int(temp) for temp in A_input.split(' ')]
        A = np.array(A, dtype=float)
        A = A.reshape(n, n)
        if mode == 'LU':
            print("A矩阵:\n", A)
            L, U = LU_Factorization(A)
            print("矩阵A经过LU分解后得到的结果：")
            print("L矩阵:\n", L)
            print("U矩阵:\n", U)
            n = len(A[0])
            x = np.zeros_like(A[0])
            y = np.zeros_like(A[0])
            for i in range(n):
                y[i] = b[i]
                for j in range(i):
                    y[i] = y[i] - y[j] * L[i][j]
            for i in range(n):
                x[n - i - 1] = y[n - i - 1]
                for j in range(i):
                    x[n - i - 1] = x[n - i - 1] - x[n - j - 1] * U[n - i - 1][n - j - 1]
                x[n - i - 1] /= U[n - i - 1][n - i - 1]
            print("AX=B的解如下：")
            print("X:", x)
            det_L, det_U = 1, 1
            for i in range(n):
                det_L = det_L * L[i][i]
                det_U = det_U * U[i][i]
            det_A = det_L * det_U
            print("A的行列式为：", det_A)

        elif mode == 'QR':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            print("A矩阵:\n", A)
            Q, R = QR_Factorization(A)
            print("矩阵A经过QR分解后得到的结果：")
            print("Q矩阵:\n", Q)
            print("R矩阵:\n", R)
            n = len(A[0])
            x = np.zeros_like(A[0])
            b = Q.dot(b.T)
            for i in range(n):
                x[i] = b[i]
                for j in range(i):
                    x[i] = x[i] - x[j] * R[i][j]
            print("AX=B的解如下：")
            print("X:", x)
            det_R = 1
            for i in range(n):
                det_R = det_R * R[i][i]
            det_A = det_R
            print("A的行列式为：", det_A)

        elif mode == 'HouseHolder':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            print("A矩阵:\n", A)
            P, T = HouseHolder(A)
            print("矩阵A经过HousHolder变换后得到的结果：")
            print("P矩阵:\n", P)
            print("T矩阵:\n", T)
            n = len(A[0])
            x = np.zeros_like(A[0])
            b = P.dot(b.T)
            for i in range(n):
                x[i] = b[i]
                for j in range(i):
                    x[i] = x[i] - x[j] * T[i, j]
            print("AX=B的解如下：")
            print("X:", x)
            det_T = 1
            for i in range(n):
                det_T = det_T * T[i, i]
            det_A = det_T
            print("A的行列式为：", det_A)

        elif mode == 'Givens':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            P, T = Givens(A)
            print("A矩阵:\n", A)
            print("矩阵A经过Givens变换后得到的结果：")
            print("P矩阵:\n", P)
            print("T矩阵:\n", T)
            n = len(A[0])
            x = np.zeros_like(A[0])
            b = P.dot(b.T)
            for i in range(n):
                x[i] = b[i]
                for j in range(i):
                    x[i] = x[i] - x[j] * T[i, j]
            print("AX=B的解如下：")
            print("X:", x)
            det_T = 1
            for i in range(n):
                det_T = det_T * T[i, i]
            det_A = det_T
            print("A的行列式为：", det_A)

        elif mode == 'URV':
            A = [[0, -20, -14],
                 [3, 27, -4],
                 [4, 11, -2]]
            U, R, V = URV_Factorization(A)
            n = len(A[0])
            x = np.zeros_like(A[0])
            y = np.zeros_like(A[0])
            b = U.dot(b.T)
            for i in range(n):
                y[i] = b[0, i]
                for j in range(i):
                    y[i] = y[i] - y[j] * R[i, j]
            print(y)
            x = V.dot(y.T)
            print("AX=B的解如下：")
            print("X:", x)
            det_A = 1
            for i in range(n):
                if R[i, i] == 0:
                    break
                det_A = det_A * R[i, i]
            print("A的行列式为：", det_A)

        else:
            print('无法选择其他方法！')
    else:
        print("只能输入1和0")
奋斗的叶小白
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
国科大UCAS 2022年矩阵分析李保滨往年题+课程作业答案
qq_42455246的博客
01-09 1250
国科大UCAS 2022年矩阵分析李保滨平时作业
国科大_李保滨_矩阵分析与应用_2014-2016年期末试卷_含答案
12-29
国科大李保滨_矩阵分析与应用_2014-2016年期末试卷_含答案
李保滨矩阵分析大作业2022：LU、QR、URV分解、Householder、Givens变换的程序实现
KiKi_688的博客
01-08 2262
本文是2022年中国科学院大学秋季学期李保滨老师矩阵分析与应用的大作业，实现LU、QR、URV分解、Householder与Givens规约变换。文章总结了代码实现与算法过程，并设计了一个主函数来汇总各个方法。主函数可以实现矩阵分解、解方程以及利用分解结果求解行列式。
国科大学习资料--矩阵分析与应用（李保滨）--2017年期末考试试卷
无名何许人的博客
10-06 793
国科大学习资料–矩阵分析与应用（李保滨）–2017年期末考试试卷 国科大学习资料–矩阵分析与应用（李保滨）–2017年期末考试试卷 国科大学习资料–矩阵分析与应用（李保滨）–2017年期末考试试卷 ...
国科大—矩阵分析与应用（李老师）—复习提纲—5.模和内积Ⅰ
qq_44860963的博客
11-12 550
国科大—矩阵分析与应用（李老师）—复习提纲—5.模和内积Ⅰ
国科大李保滨矩阵分析与应用2021回忆版
Katniss的Blog
11-15 2862
一、填空题（4‘*7） 求一4*5矩阵的秩 求矩阵的index 求正交矩阵的行列式 求一2*2矩阵在二模下的条件数K 给一向量u，求正交投影矩阵 给两个向量求角度 矩阵的无穷模 二、大题 给定线性方程组，线性方程组中的a,b取什么值有解？求无穷解时的基础解系。 说明反对称矩阵An∗nA_{n*n}An∗n​，n为奇数时，det|A|=0. classical gram-Schmidt 的流程。 所有n*n实矩阵在Rn构成的向量空间V，说明对称矩阵Sn和反对称矩阵Kn是子空间，同时说明Sn
矩阵分析与应用 大作业 李保滨 国科大
最新发布
Gowi的博客
01-23 411
2、可以用matlab、Python等编写程序，需附上简单的程序说明，比如参数代表什么意思，输入什么，输出什么等等，附上相应的例子；3、一定是可执行文件，例如 .m文件等,不能是word或者txt文档。附上源代码，不能为直接调用matlab等函数库;1、一个综合程序，根据选择参数的不同，实现不同的矩阵分解；在此基础上，实现Ax=b方程组的求解，以及计算A的行列式；
矩阵论期末考试（一）
qq_41630523的博客
06-30 9548
1⃣️范数 范数>=0 ||A||∞：行和范数，计算方式：{一行中每个元素的绝对值之和}max，本题答案是：|-i|+|2|+|5|=8 ||A||1：列和范数，计算方式：{一列中每个元素的绝对值之和}max，本题答案是：|i|+|2|+|5|=8 ||A||F：F-范数，计算方式：矩阵元素绝对值的平方之和在开根号，本题答案是：sqrt(|1|2+|0|2+|i|2+|0|2+|1|2+|2|2+|-i|2+|2|2+|5|2)=sqrt(37) ||A||2：2-范数，计算方式：sqrt({A
国科大python期末综合练习hangman代码
qq_38036598的博客
05-23 736
这份代码是我昨天晚上（2021/5/22）写的，如有纰漏，多多包涵。 游戏要求: 1、计算机从单词表中随机地选取一个单词，实现这一点的代码已经提供在文件中。 2、游戏是交互式的，游戏的流程如下： • 刚开始时，让用户知道单词的长度（即secretWord的长度） • 每一轮让用户猜一次（一个字母） • 用户能得到立即反馈，所猜字母是否是secret单词的字母 • 每一轮，需要显示已经猜中的部分，以及用户没有猜过的字母 3.游戏的额外规则： 用户可以猜8次. 每一轮猜测后提醒他剩余多少次可猜。假设用户总是每
中国科学院大学矩阵分析与应用-教材及教材答案-平时作业-期末试卷-资源集合2022
11-17
李保滨老师矩阵分析与应用的大部分资料合集，包括教材，教材答案，作业题，作业答案，多年的期末试卷等，希望对大家学习矩阵有一定的帮助
国科大python课程期末综合作业hangman游戏代码
04-17
国科大python课程期末综合作业hangman游戏代码
矩阵分析与应用期末宝典.zip
12-27
国科大 矩阵分析与应用期末试题 李保滨老师 往年试题 2014-2018中科院矩阵分析与应用期末复习整理考题包含解题过程 李保滨老师的考试内容不难，与往年内容相似
国科大 矩阵论 期末考试
01-08
国科大4套矩阵论的期末考试题，图像都经过增强，白纸黑字可以打印。
国科大李保滨矩阵分析2020课后题答案.docx
11-25
国科大李保滨老师的矩阵分析ppt2020年课后题答案，含有重要的证明分析，习题及习解答，可以作为考试的重要参考资料
国科大lbb矩阵分析与应用2021回忆版（11月）.pdf
04-25
国科大lbb矩阵分析与应用2021回忆版试题（11月）.pdf
国科大-矩阵分析与应用-2014-2017试卷
01-16
国科大李保滨老师的矩阵分析与应用，包含2014-2017试卷
国科大矩阵分析试卷2020年.jpg
09-05
国科大_李保滨_矩阵分析与应用_2020年11月期末试卷
Python期末复习知识点大合集（期末不挂科版）
热门推荐
北天的博客
02-14 2万+
Python期末考试知识点总结大合集（期末不挂科版）,祝大家期末考试顺利通过！！！总结不易，期待得到你们的点赞收藏转发三连，谢谢！
国科大—矩阵分析与应用（李老师）—复习提纲—2.矩阵代数
qq_44860963的博客
11-06 344
国科大—矩阵分析与应用（李老师）—复习提纲—2.矩阵代数
国科大ucas 2022年矩阵分析李保滨往年题+课程作业答案
11-15
2022年国科大的矩阵分析课程作业答案应该是由学生自己完成的，不应该直接使用往年的题目和答案。矩阵分析是一门重要的数学课程，通过学习这门课程可以帮助学生更好地理解和应用矩阵在科学和工程领域中的作用。因此，学生需要通过自己的努力和思考来完成课程作业，而不是简单地抄袭和借用往年的题目和答案。这样才能真正地掌握知识，并且在将来的学习和工作中能够更好地运用所学到的知识。 此外，直接使用往年的题目和答案也是一种学术上的不端行为，违背了学术道德和诚信原则。在学习和做作业的过程中，学生应该秉持诚实、勤奋和负责任的态度，通过自己的努力来完成作业和提高自己的学习能力。只有这样才能真正受益于课程，提高自己的专业水平。 因此，对于2022年国科大矩阵分析课程的作业，希望学生能够主动学习、勤奋钻研，不断提高自己的矩阵分析能力，而不是简单地寻找往年题目和答案。只有通过自己的努力和思考，才能真正地掌握和运用所学到的知识，为将来的学习和工作打下更坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值