Une classe d'algèbre (calcul matriciel) performante ?

Bonjour à tous,

En une phrase, je recherche une classe template permettant d'effectuer du calcul matriciel performant sur des matrices carrées de tailles moyenne (100 double * 100 double) à grande (2000 double * 2000 double).

Plus précisément, cette classe devrait - dans l'idéal - comporter des méthodes d'inversion de matrice intelligentes, c-à-d qui vont appeler l'un ou l'autre algorithme d'inversion en fonction de la taille de la matrice et de ses propriétés (pleine, triangulaire sup, multidiagonale, etc). Elle devrait aussi pouvoir s'intégrer sans trop de difficultés dans un projet existant de simulation numérique. Après recherche sur le web et consultation de forums, je constate qu'il y a plusieurs solutions libres proposées, et j'ai du mal à me décider pour l'une ou l'autre. Je fais donc appel à votre expérience : pouvez vous me conseiller une classe particulière ?

D'avance merci pour votre aide !

Bonjour,

la librairie uBLAS de boost répondra peut-être à ton besoin. En revanche, la documentation n'est pas géniale, et il faut un sacré background en algèbre et en c++, ou éventuellement une bonne connaissance de la librairie fortran originale, pour l'utiliser (à mon sens en tout cas). voici, toutefois - si cela t'intéresse - l'exemple de base qui permet d'inverser une matrice avec l'élimination de gauss-jordan :

/*_________________________________________________________________________________
*/
#include <boost/numeric/ublas/lu.hpp>
#include <boost/numeric/ublas/io.hpp>
/*_________________________________________________________________________________
*/
using namespace boost::numeric;
/*_________________________________________________________________________________
*/
int main( int argc, char** argv )
{
    ublas::matrix<double> A( 2 , 2 ) ;
    A( 0 , 0 ) = 1 ; A( 0 , 1 ) = 2 ;
    A( 1 , 0 ) = 3 ; A( 1 , 1 ) = 4 ;

    std::cout << A << std::endl;

     ublas::permutation_matrix< std::size_t > pm( A.size1() );

    int res( 0 );
    if ( res = ublas::lu_factorize( A , pm ) )
    {
        std::cout << "matrix rank = " << res - 1 << std::endl;
    }
    else
    {
        ublas::matrix<double> inv( ublas::identity_matrix<double>( A.size1() ) );
        ublas::lu_substitute( A , pm , inv );
        std::cout << inv << std::endl;
    }
}
/*_________________________________________________________________________________
*/

Bonjour,

Merci pour ta réponse. A première vue de l'exemple que tu donnes, je dirais que c'est une solution qui ne me convient pas vraiment, car il faut visiblement choisir la méthode d'inversion. Alors que je recherche - dans l'idéal - une solution qui va surcharger une méthode "inversion" (ou opérateur ^(-1), etc) de sorte que l'utilisateur pourrait se contenter d'écrire INV = A^(-1), la librairie se chargeant d'effectuer le travail suivant : détection automatique des propriétés de A, choix d'un algorithme d'inversion en fct de ces propriétés, puis execution. Idem pour un système linéaire A x = b, l'utilisateur se contenterait d'écrire : x = b / A ou x = A^(-1) * b.

Bienvenue ,

j'aime la programmation   bouceaups 

J'aime  tous  sur l'informatique  et  je veut  apprendre la langue anglaise ( grace à vos aides) .