Convertir Propres de la Matrice C de la matrice de

La Eigen bibliothèque peuvent la carte mémoire existant dans Propres des matrices.

float array[3];
Map<Vector3f>(array, 3).fill(10);
int data[4] = 1, 2, 3, 4;
Matrix2i mat2x2(data);
MatrixXi mat2x2 = Map<Matrix2i>(data);
MatrixXi mat2x2 = Map<MatrixXi>(data, 2, 2);

Ma question est, comment pouvons-nous obtenir de c tableau (par exemple, float[] a) à partir des modes propres de la matrice (par exemple, Matrix3f m)? Qu'elle est la véritable disposition des propres de la matrice? Est la réel à des données stockées que dans la normale c tableau?

Ce ne sont pas les types de données standard. Est "Eigen" le nom de la bibliothèque, ou une référence à des fondements mathématiques? Si ce dernier ce que la bibliothèque sont les types de? Aussi, C n'a pas de modèle type. Depuis les matrices sont en 2 dimensions, exactement ce que vous voulez dans la plaine de tableau? Une ligne ou une colonne spécifique, ou de l'ensemble de la matrice remodelé à une dimension?
Eigen se réfère à un bibliothèque.
c'est possible, mais je veux faire absolument sûr que c'est ce que lil fait référence.
oui, je reportez-vous à eigen.tuxfamily.org

InformationsquelleAutor lil | 2011-12-09

arrays c++eigen matrix

50

