C Algorithmus um 1024x1024 Matrix zu invertieren?

Question

Dies ist meine erste Frage auf dieser Website. Ich versuche (verzweifelt) eine große Matrix in meinem Programm umzukehren. Ich möchte lapack verwenden, um dies zu tun, und ich fand diesen Thread, der ziemlich vielversprechend aussieht, aber ich denke, es ist in C++ Sprache. Könntest du mir helfen?

Computing the inverse of a matrix using lapack in C

Danke.

Update: Sie haben Recht, die Antwort ist ein wenig unklar. Nach dem Einbau des Programms i in meine geschrieben, erhalte ich folgende Fehlermeldung:

mymatrixmalloc_2.c:15:18: fatal error: cstdio: non existing File or directory 
#include <cstdio> 
      ^
compilation terminated. 

ich denke, das prolem ist, dass ich havent richtig die llapack Bibliothek installiert ist, oder dass ich es bin auch beim Kompilieren.

Dies ist, wie ich die Bibliothek installiert (von Terminal, ich habe Ubuntu):

sudo apt-get install build-essential 
sudo apt-get install liblapack* 
sudo apt-get install libblas* 

Und das ist, wie ich kompilieren:

davide@John:~$ gcc -Wall -lm -llapack -lblas mymatrixmalloc_2.c -o mymatrixmalloc_2.exe 

Was mache ich falsch?

Answer 1

können Sie überprüfen, ob das C-Algorithmus eine korrekte Inversion einer kleinen Matrix führt:

gcc main.c -llapacke -llapack 
dac@dac-Latitude-E7450 ~/C/gnu> ./a.out 
dgetrf eh, 0, should be zero 
dgetri eh, 0, should be zero 
0.6, -0.7 
-0.2, 0.4⏎ 

Die obige Zahl für das Programm 2 * 2-Matrix in dieser Probe verifiziert werden:

#include <stdio.h> 
#include <stddef.h> 
#include <lapacke.h> 

int main() { 
    int N = 2; 
    int NN = 4; 
    double M[2][2] = {{4, 7}, 
         {2, 6}}; 
    int pivotArray[2]; 
    int errorHandler; 
    double lapackWorkspace[4]; 
    dgetrf_(&N, &N, M[0], &N, pivotArray, &errorHandler); 
    printf("dgetrf eh, %d, should be zero\n", errorHandler); 

    dgetri_(&N, M[0], &N, pivotArray, lapackWorkspace, &NN, &errorHandler); 
    printf("dgetri eh, %d, should be zero\n", errorHandler); 

    for (size_t row = 0; row < N; ++row) { 
     for (size_t col = 0; col < N; ++col) { 
      printf("%g", M[row][col]); 
      if (N - 1 != col) { printf(", "); } 
     } 
     if (N - 1 != row) { printf("\n"); } 
    } 
    return 0; 
}      

Jetzt brauchen wir nur eine größere Matrix 1024 * 1024 zu definieren und sie auf die gleiche Weise umzukehren.

#include <stdio.h> 
#include <lapacke.h> 
int main() { 
    int N = 1024; 
    int NN = N*N; 
    double M[N][N]; 
    for(int i=0;i<N;i++) { 
     for(int j=0;j<N;j++) { 
      M[i][j] = 0; 
      if(i==j) 
       M[i][j] = 1; 
     } 
    } 
    int pivotArray[N]; 
    int errorHandler; 
    double lapackWorkspace[N*N]; 
    dgetrf_(&N, &N, M[0], &N, pivotArray, &errorHandler); 
    printf ("dgetrf eh, %d, should be zero\n", errorHandler); 
    dgetri_(&N, M[0], &N, pivotArray, lapackWorkspace, &NN, &errorHandler); 
    printf("dgetri eh, %d should be zero\n", errorHandler); 
    return 0; 
} 

den obigen Code ausführen zu können, ich hatte auch meine Stackgröße auf Linux zu erhöhen:

ulimit -s 65532

Die Matrix der obige Code ist Matrix der Einheit verwendet, die ihre eigene inverse ist. Sie können auch jede andere Matrix verwenden, die eine Umkehrung hat, und sie zweimal invertieren, um zu überprüfen, ob Sie die ursprüngliche Matrix erhalten.