svd分解c代码（SVD分解例题）

今天给各位分享svd分解c代码的知识，其中也会对SVD分解例题进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、svd分解 c语言实现
• 2、MATLAB中SVD奇异值分解是什么作用
• 3、Python中怎样实现奇异值SVD分解
• 4、奇异值分解(SVD)
• 5、matlab 复数矩阵矩阵奇异值分解
• 6、求SVD算法的C++实现代码

svd分解 c语言实现

/*

本程序在linux g++下编译通过

bool svd(vectorvectordouble A, int K, vectorvectordouble U, vectordouble S, vectorvectordouble V);

A: 输入待分解矩阵

K: 输入，取前K大奇异值及奇异向量

U[0],U[1],...,U[K-1]: 前K大奇异值对应的左奇异向量

S[0],S[1],...,S[K-1]: 前K大奇异值 S[0]=S[1]=...=S[K-1]

V[0],V[1],...,V[K-1]: 前K大奇异值对应的右奇异向量

*/

#include cmath

#include iostream

#include iomanip

#include cstdlib

#include cstring

#include fstream

#include vector

using namespace std;

const int MAX_ITER=100000;

const double eps=0.0000001;

double get_norm(double *x, int n){

    double r=0;

    for(int i=0;in;i++)

        r+=x[i]*x[i];

    return sqrt(r);

}

double normalize(double *x, int n){

    double r=get_norm(x,n);

    if(reps)

        return 0;

    for(int i=0;in;i++)

        x[i]/=r;

    return r;

}

inline double product(double*a, double *b,int n){

    double r=0;

    for(int i=0;in;i++)

        r+=a[i]*b[i];

    return r;

}

void orth(double *a, double *b, int n){//|a|=1

    double r=product(a,b,n);

    for(int i=0;in;i++)

        b[i]-=r*a[i];

}

bool svd(vectorvectordouble A, int K, vectorvectordouble U, vectordouble S, vectorvectordouble V){

    int M=A.size();

    int N=A[0].size();

    U.clear();

    V.clear();

    S.clear();

    S.resize(K,0);

    U.resize(K);

    for(int i=0;iK;i++)

        U[i].resize(M,0);

    V.resize(K);

    for(int i=0;iK;i++)

        V[i].resize(N,0);

    srand(time(0));

    double *left_vector=new double[M];

    double *next_left_vector=new double[M];

    double *right_vector=new double[N];

    double *next_right_vector=new double[N];

    int col=0;

    for(int col=0;colK;col++){

        double diff=1;

        double r=-1;

        while(1){

            for(int i=0;iM;i++)

                left_vector[i]= (float)rand() / RAND_MAX;

            if(normalize(left_vector, M)eps)

                break;

        }

        for(int iter=0;diff=eps iterMAX_ITER;iter++){

            memset(next_left_vector,0,sizeof(double)*M);

            memset(next_right_vector,0,sizeof(double)*N);

            for(int i=0;iM;i++)

                for(int j=0;jN;j++)

                    next_right_vector[j]+=left_vector[i]*A[i][j];

            r=normalize(next_right_vector,N);

            if(reps) break;

            for(int i=0;icol;i++)

                orth(V[i][0],next_right_vector,N);

            normalize(next_right_vector,N);

            for(int i=0;iM;i++)

                for(int j=0;jN;j++)

                    next_left_vector[i]+=next_right_vector[j]*A[i][j];

            r=normalize(next_left_vector,M);

            if(reps) break;

            for(int i=0;icol;i++)

                orth(U[i][0],next_left_vector,M);

            normalize(next_left_vector,M);

            diff=0;

            for(int i=0;iM;i++){

                double d=next_left_vector[i]-left_vector[i];

                diff+=d*d;

            }

            memcpy(left_vector,next_left_vector,sizeof(double)*M);

            memcpy(right_vector,next_right_vector,sizeof(double)*N);

        }

        if(r=eps){

            S[col]=r;

            memcpy((char *)U[col][0],left_vector,sizeof(double)*M);

            memcpy((char *)V[col][0],right_vector,sizeof(double)*N);

        }else{

            coutrendl;

            break;

        }

    }

    delete [] next_left_vector;

    delete [] next_right_vector;

    delete [] left_vector;

    delete [] right_vector;

    return true;

}

void print(vectorvectordouble A){

}

