complexe matrice en utilisant GSL

Question

Multiplication

J'ai une question très simple - je veux juste multiplier deux matrices avec des entrées complexes ainsi que dans GSL C. Ainsi, par exemple, je veux définir une fonction

gsl_matrix_complex *multiply(gsl_matrix_complex *A, gsl_matrix_complex *B) { 
??? 
} 

I » Je l'ai vu quand les entrées sont doubles, mais je ne peux pas comprendre la généralisation appropriée. Toute aide serait appréciée!

Merci encore.

Answer 1

Pour multiplier les matrices en GSL, vous devez utiliser le BLAS interface légèrement cryptique.

En supposant que les matrices que vous allez multiplier n'ont pas la structure connue (par exemple sont symétriques, etc. ou hermitienne). La fonction appropriée à utiliser serait gsl_blas_zgemm. La traduction de la chaîne apparemment aléatoire de lettres dans le nom de la fonction est:

z = double precision complex 
ge = general matrices 
mm = matrix-matrix multiplication 

(Pour une liste de tous les abréviations voir here)

En utilisant les informations contenues dans les documents que nous pourrait alors écrire votre fonction

#include <gsl/gsl_blas.h> 
#include <gsl/gsl_matrix.h> 
#include <gsl/gsl_complex_math.h> 

gsl_matrix_complex *multiply(gsl_matrix_complex *A, gsl_matrix_complex *B) 
{ 
    gsl_matrix_complex *result = gsl_matrix_complex_alloc(A->size1, B->size2); 

    gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, 
        GSL_COMPLEX_ONE, A, B, 
        GSL_COMPLEX_ZERO, result); 

    return result; 
} 

Notez qu'au lieu d'attribuer la matrice de résultat dans la fonction de multiplication serait, au contraire une meilleure pratique de passer en un qui a déjà été alloué dans la fonction appelante, par exemple avec la signature:

void multiply*(gsl_matrix_complex *A, gsl_matrix_complex *B, gsl_matrix_complex *result); 

puis d'omettre l'étape d'allocation et le retour explicite. La raison de cela est qu'il vous permet de réduire le nombre d'allocations de tas votre code fonctionne aussi bien que ce qui rend plus difficile pour vous d'écrire du code accidentellement que des fuites de mémoire.