Vous pouvez utiliser le de données() fonction de membre de la Propres de la Matrice de classe. La mise en page par défaut de la colonne principale, pas de la ligne majeure, comme un caractère multidimensionnel, C array (la mise en page peut être choisi lors de la création d'un objet de la Matrice). Pour les matrices creuses de la phrase précédente n'est évidemment pas s'appliquer.

Exemple:
```
ArrayXf v = ArrayXf::LinSpaced(11, 0.f, 10.f);
//vc is the corresponding C array. Here's how you can use it yourself:
float *vc = v.data();
cout << vc[3] << endl;  //3.0
//Or you can give it to some C api call that takes a C array:
some_c_api_call(vc, v.size());
//Be careful not to use this pointer after v goes out of scope! If
//you still need the data after this point, you must copy vc. This can
//be done using in the usual C manner, or with Eigen's Map<> class.
```
- S'il vous plaît ajouter des exemples de code.
- Pour l'avenir, quelqu'un: Eigen::Matrix<float, -1, 3, Eigen::RowMajor> vertices_;
- C'est bizarre, mais les données() de la fonction membre est sans-papiers, pour une raison quelconque. Je suis à la recherche ici: eigen.tuxfamily.org/...
- href="http://eigen.tuxfamily.org/dox/classEigen_1_1PlainObjectBase.html#ac54123f62de4c46a9107ff53890b6116" >eigen.tuxfamily.org/dox/...
- Oh, ça y est. Merci, @janneb.
InformationsquelleAutor janneb
15

Pour convertir normal type de données propres de la matrice de type
```
  double *X; //non-NULL pointer to some data
```
Vous pouvez créer un nRows x nrows taille double de la matrice à l'aide de la Carte de la fonctionnalité comme ceci:
```
  MatrixXd eigenX = Map<MatrixXd>( X, nRows, nCols );
```
Pour convertir propres de la matrice de type normal en type de données
```
  MatrixXd resultEigen;   //Eigen matrix with some result (non NULL!)
  double *resultC;        //NULL pointer <-- WRONG INFO from the site. resultC must be preallocated!
  Map<MatrixXd>( resultC, resultEigen.rows(), resultEigen.cols() ) =   resultEigen;
```
De cette façon, vous pouvez obtenir dans et hors de modes propres de la matrice. Plein de crédits va à http://dovgalecs.com/blog/eigen-how-to-get-in-and-out-data-from-eigen-matrix/
- La deuxième partie n'a pas de sens. Comment peut-Eigen::Map comme par magie prendre un pointeur NULL (resultC) et y copier des données?? En effet, j'ai essayé le code ci-dessus avec un exemple de matrice 2x2 et la Carte de segmentation, comme vous le souhaitez.
- Un simple ctrl+c ctrl+v du site à l'aide des informations incorrectes! Cela ne fonctionne pas. Quelqu'un peut s'il vous plaît corriger cette réponse? Même ici @eraoul
- La première partie n'a pas de sens. Cette réponse produit de mauvais résultats parce qu'il ne prend pas en compte les différentes ordre de stockage dans Eigen et C
InformationsquelleAutor GPrathap
3

Vous devez utiliser la fonction Map de nouveau. Veuillez voir l'exemple ici:
http://forum.kde.org/viewtopic.php?f=74&t=95457

InformationsquelleAutor Prashanth
3

Si le tableau est à deux dimensions, il faut prêter attention à l'ordre de stockage. Par défaut, les Propres magasins de matrices dans la colonne ordre majeur. Cependant, une ligne ordre majeur est nécessaire pour la conversion directe de l'un tableau en un Propres de la matrice. Si de telles conversions sont effectuées fréquemment dans le code, il peut être utile d'utiliser un correspondant typedef.
```
using namespace Eigen;
typedef Matrix<int, Dynamic, Dynamic, RowMajor> RowMatrixXi;
```
Avec une telle définition, on peut obtenir un Propres de la matrice à partir d'un tableau dans un simple et compact, tout en préservant l'ordre du tableau original.

De C tableau de Eigen::Matrice
```
int nrow = 2, ncol = 3;
int arr[nrow][ncol] =  { {1 ,2, 3},  {4, 5, 6} }; 
Map<RowMatrixXi> eig(&arr[0][0], nrow, ncol);

std::cout << "Eigen matrix:\n" << eig << std::endl;

//Eigen matrix:
//1 2 3
//4 5 6
```
Dans la direction opposée, les éléments d'une Propres de la matrice peut être transféré directement à un C-gamme de style en utilisant Map.

De Eigen::Matrice de C tableau
```
int arr2[nrow][ncol];
Map<RowMatrixXi>(&arr2[0][0], nrow, ncol) = eig;

std::cout << "C array:\n";
for (int i = 0; i < nrow; ++i) {
  for (int j = 0; j < ncol; ++j) {
    std::cout << arr2[i][j] << " ";
  }
  std::cout << "\n";
}

//C array:
//1 2 3 
//4 5 6 
```
Noter que dans ce cas, la matrice d'origine eig n'a pas besoin d'être stockées en ligne-major de mise en page. Il suffit de spécifier la ligne ordre majeur dans Map.

InformationsquelleAutor RHertel

La solution avec la Carte ci-dessus de segmentation quand je l'ai essayer (voir le commentaire ci-dessus).

Au lieu de cela, voici une solution qui fonctionne pour moi, la copie les données dans un std::vector à partir d'un Eigen::Matrix. Je l'ai pré-allouer de l'espace dans le vecteur de stocker le résultat de la Carte/copier.

Eigen::MatrixXf m(2, 2);
m(0, 0) = 3;
m(1, 0) = 2.5;
m(0, 1) = -1;
m(1, 1) = 0;

cout << m << "\n";

//Output:
//   3  -1
//2.5   0

//Segfaults with this code: 
//
//float* p = nullptr;
//Eigen::Map<Eigen::MatrixXf>(p, m.rows(), m.cols()) = m;

//Better code, which also copies into a std::vector:

//Note that I initialize vec with the matrix size to begin with:
std::vector<float> vec(m.size());
Eigen::Map<Eigen::MatrixXf>(vec.data(), m.rows(), m.cols()) = m;

for (const auto& x : vec)
  cout << x << ", ";
cout << "\n";

//Output: 3, 2.5, -1, 0

InformationsquelleAutor eraoul

-2

ComplexEigenSolver < MyMatrix > es;
complex<double> *eseig;
es.compute(H);
es.eigenvalues().transpose();
eseig=(complex<double> *)es.eigenvalues().data();

InformationsquelleAutor user3097951

Vous devez vous connecter pour publier un commentaire.