int main(){

    int m=10;

    int n=8;

    int k=5;

    //分解一个10*8的矩阵A，求其前5个奇异值和奇异向量

    srand(time(0));

    vectorvectordouble A;

    A.resize(m);

    for(int i=0;im;i++){

        A[i].resize(n);

        for(int j=0;jn;j++)

            A[i][j]=(float)rand()/RAND_MAX-0.5;

    }

    cout"A="endl;

    for(int i=0;iA.size();i++){

        for(int j=0;jA[i].size();j++){

            coutsetw(12)A[i][j]' ';

        }

        coutendl;

    }

    coutendl;

    vectorvectordouble U;

    vectordouble S;

    vectorvectordouble V;

    svd(A,k,U,S,V);

    cout"U="endl;

    for(int i=0;iU[0].size();i++){

        for(int j=0;jU.size();j++){

            coutsetw(12)U[j][i]' ';

        }

        coutendl;

    }

    coutendl;

    cout"S="endl;

    for(int i=0;iS.size();i++){

        coutsetw(7)S[i]' ';

    }

    coutendl;

    cout"V="endl;

    for(int i=0;iV[0].size();i++){

        for(int j=0;jV.size();j++){

            coutsetw(12)V[j][i]' ';

        }

        coutendl;

    }

    return 0;

}

MATLAB中SVD奇异值分解是什么作用

答案1：： 奇异值分解 (sigular value decomposition,SVD) 是另一

种正交矩阵分解法；SVD是最可靠的分解法，但是它比QR 分解法要花

上近十倍的计算时间。[U,S,V]=svd(A)，其中U和V代表二个相互正交

矩阵，而S代表一对角矩阵。 和QR分解法相同者， 原矩阵A不必为正方矩阵。

使用SVD分解法的用途是解最小平方误差法和数据压缩

答案2：： 奇异值分解是线性代数中一种重要的矩阵分解，在信号处

啊？答案3：： [U,S,V]=svd(A)奇异值分解，就是要把矩阵A分解成

U*S*V' (V'代表V转置).其中U S是正交矩阵（复数域对应为酉矩阵）

奇异值分解可以用来求矩阵的逆，数据压缩等等，不过具体的用法不

是几句话就能说清楚的。总之，奇异值分解特别重要。

:::::::::::::::::::请参考以下相关问题::::::::::::::::::::

求matlab中的矩阵的奇异值分解（SVD）程序

:::::::::::::::::::请参考以下相关问题::::::::::::::::::::

最近在翻译matlab代码为VC代码，遇到SVD奇异值分解卡住了。

:::::::::::::::::::请参考以下相关问题::::::::::::::::::::

:::::::::::::::::::请参考以下相关问题:::::::::::::::::::::::::::::::::::::::请参考以下相关问题::::::::::::::::::::

Python中怎样实现奇异值SVD分解

这两个命令是完全不同的呀。

S=svd（A）表示对矩阵A进行SVD分解，分解的结果是得到3个矩阵，如果返回值只有一个，那么可以得到A的奇异值向量。

eig（A）表示求矩阵A的特征值。

所以区别就是，svd得到的是A的奇异值，eig得到的是A的特征值。

A'表示A的转置矩阵，A'*A的n个非负特征值的平方根叫作矩阵A的奇异值。记为σi(A)。

希望可以帮助你，望采纳！

奇异值分解(SVD)

奇异值分解(SVD)是一种矩阵因子分解方法。任意一个m*n的矩阵，都可以表示为三个矩阵的乘积(因子分解)的形式，分别是m阶正交矩阵、由降序排列的非负的对角线元素组成的m*n矩阵和n阶正交矩阵，称为该矩阵的奇异值分解。矩阵的奇异值分解一定存在，但不唯一。奇异值分解可以看作出矩阵数据压缩的一种方法。即用因子分解的方式近似地表示原始矩阵，这种矩阵在平方损失意义下的最优近似。

矩阵的奇异值分解是指，将一个非零的m*n实矩阵 ，表示为以下三个实矩阵乘积形式的运算，即进行矩阵的因子分解

其中U是m阶正交矩阵，V是n阶正交矩阵， 是由降序排列的非负的对角元素组成的 的矩形对角矩阵

称为矩阵的奇异值分解， 称为矩阵A的奇异值, 的列向量称为左奇异向量， 的列向量成为右奇异向量

