矩阵分解 Cholesky分解

Cholesky分解法又叫平方根法，是求解对称正定线性方程组最常用的方法之一。对于一般矩阵，为了消除LU分

解的局限性和误差的过分积累，采用了选主元的方法，但对于对称正定矩阵而言，选主元是不必要的。

 

定理：若对称正定，则存在一个对角元为正数的下三角矩阵，使得成立。

 

Cholesky分解的条件(这里针对复数矩阵)

一、Hermitian matrix（埃尔米特矩阵）：矩阵中的元素共轭对称（复数域的定义，类比于实数对称矩阵）。

Hermitian意味着对于任意向量x和y，(x*)Ay共轭相等

二、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

假设现在要求解线性方程组，其中为对称正定矩阵，那么可通过下面步骤求解

 

（1）求的Cholesky分解，得到

（2）求解，得到

（3）求解，得到

 

现在的关键问题是对进行Cholesky分解。假设

 

       

 

通过比较两边的关系，首先由，再由

 

       

 

这样便得到了矩阵的第一列元素，假定已经算出了的前列元素，通过

 

       

 

可以得到

 

       

 

进一步再由

 

                 

 

最终得到

 

       

 

这样便通过的前列求出了第列，一直递推下去即可求出，这种方法称为平方根法。

 

代码：

 #include
 #include
 #include
 #include
 #include

 using namespace std;
 const int N = 1005;
 typedef double Type;

 Type A[N][N], L[N][N];

 /** 分解A得到A = L * L^T */
 void Cholesky(Type A[][N], Type L[][N], int n)
 {
     for(int k = 0; k < n; k++)
     {
         Type sum = 0;
         for(int i = 0; i < k; i++)
             sum += L[k][i] * L[k][i];
         sum = A[k][k] - sum;
         L[k][k] = sqrt(sum > 0 ? sum : 0);
         for(int i = k + 1; i < n; i++)
         {
             sum = 0;
             for(int j = 0; j < k; j++)
                 sum += L[i][j] * L[k][j];
             L[i][k] = (A[i][k] - sum) / L[k][k];
         }
         for(int j = 0; j < k; j++)
             L[j][k] = 0;
     }
 }

 /** 回带过程 */
 vector Solve(Type L[][N], vector X, int n)
 {
     /** LY = B  => Y */
     for(int k = 0; k < n; k++)
     {
         for(int i = 0; i < k; i++)
             X[k] -= X[i] * L[k][i];
         X[k] /= L[k][k];
     }
     /** L^TX = Y => X */
     for(int k = n - 1; k >= 0; k--)
     {
         for(int i = k + 1; i < n; i++)
             X[k] -= X[i] * L[i][k];
         X[k] /= L[k][k];
     }
     return X;
 }

 void Print(Type L[][N], const vector B, int n)
 {
     for(int i = 0; i < n; i++)
     {
         for(int j = 0; j < n; j++)
             cout<" ";
         cout<
     }
     cout<
     vector X = Solve(L, B, n);
     vector::iterator it;
     for(it = X.begin(); it != X.end(); it++)
         cout<<*it<<" ";
     cout<
 }

 int main()
 {
     int n;
     cin>>n;
     memset(L, 0, sizeof(L));
     for(int i = 0; i < n; i++)
     {
         for(int j = 0; j < n; j++)
             cin>>A[i][j];
     }
     vector B;
     for(int i = 0; i < n; i++)
     {
         Type y;
         cin>>y;
         B.push_back(y);
     }
     Cholesky(A, L, n);
     Print(L, B, n);
     return 0;
 }

 /**data**
 4
 4 -2 4 2
 -2 10 -2 -7
 4 -2 8 4
 2 -7 4 7
 8 2 16 6
 */

用上述的方法需要进行开方，这有可能损失精度和增加运算量，为了避免开方，Cholesky分解有个改进的版本分解。

 

参考资料：http://class.htu.cn/nla/cha1/sect3.htm

转自：http://blog.csdn.net/acdreamers/article/details/44656847

http://blog.csdn.net/zhouliyang1990/article/details/21952485