Introduction/Fonctionnalités

L'objet du module matrix de la librairie Opale est de fournir un ensemble de classes permettant la construction et la manipulation de matrices quelconques, ainsi que les traitements mathématiques classiquement associés tels que la résolution de système ou encore le calcul de valeurs propres etc...

Par conception, l'ensemble des classes du module matrix se doit de se présenter au développeur ou utilisateur comme une API structurée, facilement extensible, suffisamment cohérente pour mener à une utilisation quasi-intuitive. Ainsi des classes de base viennent chapeauter les différents types de matrices afin que les mêmes services soient disponibles pour tous les types de matrices et accessibles par les mêmes mécanismes. La résolution d'un système linéaire, se veut ainsi simple depuis la construction de la matrice, jusqu'au choix du résolveur (solver) et de l'appel de la méthode de résolution.

Les objectifs du module matrix sont :

• Gestion de matrices selon différentes techniques de stockage : pleine, symétrique, morse, bande etc...
• Inversion de systèmes linéaires : méthodes directes LU, Cholesky etc... optimisées pour chaque type de stockage ; méthodes itératives performantes Gradient conjugué etc... pour les grands systèmes linéaires.
• Calcul des valeurs propres (aucune méthode disponible pour l'heure) : méthode de la puissance etc...

La position du module matrix au sein la librairie Opale est à double usage :

• se présenter comme un module autonome pouvant être utilisé à volonté à l'extérieur dans d'autres programmes où des besoins en calculs matriciels sont demandés ;
• mais également apparaître comme un module-outil de base pour le développement des autres modules de Opale plus orientés "métiers" comme le module de résolution d'équations différentielles (ODE) ou le module de statistiques où des besoins en calculs matriciel peuvent être importants.

Exemple d'utilisation

Voici un exemple simple d'utilisation du module matrix dans un programme extérieur. Il s'agit de construire une matrice tri-diagonale (profiter de la structure de la matrice pour la stocker dans une matrice type "bande") et d'inverser un système linéaire par une méthode LU.

Voici le code source largement commenté :

import opale.mathtools.*;
import opale.matrix.*; 				// import du package matrix
import opale.matrix.solver.*;			// import du package solveur


public class LUBand
{

  public static void main(String[] arg)
  {
    int size = 100; 			//: Taille de la matrice à construire
    // Déclaration de la matrice taille=size
    //, largeur de bande= 3 (matrice tridiagonale)
    BandMatrix A = new BandMatrix (size,3); 
                                                                         
    for (int i=0; i < size; i++)		// on remplit la matrice	
    {
    	A.set(i,i,2);			// la diagonale
	if (i > 0) { A.set(i,i-1,-7);}	// la sous diagonale
	if (i< size-1) { A.set(i,i+1,-7);} 	// la surdiagonale
    }	
    //System.out.println(A);
    //System.out.println(A.get(2,2));
   
    DVect b = new DVect(size); 		// le second membre
    DVect x = new DVect(size); 		// le vecteur solution

    b.set(0,1);  				// valeur du second membre (1;0;0;...;0)
    b.set(1,0);
   
    BandMatrix AA = (BandMatrix) A.clone();	 //Facultatif : pour conserver la matrice d origine
    SolverLUBand lu = new SolverLUBand(); 	//On instancie un solveur type LU optimisé stockage "bande"
    lu.decomp(A); 				// on appele la décomposition par LU de la matrice

    System.out.println("det = "+lu.determinant()); // affichage du déterminant
    lu.solve(null,b,x); 			//on résout (pas besoin de spécifier la matrice dans le cadre 
			    			// d'une méthode directe, la décomposition de la matrice est utilisée.

    System.out.println(x); // Affichage de la solution
   
    DVect err = new DVect(size);
    DVect Ax = new DVect(size);
    Ax = AA.mul(x);
    for (int i=0; i < size; i++)
    {
      err.set(i,Ax.get(i)-b.get(i));
    }	
    
    System.out.println("Err = "+err.getMax());
  }  
}

Opale Team : January 31 2004 23:14:10.