精华内容
下载资源
问答
  • Cholesky分解

    2019-08-28 15:06:54
    Cholesky分解是一种分解矩阵的方法, 在线性代数中有重要的应用。Cholesky分解把矩阵分解为一个下三角矩阵以及它的共轭转置矩阵的乘积(那实数界来类比的话,此分解就好像求平方根)。与一般的矩阵分解求解方程的方法...

    Cholesky分解是一种分解矩阵的方法, 在线性代数中有重要的应用。Cholesky分解把矩阵分解为一个下三角矩阵以及它的共轭转置矩阵的乘积(那实数界来类比的话,此分解就好像求平方根)。与一般的矩阵分解求解方程的方法比较,Cholesky分解效率很高。Cholesky是生于19世纪末的法国数学家,曾就读于巴黎综合理工学院。Cholesky分解是他在学术界最重要的贡献。后来,Cholesky参加了法国军队,不久在一战初始阵亡。

    一、Cholesky分解的条件

    1、Hermitianmatrix:矩阵中的元素共轭对称(复数域的定义,类比于实数对称矩阵)。Hermitiank意味着对于任意向量x和y,(x*)Ay共轭相等

    2、Positive-definite:正定(矩阵域,类比于正实数的一种定义)。正定矩阵A意味着,对于任何向量x,(x^T)Ax总是大于零(复数域是(x*)Ax>0)

    二、Cholesky分解的形式

    可记作A = L L*。其中L是下三角矩阵。L*是L的共轭转置矩阵。

    可以证明,只要A满足以上两个条件,L是唯一确定的,而且L的对角元素肯定是正数。反过来也对,即存在L把A分解的话,A满足以上两个条件。

    如果A是半正定的(semi-definite),也可以分解,不过这时候L就不唯一了。

    特别的,如果A是实数对称矩阵,那么L的元素肯定也是实数。

    另外,满足以上两个条件意味着A矩阵的特征值都为正实数,因为Ax = lamda * x,

    (x*)Ax = lamda * (x*)x > 0, lamda > 0

     

    展开全文
  • cholesky分解

    2014-05-11 17:47:00
    接着LU分解继续往下,就会发展出很多相关但是并不完全一样的矩阵分解,最后对于对称正定矩阵,我们则可以给出非常有用的cholesky分解。这些分解的来源就在于矩阵本身存在的特殊的 结构。对于矩阵A,如果没有任何的...

        接着LU分解继续往下,就会发展出很多相关但是并不完全一样的矩阵分解,最后对于对称正定矩阵,我们则可以给出非常有用的cholesky分解。这些分解的来源就在于矩阵本身存在的特殊的

    结构。对于矩阵A,如果没有任何的特殊结构,那么可以给出A=L*U分解,其中L是下三角矩阵且对角线全部为1,U是上三角矩阵但是对角线的值任意,将U正规化成对角线为1的矩阵,产生分解A = L*D*U, D为对角矩阵。如果A为对称矩阵,那么会产生A=L*D*L分解。如果A为正定对称矩阵,那么就会产生A=G*G,可以这么理解G=L*sqrt(D)。

    A=L*D*U分解对应的Matlab代码如下:

    function[L, D, U] =zldu(A)

    %LDU decomposition of square matrix A. The first step for Cholesky

    %decomposition

     

    [m, n] = size(A);

    if m ~= n

        error('support square matrix only')

    end

     

    L = eye(n);

    U = eye(n);

    d = zeros(n,1);

     

    for k=1:n

        

        v = zeros(n, 1);

        if k == 1

            v(k:end) = A(k:end, k);

        else

            m = L(1:k-1, 1:k-1) \ A(1:k-1, k);

            for j = 1:k-1

                U(j, k) = m(j) / d(j);

            end

            

            v(k:end) = A(k:end, k) - L(k:end, 1:k-1)*m(:);

        end

        

        d(k) = v(k);

        

        if k < n

            L(k+1:end, k) = v(k+1:end)/v(k);

        end

        

    end

     

    D = diag(d);

    分解的稳定性和精度结果如下:

    mean of my lu     : 9.0307e-15

    variance of my lu : 4.17441e-27

    mean of matlab lu     : 3.70519e-16

    variance of matlab lu : 2.07393e-32

    这里的计算是基于Gaxpy,所以稳定性和精确度相当之好。

     

    A=L*D*L分解对应代码如下,这里要求A必须为对称矩阵:

    function[D, L] =zldl(A)

    %A = L*D*L' another version of LU decomposition for matrix A

     

    [m, n] = size(A);

     

    if m ~= n

        error('support square matrix only')

    end

     

    L = eye(n);

    d = zeros(n,1);

     

    for k=1:n

        v = zeros(n,1);

        

        for j=1:k-1

            v(j) = L(k, j)*d(j);

        end

        

        v(k) = A(k,k) - L(k, 1:k-1)*v(1:k-1);

        

        d(k) = v(k);

        

        L(k+1:end, k) = (A(k+1:end,k) - A(k+1:end, 1:k-1)*v(1:k-1)) / v(k);

    end

     

    D = diag(d);

    对应分解的精确度和稳定度如下:

    mean of my lu : 35.264
    variance of my lu : 29011.2
    mean of matlab lu : 5.88824e-16
    variance of matlab lu : 8.40037e-32

    使用如下的代码做测试:

    n = 1500;

    my_error = zeros(1, n);

    sys_error = zeros(1, n);

     

    for i = 1:n

        test = gensys(5);

        [zd, zl] = zldl(test);

        [l, d] = ldl(test);

     

        my_error(i) = norm(zl*zd*(zl') - test, 'fro');

        sys_error(i) = norm(l*d*(l') - test, 'fro');

    end

     

    fprintf('mean of my lu     : %g\n', mean(my_error));

    fprintf('variance of my lu : %g\n', var(my_error));

     

    fprintf('mean of matlab lu     : %g\n', mean(sys_error));

    fprintf('variance of matlab lu : %g\n', var(sys_error));


    对于运算的精度如此之低的原因并不清楚

     

    A=G*G’; cholesky分解对应的代码如下:

    function[G] =zgaxpychol(A)

    %cholesky decomposition for symmetric positive definite matrix

    %the only requirement is matrix A: symmetric positive definite

     

    [m, n] = size(A);

     

    if m ~= n

        error('support square matrix only')

    end

     

    G = eye(n);

     

    for k=1:n

        

        v = A(:,k);

        

        if k > 1

            v(:) = v(:) - G(:,1:k-1)*G(k,1:k-1)';

        end

        

        G(k:end, k) = v(k:end) / sqrt(v(k));

    end

    对应的测试结果如下

    mean of my lu : 1.10711e-15
    variance of my lu : 3.04741e-31
    mean of matlab lu : 5.5205e-16
    variance of matlab lu : 9.64928e-32

    自己代码的精确度和稳定性可以媲美Matlab的代码,产生这种结果的原因应该是positive sysmetric definite matrix的原因,这段代码基于gaxpy的结果,下面给出另外一种基于外积的运算结果。

    function[G] =zopchol(A)

    %cholesky decomposition based on rank-1 matrix update

     

    [m, n] = size(A);

    if m ~= n

        error('support square matrix only')

    end

     

    G = zeros(n);

     

    for k=1:n

        

        G(k,k) = sqrt(A(k,k));

        G(k+1:end, k) = A(k+1:end, k) / G(k,k);

        

        %update matrix A

        for j = (k+1):n

            A(k+1:end,j) = A(k+1:end,j) - G(j,k)*G(k+1:end,k);

        end

    end

     

    对应的测试结果如下:

    mean of my lu : 9.33114e-16
    variance of my lu : 1.71179e-31
    mean of matlab lu : 9.92241e-16
    variance of matlab lu : 1.60667e-31

    对应的测试程序如下,这里使用系统自带的chol函数完成cholesky分解。

    n = 1500;

    my_error = zeros(1, n);

    sys_error = zeros(1, n);

     

    for i = 1:n

        test = genpd(5);

        [zg] = zopchol(test);

        l = chol(test, 'lower');

     

        my_error(i) = norm(zg*(zg') - test, 'fro');

        sys_error(i) = norm(l*(l') - test, 'fro');

    end

     

    fprintf('mean of my lu     : %g\n', mean(my_error));

    fprintf('variance of my lu : %g\n', var(my_error));

     

    fprintf('mean of matlab lu     : %g\n', mean(sys_error));

    fprintf('variance of matlab lu : %g\n', var(sys_error));


    将两个结果想比较,可以发现两个版本的cholesky分解的精确度和稳定度差不多。

    Cholesky分解的核心在于矩阵对称正定的结构,基于LU分解的再次扩展。

    转载于:https://www.cnblogs.com/lacozhang/p/3721994.html

    展开全文
  • 接着LU分解继续往下,就会发展出很多相关但是并不完全一样的矩阵分解,最后对于对称正定矩阵,我们则可以给出非常有用的cholesky分解。这些分解的来源就在于矩阵本身存在的特殊的结构。对于矩阵A,如果没有任何的...

    接着LU分解继续往下,就会发展出很多相关但是并不完全一样的矩阵分解,最后对于对称正定矩阵,我们则可以给出非常有用的cholesky分解。这些分解的来源就在于矩阵本身存在的特殊的

    结构。对于矩阵A,如果没有任何的特殊结构,那么可以给出A=L*U分解,其中L是下三角矩阵且对角线全部为1,U是上三角矩阵但是对角线的值任意,将U正规化成对角线为1的矩阵,产生分解A = L*D*U, D为对角矩阵。如果A为对称矩阵,那么会产生A=L*D*L分解。如果A为正定对称矩阵,那么就会产生A=G*G,可以这么理解G=L*sqrt(D)。

    A=L*D*U分解对应的Matlab代码如下:

    function[L, D, U] =zldu(A)

    %LDU decomposition of square matrix A. The first step for Cholesky

    %decomposition

    [m, n] = size(A);

    if m ~= n

    error('support square matrix only')

    end

    L = eye(n);

    U = eye(n);

    d = zeros(n,1);

    for k=1:n

    v = zeros(n, 1);

    if k == 1

    v(k:end) = A(k:end, k);

    else

    m = L(1:k-1, 1:k-1) \ A(1:k-1, k);

    for j = 1:k-1

    U(j, k) = m(j) / d(j);

    end

    v(k:end) = A(k:end, k) - L(k:end, 1:k-1)*m(:);

    end

    d(k) = v(k);

    if k < n

    L(k+1:end, k) = v(k+1:end)/v(k);

    end

    end

    D = diag(d);

    分解的稳定性和精度结果如下:

    mean of my lu     : 9.0307e-15

    variance of my lu : 4.17441e-27

    mean of matlab lu     : 3.70519e-16

    variance of matlab lu : 2.07393e-32

    这里的计算是基于Gaxpy,所以稳定性和精确度相当之好。

    A=L*D*L分解对应代码如下,这里要求A必须为对称矩阵:

    function[D, L] =zldl(A)

    %A = L*D*L' another version of LU decomposition for matrix A

    [m, n] = size(A);

    if m ~= n

    error('support square matrix only')

    end

    L = eye(n);

    d = zeros(n,1);

    for k=1:n

    v = zeros(n,1);

    for j=1:k-1

    v(j) = L(k, j)*d(j);

    end

    v(k) = A(k,k) - L(k, 1:k-1)*v(1:k-1);

    d(k) = v(k);

    L(k+1:end, k) = (A(k+1:end,k) - A(k+1:end, 1:k-1)*v(1:k-1)) / v(k);

    end

    D = diag(d);

    对应分解的精确度和稳定度如下:

    mean of my lu : 35.264

    variance of my lu : 29011.2

    mean of matlab lu : 5.88824e-16

    variance of matlab lu : 8.40037e-32

    使用如下的代码做测试:

    n = 1500;

    my_error = zeros(1, n);

    sys_error = zeros(1, n);

    for i = 1:n

    test = gensys(5);

    [zd, zl] = zldl(test);

    [l, d] = ldl(test);

    my_error(i) = norm(zl*zd*(zl') - test, 'fro');

    sys_error(i) = norm(l*d*(l') - test, 'fro');

    end

    fprintf('mean of my lu     : %g\n', mean(my_error));

    fprintf('variance of my lu : %g\n', var(my_error));

    fprintf('mean of matlab lu     : %g\n', mean(sys_error));

    fprintf('variance of matlab lu : %g\n', var(sys_error));

    对于运算的精度如此之低的原因并不清楚

    A=G*G’; cholesky分解对应的代码如下:

    function[G] =zgaxpychol(A)

    %cholesky decomposition for symmetric positive definite matrix

    %the only requirement is matrix A: symmetric positive definite

    [m, n] = size(A);

    if m ~= n

    error('support square matrix only')

    end

    G = eye(n);

    for k=1:n

    v = A(:,k);

    if k > 1

    v(:) = v(:) - G(:,1:k-1)*G(k,1:k-1)';

    end

    G(k:end, k) = v(k:end) / sqrt(v(k));

    end

    对应的测试结果如下

    mean of my lu : 1.10711e-15

    variance of my lu : 3.04741e-31

    mean of matlab lu : 5.5205e-16

    variance of matlab lu : 9.64928e-32

    自己代码的精确度和稳定性可以媲美Matlab的代码,产生这种结果的原因应该是positive sysmetric definite matrix的原因,这段代码基于gaxpy的结果,下面给出另外一种基于外积的运算结果。

    function[G] =zopchol(A)

    %cholesky decomposition based on rank-1 matrix update

    [m, n] = size(A);

    if m ~= n

    error('support square matrix only')

    end

    G = zeros(n);

    for k=1:n

    G(k,k) = sqrt(A(k,k));

    G(k+1:end, k) = A(k+1:end, k) / G(k,k);

    %update matrix A

    for j = (k+1):n

    A(k+1:end,j) = A(k+1:end,j) - G(j,k)*G(k+1:end,k);

    end

    end

    对应的测试结果如下:

    mean of my lu : 9.33114e-16

    variance of my lu : 1.71179e-31

    mean of matlab lu : 9.92241e-16

    variance of matlab lu : 1.60667e-31

    对应的测试程序如下,这里使用系统自带的chol函数完成cholesky分解。

    n = 1500;

    my_error = zeros(1, n);

    sys_error = zeros(1, n);

    for i = 1:n

    test = genpd(5);

    [zg] = zopchol(test);

    l = chol(test, 'lower');

    my_error(i) = norm(zg*(zg') - test, 'fro');

    sys_error(i) = norm(l*(l') - test, 'fro');

    end

    fprintf('mean of my lu     : %g\n', mean(my_error));

    fprintf('variance of my lu : %g\n', var(my_error));

    fprintf('mean of matlab lu     : %g\n', mean(sys_error));

    fprintf('variance of matlab lu : %g\n', var(sys_error));

    将两个结果想比较,可以发现两个版本的cholesky分解的精确度和稳定度差不多。

    Cholesky分解的核心在于矩阵对称正定的结构,基于LU分解的再次扩展。

    展开全文
  • Cholesky分解法又称平方根法,是当A为实对称正定矩阵时,LU三角分解法的变形。通过直接比较A=L*L^T两边的对应元素来计算L,其中L^T为L的转置。思路如下:L为一实下三角矩阵,求L的步骤如下:1、Amn = Lm1*Ln1 + Lm.....

    Cholesky 分解是把一个对称正定的矩阵表示成一个下三角矩阵L和其转置的乘积的分解。

    它要求矩阵的所有特征值必须大于零,故分解的下三角的对角元也是大于零的。

    Cholesky分解法又称平方根法,是当A为实对称正定矩阵时,LU三角分解法的变形。

    通过直接比较A=L*L^T两边的对应元素来计算L,其中L^T为L的转置。

    思路如下:

    L为一实下三角矩阵,求L的步骤如下:

    1、Amn = Lm1*Ln1 + Lm2*Ln2 + ... + Lmx*Lnx其中x = min(m,n)

    2、Umn = Amn - sum(Lmk*Lnk) 其中k ~ (0, min(m,n)),Umn包含Lmn*Lnn

    3、当m < n时,由于是下三角矩阵,所以Umn为0,仅求m >= n的情况

    4、如果 m == n 时 Lmn = sqrt(Umn),否则,Lmn = Umn / Lnn

    5、即求出Lmn的值

    根据此思路的代码实现如下:

    public class MyCholeskyDecomposition {

    /**

    * 2.0000000000 0.0000000000 0.0000000000

    * 0.5000000000 1.3228756555 0.0000000000

    * 0.5000000000 2.0788046016 1.1952286093

    * @param args

    */

    public static void main(String[] args) {

    double[][] A = {{4.,1.,1.},{1.,2.,3.},{1.,3.,6.}};

    double[][] L = new double[3][3];

    for(int m = 0; m < A.length; m++){

    for(int n = 0; n <= m; n++){

    L[m][n] = A[m][n];

    for(int k = 0; k < n; k++){

    L[m][n] -= L[m][k] * L[n][k];

    }

    if(m == n){

    L[m][n] = Math.sqrt(L[m][n]);

    }else{

    L[m][n] = L[m][n] / L[n][n];

    }

    }

    for(int x = m + 1; x < A.length; x++){

    L[m][x] = 0.0;

    }

    }

    for(int i = 0; i < L.length; i++){

    for(int j = 0; j < L.length; j++){

    System.out.print(L[i][j] + " ");

    }

    System.out.println();

    }

    }

    }

    ————————————————

    版权声明:本文为CSDN博主「expleeve」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

    原文链接:https://blog.csdn.net/expleeve/article/details/51933762

    展开全文
  • Cholesky分解法又称平方根法,是当A为实对称正定矩阵时,LU三角分解法的变形。通过直接比较A=L*L^T两边的对应元素来计算L,其中L^T为L的转置。思路如下:L为一实下三角矩阵,求L的步骤如下:1、Amn = Lm1*Ln1 + Lm.....
  • 矩阵Cholesky分解定义,对于正定矩阵其中为上三角矩阵,对角元素为正数。这个矩阵分解是从哪里来的呢?其并没有深刻的数学推导,就是等号左右两边对应相等算法那么首先能得到第二步没有栗子我是看不懂滴:这就是典型...
  • VAR模型的方差分解中,很重要的一步是使用cholesky分解对误差项的协方差矩阵进行变形,cholesky分解的本质是将对称的正定矩阵,进行特殊的LU分解,化为如下的形式: 其中L表示下三角矩阵,等于chlesky分解将A变化为...
  • Cholesky 应该怎么念,o(╯□╰)o,我感觉比较像‘瞅乐死骑’,毕竟这是 名字,哈哈哈哈 这个矩阵非常重要,之前在最小二乘法也见过它,如果: 无解,也就是 不成立, A 不可逆,我们无法计算 .那么我们会想要最小化...
  • 概念LDL分解是经典Cholesky分解的一个变形:L 为下三角矩阵,且对角元素必须为1;D为对角矩阵。转换特征LDL变形如果得以有效运行,构造及使用时所需求的空间及计算的复杂性与经典Cholesky分解是相同的,但是可避免...
  • 矩阵分解 Cholesky分解 *

    千次阅读 2018-10-05 09:29:25
    矩阵分解Cholesky分解
  • GPU实现Cholesky分解 该文件包含用于在GPU上运行Cholesky分解的代码。 它是在安装了CUDA 11.0开发套件的Visual Studio 2019中创建并运行的。 输入矩阵在代码中定义。 它可以是随机生成的,也可以是一些预定义的矩阵...
  • Cholesky 分解,QR分解

    2021-05-07 17:25:47
    Cholesky 分解适用于正定的,对称的矩阵, A=LL‘ 不需要其余矩阵那样分解为 A=LU
  • cholesky分解C程序

    2013-03-23 20:13:12
    C语言实现cholesky分解并求逆,cholesky分解要求矩阵正定对称
  • 1、为什么要进行矩阵分解个人认为,首先,当数据量很大时,将一个矩阵分解为若干个矩阵的乘积可以大大降低存储空间;其次,可以减少真正进行问题处理时的计算量,毕竟算法扫描的元素越少完成任务的速度越快,这个...
  • cholesky分解 用来分解对称正定矩阵的matlab代码 从而方便求解线性方程组
  • 矩阵分解 Cholesky分解

    万次阅读 2017-11-17 11:36:08
    Cholesky分解法又叫平方根法,是求解对称正定线性方程组最常用的方法之一。对于一般矩阵,为了消除LU分 解的局限性和误差的过分积累,采用了选主元的方法,但对于对称正定矩阵而言,选主元是不必要的。   定理:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 522
精华内容 208
关键字:

cholesky分解