紧凑奇异值分解是与原始矩阵等秩的奇异值分解，截断奇异值分解是比原始矩阵降低秩的奇异值分解。在实际应用中，常常需要对矩阵的数据进行压缩，将其近似表示，奇异值分解提供了一种方法。奇异值分解是在平方损失意义下对矩阵的最优近似。紧奇异值分解对应着无损压缩，截断奇异值分解对应着有损压缩

设有 实矩阵A，其秩为rank(A) = r, ，则称 为A的紧奇异值分解，即

其中 是 矩阵， 是 矩阵， 是r阶对角矩阵，矩阵 由完全奇异分解中的前r列，矩阵 由V的前r列，矩阵 由 的前r个对角线元素得到，紧奇分解的对角矩阵 的秩与原始矩阵A的秩相等

在矩阵的奇异值分解中，只取最大的k个奇异值(k r,r为矩阵的秩）对应的部分，就得到矩阵的截断奇异值分解。实际应用中提到的矩阵的奇异值分解，通常指截断奇异值分解

设A为 实矩阵，其秩rank(A)=r,且， ，则称 为矩阵A的截断奇异值分解

其中 是 矩阵， 是n*k矩阵， 是k阶对角矩阵；矩阵 由完全奇异分解U的前k列，矩阵 由V的前k列，矩阵 由 的前k个对角线元素得到。对角矩阵 的秩比原始矩阵A的秩低。

从线性变换的角度理解奇异值分解， 矩阵A表示从n维空间 到m空间 的一个线性变换，

x和Ax分别表示各自空间的向量。线性变换可以分解为三个简单的变换：一个坐标系的旋转或反射变换、一个坐标轴的缩放变换、另一个坐标系的旋转或反射。

对矩阵A进行奇异值分解，得到 ,V和U都是正交矩阵，所以V的列向量 构成空间的一组标准正交基，表示 中的正交坐标系的旋转或反射；U的列向量 构成 空间的一组标准正交基，表示 中正交坐标系的旋转或反射； 的对角元素 是一组非负实数，表示 中原始正坐标系坐标轴的 倍的缩放变换。

任意一个向量 ，经过基于 的线性变换，等价于经过坐标系的旋转或反射变换 ，坐标轴的缩放变换 ，以及坐标轴的旋转或反射变换U,得到相框

矩阵A是 的正交实矩阵，则矩阵 是n阶实对称矩阵，因而 的特征值都是实数，并且存在一个n阶正实矩阵V实现 的对角化，使得 成立，其中 是n阶对角矩阵，其对角元素由 的特征值组成。

而且， 的特征值都是非负的。事实上，令 是 的一个特征值，x是对应的特征向量，则

于是

可以假设正交矩阵V的列排列使得对应的特征值形成降序排列。

计算特征值的平方根(实际上解释矩阵A的奇异值)

设矩阵A的秩是r,rank(A)=r,则矩阵 的秩也是r。由于 是对称矩阵，它的秩等于正的特征值的个数。

对应的

令

其中 为 的特征值对应的特征向量， 为0特征值对应的特征向量。

则

这就是矩阵A的奇异值分解中的n阶正交矩阵V

令

则 是个一个r阶对角矩阵，其对角线元素为按降序排列的正的 ，于是 矩形对角矩阵 可以表示为

这就是矩阵A的奇异值分解中的 矩阵对角矩阵

接着构造m阶正交实矩阵U

令

则有

的列向量构成正交基是因为

对 的非零空间的一组标准正交基 ，令

并令

matlab 复数矩阵矩阵奇异值分解

不论实矩阵或是虚矩阵，奇异值分解的结果都是非负的、实数的奇异值，如：

a=magic(5);b=svd(a)

c=rand(5);d=a+1i*c;e=svd(d)

结果是：

b =

65.0000

22.5471

21.6874

13.4036

11.9008

e =

65.0554

22.5819

21.6764

13.4087

11.8961

求SVD算法的C++实现代码

/** C++ function for SVD

函数原型:

bool svd(vectorvectordouble A, int K, std::vectorstd::vectordouble U, std::vectordouble S, std::vectorstd::vectordouble V);

其中

A是输入矩阵，假设A的维数是m*n，那么本函数将A分解为U diag(S) V'

其中U是m*K的列正交的矩阵. V是n*K的列正交矩阵，S是K维向量。K由第二个参数指定。

U的第i列是A的第i大奇异值对应的左歧义向量,S[i]=A的第 i大奇异值,V的第i列是A的第i大奇异值对应的右歧义响亮.

K是需要分解的rank，0K=min(m,n)

本程序采用的是最基本幂迭代算法，在linux g++下编译通过

**/

#include cmath

#include iostream

#include iomanip

#include cstdlib

#include cstring

#include fstream

#include vector

using namespace std;

const int MAX_ITER=100000;

const double eps=0.0000001;

double get_norm(double *x, int n){

    double r=0;

    for(int i=0;in;i++)

        r+=x[i]*x[i];

    return sqrt(r);

}

double normalize(double *x, int n){

    double r=get_norm(x,n);

    if(reps)

        return 0;

    for(int i=0;in;i++)

        x[i]/=r;

    return r;

}

inline double product(double*a, double *b,int n){

    double r=0;

    for(int i=0;in;i++)

        r+=a[i]*b[i];

    return r;

}

void orth(double *a, double *b, int n){//|a|=1

    double r=product(a,b,n);

    for(int i=0;in;i++)

        b[i]-=r*a[i];

}

bool svd(vectorvectordouble A, int K, std::vectorstd::vectordouble U, std::vectordouble S, std::vectorstd::vectordouble V){

    int M=A.size();

    int N=A[0].size();

    U.clear();

    V.clear();

    S.clear();

    S.resize(K,0);

    U.resize(K);

    for(int i=0;iK;i++)

        U[i].resize(M,0);

    V.resize(K);

    for(int i=0;iK;i++)

        V[i].resize(N,0);

    srand(time(0));

    double *left_vector=new double[M];

    double *next_left_vector=new double[M];

    double *right_vector=new double[N];

    double *next_right_vector=new double[N];

    while(1){

        for(int i=0;iM;i++)

            left_vector[i]= (float)rand() / RAND_MAX;

        if(normalize(left_vector, M)eps)

            break;

    }

    int col=0;

    for(int col=0;colK;col++){

        double diff=1;

        double r=-1;

        for(int iter=0;diff=eps iterMAX_ITER;iter++){

            memset(next_left_vector,0,sizeof(double)*M);

            memset(next_right_vector,0,sizeof(double)*N);

            for(int i=0;iM;i++)

                for(int j=0;jN;j++)

                    next_right_vector[j]+=left_vector[i]*A[i][j];

            r=normalize(next_right_vector,N);

            if(reps) break;

            for(int i=0;icol;i++)

                orth(V[i][0],next_right_vector,N);

            normalize(next_right_vector,N);

            for(int i=0;iM;i++)

                for(int j=0;jN;j++)

                    next_left_vector[i]+=next_right_vector[j]*A[i][j];

            r=normalize(next_left_vector,M);

            if(reps) break;

            for(int i=0;icol;i++)

                orth(U[i][0],next_left_vector,M);

            normalize(next_left_vector,M);

            diff=0;

            for(int i=0;iM;i++){

                double d=next_left_vector[i]-left_vector[i];

                diff+=d*d;

            }

            memcpy(left_vector,next_left_vector,sizeof(double)*M);

            memcpy(right_vector,next_right_vector,sizeof(double)*N);

        }

        if(r=eps){

            S[col]=r;

            memcpy((char *)U[col][0],left_vector,sizeof(double)*M);

            memcpy((char *)V[col][0],right_vector,sizeof(double)*N);

        }else

            break;

    }

    delete [] next_left_vector;

    delete [] next_right_vector;

    delete [] left_vector;

    delete [] right_vector;

    return true;

}

void print(vectorvectordouble A){

    for(int i=0;iA.size();i++){

        for(int j=0;jA[i].size();j++){

            coutsetprecision(3)A[i][j]' ';

        }

        coutendl;

    }

}

int main(){

    int m=10;

    int n=5;

    srand(time(0));

    vectorvectordouble A;

    A.resize(m);

    for(int i=0;im;i++){

        A[i].resize(n);

        for(int j=0;jn;j++)

            A[i][j]=(float)rand()/RAND_MAX;

    }

    print(A);

    coutendl;

    vectorvectordouble U;

    vectordouble S;

    vectorvectordouble V;

    svd(A,2,U,S,V);

    cout"U="endl;

    print(U);

    coutendl;

    cout"S="endl;

    for(int i=0;iS.size();i++){

        coutS[i]' ';

    }

    coutendl;

    cout"V="endl;

    print(V);

    return 0;

}

关于svd分解c代码和SVD分解例题的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。