C++ (Cpp) ComplexEigenSolver::eigenvectors Exemples

Exemple #1

Fichier : eigensolver_complex.cpp Projet : 13221325403/openbr

template<typename MatrixType> void eigensolver_verify_assert(const MatrixType& m)
{
  ComplexEigenSolver<MatrixType> eig;
  VERIFY_RAISES_ASSERT(eig.eigenvectors());
  VERIFY_RAISES_ASSERT(eig.eigenvalues());

  MatrixType a = MatrixType::Random(m.rows(),m.cols());
  eig.compute(a, false);
  VERIFY_RAISES_ASSERT(eig.eigenvectors());
}

Exemple #2

Fichier : compile_ComplexEigenSolver_compute.cpp Projet : DendyTheElephant/VisuProject

int main(int, char**)
{
  cout.precision(3);
  MatrixXcf A = MatrixXcf::Random(4,4);
cout << "Here is a random 4x4 matrix, A:" << endl << A << endl << endl;

ComplexEigenSolver<MatrixXcf> ces;
ces.compute(A);
cout << "The eigenvalues of A are:" << endl << ces.eigenvalues() << endl;
cout << "The matrix of eigenvectors, V, is:" << endl << ces.eigenvectors() << endl << endl;

complex<float> lambda = ces.eigenvalues()[0];
cout << "Consider the first eigenvalue, lambda = " << lambda << endl;
VectorXcf v = ces.eigenvectors().col(0);
cout << "If v is the corresponding eigenvector, then lambda * v = " << endl << lambda * v << endl;
cout << "... and A * v = " << endl << A * v << endl << endl;

cout << "Finally, V * D * V^(-1) = " << endl
     << ces.eigenvectors() * ces.eigenvalues().asDiagonal() * ces.eigenvectors().inverse() << endl;

  return 0;
}

Exemple #3

Fichier : PMS.cpp Projet : jhseong7/Gait-Recognition-MoG-Fast

vector<complex<float> > PMS(vector<vector<complex<float> >> CSC_array)
{
    int CSC_size = (int)CSC_array.size();
    int array_size = 0;
    int i;
    int m,n;

    vector<vector< complex<float>> > Product_mat;
    vector<vector< complex<float>> > S_Z;
    vector<complex<float> > temp_mat;
    vector<complex<float> > Major_eigen_vector;
    complex<float> mat_ij_1;
    complex<float> mat_ij_2;
    complex<float> scalar(0,0);
    S_Z.resize(40, vector< complex<float>>(40, 0));
    for (m = 0; m<40; m++)
    {
        for (n = 0; n<40; n++)
        {
            S_Z[m][n] = 0;
        }
    }

    for(i=0; i<period; i++)
    {
        array_size = (int)(CSC_array[i]).size();

        for(m=0; m<array_size; m++)
        {
            mat_ij_1 = CSC_array[i][m];
            scalar = scalar + mat_ij_1*conj(mat_ij_1);
            for(n=0; n<array_size; n++)
            {
                mat_ij_2 = CSC_array[i][n];
                mat_ij_2 = conj(mat_ij_2);
                temp_mat.push_back(mat_ij_1*mat_ij_2);
            }
            Product_mat.push_back(temp_mat);
            temp_mat.clear();
        }

        for(m=0; m<array_size; m++)
        {
            for(n=0; n<array_size; n++)
            {
                Product_mat[m][n] = Product_mat[m][n]/scalar;
            }
        }

        for(m=0; m<array_size; m++)
        {
            for(n=0; n<array_size; n++)
            {
                S_Z[m][n] = S_Z[m][n] + Product_mat[m][n];
            }
        }

        scalar = 0;
        Product_mat.clear();
    }

    MatrixXcf temp(array_size,array_size);
    MatrixXcf evec(array_size,array_size);
    MatrixXcf eval(array_size,1);

    for(m=0; m<array_size; m++)
    {
        for(n=0; n<array_size; n++)
        {
            temp(m,n) = S_Z[m][n];
        }
    }

    ComplexEigenSolver<MatrixXcf> ces;
    ces.compute(temp);

    evec = ces.eigenvectors();
    eval = ces.eigenvalues();

    //cout << " Eigen " << eval(0,0) << endl;
    //cout << " EE " << evec(0,0) << endl;

    float Max_eigen=0.0;
    int Max_eigen_index=0;
    float temp_value=0.0;

    for(i=0; i<array_size; i++)
    {
        temp_value = norm( (i,0));
        if(temp_value > Max_eigen)
        {
            Max_eigen = temp_value;
            Max_eigen_index = i;
        }
    }

    /*
    cout << "The eigenvector of temp are" << endl << evec << endl;
    cout << "The eigenvalue of temp are" << endl << eval << endl;
    cout << "Max eigenvalue " << endl << Max_eigen << endl;
    cout << "Max eigenvalue index " << endl << Max_eigen_index << endl;
    cout << "Max eigenvector " << endl << Max_eigen*evec(i) << endl;
    */

    for(i=0; i<array_size; i++)
    {
        Major_eigen_vector.push_back(evec(i, Max_eigen_index));
        //Major_eigen_vector.push_back(Max_eigen*evec(i,Max_eigen_index));
        //cout << Major_eigen_vector[i] << endl;
    }

    return Major_eigen_vector;
}