精华内容
下载资源
问答
  • 矩阵求逆中的小困扰

    2017-11-13 20:52:00
    距上次矩阵乘法一月有余,目前矩阵求逆也逐渐略有眉头,从刚开始的小模块搭建,到后来整个求逆操作的循环,终于向前进步一大步,虽然结果并不正确,可思路没毛病呀! 接下来就是对负数的处理,解决这一关,循环基本...

              距上次矩阵乘法一月有余,目前矩阵求逆也逐渐略有眉头,从刚开始的小模块搭建,到后来整个求逆操作的循环,终于向前进步一大步,虽然结果并不正确,可思路没毛病呀!

    接下来就是对负数的处理,解决这一关,循环基本上可以告一段落了,也可以紧接着往下进行,兜兜转转,在这个循环上浪费很多时间,双十一的风潮碾压过后,真是又穷又累,

    调整状态,等待我的求逆完成!

     

    转载于:https://www.cnblogs.com/fangx/p/7828074.html

    展开全文
  • 矩阵求逆(基于LU分解法)

    千次阅读 2013-05-04 22:52:06
    算法名称:矩阵求逆(基于LU分解法)   LU分解算法评价:  LU分解大约需要执行N3/3次内层循环(每次包括一次乘法和一次加法)。这是求解一个(或少量几个)右端项时的运算次数,它要比Gauss-Jordan消去法快三倍...
    算法名称:矩阵求逆(基于LU分解法)
     
    LU分解算法评价:
           LU分解大约需要执行N3/3次内层循环(每次包括一次乘法和一次加法)。这是求解一个(或少量几个)右端项时的运算次数,它要比Gauss-Jordan消去法快三倍,比不计算逆矩阵的Gauss-Jordan法快1.5倍。
           当要求解逆矩阵时,总的运算次数(包括向前替代和回代部分)为N3,与Gauss-Jordan法相同。
     
    算法描述:
    简言之,我们只需对原始矩阵进行一次LU分解,然后变换右端向量b就可以了,即设我们的原始矩阵为4×4阶方阵,那么我们的b依次
    然后重新排列成的矩阵就是逆矩阵了。
     
    运行示例:
    Origin matrix:
     | 0.0 2.0 0.0 1.0 |
     | 2.0 2.0 3.0 2.0 |
     | 4.0 -3.0 0.0 1.0 |
     | 6.0 1.0 -6.0 -5.0 |
    -----------------------------------------------
    Its inverse matrix:
     | -0.025641025641025623 0.1282051282051282 0.08974358974358977 0.0641025641025641 |
     | 0.17948717948717946 0.10256410256410259 -0.12820512820512822 0.05128205128205129 |
     | -0.5299145299145299 0.3162393162393163 -0.14529914529914528 -0.00854700854700854 |
     | 0.6410256410256411 -0.20512820512820518 0.25641025641025644 -0.10256410256410257 |
    -----------------------------------------------
    示例程序:
    package com.nc4nr.chapter02.matrixinver;

    public class MatrixInver {

        
    double[][] a = {
                
    {0.02.00.01.0},
                
    {2.02.03.02.0},
                
    {4.0-3.00.01.0},
                
    {6.01.0-6.0-5.0}
        }
    ;
        
        
    double[] b = null;
        
        
    int anrow = 4;
        
    double[] vv = new double[anrow];
        
    int[] indx = new int[anrow];
        
        
    private void lucmp() {
            
    int n = anrow, imax = 0;
            
    for (int i = 0; i < n; i++{
                
    double big = 0.0;
                
    for (int j = 0; j < n; j++{
                    
    double temp = Math.abs(a[i][j]);
                    
    if (temp > big) big = temp;
                }

                vv[i] 
    = 1.0 / big;
            }

            
    for (int j = 0; j < n; j++{
                
    for (int i = 0; i < j; i++{
                    
    double sum = a[i][j];
                    
    for (int k = 0; k < i; k++) sum -= a[i][k] * a[k][j];
                    a[i][j] 
    = sum;
                }

                
    double big = 0.0;
                
    for (int i = j; i < n; i++{
                    
    double sum = a[i][j];
                    
    for (int k = 0; k < j; k++) sum -= a[i][k] * a[k][j];
                    a[i][j] 
    = sum;
                    
    double dum = vv[i] * Math.abs(sum);
                    
    if (dum >= big) {
                        big 
    = dum;
                        imax 
    = i;
                    }

                }

                
    if (j != imax) {
                    
    for (int i = 0; i < n; i++{
                        
    double mid = a[imax][i];
                        a[imax][i] 
    = a[j][i];
                        a[j][i] 
    = mid;
                    }

                    
    double mid = vv[j];
                    vv[j] 
    = vv[imax];
                    vv[imax] 
    = mid;
                }

                indx[j] 
    = imax;
                
    if (j != n - 1{
                    
    double dum = 1.0/a[j][j];
                    
    for (int i = j + 1; i < n; i++) a[i][j] *= dum; 
                }

            }

        }

        
        
    private void lubksb(double[] b) {
            
    int n = anrow, ii = 0;
            
    // y
            for (int i = 0; i < n; i++{    
                
    int ip = indx[i];        
                
    double sum = b[ip];
                b[ip] 
    = b[i];
                
    if (ii != 0)
                    
    for (int j = ii - 1; j < i; j++) sum -= a[i][j] * b[j];
                
    else
                    ii 
    = i + 1;
                b[i] 
    = sum;
            }

            
    // x
            for (int i = n - 1; i >= 0; i--{
                
    double sum = b[i];
                
    for (int j = i + 1; j < n; j++) sum -= a[i][j]*b[j];
                b[i] 
    = sum / a[i][i];
            }

        }

        
        
    private void output(double a[][], int anrow) {
            
    for (int i = 0; i < anrow; i++{
                System.out.println(
    " | " + a[i][0+ " " + 
                        a[i][
    1+ " " + 
                        a[i][
    2+ " " + 
                        a[i][
    3+ " | ");
            }

            System.out.println(
    "-----------------------------------------------");
        }

        
        
    public MatrixInver() {
            System.out.println(
    "Origin matrix:");
            output(a,
    4);
            lucmp();
            
    double[] b = new double[anrow];
            
    double[][] y = new double[anrow][anrow];
            
    for (int i = 0; i < anrow; i++
                
    for (int j = 0; j < anrow; j++) b[j] = 0;
                b[i] 
    = 1.0;
                lubksb(b);
                
    for (int j = 0; j < anrow; j++) y[j][i] = b[j];
            }

            System.out.println(
    "Its inverse matrix:");
            output(y,
    4);
        }

        
        
    public static void main(String[] args) {
            
    new MatrixInver();
        }


    }
    展开全文
  • 矩阵的分块求逆及解线性方程组实验3 矩阵的分块求逆及解线性方程组问题化已知矩阵为上三角矩阵,构作范德蒙矩阵,高阶非奇异矩阵的分块求逆,求非齐次线性方程组的通解。实验目的学会用Matlab语言编程,实施矩阵的...

    矩阵的分块求逆及解线性方程组

    实验3 矩阵的分块求逆及解线性方程组

    问题

    化已知矩阵为上三角矩阵,构作范德蒙矩阵,高阶非奇异矩阵的分块求逆,求非齐次线性方程组的通解。

    实验目的

    学会用Matlab语言编程,实施矩阵的初等变换将已知矩阵化为上三角矩阵;掌握用循环语句由已知向量构造范德蒙矩阵;了解高阶非奇异矩阵用不同分块法求逆矩阵的误差分析;能根据由软件求得的非齐次线性方程组增广矩阵的阶梯型的最简形式写出线性方程组的通解。

    预备知识

    线性代数知识:

    向量作出的 n 阶范德蒙矩阵为

    (2)分块矩阵,其中为方的可逆子块,求逆矩阵有如下公式:

    设,则,

    (3)常用的矩阵范数为Frobenius范数;

    本实验所用Matlab命令提示:

    (1)输入语句:input('输入提示');

    (2)循环语句:for 循环变量=初始值 :步长 :终值

    循环语句组

    end

    (3)条件语句: if(条件式1)

    条件块语句组1

    elseif(条件式2)

    条件块语句组2

    else

    条件块语句组3

    end

    (4)矩阵和向量的范数:norm(A);

    (5)求矩阵A的秩:rank(A);

    (6)求矩阵A的阶梯型的行最简形式:rref(A)。

    实验内容及要求

    在建立的sy31.m文件中编程将任意给定的n阶方阵B1,化为上三角矩阵B1;调用时输入:B1=A ,n=6;其A为实验1[矩阵的基本运算]中的矩阵A矩阵;

    在建立的sy32.m文件中编程用1~6单位增量的行向量产生一个范德蒙矩阵B2;

    在建立的sy33.m文件中编程对任意输入的高阶分块可逆矩阵B3实现分块法求逆;(1)调用sy33.m文件时输入:B3=A^2 ,输入n1=2求出B3的逆C2 ;

    (2)调用sy33.m文件时输入同上的B3,输入n1=4求出B3的逆C4 ;

    (3)调用sy33.m文件时输入同上的B3,输入n1=6求出B3的逆C6 ;

    (4)用norm()函数对上面三种方法所求的逆作误差分析[即作(B3*Ci-E)的范数];

    建立sy34.m文件,求下列非齐次线性方程组的通解。

    五、思考与练习

    求下列齐次线性方程组的基础解系

    2.用任意输入的8维行向量构造一个8阶范德蒙矩阵。

    六、操作提示

    1.计算过程

    (1)sy31.m文件

    B1=input('B1=')

    N=input('N=')

    for j=1:N

    for i=j+1:N

    B1(i,:)=-B1(i,j)/B1(j,j)*B1(j,:)+B1(i,:)

    end

    end

    B1

    调用时输入:Load sy1 A

    B1=A ,n=6

    (2)sy32.m文件

    t=input('t=');

    t

    n=input('n=');

    for i=1:n

    B2(i,:)=t.^(i-1);

    end

    B2

    调用时输入:T=1:6 ,n=6

    (3)sy33.m文件

    B3=input('B3=');

    [n,m]=size(B3);

    n1=input('n1=');

    if(n1>n)

    disp('n1>n')

    elseif(n1==n)

    C1=inv(B3)

    else

    b11=B3(1:n1,1:n1);

    b12=B3(1:n1,n1+1:n);

    b21=B3(n1+1:n,1:n1);

    b22=B3(n1+1:n,n1+1:n);

    ib11=inv(b11);c22=inv(b22-b21*ib11*b12);

    c12=-ib11*b12*c22;c21=-c22*b21*ib11;

    c11=ib11-c12*b21*ib11;

    C=[c11 c12;c21 c22]

    End

    调用时输入:B3=A^2 ,n1=4; 转换C4=C;

    调用时输入:同上的B3 ,n1=2; 转换C2=C;

    调用时输入:同上的B3 ,n1=6; 转换C6=C;

    E=eye(size(B3));

    norm(B3*C2-E);

    norm(B3*C4-E);

    norm(B3*C6-E);

    (4)sy34.m文件

    A34=[1 2 4 6 -3 2 4;2 4 -4 5 1 -5 3;3 6 2 0 5 -9 -1;...

    2 3 0 4 0 1 8;0 -4 -5 2 1 4 -5;5 5 -3 6 6 -4 2]

    rank(A34)

    A35=rref(A34)

    2.计算结果

    >> sy31

    B1=A

    B1 =

    3 4 -1 1 -9 10

    6 5

    展开全文
  • 矩阵求逆算法实现(基于LU分解法)

    千次阅读 2007-12-03 19:14:00
    算法名称:矩阵求逆(基于LU分解法) LU分解算法评价: LU分解大约需要执行N3/3次内层循环(每次包括一次乘法和一次加法)。这是求解一个(或少量几个)右端项时的运算次数,它要比Gauss-Jordan消去法快三倍,比不...
     
    算法名称:矩阵求逆(基于LU分解法)
     
    LU分解算法评价:
           LU分解大约需要执行N3/3次内层循环(每次包括一次乘法和一次加法)。这是求解一个(或少量几个)右端项时的运算次数,它要比Gauss-Jordan消去法快三倍,比不计算逆矩阵的Gauss-Jordan法快1.5倍。
           当要求解逆矩阵时,总的运算次数(包括向前替代和回代部分)为N3,与Gauss-Jordan法相同。
     
    算法描述:
    简言之,我们只需对原始矩阵进行一次LU分解,然后变换右端向量b就可以了,即设我们的原始矩阵为4×4阶方阵,那么我们的b依次
    然后重新排列成的矩阵就是逆矩阵了。
     
    运行示例:
    Origin matrix:
     | 0.0 2.0 0.0 1.0 |
     | 2.0 2.0 3.0 2.0 |
     | 4.0 -3.0 0.0 1.0 |
     | 6.0 1.0 -6.0 -5.0 |
    -----------------------------------------------
    Its inverse matrix:
     | -0.025641025641025623 0.1282051282051282 0.08974358974358977 0.0641025641025641 |
     | 0.17948717948717946 0.10256410256410259 -0.12820512820512822 0.05128205128205129 |
     | -0.5299145299145299 0.3162393162393163 -0.14529914529914528 -0.00854700854700854 |
     | 0.6410256410256411 -0.20512820512820518 0.25641025641025644 -0.10256410256410257 |
    -----------------------------------------------
    示例程序:
    package com.nc4nr.chapter02.matrixinver;

    public class MatrixInver {

        
    double[][] a = {
                
    {0.02.00.01.0},
                
    {2.02.03.02.0},
                
    {4.0-3.00.01.0},
                
    {6.01.0-6.0-5.0}
        }
    ;
        
        
    double[] b = null;
        
        
    int anrow = 4;
        
    double[] vv = new double[anrow];
        
    int[] indx = new int[anrow];
        
        
    private void lucmp() {
            
    int n = anrow, imax = 0;
            
    for (int i = 0; i < n; i++{
                
    double big = 0.0;
                
    for (int j = 0; j < n; j++{
                    
    double temp = Math.abs(a[i][j]);
                    
    if (temp > big) big = temp;
                }

                vv[i] 
    = 1.0 / big;
            }

            
    for (int j = 0; j < n; j++{
                
    for (int i = 0; i < j; i++{
                    
    double sum = a[i][j];
                    
    for (int k = 0; k < i; k++) sum -= a[i][k] * a[k][j];
                    a[i][j] 
    = sum;
                }

                
    double big = 0.0;
                
    for (int i = j; i < n; i++{
                    
    double sum = a[i][j];
                    
    for (int k = 0; k < j; k++) sum -= a[i][k] * a[k][j];
                    a[i][j] 
    = sum;
                    
    double dum = vv[i] * Math.abs(sum);
                    
    if (dum >= big) {
                        big 
    = dum;
                        imax 
    = i;
                    }

                }

                
    if (j != imax) {
                    
    for (int i = 0; i < n; i++{
                        
    double mid = a[imax][i];
                        a[imax][i] 
    = a[j][i];
                        a[j][i] 
    = mid;
                    }

                    
    double mid = vv[j];
                    vv[j] 
    = vv[imax];
                    vv[imax] 
    = mid;
                }

                indx[j] 
    = imax;
                
    if (j != n - 1{
                    
    double dum = 1.0/a[j][j];
                    
    for (int i = j + 1; i < n; i++) a[i][j] *= dum; 
                }

            }

        }

        
        
    private void lubksb(double[] b) {
            
    int n = anrow, ii = 0;
            
    // y
            for (int i = 0; i < n; i++{    
                
    int ip = indx[i];        
                
    double sum = b[ip];
                b[ip] 
    = b[i];
                
    if (ii != 0)
                    
    for (int j = ii - 1; j < i; j++) sum -= a[i][j] * b[j];
                
    else
                    ii 
    = i + 1;
                b[i] 
    = sum;
            }

            
    // x
            for (int i = n - 1; i >= 0; i--{
                
    double sum = b[i];
                
    for (int j = i + 1; j < n; j++) sum -= a[i][j]*b[j];
                b[i] 
    = sum / a[i][i];
            }

        }

        
        
    private void output(double a[][], int anrow) {
            
    for (int i = 0; i < anrow; i++{
                System.out.println(
    " | " + a[i][0+ " " + 
                        a[i][
    1+ " " + 
                        a[i][
    2+ " " + 
                        a[i][
    3+ " | ");
            }

            System.out.println(
    "-----------------------------------------------");
        }

        
        
    public MatrixInver() {
            System.out.println(
    "Origin matrix:");
            output(a,
    4);
            lucmp();
            
    double[] b = new double[anrow];
            
    double[][] y = new double[anrow][anrow];
            
    for (int i = 0; i < anrow; i++
                
    for (int j = 0; j < anrow; j++) b[j] = 0;
                b[i] 
    = 1.0;
                lubksb(b);
                
    for (int j = 0; j < anrow; j++) y[j][i] = b[j];
            }

            System.out.println(
    "Its inverse matrix:");
            output(y,
    4);
        }

        
        
    public static void main(String[] args) {
            
    new MatrixInver();
        }


    }

    展开全文
  • 雅可比方法用于求解实对称矩阵的特征值和特征向量,对于实对称矩阵AAA,必有正交矩阵UUU,使得UTAU=DU^{T}AU=DUTAU=D.DDD是一个对角阵,主对角线的元素是矩阵AAA的特征值,正交矩阵UUU的每一列对应于属于矩阵DDD的主对角...
  • Java求逆矩阵

    2021-01-18 13:21:33
    @[初学Java,写了一个求逆矩阵的程序) 初学Java,写了一个求逆矩阵的程序 经过几天摸爬滚打,总算是成功了,以下是具体的实现步骤,后续还会进行改进 计算方法 本程序目前只能实现用伴随矩阵法实现逆矩阵的求解。拿...
  • } 五、求矩阵 public static double[,] Inverse(double[,] Array) { int m = 0; int n = 0; m = Array.GetLength(0); n = Array.GetLength(1); double[,] array = new double[2 * m + 1, 2 * n + 1]; for (int ...
  • PLU-分解以及求逆矩阵

    2021-02-03 11:17:40
    PLU-分解是对LU分解的一种改进,其增加了选主元的操作增加了计算的稳定性,及在第i次循环中将 j=where(max⁡(∣A[i:n,i]∣))j=where(\max(|A[i:n,i]|))j=where(max(∣A[i:n,i]∣)) 行和第i行进行交换来比避免对角...
  • C语言关于矩阵的一些运算(转置,求逆,乘法) 1.矩阵的转置 Transpose(例子,以3*4的矩阵为例,其他修改数字即可) void Transpose(int Mat[3][4], int newMat[4][3])//Mat是要进行转置的,newMat是转置后的 { for ...
  • 多篇矩阵相关的论文

    2013-12-09 09:21:31
    包含《循环矩阵求逆的快速算法》、《Hankel矩阵及其逆矩阵的快速三角分解算法的改进》、《对称循环矩阵及其逆矩阵三角分解的快速算法》等论文
  • 作业要求用适当的方法求逆矩阵,给出判别条件,编写程序。我在网上找的程序、但是看不懂、求高手帮我看看这个程序用的是什么方法、再帮我画出NS流程图、感激不尽 #include <stdio.h>#include <malloc.h>void main...
  • LU分解的矩阵逆运算

    千次阅读 2016-08-26 15:47:52
    LU分解的矩阵逆运算 标签: matrixoutput算法inistring 2010-11-07 00:24 2440人阅读 评论(0) ...算法名称:矩阵求逆(基于LU分解法)   LU分解算法评价:  LU分解大约需要执行N3/3次内层循环(每
  •  解题报告:n挺大,不过矩阵仍然是循环矩阵,可以在n^2复杂度内出。  对于走w步时矩阵的构建要注意,w可能大于n。而且顺时针和时针可能走到相同的位置。所以是在可能的位置+0.5。  代码如下: #include #...
  • 限制坐标范围matlab中的不等号matlab求逆运算冒号的使用方法在for循环中的用法在矩阵中的用法. 号用法.* 与 * 的区别绘图——已知两点画线段限制坐标轴的范围 本文用来记录使用matlab时出现的一些问题,内容主要是...
  • 题目大意:9种操作可以让不同的种转动90度,最小上升的操作方式。  解题报告:这题解法众多,也很有趣。可以BFS,DFS,9重循环暴搜也没问题= =。当然,为了学习还是用高斯消元法做的。  Discuss也有人讨论了,4...
  • 从(1,1)点出发,时针,然后顺时针,一直循环矩阵给出的数字的坐标是多少。 思路: 暴力肯定是不行了,没有那么大的数组,所以只能找规律。注意到偶数行,奇数列的起始都是坐标的平方,这样通过计算与...
  • 在权值优化过程中,每一次只更新权向量的一部分,通过多次迭代更新使系统搜索得到最优权值,避免了全维相关矩阵求逆运算。实验结果表明,与传统方法相比,该方法在大规模阵列波束形成时能够获得更高的信干噪比,并...
  • 题目: 设将n个整数存放在一维数组R中,设计一个在时间和空间两...解决思路:矩阵求逆,先将a逆置得到a^-1b,再将b逆置得到a^-1b^-1,最后将整个a^-1b^-1逆置得到(a^-1b^-1)^-1=ba,数组逆置即为数组反转 代
  • 目标跟踪:KCF

    千次阅读 2017-04-24 23:58:32
    KCF,由目标区域形成循环矩阵,再利用循环矩阵在傅立叶空间可对角化等一些性质,通过岭回归得到通用的预测公式,特别要说一点就是该预测公式没有矩阵求逆的计算,这都归功于作者巧妙地将循环矩阵在傅立叶空间的性质...
  • 然后基于循环矩阵的特性把问题的求解变换到了离散傅里叶变换域,从而避免了矩阵求逆的过程,降低了好几个数量级的算法复杂度. 一: https://www.2cto.com/kf/201707/655288.html KCF跟踪算法代码摘要: 主要讲了...
  • KCF最近刚接触了跟踪算法,KCF是第一个深读的算法,接下来主要详细地说下该算法原理,此算法的优势...然后基于循环矩阵的特性把问题的求解变换到了傅里叶变换域,从而避免了矩阵求逆的过程,大大降低了算法的复杂度。
  • KCF原理分析

    千次阅读 2019-05-21 21:24:17
    KCF作为单目标跟踪的经典之作,在准确率和实时性... 利用循环矩阵可DFT对角化的性质,将循环矩阵求逆运算转化为向量的点乘; 3. 针对线性不可分的情况,引入核技巧映射到高维,线性可分; 牵涉到的基础知识点...
  • 2. 利用循环矩阵可DFT对角化的性质,将循环矩阵求逆运算转化为向量的点乘; 3. 针对线性不可分的情况,引入核技巧映射到高维,线性可分; 1 算法介绍 KCF全称为Kernel Correlation Filter 核相关滤波算法。是在...
  • 2. 利用循环矩阵可DFT对角化的性质,将循环矩阵求逆运算转化为向量的点乘; 3. 针对线性不可分的情况,引入核技巧映射到高维,线性可分; 1 算法介绍 KCF全称为Kernel Correlation Filter 核相关滤波算法。是在...

空空如也

空空如也

1 2 3 4 5
收藏数 86
精华内容 34
关键字:

循环矩阵求逆