मेरे पास ~ 3000x3000 कॉन्वर्सिस-समान मैट्रिक्स है जिस पर मैं eigenvalue-eigenvector अपघटन (यह एक ओपनसीवी मैट्रिक्स है) की गणना करता है, और मैं नौकरी पाने के लिए cv::eigen() का उपयोग करता हूं)।सी ++ eigenvalue/वेक्टर अपघटन, केवल पहले n वैक्टरों की आवश्यकता है
हालांकि, मुझे वास्तव में केवल 30 कहानियों/वैक्टरों की आवश्यकता है, मुझे बाकी की परवाह नहीं है। सैद्धांतिक रूप से, यह गणना गणना को तेज करने की अनुमति देनी चाहिए, है ना? मेरा मतलब है, इसका मतलब है कि इसमें 2 9 70 ईजिनवेक्टर कम हैं जिन्हें गणना करने की आवश्यकता है।
कौन सी सी ++ लाइब्रेरी मुझे ऐसा करने की अनुमति देगी? कृपया ध्यान दें OpenCV के eigen() विधि के लिए पैरामीटर है कि है, लेकिन प्रलेखन कहते हैं कि वे ध्यान नहीं दिया जाता है, और मैं इसे अपने आप परीक्षण किया है, वे वास्तव में अनदेखी कर रहे हैं: डी
अद्यतन: मैं के साथ यह करने के लिए प्रबंधित ARPACK। मैं इसे विंडोज़ के लिए संकलित करने में कामयाब रहा, और इसका इस्तेमाल भी किया। परिणाम, आशाजनक लग रही है एक उदाहरण इस खिलौने उदाहरण में देखा जा सकता है:
#include "ardsmat.h"
#include "ardssym.h"
int n = 3; // Dimension of the problem.
double* EigVal = NULL; // Eigenvalues.
double* EigVec = NULL; // Eigenvectors stored sequentially.
int lowerHalfElementCount = (n*n+n)/2;
//whole matrix:
/*
2 3 8
3 9 -7
8 -7 19
*/
double* lower = new double[lowerHalfElementCount]; //lower half of the matrix
//to be filled with COLUMN major (i.e. one column after the other, always starting from the diagonal element)
lower[0] = 2; lower[1] = 3; lower[2] = 8; lower[3] = 9; lower[4] = -7; lower[5] = 19;
//params: dimensions (i.e. width/height), array with values of the lower or upper half (sequentially, row major), 'L' or 'U' for upper or lower
ARdsSymMatrix<double> mat(n, lower, 'L');
// Defining the eigenvalue problem.
int noOfEigVecValues = 2;
//int maxIterations = 50000000;
//ARluSymStdEig<double> dprob(noOfEigVecValues, mat, "LM", 0, 0.5, maxIterations);
ARluSymStdEig<double> dprob(noOfEigVecValues, mat);
// Finding eigenvalues and eigenvectors.
int converged = dprob.EigenValVectors(EigVec, EigVal);
for (int eigValIdx = 0; eigValIdx < noOfEigVecValues; eigValIdx++) {
std::cout << "Eigenvalue: " << EigVal[eigValIdx] << "\nEigenvector: ";
for (int i = 0; i < n; i++) {
int idx = n*eigValIdx+i;
std::cout << EigVec[idx] << " ";
}
std::cout << std::endl;
}
परिणाम हैं:
9.4298, 24.24059
, और
-0.523207, -0.83446237, -0.17299346
0.273269, -0.356554, 0.893416
(प्रति पंक्ति एक eigenvector) कोड 3 eigenvectors खोजने में विफल रहता है (यह केवल इस मामले में 1-2 पा सकता है, एक जोर() सुनिश्चित करता है, लेकिन ठीक है, यह कोई समस्या नहीं है)।
'पहले 30 eigenvalues / वैक्टर' करके, आप सबसे बड़ा moduli, सबसे बड़ा वास्तविक भागों, या कुछ और के साथ eigenvalues क्या मतलब है? गुगलिंग के बाद, ऐसा लगता है कि [SLEPc] (http://www.grycap.upv.es/slepc/) हो सकता है कि आप जो खोज रहे हैं। – James
मैं 30 ईजिनवेक्टरों की तलाश में हूं जो कि 30 वास्तविक वास्तविकता के अनुरूप हैं, जिसके परिणामस्वरूप वास्तविक, सममित मैट्रिक्स की ईजिन-अपघटन होती है। – NameZero912
मैं इसके लिए ARPACK का उपयोग करूंगा। आप तुरंत अपने 30 eigenvectors मिल जाएगा। –