Doolitter分解 三对角矩阵分解 拟三对角分解

 #include <cstdio>
 #include <cstdlib>
 #include <algorithm>
 #include <cmath>
 #include <cassert>
 #include <vector>
 #include <ctime>

 class MclVector
 {
 public:
     int n;
     double *Mat;
     /**
       type=0: 列向量(默认)
       type=1: 行向量
     **/
     int type;

     MclVector() { Mat=NULL; n=; }
     MclVector(int len,double initVal=0.0)
     {
         n=len;
         Mat=];
         ;i<=n;i++) Mat[i]=initVal;
         type=;
     }

     double operator[](int id) const
     {
         return Mat[id];
     }

     double& operator[](int id)
     {
         return Mat[id];
     }

     double length() const
     {
         ;
         ;i<=n;i++) sum+=Mat[i]*Mat[i];
         return sqrt(sum);
     }

     MclVector operator*(double val) const
     {
         MclVector ans=MclVector(n);
         ;i<=n;i++) ans[i]=Mat[i]*val;
         return ans;
     }

     MclVector operator/(double val) const
     {
         MclVector ans=MclVector(n);
         ;i<=n;i++) ans[i]=Mat[i]/val;
         return ans;
     }

     MclVector operator+(const MclVector &newVector) const
     {
         MclVector ans=MclVector(n);
         ;i<=n;i++) ans[i]=Mat[i]+newVector[i];
         return ans;
     }

     MclVector operator-(const MclVector &newVector) const
     {
         MclVector ans=MclVector(n);
         ;i<=n;i++) ans[i]=Mat[i]-newVector[i];
         return ans;
     }

     MclVector operator*=(double val)
     {
         ;i<=n;i++) Mat[i]=Mat[i]*val;
         return *this;
     }

     MclVector operator/=(double val)
     {
         ;i<=n;i++) Mat[i]=Mat[i]/val;
         return *this;
     }

     MclVector operator+=(const MclVector &newVector)
     {
         ;i<=n;i++) Mat[i]+=newVector[i];
         return *this;
     }

     MclVector operator-=(const MclVector &newVector)
     {
         ;i<=n;i++) Mat[i]-=newVector[i];
         return *this;
     }

     MclVector GetTranspose() const
     {
         MclVector ans=*this;
         ans.type=;
         return ans;
     }

     void print() const
     {
         ;i<=n;i++) printf("%8.3lf ",Mat[i]);
         puts("");
     }

 };

 class MclMatrix
 {
 public:
     int row,col;
     MclVector *Mat;

     MclMatrix() {Mat=NULL;}
     MclMatrix(int _row,int _col,double initVal=0.0)
     {
         row=_row;
         col=_col;
         Mat=];
         ;i<=row;i++) Mat[i]=MclVector(col,initVal);
     }

     void setIdentityMatrix()
     {
         ;i<=row;i++)
         {
             ;j<=col;j++)
             {
                 ;
                 ;
             }
         }
     }

     MclMatrix GetTranspose() const
     {
         MclMatrix ans=MclMatrix(col,row);
         ;i<=ans.row;i++)
         {
             ;j<=ans.col;j++)
             {
                 ans[i][j]=Mat[j][i];
             }
         }
         return ans;
     }

     void print() const
     {
         ;i<=row;i++) Mat[i].print();
         puts("");
     }

     MclVector& operator[](int id) const
     {
         return Mat[id];
     }

     MclVector& operator[](int id)
     {
         return Mat[id];
     }

     MclMatrix operator*(const MclMatrix &Matrix) const
     {
         MclMatrix ans=MclMatrix(row,Matrix.col);
         ;i<=row;i++)
         {
             ;j<=Matrix.col;j++)
             {
                 ;k<=col;k++)
                 {
                     ans[i][j]+=Mat[i][k]*Matrix[k][j];
                 }
             }
         }
         return ans;
     }

     MclMatrix operator+(const MclMatrix &Matrix) const
     {
         MclMatrix ans=MclMatrix(row,Matrix.col);
         ;i<=row;i++)
         {
             ;j<=Matrix.col;j++)
             {
                 ans[i][j]=Mat[i][j]+Matrix[i][j];
             }
         }
         return ans;
     }

     MclMatrix operator-(const MclMatrix &Matrix) const
     {
         MclMatrix ans=MclMatrix(row,Matrix.col);
         ;i<=row;i++)
         {
             ;j<=Matrix.col;j++)
             {
                 ans[i][j]=Mat[i][j]-Matrix[i][j];
             }
         }
         return ans;
     }

     MclVector GetCol(int colId) const
     {
         MclVector ans=MclVector(row);
         ;i<=row;i++) ans[i]=Mat[i][colId];
         return ans;
     }
     MclVector GetRow(int rowId) const
     {
         MclVector ans=MclVector(row);
         ;i<=col;i++) ans[i]=Mat[rowId][i];
         return ans;
     }

     MclMatrix operator*=(const MclMatrix &Matrix)
     {
         return *this=*this*Matrix;
     }
     MclMatrix operator+=(const MclMatrix &Matrix)
     {
         return *this=*this+Matrix;
     }
     MclMatrix operator-=(const MclMatrix &Matrix)
     {
         return *this=*this-Matrix;
     }

     MclMatrix operator*(double x) const
     {
         MclMatrix ans=*this;
         ;i<=row;i++)
         {
             ;j<=col;j++)
             {
                 ans[i][j]*=x;
             }
         }
         return ans;
     }

 };

 MclMatrix vectorMulVector(const MclVector &A,const MclVector& B)
 {
     )
     {
         MclMatrix ans=MclMatrix(A.n,B.n);
         ;i<=A.n;i++)
         {
             ;j<=B.n;j++)
             {
                 ans[i][j]+=A[i]*B[j];
             }
         }
         return ans;
     }
     else
     {
         assert(A.n==B.n);
         MclMatrix ans=MclMatrix(,);
         ;i<=A.n;i++)
         {
             ans[][]+=A[i]*B[i];
         }
         return ans;
     }
 }

 int sgn(double x)
 {
     ;
     ;
     ;
 }

 /**
    矩阵的 Doolittle分解:
       [1] Mat是方阵
       [2] Mat的前n-1阶主子式行列式不为0
       [3] 分解的L为单位下三角阵
       [4] 分解的U为上三角阵
       [5] 返回值为<L,R>
 **/
 std::pair<MclMatrix,MclMatrix> DoolittleSplit(const MclMatrix &Mat)
 {
     int n=Mat.row;
     MclMatrix L=MclMatrix(n,n);
     MclMatrix U=MclMatrix(n,n);
     ;k<=n;k++)
     {
         for(int j=k;j<=n;j++)
         {
             U[k][j]=Mat[k][j];
             ;t<=k-;t++) U[k][j]-=L[k][t]*U[t][j];
         }
         if(k==n) continue;

         ;i<=n;i++)
         {
             L[i][k]=Mat[i][k];
             ;t<=k-;t++) L[i][k]-=L[i][t]*U[t][k];
             L[i][k]/=U[k][k];
         }
     }
     ;i<=n;i++) L[i][i]=;
     return std::make_pair(L,U);
 }

 /**
    三角矩阵分解:
       [1] Mat是方阵
       [2] j<i且i-j>r时 Mat[i][j]=0
       [2] j>i且j-i>s时 Mat[i][j]=0
 **/
 std::pair<MclMatrix,MclMatrix> TriangleSplit(const MclMatrix &Mat,int r,int s)
 {
     int n=Mat.row;
     MclMatrix L=MclMatrix(n,n);
     MclMatrix U=MclMatrix(n,n);
     ;k<=n;k++)
     {
         for(int j=k;j<=n;j++)
         {
             U[k][j]=Mat[k][j];
             ,std::max(k-r,j-s));t<=k-;t++) U[k][j]-=L[k][t]*U[t][j];
         }
         if(k==n) continue;

         ;i<=n;i++)
         {
             L[i][k]=Mat[i][k];
             ,std::max(i-r,k-s));t<=k-;t++) L[i][k]-=L[i][t]*U[t][k];
             L[i][k]/=U[k][k];
         }
     }
     ;i<=n;i++) L[i][i]=;
     return std::make_pair(L,U);
 }

 /**
   拟三对角矩阵分解
   对n=5 矩阵A样子如下：
       a1  c1  0   0  d1
       d2  a2  c2  0  0
       0   d3  a3  c3 0
       0   0   d4  a4 c4
       c5  0   0   d5 a5
    即输入为三个长度为n的向量

    A=LU
    L样子如下：
      p1  0  0  0  0
      d2  p2 0  0  0
      0   d3 p3 0  0
      0   0  d3 p4 0
      r1  r2 r3 r4 r5

    U样子如下:
      1  q1  0  0  s1
      0  1   q2 0  s2
      0  0   1  q3 s3
      0  0   0  1  s4
      0  0   0  0  1

     即将返回p,q,s,r四个向量(所有的向量长度都是n)
     vector[0]=p
     vector[1]=q
     vector[2]=s
     vector[3]=r
 **/

 std::vector<MclVector> QuasiDiagonalSplit(const MclVector &a,const MclVector &c,const MclVector &d)
 {
     int n=a.n;
     assert(c.n==n);
     assert(d.n==n);
     assert(n>);

     MclVector p=MclVector(n);
     MclVector q=MclVector(n);
     MclVector s=MclVector(n);
     MclVector r=MclVector(n);

     p[]=a[];
     ;i<=n-;i++)
     {
         q[i]=c[i]/p[i];
         p[i+]=a[i+]-d[i+]*q[i];
     }

     s[]=d[]/p[];
     ;i<=n-;i++) s[i]=-d[i]*s[i-]/p[i];
     s[n-]=(c[n-]-d[n-]*s[n-])/p[n-];

     r[]=c[n];
     ;j<=n-;j++) r[j]=-r[j-]*q[j-];
     r[n-]=d[n]-r[n-]*q[n-];
     r[n]=a[n];
     ;j<=n-;j++) r[n]=r[n]-r[j]*s[j];

     std::vector<MclVector> ans;
     ans.push_back(p);
     ans.push_back(q);
     ans.push_back(s);
     ans.push_back(r);

     return ans;
 }