Herezh_dev/Resolin/Matrices/matrices_lapack/MatLapack.cc

3790 lines
147 KiB
C++

// FICHIER : MatLapack.cc
// CLASSE : MatLapack
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
# include <iostream>
using namespace std; //introduces namespace std
#include "MatLapack.h"
#include "Sortie.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "MatDiag.h"
#include <math.h>
#include <stdlib.h>
#include "CharUtil.h"
#include "ExceptionsMatrices.h"
#ifdef ENLINUX_2009
#include "cblas.h"
#else
#ifdef SYSTEM_MAC_OS_X_unix
// #include </System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Headers/cblas.h>
// #include "Headers/cblas.h"
#include <Accelerate.h>
#endif
#endif
#ifdef SYSTEM_MAC_OS_X
#include <Versions/A/Headers/cblas.h>
#endif
#ifndef MatLapack_H_deja_inclus
#ifndef MISE_AU_POINT
inline
#endif
// il est nécessaire ensuite de définir les données pour l'utiliser
MatLapack::MatLapack ():
Mat_abstraite(RECTANGLE_LAPACK,GAUSS,RIEN_PRECONDITIONNEMENT)
,mat(),ipiv(NULL),ptB(NULL),travail(1)
,nb_lign(0),nb_col(0),ldb(1),kl(0),ku(0),lda(1) // seules les grandeurs pour le stockage rectangle sont bien initialisées
{ Coor = &MatLapack::Coor_GE; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_GE_const;
};
#ifndef MISE_AU_POINT
inline
#endif
// Constructeur pour une matrice carree quelconque, ou symétrique
// se servant d'un nombre de lignes = colonnes, et eventuellement
// d'une valeur d'initialisation
MatLapack::MatLapack (int nb_l,int nb_c, bool symetrique, double val_init
,Enum_type_resolution_matri type_resol
,Enum_preconditionnement type_precondi):
Mat_abstraite(CARREE_LAPACK,type_resol,type_precondi)
,mat(0) // on le met à 0 au début
,ipiv(NULL),ptB(NULL),travail(1)
,nb_lign(nb_l),nb_col(nb_c),ldb(MaX(1,nb_l)),lda(MaX(1,nb_l))
,kl(0),ku(0) // ne servent pas
{ // on rectifie le type de matrice
if (symetrique)
{type_matrice = CARREE_SYMETRIQUE_LAPACK;
Coor = &MatLapack::Coor_PP; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_PP_const;
if (type_resol == RIEN_TYPE_RESOLUTION_MATRI)
type_resolution = CHOLESKY; // par défaut si rien n'est défini
mat.Change_taille(nb_l*(nb_c-1)/2+nb_c,val_init);
}
else
// sinon on n'est pas en symétrique
{ Coor = &MatLapack::Coor_GE; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_GE_const;
mat.Change_taille(nb_l*nb_c,val_init);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Constructeur pour une matrice bande quelconque, ou symétrique
// se servant d'un nombre de lignes, de = colonnes, et eventuellement
// d'une valeur d'initialisation et d'un type de résolution
MatLapack::MatLapack (Enum_matrice enu_mat, int lb_totale,int dim ,bool symetrique, double val_init
,Enum_type_resolution_matri type_resol
,Enum_preconditionnement type_precondi
):
Mat_abstraite(enu_mat,type_resol,type_precondi)
,mat() ,nb_lign(dim),nb_col(lb_totale)
,ipiv(NULL),ptB(NULL),travail(1)
,ldb(MaX(1,dim)),kl(0),ku(0),lda(0)
{
if (enu_mat == BANDE_NON_SYMETRIQUE_LAPACK)
{// les colonnes de 1 à lb= (lb_totale-1)/2 sont utilisée par lapack
// pour les routines d'herezh, seules les valeurs à partir de la colonne 1+lb sont utilisées
// int lb = (lb_totale-1)/2;
kl=ku=((lb_totale-1)/2);
lda=2*kl+ku+1;
Coor = &MatLapack::Coor_GB; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_GB_const;
if (type_resolution == CHOLESKY)
#ifdef MISE_AU_POINT
{ cout << "\n ** attention, le type de resolution par defaut avec BANDE_NON_SYMETRIQUE_LAPACK "
<< " est GAUSS " ;
};
#endif
if ((type_resolution == RIEN_TYPE_RESOLUTION_MATRI)||(type_resolution == CHOLESKY))
type_resolution = GAUSS; // par défaut si rien n'est défini
}
else if (enu_mat == BANDE_SYMETRIQUE_LAPACK)
{// là on ne stocke que la partie symétrique, on suppose de plus que la matrice
// est définie positive, enfin il n'y a pas de stockage supplémentaire utilisé par lapack
// pour les routines d'herezh, les valeurs à partir de la colonne 1 sont utilisées
// int lb = lb_totale;
kl=ku=lb_totale-1;
lda=ku+1;
Coor = &MatLapack::Coor_PB; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_PB_const;
if (type_resolution == RIEN_TYPE_RESOLUTION_MATRI)
type_resolution = CHOLESKY; // par défaut si rien n'est défini
}
//*** en chantier
// else if (enu_mat == TRIDIAGONALE_GENE_LAPACK)
// {// matrice quelconque tri: là on stocke toute la matrice
// // est définie positive, enfin il n'y a pas de stockage supplémentaire utilisé par lapack
// // pour les routines d'herezh, les valeurs à partir de la colonne 1 sont utilisées
// // int lb = lb_totale;
// kl=ku=lb_totale-1;
// lda=ku+1;
// Coor = &MatLapack::Coor_PB; // association pour la récupération des coordonnées
// Coor_const = &MatLapack::Coor_PB_const;
// if (type_resolution == RIEN_TYPE_RESOLUTION_MATRI)
// type_resolution = CHOLESKY; // par défaut si rien n'est défini
// }
// else if (enu_mat == BANDE_SYMETRIQUE_LAPACK)
// {// là on ne stocke que la partie symétrique, on suppose de plus que la matrice
// // est définie positive, enfin il n'y a pas de stockage supplémentaire utilisé par lapack
// // pour les routines d'herezh, les valeurs à partir de la colonne 1 sont utilisées
// // int lb = lb_totale;
// kl=ku=lb_totale-1;
// lda=ku+1;
// Coor = &MatLapack::Coor_PB; // association pour la récupération des coordonnées
// Coor_const = &MatLapack::Coor_PB_const;
// if (type_resolution == RIEN_TYPE_RESOLUTION_MATRI)
// type_resolution = CHOLESKY; // par défaut si rien n'est défini
// }
//*** fin chantier
;
// def du conteneur de la matrice
mat.Change_taille(lda*ldb,val_init);
#ifdef MISE_AU_POINT
// pour l'instant on ne considère que des bandes d'étendues égales de part et autres de la diagonale
if ((enu_mat == BANDE_NON_SYMETRIQUE_LAPACK) && ((lb_totale % 2) == 0))
{ cout << "erreur de dimensionnement d'une matrice bande lapack ";
cout << " largeur de bande = " << lb_totale << " devrait etre un nombre impair " ;
cout << "\n MatLapack::MatLapack (... " << endl;
Sortie(1);
};
#endif
#ifdef MISE_AU_POINT
// vérif que l'on est bien en bande lapack
if ((enu_mat != BANDE_SYMETRIQUE_LAPACK) && (enu_mat != BANDE_NON_SYMETRIQUE_LAPACK))
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(enu_mat)
<< "\n MatLapack::MatLapack (Enum_matrice enu_mat,...";
Sortie(1);
};
if ((nb_lign < 0) || (nb_col < 0))
{ cout << "erreur de dimensionnement d une matrice bande";
cout << " LB = " << nb_col << " dim = " << nb_lign << '\n';
cout << "\n MatLapack::MatLapack (Enum_matrice enu_mat..." << endl;
Sortie(1);
};
#endif
};
// Constructeur de copie
#ifndef MISE_AU_POINT
inline
#endif
MatLapack::MatLapack (const MatLapack& mat_pl) :
Mat_abstraite(mat_pl)
,mat(mat_pl.mat)
,nb_lign(mat_pl.nb_lign),nb_col(mat_pl.nb_col)
,ipiv(NULL),ptB(NULL),travail(1)
,ldb(mat_pl.ldb),lda(mat_pl.lda),ku(mat_pl.ku),kl(mat_pl.kl)
{
if (type_matrice == CARREE_SYMETRIQUE_LAPACK)
{Coor = &MatLapack::Coor_PP; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_PP_const;
}
else if(type_matrice == CARREE_LAPACK)
// sinon on n'est pas en symétrique
{ Coor = &MatLapack::Coor_GE; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_GE_const;
}
else if (type_matrice == BANDE_NON_SYMETRIQUE_LAPACK)
{Coor = &MatLapack::Coor_GB; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_GB_const;
}
else if (type_matrice == BANDE_SYMETRIQUE_LAPACK)
{Coor = &MatLapack::Coor_PB; // association pour la récupération des coordonnées
Coor_const = &MatLapack::Coor_PB_const;
}
//*** en chantier
// else if (enu_mat == TRIDIAGONALE_GENE_LAPACK)
// {// matrice quelconque tri: là on stocke toute la matrice
// // est définie positive, enfin il n'y a pas de stockage supplémentaire utilisé par lapack
// // pour les routines d'herezh, les valeurs à partir de la colonne 1 sont utilisées
// // int lb = lb_totale;
// kl=ku=lb_totale-1;
// lda=ku+1;
// Coor = &MatLapack::Coor_PB; // association pour la récupération des coordonnées
// Coor_const = &MatLapack::Coor_PB_const;
// if (type_resolution == RIEN_TYPE_RESOLUTION_MATRI)
// type_resolution = CHOLESKY; // par défaut si rien n'est défini
// }
// else if (enu_mat == BANDE_SYMETRIQUE_LAPACK)
// {// là on ne stocke que la partie symétrique, on suppose de plus que la matrice
// // est définie positive, enfin il n'y a pas de stockage supplémentaire utilisé par lapack
// // pour les routines d'herezh, les valeurs à partir de la colonne 1 sont utilisées
// // int lb = lb_totale;
// kl=ku=lb_totale-1;
// lda=ku+1;
// Coor = &MatLapack::Coor_PB; // association pour la récupération des coordonnées
// Coor_const = &MatLapack::Coor_PB_const;
// if (type_resolution == RIEN_TYPE_RESOLUTION_MATRI)
// type_resolution = CHOLESKY; // par défaut si rien n'est défini
// }
//*** fin chantier
;
};
#ifndef MISE_AU_POINT
inline
#endif
MatLapack::~MatLapack ()
// Destructeur
{ if (ipiv != NULL) delete [] ipiv;
if (ptB != NULL) delete ptB;
};
// fonction permettant de creer une nouvelle instance d'element
#ifndef MISE_AU_POINT
inline
#endif
Mat_abstraite * MatLapack::NouvelElement() const
{ Mat_abstraite * a;
a = new MatLapack(*this);
return a;
};
// surcharge de l'opérateur d'affectation: cas des matrices abstraites
// il faut que les matrices soient ici de type et de tailles identiques sinon erreur
#ifndef MISE_AU_POINT
inline
#endif
Mat_abstraite & MatLapack::operator = ( const Mat_abstraite & b)
{
#ifdef MISE_AU_POINT
// dans le cas où les matrices ne sont pas de caractéristiques identiques
// il y a un message d'erreur
if (type_matrice != b.Type_matrice())
{cout << "erreur dans l'operation d'affectation";
cout << " les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(b.Type_matrice()) << '\n';
cout << "MatLapack::operator = ( const Mat_abstraite & b)" << endl;
Sortie(1);
}
#endif
const MatLapack & mat_pl = *((MatLapack*) & b);
(*this)=mat_pl;
// retour
return (*this);
};
// transfert des informations de *this dans la matrice passée en paramètre
// la matrice paramètre est au préalable, mise à 0.
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Transfert_vers_mat( Mat_abstraite & b )
{b.Initialise(0.); // init de la matrice
// puis on transfert
switch (type_matrice)
{case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{int le_max = nb_lign+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
{int le_maxj = nb_col+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j=1;j< le_maxj;j++)
b(i,j)= (this->*Coor_const)(i,j);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{int lb = ku;
int le_max = nb_lign+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
{int le_maxj = MiN(nb_lign,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< le_maxj;j++)
b(i,j)=(*this)(i,j);
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{int lb = ku; // largeur de bande hors diagonale
int le_max = nb_lign+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
{int le_maxj = MiN(nb_lign,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< le_maxj;j++)
b(i,j)=(*this)(i,j);
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Affiche ()const "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
MatLapack& MatLapack::operator= ( const MatLapack& mat_pl)
// Surcharge de l'operateur = : affectation d'une matrice a une autre
// il faut que les matrices soient ici de tailles identiques sinon erreur
{
#ifdef MISE_AU_POINT
// si la place à affecter n'est pas identique -> erreur
if ((nb_lign != mat_pl.nb_lign) || (nb_col != mat_pl.nb_col))
{cout << "erreur dans l'operation d'affectation";
cout << " les matrices ont un nombre de lignes ou colonnes différents: nb ligne= "
<< nb_lign << " " << mat_pl.nb_lign << " nb colonne= " << nb_col << " " << mat_pl.nb_col << '\n';
cout << "MatLapack::operator = ( const MatLapack & )" << endl;
Sortie(1);
};
#endif
// les deux matrices sont identiques en type et taille on affecte basiquement
// donc toutes les variables intermédiaires de dimensionnement sont identiques, reste le contenu de la matrice
mat = mat_pl.mat;
// en fait dans le cas d'un stockage bande, on applique également pour la partie travail
// qui sert pour la résolution uniquement, cependant, comme c'est difficile de séparer les grandeurs utiles (i,j)
// et celles de travail, on applique à toute la matrice (la partie travail sera de toute manière recalculée avant emploi
// retour
return (*this);
};
// Surcharge de l'operateur += : addition d'une matrice a la matrice courante
// la matrice à additionner doit être de même type ou diagonale, de même nombre
// de ligne
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::operator+= (const Mat_abstraite& b)
{
#ifdef MISE_AU_POINT
// dans le cas où les matrices ne sont pas de caractéristiques identiques
// il y a un message d'erreur
if ((type_matrice != b.Type_matrice())&&(b.Type_matrice() != DIAGONALE))
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(b.Type_matrice()) << '\n';
cout << "MatLapack::operator+= (const Mat_abstraite& b)" << endl;
Sortie(1);
};
#endif
if (b.Type_matrice() != DIAGONALE)
{ const MatLapack & mat_pl = *((MatLapack*) & b);
this->operator+= (mat_pl); // dans le cas de bande : cf. NBM operator= ( const MatLapack& mat_pl)
}
else // cas d'une matrice argument diagonale
{
#ifdef MISE_AU_POINT
// il faut que le nombre de ligne soit identique
if (nb_lign != b.Nb_ligne())
{cout << " les matrices ont un nombre de ligne différent "
<< nb_lign << " " << b.Nb_ligne() << '\n';
cout << "MatLapack::operator+= (const Mat_abstraite& b)" << endl;
Sortie(1);
};
#endif
const MatDiag & mat_d = *((MatDiag*) & b);
int le_max = nb_lign+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
(*this)(i,i) += mat_d(i,i);
// mat += mat_d.Vecteur_MatDiag(); ?? une erreur 2 mai 2012
};
};
// Surcharge de l'operateur -= : soustraction d'une matrice a la matrice courante
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::operator-= (const Mat_abstraite& b)
{
#ifdef MISE_AU_POINT
// dans le cas où les matrices ne sont pas de caractéristiques identiques
// il y a un message d'erreur
if ((type_matrice != b.Type_matrice())&&(b.Type_matrice() != DIAGONALE))
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(b.Type_matrice()) << '\n';
cout << "MatLapack::operator-= (const Mat_abstraite& b)" << endl;
Sortie(1);
};
#endif
if (b.Type_matrice() != DIAGONALE)
{ const MatLapack & mat_pl = *((MatLapack*) & b);
this->operator-= (mat_pl); // dans le cas de bande : cf. NBM operator= ( const MatLapack& mat_pl)
}
else // cas d'une matrice argument diagonale
{ const MatDiag & mat_d = *((MatDiag*) & b);
#ifdef MISE_AU_POINT
// il faut que le nombre de ligne soit identique
if (nb_lign != b.Nb_ligne())
{cout << " les matrices ont un nombre de ligne différent "
<< nb_lign << " " << b.Nb_ligne() << '\n';
cout << "MatLapack::operator-= (const Mat_abstraite& b)" << endl;
Sortie(1);
};
#endif
int le_max = nb_lign; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
(*this)(i,i) -= mat_d(i,i);
// mat -= mat_d.Vecteur_MatDiag(); ?? une erreur 2 mai 2012
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Addition a la matrice courante de la matrice mat_pl
void MatLapack::operator+= ( const MatLapack& mat_pl)
{
#ifdef MISE_AU_POINT
// il faut que les deux matrices de type lapack soient identiques
if (type_matrice != mat_pl.type_matrice)
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(mat_pl.type_matrice) << '\n';
cout << "MatLapack::operator+= (const MatLapack& )" << endl;
Sortie(1);
};
if ( ( nb_lign!=mat_pl.nb_lign )|| ( nb_col!=mat_pl.nb_col ) )
{cout << "Erreur : dimensions des matrices non egales\n";
cout << "MatLapack::OPERATOR+= (const MatLapack& )\n";
Sortie(1);
};
#endif
// les deux matrices sont identiques en type et taille on affecte basiquement
mat += mat_pl.mat; // dans le cas de bande : cf. NBM operator= ( const MatLapack& mat_pl)
};
#ifndef MISE_AU_POINT
inline
#endif
// Soustrait a la matrice courante la matrice mat_pl
void MatLapack::operator-= ( const MatLapack& mat_pl)
{
#ifdef MISE_AU_POINT
if (type_matrice != mat_pl.type_matrice)
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(mat_pl.type_matrice) << '\n';
cout << "MatLapack::operator-= (const MatLapack& )" << endl;
Sortie(1);
};
if ( ( nb_lign!=mat_pl.nb_lign )|| ( nb_col!=mat_pl.nb_col ) )
{cout << "Erreur : dimensions des matrices non egales\n";
cout << "MatLapack::OPERATOR-= (const MatLapack& )\n";
Sortie(1);
};
#endif
// les deux matrices sont identiques en type et taille on affecte basiquement
mat -= mat_pl.mat; // dans le cas de bande : cf. NBM operator= ( const MatLapack& mat_pl)
};
#ifndef MISE_AU_POINT
inline
#endif
//multiplication de la matrice courante par un scalaire
void MatLapack::operator*= (double coeff)
{ mat *= coeff; };
// Surcharge de l'operateur == : test d'egalite entre deux matrices
#ifndef MISE_AU_POINT
inline
#endif
int MatLapack::operator== (const Mat_abstraite& b) const
{
#ifdef MISE_AU_POINT
// dans le cas où les matrices ne sont pas de caractéristiques identiques
// il y a un message d'erreur
if (type_matrice != b.Type_matrice())
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(b.Type_matrice()) << '\n';
cout << "MatLapack::operator+= (const Mat_abstraite& b)" << endl;
Sortie(1);
}
#endif
const MatLapack & mat_pl = *((MatLapack*) & b);
return this->operator==(mat_pl);
};
#ifndef MISE_AU_POINT
inline
#endif
// Acces aux valeurs de la matrices en écriture
// i : indice de ligne, j : indice de colonne
double& MatLapack::operator () (int i, int j)
{
#ifdef MISE_AU_POINT
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{if ((i < 1) || (i>nb_lign))
{cout << "erreur d acces aux composantes d une matrice rectangulaire";
cout << "\n erreur l'indice en i; " << i << " est impossible "
<< " car nb_ligne de la matrice = " << nb_lign
<< "\n double& MatLapack::operator () ( int i, int j)" << endl;
Sortie(1);
};
if ((j < 1) || (j > nb_col))
{cout << "erreur d acces aux composantes d une matrice rectangulaire";
cout << "\n erreur l'indice en j; " << j << " est impossible "
<< " car nb_col de la matrice = " << nb_col
<< "\n double& MatLapack::operator () ( int i, int j)" << endl;
Sortie(1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:case BANDE_SYMETRIQUE_LAPACK:
{ if (i<1 || (abs(i-j) > ku))
{cout << "erreur d acces aux composantes d une matrice bande lapack";
cout << " indice hors borne (" << i << "," << j <<"), lb = " << ku;
cout << ", condition inacceptable: i<1 || abs(i-j)="<< abs(i-j)<< " >= lb " << '\n';
cout << "double& MatLapack::operator () (int i, int j )" << endl;
};
if (j<1 || j>nb_lign)
{cout << "erreur d acces aux composantes d une matrice bande";
cout << " second indice hors borne j = " << j <<" dim = " << nb_lign << '\n';
cout << "double& MatLapack::operator () (int i, int j )" << endl;
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::operator () (int i, int j) "<<endl;
Sortie(1);
};
#endif
return (this->*Coor)(i,j);
};
#ifndef MISE_AU_POINT
inline
#endif
// Acces aux valeurs de la matrices en lecture
// cas ou l'on ne veut pas modifier les valeurs
// i : indice de ligne, j : indice de colonne
// !!! important, si l'élément n'existe pas du au type de stockage
// utilisé, (mais que les indices sont possible) le retour est 0
double MatLapack::operator () ( int i, int j) const
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i>nb_lign))
{cout << "erreur d acces aux composantes d une matrice ";
cout << "\n erreur l'indice en i; " << i << " est impossible "
<< " car nb_ligne de la matrice = " << nb_lign
<< "\n MatLapack::operator () ( int i, int j) const " << endl;
Sortie(1);
};
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{if ((j < 1) || (j > nb_col))
{cout << "erreur d acces aux composantes d une matrice ";
cout << "\n erreur l'indice en j; " << j << " est impossible "
<< " car nb_col de la matrice = " << nb_col
<< "\n MatLapack::operator () ( int i, int j) const " << endl;
Sortie(1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
// {if (i<1 || (abs(i-j) >= (nb_col-1)/2 +1))
{if (i<1)
{cout << "erreur d acces aux composantes d une matrice bande lapack";
cout << " indice hors borne (" << i << "," << j <<"), lb = " << ku;
cout << ", condition acceptable: i<1 || abs(i-j) >= 2*lb " << '\n';
cout << "MatLapack::operator () ( int i, int j) const" << endl;
Sortie(1);
};
if (j<1 || j>nb_lign)
{cout << "erreur d acces aux composantes d une matrice bande";
cout << " second indice hors borne j = " << j <<" dim = " << nb_lign << '\n';
cout << "MatLapack::operator () ( int i, int j) const" << endl;
Sortie(1);
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::operator () (int i, int j)const "<<endl;
Sortie(1);
};
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{ return (this->*Coor_const)(i,j); break;}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ if (abs(i-j) >= 2*kl) { return 0;}
else {return (this->*Coor_const)(i,j);};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::operator () (int i, int j)const "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// ramène true si la place (i,j) existe, false sinon
// ici on ne test pas le fait que i et j puissent être négatif ou pas
bool MatLapack::Existe(int i, int j) const
{switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: return true;break;
case CARREE_SYMETRIQUE_LAPACK:
return ((i-j)<1);
// erreur: corr 23 sep 2014 case BANDE_NON_SYMETRIQUE_LAPACK: return ((abs(i-j)-(nb_col-1)/2) < 0);break;
case BANDE_NON_SYMETRIQUE_LAPACK: return ((abs(i-j)-(nb_col-1)/2) < 1);break;
case BANDE_SYMETRIQUE_LAPACK:
return ( ((i-j)<1) && ((i-j)<(ku+1)) );
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Existe(.. "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Affiche () const
// Affiche les donnees de la matrice : dimensions, composantes
{switch (type_matrice)
{case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{cout << "\tNombre de lignes : " << Nb_ligne() << "\n";
cout << "\tNombre de colonnes : " << Nb_colonne() << "\n";
int le_max = nb_lign+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
{cout << "Ligne " << i << " :\t{\t";
int le_maxj = nb_col+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j=1;j< le_maxj;j++)
cout << (this->*Coor_const)(i,j) << "\t";
cout << "}\n";
};
cout << "\n";
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{cout << "\n affichage d une matrice bande non symetrique de largeur= "
<< (2*ku+1) << " dimension= " << nb_lign << '\n';
int lb = ku;
int le_max = nb_lign+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
{int le_maxj = MiN(nb_lign,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< le_maxj;j++)
{cout << setw(4) << " i= " << i << " j= " << j << " * "
<< setw(14) << setprecision(7) << (*this)(i,j) << '\n';
};
};
cout << endl ;
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{cout << "\n affichage d une matrice bande symetrique de largeur= "
<< 2*ku+1 << " dimension= " << nb_lign << '\n';
int lb = ku; // largeur de bande hors diagonale
int le_max = nb_lign+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i< le_max;i++)
{int le_maxj = MiN(nb_lign,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< le_maxj;j++)
{cout << setw(4) << " i= " << i << " j= " << j << " * "
<< setw(14) << setprecision(7) << (*this)(i,j) << '\n';
};
};
cout << endl ;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Affiche ()const "<<endl;
Sortie(1);
};
};
// Affiche une partie de la matrice (utile pour le debug)
// MiN_ et max_ sont les bornes de la sous_matrice
// pas_ indique le pas en i et j pour les indices
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Affiche1(int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j) const
{switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ Mat_abstraite::Affiche1(min_i,max_i,pas_i,min_j,max_j,pas_j);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ cout << "\n affichage d une matrice bande non symetrique de largeur= " <<
nb_col << " dimension= " << nb_lign << '\n';
int lb = (nb_col-1)/2; // largeur de bande hors diagonale
cout << " ";
for (int j=min_j;j<=max_j;j+=pas_j) cout << "col " << setw(4) << j << " " ;
cout << '\n';
for (int i=min_i;i<=max_i;i+=pas_i)
{ cout << "lig " << setw(4) << i << " * ";
for (int j=min_j;j<=max_j;j+=pas_j)
if(abs(i-j)<=lb)
cout << setw(11) << setprecision(7) << (*this)(i,j);
else
cout << "...........";
cout << '\n';
};
cout << endl;
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ cout << "\n affichage d une matrice bande symetrique de largeur= " <<
nb_col << " dimension= " << nb_lign << '\n';
int lb = (nb_col-1); // largeur de bande hors diagonale
cout << " ";
for (int j=min_j;j<=max_j;j+=pas_j) cout << "col " << setw(4) << j << " " ;
cout << '\n';
for (int i=min_i;i<=max_i;i+=pas_i)
{ cout << "lig " << setw(4) << i << " * ";
for (int j=min_j;j<=max_j;j+=pas_j)
if(abs(i-j)<=lb)
cout << setw(11) << setprecision(7) << (*this)(i,j);
else
cout << "...........";
cout << '\n';
};
cout << endl;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Affiche1(.. "<<endl;
Sortie(1);
};
};
// Affiche une partie de la matrice (utile pour le debug)
// MiN_ et max_ sont les bornes de la sous_matrice
// pas_ indique le pas en i et j pour les indices
// avec en plus le nb de digit = nd
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Affiche2
(int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd) const
{switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ Mat_abstraite::Affiche2(min_i,max_i,pas_i,min_j,max_j,pas_j,nd);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ cout << "\n affichage d une matrice bande de largeur= "
<< nb_col << " dimension= " << nb_lign << '\n';
#ifdef MISE_AU_POINT
if (nd < 7)
{ cout << " dimension des colonnes trop faible (<7 ! ) " << endl;
return;
};
#endif
int lb = ku; // largeur de bande hors diagonale
SortBlanc(7+9);
for (int j=min_j;j<=max_j;j+=pas_j)
{ cout << "col " << setw(2) << j ;
SortBlanc(nd-6);
};
cout << '\n';
for (int i=min_i;i<=max_i;i+=pas_i)
{ cout << "li " << setw(3) << i << "* ";
for (int j=min_j;j<=max_j;j+=pas_j)
if(abs(i-j)<=lb)
cout << setw(nd) << setprecision(7) << (*this)(i,j);
else
Sortcar(nd,'.');
cout << '\n';
};
cout << endl;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Affiche2 ()const "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// changement du choix de la méthode de résolution si c'est possible
// peut être surchargé par les classes dérivées en fonction des spécificités
void MatLapack::Change_Choix_resolution(Enum_type_resolution_matri type_resol,
Enum_preconditionnement type_precondi)
{
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ // pour l'instant seul GAUSS et CHOLESKY sont possibles !! non !!
// if ((type_resol != GAUSS) && (type_resol != CHOLESKY))
// { cout << "\n ** attention le type de resolution " << Nom_resolution(type_resol)
// << " n'est pas possible avec la matrice " << Nom_matrice(type_matrice)
// << " on change en la valeur par defaut : GAUSS ";
// type_resolution = GAUSS; type_preconditionnement = RIEN_PRECONDITIONNEMENT;
// }
// else
{ type_resolution = type_resol; type_preconditionnement = type_precondi; };
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ if (type_resol == GAUSS) // gauss n'est pas possible
{ cout << "\n ** attention le type de resolution " << Nom_resolution(type_resol)
<< " n'est pas possible avec la matrice " << Nom_matrice(type_matrice)
<< " on change en la valeur par defaut : CHOLESKY ";
type_resolution = CHOLESKY; type_preconditionnement = RIEN_PRECONDITIONNEMENT;
}
else
{ type_resolution = type_resol; type_preconditionnement = type_precondi; };
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ // CHOLESKY n'est pas possible
if (type_resol == CHOLESKY)
{ cout << "\n ** attention le type de resolution " << Nom_resolution(type_resol)
<< " n'est pas possible avec la matrice " << Nom_matrice(type_matrice)
<< " on change en la valeur par defaut : GAUSS ";
type_resolution = GAUSS; type_preconditionnement = RIEN_PRECONDITIONNEMENT;
}
else
{ type_resolution = type_resol; type_preconditionnement = type_precondi; };
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ // GAUSS n'est pas possible
if (type_resol == GAUSS)
{ cout << "\n ** attention le type de resolution " << Nom_resolution(type_resol)
<< " n'est pas possible avec la matrice " << Nom_matrice(type_matrice)
<< " on change en la valeur par defaut : CHOLESKY ";
type_resolution = CHOLESKY; type_preconditionnement = RIEN_PRECONDITIONNEMENT;
}
else
{ type_resolution = type_resol; type_preconditionnement = type_precondi; };
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Change_Choix_resolution(...";
Sortie(1);
};
};
};
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Initialise (double val_init)
// Initialise les composantes de la matrice a val_init
{ // initialisation
mat.Inita(val_init); // dans le cas de bande : voir NB operator= ( const MatLapack& mat_pl)
};
#ifndef MISE_AU_POINT
inline
#endif
// Liberation de la place memoire
void MatLapack::Libere ()
{ mat.Libere();
nb_lign=nb_col=0;
if (ipiv != NULL) {delete [] ipiv;ipiv=NULL;};
if (ptB != NULL) {delete ptB ; ptB=NULL;};//->Libere();
};
#ifndef MISE_AU_POINT
inline
#endif
// changement de taille avec initialisation non nulle éventuelle
// si les tailles existantes sont identiques, on ne fait que initialiser
void MatLapack::Change_taille(int nb_li,int nb_co, const double& val_init)
{
#ifdef MISE_AU_POINT
if ((nb_li < 0) || (nb_co < 0))
{cout << "erreur de dimensionnement d une matrice ";
cout << " nb_li = " << nb_li << " nb_co = " << nb_co << '\n';
cout << "void MatLapack::Change_taille(... " << endl;
}
#endif
if ((nb_li != nb_lign) || (nb_co != nb_col))
{ ldb = MaX(1,nb_li);
this->Libere();
nb_lign = nb_li; nb_col = nb_co;
bool matrice_a_dimensionner = false; // init
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{// on change de taille
lda= MaX(1,nb_lign);
kl=ku=0;
matrice_a_dimensionner=true;
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{// on change de taille, on utilise un stockage compacté, qui utilise la moitié de la taille théorique
lda= MaX(1,nb_lign);
kl=ku=0;
mat.Change_taille(nb_lign*(nb_col+1)/2,val_init); // division entière !
matrice_a_dimensionner=false; // pour signaler que le dimensionnement est déjà fait
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{// calcul des grandeurs relatives à la largeur de bande
#ifdef MISE_AU_POINT
// pour l'instant on ne considère que des bandes d'étendues symétriques de part et autres de la diagonale
if ((nb_co % 2) == 0)
{ cout << "erreur de dimensionnement d'une matrice bande non symetrique lapack ";
cout << " largeur de bande = " << nb_co << " devrait etre un nombre impair " ;
cout << "\n MatLapack::Change_taille(... " << endl;
Sortie(1);
};
#endif
kl = (nb_col-1)/2; ku=kl;
lda = 2*kl+ku+1;
matrice_a_dimensionner=true;
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{// là on ne stocke que la partie symétrique, on suppose de plus que la matrice
// est définie positive, enfin il n'y a pas de stockage supplémentaire utilisé par lapack
// pour les routines d'herezh, les valeurs à partir de la colonne 1 sont utilisées
// int lb = lb_totale;
kl = ku = nb_col-1;
lda = nb_col;
matrice_a_dimensionner=true;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Change_taille(.. "<<endl;
Sortie(1);
};
// dimensionnement conditionnel
if (matrice_a_dimensionner)
mat.Change_taille(lda*ldb,val_init);
}
else
// sinon c'est seulement un dimensionnement qui est demandé
{ mat.Inita(val_init); }; // dans le cas de bande : voir NB operator= ( const MatLapack& mat_pl)
};
#ifndef MISE_AU_POINT
inline
#endif
// Test sur la symetrie de la matrice
// Retourne 1 si la matrice est symetrique
// 0 sinon
int MatLapack::Symetrie () const
{ switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ if ( nb_lign != nb_col )
return 0;
for (int i=1;i<=nb_lign;i++)
for (int j=1;j<i;j++)
if ( diffpetit((this->*Coor_const)(i,j),(this->*Coor_const)(j,i))) // test d'egalite de la ieme jieme composante
return 0;
return 1;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ int lb = (nb_col-1)/2;
for (int i=1;i<=nb_lign;i++)
for (int j=1;j<i;j++)
if (abs(i-j) <= lb)
if ( diffpetit((this->*Coor_const)(i,j),(this->*Coor_const)(j,i))) // test d'egalite de la ieme jieme composante
return 0;
return 1;
break;
}
case BANDE_SYMETRIQUE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ return 1; // par construction la matrice est symétrique
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Symetrie(.. "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne la ieme ligne de la matrice
// lorsque implemente ( a verifier )
Vecteur& MatLapack::Ligne_set(int )
{ cout << "\n erreur methode non implante "
<< "\n MatLapack::Ligne_set(int i)";
Sortie(1);
// on passe jamais dans la suite !
return mat; // pour taire le compilo
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne la ieme ligne de la matrice
Vecteur MatLapack::Ligne(int i) const
{ Vecteur ret(nb_lign); // init d'un vecteur total (indépendament du stockage)
// nb_lign = la dimension de la matrice
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ int le_max = nb_col+1; // +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j=1;j< le_max;j++)
ret(j)=(this->*Coor_const)(i,j);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{// nb_lign = la dimension de la matrice théorique carrée
int lb=(nb_col-1)/2; int dim = nb_lign;
int maxJ = MiN(dim,i+lb)+1;// +1 pour inférieur pure sur la ligne qui suit
for (int j= MaX(1,i-lb);j< maxJ;j++)
ret(j) = (this->*Coor_const)(i,j);
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{// nb_lign = la dimension de la matrice théorique carrée
int lb=ku;
int maxJ=MiN(nb_lign,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< maxJ;j++)
ret(j) = (this->*Coor_const)(i,j);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Ligne(.. "<<endl;
Sortie(1);
};
return ret;
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne la ieme ligne de la matrice
// sous le format de stokage propre a la matrice
// donc a n'utiliser que comme sauvegarde en parallele
// avec la fonction RemplaceLigne
Vecteur MatLapack::LigneSpe(int i) const
{ switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{Vecteur ret(nb_col);
for (int j=1;j<=nb_col;j++)
ret(j)=(this->*Coor_const)(i,j);
return ret;
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{// comme la ligne adresse deux mêmes parties symétriques, il vaut mieux
// sauvegarder toute la ligne
Vecteur ret(nb_col);
for (int j=1 ;j<=nb_col;j++)
ret(j)=(this->*Coor_const)(i,j);
return ret;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{Vecteur ligne(nb_col); // mise a zero de ligne
int lb=(nb_col-1)/2; int dim = nb_lign;
int maxJ = MiN(dim,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< maxJ;j++)
ligne(i-j+lb+1) = (this->*Coor_const)(i,j);
return ligne;
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{// comme la ligne adresse deux mêmes parties symétriques, il vaut mieux
// sauvegarder toute la ligne
int lb=nb_col-1; int dim = nb_lign;
Vecteur ligne(2*lb+1); // mise a zero de ligne
int le_max = MiN(dim,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
int le_min = MaX(1,i-lb);
for (int j= le_min;j < le_max;j++)
// for (int j= MaX(1,i);j<= MiN(dim,i+lb);j++)
ligne(i-j+lb+1) = (this->*Coor_const)(i,j);
return ligne;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::LigneSpe(.. "<<endl;
Sortie(1);
};
};
// remplace la ligne de la matrice par la ligne fournie
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::RemplaceLigneSpe(int i,const Vecteur & v)
{
#ifdef MISE_AU_POINT
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{if (nb_col != v.Taille())
{cout << " \nla taille de la ligne i= " << i <<" a remplacer n est pas bonne " ;
cout << " taille = " << v.Taille() << " tailleLigneMatrice = " << nb_col;
cout << " void MatLapack::RemplaceLigne(int i,Vecteur & v)" << endl;
Sortie (1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{if (v.Taille() != nb_col)
{cout << "\nerreur d affectation pour le vecteur";
cout << " dim vecteur = " << v.Taille() << " au lieu de " << nb_col <<'\n';
cout << "void MatLapack::RemplaceLigne(int i,Vecteur & v)" << endl;
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{if (v.Taille() != nb_col)
{cout << "\nerreur d affectation pour le vecteur";
cout << " dim vecteur = " << v.Taille() << " au lieu de " << nb_col <<'\n';
cout << "void MatLapack::RemplaceLigne(int i,Vecteur & v)" << endl;
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::RemplaceLigneSpe(.. "<<endl;
Sortie(1);
};
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ for(int j=1; j <= nb_col; j++)
(this->*Coor)(i,j)=v(j);
break;
}
case CARREE_SYMETRIQUE_LAPACK:
// comme la ligne adresse deux mêmes parties symétriques, il vaut mieux
// sauvegarder toute la ligne
{for (int j=1 ;j<=nb_col;j++)
(this->*Coor)(i,j)=v(j);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{int lb=(nb_col-1)/2; int dim = nb_lign;
int maxJ = MiN(dim,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int j= MaX(1,i-lb);j< maxJ;j++)
(this->*Coor)(i,j)=v(i-j+lb+1);
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{// comme la ligne adresse deux mêmes parties symétriques, il vaut mieux
// sauvegarder toute la ligne
int lb=nb_col-1; int dim = nb_lign;
Vecteur ligne(2*lb+1); // mise a zero de ligne
int le_max = MiN(dim,i+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
int le_min = MaX(1,i-lb);
for (int j= le_min;j< le_max;j++)
(this->*Coor)(i,j)=v(i-j+lb+1);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::RemplaceLigneSpe(.. "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Resolution du systeme Ax=b
Vecteur MatLapack::Resol_syst(const Vecteur& b,const double &tole, const int maxi, const int rest)
{// init général
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
Vecteur resul(b); // Vecteur solution initialisé = second membre
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Resol_syst");
#endif
// appel de la routine clapack
// /* Subroutine */ int dgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *a, __CLPK_integer
// *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
dgesv_(&nb_lign,&nb_SM,mat.v,&lda,ipiv,resul.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Vecteur resul(b);
Mat_abstraite::Resolution_syst(b,resul,tole,maxi,rest);
return resul;
}
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dppsv_(&uplo,&nb_lign,&nb_SM,mat.v,resul.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Vecteur resul(b);
Mat_abstraite::Resolution_syst(b,resul,tole,maxi,rest);
return resul;
}
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{// ici les parties sup et inf de la largeur de bande sont supposée identique
// appel de la routine clapack
// /* Subroutine */ int dgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
// __CLPK_integer *ldb, __CLPK_integer *info);
dgbsv_(&nb_lign,&kl,&ku,&nb_SM,mat.v,&lda,ipiv,resul.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,resul,tole,maxi,rest);
}
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// ici seule la partie sup de la largeur de bande est définie
// appel de la routine clapack
///* Subroutine */ int dpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbsv_(&uplo,&nb_lign,&ku,&nb_SM,mat.v,&lda,resul.v,&ldb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,resul,tole,maxi,rest);
}
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Resol_syst(...";
Sortie(1);
};
};
// retour
return resul;
};
//2) avec en sortie le vecteur d'entree
#ifndef MISE_AU_POINT
inline
#endif
Vecteur& MatLapack::Resol_systID
(Vecteur& b,const double &tole, const int maxi, const int rest)
{
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Resol_systID");
#endif
// appel de la routine clapack
dgesv_(&nb_lign,&nb_SM,mat.v,&lda,ipiv,b.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
};
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
//*ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dppsv_(&uplo,&nb_lign,&nb_SM,mat.v,b.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
};
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
// __CLPK_integer *ldb, __CLPK_integer *info);
dgbsv_(&nb_lign,&kl,&ku,&nb_SM,mat.v,&lda,ipiv,b.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
};
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// ici seule la partie sup de la largeur de bande est définie
// appel de la routine clapack
///* Subroutine */ int dpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbsv_(&uplo,&nb_lign,&ku,&nb_SM,mat.v,&lda,b.v,&ldb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
};
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Resol_syst(...";
Sortie(1);
};
};
// retour
return b;
};
//3) avec en entrée un tableau de vecteur second membre et
// en sortie un nouveau tableau de vecteurs
#ifndef MISE_AU_POINT
inline
#endif
Tableau <Vecteur> MatLapack::Resol_syst
(const Tableau <Vecteur>& b,const double &tole, const int maxi, const int rest)
{
ENTIER_POUR_CLAPACK nb_SM = b.Taille(); // a priori plusieurs second membre
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
ENTIER_POUR_CLAPACK info=0; // info de sortie
// on s'occupe de la matrice rectangulaire qui contient tous les seconds membres: init général
// ici le type de résolution importe peu, c'est du stockage
if (ptB == NULL)
{ptB = new MatLapack(nb_lign,nb_SM,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT);}
else // on regarde si la taille est correcte
{ if ((nb_lign != ptB->Nb_ligne()) || (nb_SM != ptB->Nb_colonne()))
// c'est différent donc on redimentionne
{ ptB->Change_taille(nb_lign,nb_SM); };
};
// init particulier
for (int k=1;k<=nb_SM;k++)
{const Vecteur & bk=b(k);
for (int i=1;i<=nb_lign;i++)
(ptB->*Coor)(i,k)=bk(i);
};
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Resol_syst");
#endif
// appel de la routine clapack
dgesv_(&nb_lign,&nb_SM,mat.v,&lda,ipiv,(*ptB).mat.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
return bb;
}
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dppsv_(&uplo,&nb_lign,&nb_SM,mat.v,(*ptB).mat.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
return bb;
}
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
// __CLPK_integer *ldb, __CLPK_integer *info);
dgbsv_(&nb_lign,&kl,&ku,&nb_SM,mat.v,&lda,ipiv,(*ptB).mat.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
return bb;
}
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// ici seule la partie sup de la largeur de bande est définie
// appel de la routine clapack
///* Subroutine */ int dpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbsv_(&uplo,&nb_lign,&ku,&nb_SM,mat.v,&lda,(*ptB).mat.v,&ldb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
return bb;
}
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Resol_syst(...";
Sortie(1);
};
};
// récup du résultat
Tableau <Vecteur> bksortie(nb_SM);
for (int k=1;k<=nb_SM;k++)
{ bksortie(k).Change_taille(nb_lign);
Vecteur & bksortie_k=bksortie(k);
for (int i=1;i<=nb_lign;i++)
bksortie_k(i) = (ptB->*Coor_const)(i,k);
};
// retour des résultats
return bksortie;
};
//4) avec en entrée un tableau de vecteur second membre et
// en sortie le tableau de vecteurs d'entree
#ifndef MISE_AU_POINT
inline
#endif
Tableau <Vecteur>& MatLapack::Resol_systID
(Tableau <Vecteur>& b,const double &tole, const int maxi, const int rest)
{
ENTIER_POUR_CLAPACK nb_SM = b.Taille(); // a priori plusieurs second membre
// init général
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
// pour les seconds membres, le type de résolution importe peu, on met une grandeur par défaut
if (ptB == NULL)
{ ptB = new MatLapack(nb_lign,nb_SM,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT);}
else // on regarde si la taille est correcte
{ if ((nb_lign != ptB->Nb_ligne()) || (nb_SM != ptB->Nb_colonne()))
// c'est différent donc on redimentionne
{ ptB->Change_taille(nb_lign,nb_SM); };
};
ENTIER_POUR_CLAPACK info=0; // info de sortie
// init particulier
for (int k=1;k<=nb_SM;k++)
{const Vecteur & bk=b(k);
for (int i=1;i<=nb_lign;i++)
(ptB->*Coor)(i,k)=bk(i);
};
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Resol_systID");
#endif
// appel de la routine clapack
dgesv_(&nb_lign,&nb_SM,mat.v,&lda,ipiv,(*ptB).mat.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
return b;
};
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dppsv_(&uplo,&nb_lign,&nb_SM,mat.v,(*ptB).mat.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
return b;
}
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
// __CLPK_integer *ldb, __CLPK_integer *info);
dgbsv_(&nb_lign,&kl,&ku,&nb_SM,mat.v,&lda,ipiv,(*ptB).mat.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
return b;
};
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// ici seule la partie sup de la largeur de bande est définie
// appel de la routine clapack
///* Subroutine */ int dpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbsv_(&uplo,&nb_lign,&ku,&nb_SM,mat.v,&lda,(*ptB).mat.v,&ldb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
// le résultat est dans b.v
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tole,maxi,rest);
b = bb;
return b;
}
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Resol_syst(...";
Sortie(1);
};
};
// récup du résultat
for (int k=1;k<=nb_SM;k++)
{Vecteur & bk=b(k);
for (int i=1;i<=nb_lign;i++)
bk(i) = (ptB->*Coor_const)(i,k);
};
return b;
};
#ifndef MISE_AU_POINT
inline
#endif
// Realise le produit du vecteur vec par la matrice
Vecteur MatLapack::Prod_vec_mat (const Vecteur& vec) const
{
#ifdef MISE_AU_POINT
if (vec.Taille() != nb_lign)
{cout << "erreur de taille, la dimension du vecteur: " << vec.Taille()
<< " devrait etre identique au nombre de ligne de la matrice= " << nb_lign << " "
<< "\n MatLapack::Prod_vec_mat (const Vecteur& vec)" << endl;
Sortie(1);
};
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ Vecteur result(nb_col);
for (int j=1;j<= nb_col;j++)
{double* pt=&result(j);
for (int k=1; k<= nb_lign; k++)
(*pt) += vec(k) * (this->*Coor_const)(k,j);
};
return result;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:case BANDE_SYMETRIQUE_LAPACK:
{ // on considère que la matrice doit représenter une matrice carrée
int lb=ku; int dim = nb_lign;
Vecteur res(dim);
for (int j=1;j<=dim;j++)
for (int i= MaX(1,j-lb);i<= MiN(dim,j+lb);i++)
res(j) += vec(i) * (this->*Coor_const)(i,j);
return res;
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Prod_vec_mat(...";
Sortie(1);
};
};
};
#ifndef MISE_AU_POINT
inline
#endif
Vecteur& MatLapack::Prod_vec_mat (const Vecteur& vec,Vecteur& res) const
// Realise le produit du vecteur vec par la matrice
// ici on se sert du second vecteur pour le résultat
{
#ifdef MISE_AU_POINT
if (vec.Taille() != nb_lign)
{cout << "erreur de taille, la dimension du vecteur: " << vec.Taille()
<< " devrait etre identique au nombre de ligne de la matrice= " << nb_lign << " "
<< "\n MatLapack::Prod_vec_mat(const Vecteur& vec,Vecteur& result)" << endl;
Sortie(1);
}
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ res.Change_taille(nb_col);
for (int j=1;j<= nb_col;j++)
{ double* pt=&res(j);
for (int k=1; k<= nb_lign; k++)
(*pt) += vec(k) * (this->*Coor_const)(k,j);
};
return res;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:case BANDE_SYMETRIQUE_LAPACK:
{ // on considère que la matrice doit représenter une matrice carrée
int lb=ku; int dim = nb_lign;
res.Change_taille(dim);
for (int j=1;j<=dim;j++)
{int maxj = MiN(dim,j+lb)+1; // +1 pour < strict dans la boucle
for (int i= MaX(1,j-lb);i< maxj;i++)
res(j) += vec(i) * (this->*Coor_const)(i,j);
};
return res;
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Prod_vec_mat(...";
Sortie(1);
};
};
};
//5) avec en sortie le dernier vecteur d'entree, le premier étant le second membre
// et restant inchangé, en sortie c'est donc soit le retour ou soit vortie, les
// deux étant identiques
#ifndef MISE_AU_POINT
inline
#endif
Vecteur& MatLapack::Resol_systID_2 (const Vecteur& b,Vecteur& vortie
, const double &tole,const int maxi,const int rest)
{// init général
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
vortie=b; // Vecteur solution initialisé = second membre
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Resol_systID_2");
#endif
// appel de la routine clapack
dgesv_(&nb_lign,&nb_SM,mat.v,&lda,ipiv,vortie.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tole,maxi,rest);};
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{switch (type_resolution)
{case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
// __CLPK_integer *ldb, __CLPK_integer *info);
dgbsv_(&nb_lign,&kl,&ku,&nb_SM,mat.v,&lda,ipiv,vortie.v,&ldb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tole,maxi,rest);};
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// ici seule la partie sup de la largeur de bande est définie
// appel de la routine clapack
///* Subroutine */ int dpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbsv_(&uplo,&nb_lign,&ku,&nb_SM,mat.v,&lda,vortie.v,&ldb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
// le résultat est dans vortie.v
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tole,maxi,rest);};
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Resol_syst(...";
Sortie(1);
};
};
// retour
return vortie;
};
// ===== RÉSOLUTION EN DEUX TEMPS ================ :
// 1) préparation de la matrice donc modification de la matrice
// ici on calcul la factorisation LU de la matrice
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Preparation_resol()
{
// init général
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];}; // normalement ipiv doit avoir ici
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{ // appel de la routine lapack
dgetrf_(&nb_lign,&nb_col,mat.v,&lda,ipiv,&info);
break;
}
// dans les autres cas on ne fait rien
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Preparation_resol (.. "<<endl;
Sortie(1);
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpptrf_(&uplo,&nb_lign,mat.v,&info) ;
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
// dans les autres cas on ne fait rien
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Preparation_resol (.. "<<endl;
Sortie(1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbtrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
// __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
dgbtrf_(&nb_lign,&nb_lign,&kl,&ku,mat.v,&lda,ipiv,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Preparation_resol (.. "<<endl;
Sortie(1);
// dans les autres cas on ne fait rien
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
// ab, __CLPK_integer *ldab, __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbtrf_(&uplo,&nb_lign,&ku,mat.v,&lda,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Preparation_resol (.. "<<endl;
Sortie(1);
// dans les autres cas on ne fait rien
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Preparation_resol(...";
Sortie(1);
};
};
// retour
};
// 2) *** résolution sans modification de la matrice DOIT ÊTRE PRÉCÉDÉ DE L'APPEL DE
// Preparation_resol
// a) avec en sortie un new vecteur
#ifndef MISE_AU_POINT
inline
#endif
Vecteur MatLapack::Simple_Resol_syst (const Vecteur& b,const double &tol
,const int maxi,const int rest) const
{// init général
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre
if ((type_matrice != BANDE_SYMETRIQUE_LAPACK) && (ipiv == NULL))
{cout << "\n erreur: la methode MatLapack::Preparation_resol() n'a pas ete appelee "
<< " le tableau ipiv n'est pas correcte, on ne peut pas continuer ! "
<< "\n MatLapack::Simple_Resol_syst (.... ";
Sortie(1);
};
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
Vecteur resul(b); // Vecteur solution initialisé = second membre
char trans = 'N'; // "No transpose"
// comme la méthode est const, on doit utiliser des cast, se qui n'est pas sûr mais difficile de faire autrement !
double * matric_v = (double *) mat.v; // on impose un cast
ENTIER_POUR_CLAPACK * ipiva = (ENTIER_POUR_CLAPACK*) ipiv; // ""
// toujour à cause du const, on est obligé d'utiliser des variables intermédiaires
ENTIER_POUR_CLAPACK nb_ligne=nb_lign;
ENTIER_POUR_CLAPACK ldaa = lda;
ENTIER_POUR_CLAPACK ldbb = ldb;
ENTIER_POUR_CLAPACK kll = kl ;
ENTIER_POUR_CLAPACK kuu = ku ;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Simple_Resol_syst");
#endif
// appel de la routine clapack
// /* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
// ldb, __CLPK_integer *info);
dgetrs_(&trans,&nb_ligne,&nb_SM,matric_v,&ldaa,ipiva,resul.v,&ldbb,&info);
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,resul,tol,maxi,rest);}
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpptrs_(&uplo,&nb_ligne,&nb_SM,matric_v,resul.v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,resul,tol,maxi,rest);}
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
// ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
// __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
dgbtrs_(&trans,&nb_ligne,&kll,&kuu,&nb_SM,matric_v,&ldaa,ipiva,resul.v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,resul,tol,maxi,rest);}
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbtrs_(&uplo,&nb_ligne,&kuu,&nb_SM,matric_v,&ldaa,resul.v,&ldbb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,resul,tol,maxi,rest);}
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_syst (...";
Sortie(1);
};
};
// retour
return resul;
};
// b) avec en sortie le vecteur d'entree
#ifndef MISE_AU_POINT
inline
#endif
Vecteur& MatLapack::Simple_Resol_systID (Vecteur& b,const double &tol
,const int maxi,const int restart ) const
{// init général
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre
if ((type_matrice != BANDE_SYMETRIQUE_LAPACK) && (ipiv == NULL))
{cout << "\n erreur: la methode MatLapack::Preparation_resol() n'a pas ete appelee "
<< " le tableau ipiv n'est pas correcte, on ne peut pas continuer ! "
<< "\n MatLapack::Simple_Resol_systID (.... ";
Sortie(1);
};
ENTIER_POUR_CLAPACK ldb = MaX(1,nb_lign);
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
char trans = 'N'; // "No transpose"
// comme la méthode est const, on doit utiliser des cast, se qui n'est pas sûr mais difficile de faire autrement !
double * matric_v = (double *) mat.v; // on impose un cast
ENTIER_POUR_CLAPACK * ipiva = (ENTIER_POUR_CLAPACK*) ipiv; // ""
// toujour à cause du const, on est obligé d'utiliser des variables intermédiaires
ENTIER_POUR_CLAPACK nb_ligne=nb_lign;
ENTIER_POUR_CLAPACK ldaa = lda;
ENTIER_POUR_CLAPACK ldbb = ldb;
ENTIER_POUR_CLAPACK kll = kl ;
ENTIER_POUR_CLAPACK kuu = ku ;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Simple_Resol_systID");
#endif
// appel de la routine clapack
// /* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
// ldb, __CLPK_integer *info);
dgetrs_(&trans,&nb_ligne,&nb_SM,matric_v,&ldaa,ipiva,b.v,&ldbb,&info);
break;
}
default:
{ Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpptrs_(&uplo,&nb_ligne,&nb_SM,matric_v,b.v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
// ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
// __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
dgbtrs_(&trans,&nb_ligne,&kll,&kuu,&nb_SM,matric_v,&ldaa,ipiva,b.v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbtrs_(&uplo,&nb_ligne,&kuu,&nb_SM,matric_v,&ldaa,b.v,&ldbb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Vecteur bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_syst (...";
Sortie(1);
};
};
return b;
};
// c) avec en entrée un tableau de vecteur second membre et
// en sortie un nouveau tableau de vecteurs
#ifndef MISE_AU_POINT
inline
#endif
Tableau <Vecteur> MatLapack::Simple_Resol_syst
(const Tableau <Vecteur>& b,const double &tol
,const int maxi,const int restart ) const
{
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre à la fois
if ((type_matrice != BANDE_SYMETRIQUE_LAPACK) && (ipiv == NULL))
{ cout << "\n erreur: la methode MatLapack::Preparation_resol() n'a pas ete appeled "
<< " le tableau ipiv n'est pas correcte, on ne peut pas continuer ! "
<< "\n MatLapack::Simple_Resol_syst (Tableau <Vecteur>&.... ";
Sortie(1);
};
// #ifdef MISE_AU_POINT
// Verif_nb_composante(b,"Simple_Resol_syst");
// #endif
ENTIER_POUR_CLAPACK ldb = MaX(1,nb_lign);
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
char trans = 'N'; // "No transpose"
// comme la méthode est const, on doit utiliser des cast, ce qui n'est pas sûr mais difficile de faire autrement !
double * matric_v = (double *) mat.v; // on impose un cast
ENTIER_POUR_CLAPACK * ipiva = (ENTIER_POUR_CLAPACK*) ipiv; // ""
// toujour à cause du const, on est obligé d'utiliser des variables intermédiaires
ENTIER_POUR_CLAPACK nb_ligne=nb_lign;
ENTIER_POUR_CLAPACK ldaa = lda;
ENTIER_POUR_CLAPACK ldbb = ldb;
ENTIER_POUR_CLAPACK kll = kl ;
ENTIER_POUR_CLAPACK kuu = ku ;
// appel de la routine clapack
int nb_vrai_sm=b.Taille();
Tableau <Vecteur> bretour(b);
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Simple_Resol_systID");
#endif
// appel de la routine clapack
// /* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
// ldb, __CLPK_integer *info);
for (int im=1;im<=nb_vrai_sm;im++)
dgetrs_(&trans,&nb_ligne,&nb_SM,matric_v,&ldaa,ipiva,bretour(im).v,&ldbb,&info);
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,bretour,tol,maxi,restart);};
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
for (int im=1;im<=nb_vrai_sm;im++)
{dpptrs_(&uplo,&nb_ligne,&nb_SM,matric_v,bretour(im).v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
};
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,bretour,tol,maxi,restart);};
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
// ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
// __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
for (int im=1;im<=nb_vrai_sm;im++)
dgbtrs_(&trans,&nb_ligne,&kll,&kuu,&nb_SM,matric_v,&ldaa,ipiva,bretour(im).v,&ldbb,&info);
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,bretour,tol,maxi,restart);};
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
for (int im=1;im<=nb_vrai_sm;im++)
dpbtrs_(&uplo,&nb_ligne,&kuu,&nb_SM,matric_v,&ldaa,bretour(im).v,&ldbb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,bretour,tol,maxi,restart);};
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_syst (...";
Sortie(1);
};
};
return bretour;
};
// d) avec en entrée un tableau de vecteur second membre et
// en sortie le tableau de vecteurs d'entree
#ifndef MISE_AU_POINT
inline
#endif
Tableau <Vecteur>& MatLapack::Simple_Resol_systID
(Tableau <Vecteur>& b,const double &tol
,const int maxi,const int restart ) const
{
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre à la fois
if ((type_matrice != BANDE_SYMETRIQUE_LAPACK) && (ipiv == NULL))
{ cout << "\n erreur: la methode MatLapack::Preparation_resol() n'a pas ete appelee "
<< " le tableau ipiv n'est pas correcte, on ne peut pas continuer ! "
<< "\n MatLapack::Simple_Resol_systID (Tableau <Vecteur>&.... ";
Sortie(1);
};
// #ifdef MISE_AU_POINT
// Verif_nb_composante(b,"Simple_Resol_systID");
// #endif
ENTIER_POUR_CLAPACK ldb = MaX(1,nb_lign);
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
char trans = 'N'; // "No transpose"
// comme la méthode est const, on doit utiliser des cast, ce qui n'est pas sûr mais difficile de faire autrement !
double * matric_v = (double *) mat.v; // on impose un cast
ENTIER_POUR_CLAPACK * ipiva = (ENTIER_POUR_CLAPACK*) ipiv; // ""
// toujour à cause du const, on est obligé d'utiliser des variables intermédiaires
ENTIER_POUR_CLAPACK nb_ligne=nb_lign;
ENTIER_POUR_CLAPACK ldaa = lda;
ENTIER_POUR_CLAPACK ldbb = ldb;
ENTIER_POUR_CLAPACK kll = kl ;
ENTIER_POUR_CLAPACK kuu = ku ;
// appel de la routine clapack
int nb_vrai_sm=b.Taille();
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Simple_Resol_systID");
#endif
// appel de la routine clapack
// /* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
// ldb, __CLPK_integer *info);
for (int im=1;im<=nb_vrai_sm;im++)
dgetrs_(&trans,&nb_ligne,&nb_SM,matric_v,&ldaa,ipiva,b(im).v,&ldbb,&info);
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
for (int im=1;im<=nb_vrai_sm;im++)
{dpptrs_(&uplo,&nb_ligne,&nb_SM,matric_v,b(im).v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
};
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
// ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
// __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
for (int im=1;im<=nb_vrai_sm;im++)
dgbtrs_(&trans,&nb_ligne,&kll,&kuu,&nb_SM,matric_v,&ldaa,ipiva,b(im).v,&ldbb,&info);
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
for (int im=1;im<=nb_vrai_sm;im++)
dpbtrs_(&uplo,&nb_ligne,&kuu,&nb_SM,matric_v,&ldaa,b(im).v,&ldbb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
{Tableau <Vecteur> bb(b);
Mat_abstraite::Resolution_syst(b,bb,tol,maxi,restart);
b = bb;
};
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_systID (...";
Sortie(1);
};
};
return b;
};
// e) avec en sortie le dernier vecteur d'entree, le premier étant le second membre
// et restant inchangé, en sortie c'est donc soit le retour ou soit vortie, les
// deux étant identiques
#ifndef MISE_AU_POINT
inline
#endif
Vecteur& MatLapack::Simple_Resol_systID_2 (const Vecteur& b,Vecteur& vortie
, const double &tol,const int maxi,const int rest) const
{// init général
ENTIER_POUR_CLAPACK nb_SM = 1; // un seul second membre
if ((type_matrice != BANDE_SYMETRIQUE_LAPACK) && (ipiv == NULL))
{cout << "\n erreur: la methode MatLapack::Preparation_resol() n'a pas ete appelee "
<< " le tableau ipiv n'est pas correcte, on ne peut pas continuer ! "
<< "\n MatLapack::Simple_Resol_systID_2 (.... ";
Sortie(1);
};
ENTIER_POUR_CLAPACK ldb = MaX(1,nb_lign);
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
vortie=b; // init
char trans = 'N'; // "No transpose"
// comme la méthode est const, on doit utiliser des cast, se qui n'est pas sûr mais difficile de faire autrement !
double * matric_v = (double *) mat.v; // on impose un cast
ENTIER_POUR_CLAPACK * ipiva = (ENTIER_POUR_CLAPACK*) ipiv; // ""
// toujour à cause du const, on est obligé d'utiliser des variables intermédiaires
ENTIER_POUR_CLAPACK nb_ligne=nb_lign;
ENTIER_POUR_CLAPACK ldaa = lda;
ENTIER_POUR_CLAPACK ldbb = ldb;
ENTIER_POUR_CLAPACK kll = kl ;
ENTIER_POUR_CLAPACK kuu = ku ;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{
#ifdef MISE_AU_POINT
Verif_nb_composante(b,"Simple_Resol_systID_2");
#endif
// appel de la routine clapack
// /* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
// ldb, __CLPK_integer *info);
dgetrs_(&trans,&nb_ligne,&nb_SM,matric_v,&ldaa,ipiva,vortie.v,&ldbb,&info);
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tol,maxi,rest);}
};
break;
}
case CARREE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
// __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info)
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpptrs_(&uplo,&nb_ligne,&nb_SM,matric_v,vortie.v,&ldbb,&info);
GestionErreurDg_sv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tol,maxi,rest);}
}
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case GAUSS:
{// appel de la routine clapack
// /* Subroutine */ int dgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
// ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
// __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
dgbtrs_(&trans,&nb_ligne,&kll,&kuu,&nb_SM,matric_v,&ldaa,ipiva,vortie.v,&ldbb,&info);
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tol,maxi,rest);}
};
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ switch (type_resolution)
{ case CHOLESKY:
{// appel de la routine clapack
// /* Subroutine */ int dpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
// nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
// __CLPK_integer *info) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
char uplo = 'U'; // up diagonal: stockage au dessus de la diagonale
dpbtrs_(&uplo,&nb_ligne,&kuu,&nb_SM,matric_v,&ldaa,vortie.v,&ldbb,&info);
GestionErreurDpbsv(info); // affichage d'erreurs éventuelles
break;
}
default:
{ Mat_abstraite::Resolution_syst(b,vortie,tol,maxi,rest);}
};
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_systID_2 (...";
Sortie(1);
};
};
// retour
return vortie;
};
// ===== FIN RÉSOLUTION EN DEUX TEMPS ================ :
#ifndef MISE_AU_POINT
inline
#endif
// Realise le produit de la matrice par le vecteur vec
Vecteur MatLapack::Prod_mat_vec (const Vecteur& vec) const
{ Vecteur result(nb_lign);
#ifdef MISE_AU_POINT
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{ if (nb_col != vec.Taille())
{ cout << "erreur de taille, le vecteur doit avoir une dimension identique au nombre"
<< " de colonne de la matrice";
cout << " \n Prod_mat_vec, tailleligneMatrice = " <<nb_col
<< " taillevecteur = " << vec.Taille();
cout << " Vecteur MatLapack::Prod_mat_vec (... " << endl;
Sortie (1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ if (vec.Taille() != nb_lign)
{ cout << "erreur de taille, le vecteur doit avoir une dimension identique au nombre"
<< " de colonne de la matrice";
cout << " \n Prod_mat_vec, tailleligneMatrice = " <<nb_lign
<< " taillevecteur = " << vec.Taille();
cout << " Vecteur MatLapack::Prod_mat_vec (... " << endl;
Sortie (1);
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n Vecteur MatLapack::Prod_mat_vec (... " << endl;
Sortie(1);
};
#endif
// y := alpha*A*x + beta*y,
// avec ici beta = 0.,
double alpha=1.;double beta = 0.;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ //void cblas_dgemv(const enum CBLAS_ORDER Order,
// const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
// const double alpha, const double *A, const int lda,
// const double *X, const int incX, const double beta,
// double *Y, const int incY) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
cblas_dgemv(CblasRowMajor,CblasNoTrans, nb_lign, lda,alpha,mat.v,lda,vec.v,1,beta,result.v,1);
//for (int i=1;i<=nb_lign;i++)
// {double* pt= &result(i);
// for (int k=1;k<=nb_col;k++)
// (*pt) += (this->*Coor_const)(i,k) * vec(k);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ //void cblas_dgbmv(const enum CBLAS_ORDER Order,
// const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
// const int KL, const int KU, const double alpha,
// const double *A, const int lda, const double *X,
// const int incX, const double beta, double *Y, const int incY)
cblas_dgbmv(CblasRowMajor,CblasNoTrans, nb_lign, lda,kl,ku,alpha,mat.v,lda,vec.v,1,beta,result.v,1);
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ //void cblas_dsbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
// const int N, const int K, const double alpha, const double *A,
// const int lda, const double *X, const int incX,
// const double beta, double *Y, const int incY) __OSX_AVAILABLE_STARTING(__MAC_10_2,
cblas_dsbmv(CblasRowMajor, CblasUpper,nb_lign,ku,alpha,mat.v,lda,vec.v,1,beta,result.v,1);
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_systID_2 (...";
Sortie(1);
};
};
return result;
};
#ifndef MISE_AU_POINT
inline
#endif
// Realise le produit de la matrice par le vecteur vec
// ici on se sert du second vecteur pour le résultat
Vecteur& MatLapack::Prod_mat_vec (const Vecteur& vec,Vecteur& result) const
{ result.Change_taille(nb_lign);
#ifdef MISE_AU_POINT
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{ if (nb_col != vec.Taille())
{ cout << "erreur de taille, le vecteur doit avoir une dimension identique au nombre"
<< " de colonne de la matrice";
cout << " \n Prod_mat_vec, tailleligneMatrice = " <<nb_col
<< " taillevecteur = " << vec.Taille();
cout << " Vecteur& MatLapack::Prod_mat_vec (... " << endl;
Sortie (1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ if (vec.Taille() != nb_lign)
{ cout << "erreur de taille, le vecteur doit avoir une dimension identique au nombre"
<< " de colonne de la matrice";
cout << " \n Prod_mat_vec, tailleligneMatrice = " <<nb_lign
<< " taillevecteur = " << vec.Taille();
cout << " Vecteur& MatLapack::Prod_mat_vec (... " << endl;
Sortie (1);
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n Vecteur& MatLapack::Prod_mat_vec (... " << endl;
Sortie(1);
};
#endif
#ifdef MISE_AU_POINT
// il faut que les lignes et vec aient la même dimension
if (vec.Taille() != Ligne(1).Taille())
{cout << "erreur de taille, la première ligne de la matrice n'a pas la même dimension";
cout << " que le vecteur à multiplier "
<< "\n MatLapack::Prod_mat_vec (const Vecteur& vec,Vecteur& result)" << endl;
Sortie(1);
}
#endif
// for (int i=1;i<=nb_lign;i++)
// {double* pt= &result(i);
// for (int k=1;k<=nb_col;k++)
// (*pt) += (this->*Coor_const)(i,k) * vec(k);
// };
// y := alpha*A*x + beta*y,
// avec ici beta = 0.,
double alpha=1.;double beta = 0.;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ //void cblas_dgemv(const enum CBLAS_ORDER Order,
// const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
// const double alpha, const double *A, const int lda,
// const double *X, const int incX, const double beta,
// double *Y, const int incY) __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_4_0);
cblas_dgemv(CblasRowMajor,CblasNoTrans, nb_lign, lda,alpha,mat.v,lda,vec.v,1,beta,result.v,1);
//for (int i=1;i<=nb_lign;i++)
// {double* pt= &result(i);
// for (int k=1;k<=nb_col;k++)
// (*pt) += (this->*Coor_const)(i,k) * vec(k);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ //void cblas_dgbmv(const enum CBLAS_ORDER Order,
// const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
// const int KL, const int KU, const double alpha,
// const double *A, const int lda, const double *X,
// const int incX, const double beta, double *Y, const int incY)
cblas_dgbmv(CblasRowMajor,CblasNoTrans, nb_lign, lda,kl,ku,alpha,mat.v,lda,vec.v,1,beta,result.v,1);
break;
}
case BANDE_SYMETRIQUE_LAPACK:
{ //void cblas_dsbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
// const int N, const int K, const double alpha, const double *A,
// const int lda, const double *X, const int incX,
// const double beta, double *Y, const int incY) __OSX_AVAILABLE_STARTING(__MAC_10_2,
cblas_dsbmv(CblasRowMajor, CblasUpper,nb_lign,ku,alpha,mat.v,lda,vec.v,1,beta,result.v,1);
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_systID_2 (...";
Sortie(1);
};
};
return result;
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne la transposee de la matrice mat
// il y a création d'une matrice de sortie
MatLapack MatLapack::Transpose () const
{
#ifdef MISE_AU_POINT
if ( ( nb_lign ==0 ) || ( nb_col ==0 ) )
{
cout << "Erreur : une des dimensions de la matrice:NxM= " << nb_lign <<"x"<< nb_col
<< " est nulle, la transposee n'a pas de sens ici ";
cout << "\n MatLapack::TRANSPOSE ( )\n";
Sortie(1);
};
#endif
// comme résolution et type de matrice on met la même chose que this
// for (int i=1;i <= nb_col;i++)
// for (int j=1;j <= nb_lign;j++)
// (result.*Coor)(i,j)=(this->*Coor_const)(j,i);
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ // dans le cas d'une matrice carrée ou rectangulaire on inverse les dimensions
// car on considère que le stockage décri la forme réelle de la matrice
MatLapack result(nb_col,nb_lign
,Symetrique_Enum_matrice(this->type_matrice),0.
,this->type_resolution,this->type_preconditionnement);
for (int i=1;i <= nb_col;i++)
for (int j=2;j <= nb_lign;j++) // on commence à 2, car la diag ne change pas
(result.*Coor)(i,j)=(this->*Coor_const)(j,i);
return result;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ // on considère que la matrice réelle est carrée, et que son stockage bande n'est là
// que pour l'optimisation. Donc la matrice transposée est exactement de même type
// même largeur de bande etc, et dans notre cas on considère que la bande est de même 1/2 largeur
// dessus et dessous, donc kl = ku
MatLapack result(*this);
for (int i=1;i <= nb_col;i++)
for (int j=2;j <= nb_lign;j++) // on commence à 2, car la diag ne change pas
(result.*Coor)(i,j)=(this->*Coor_const)(j,i);
return result;
break;
}
case BANDE_SYMETRIQUE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ // on considère que la matrice réelle est carrée, et que son stockage bande est symétrique supérieur
// donc la transposée est identique
MatLapack result(*this);
return result;
break;
}
default:
{ cout << "\n **** erreur: mauvais choix de matrice: " << Nom_matrice(type_matrice)
<< "\n MatLapack::Simple_Resol_systID_2 (...";
Sortie(1);
};
};
};
// determine l'inverse d'une matrice carre
#ifndef MISE_AU_POINT
inline
#endif
MatLapack MatLapack::Inverse()
{switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
// l'appel n'est possible que si la matrice est carré
if (nb_lign != nb_col)
{cout << "\n erreur la matrice n'est pas carree, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::Inverse(..." << endl;
Sortie(1);
}
// l'appel n'est pas possible si la matrice a des coefficients
if (nb_lign == 0)
{cout << "\n erreur la matrice n'a pas de coefficient, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::Inverse(..." << endl;
Sortie(1);
}
#endif
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
// init général
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
MatLapack Msortie(*this);
// def de la taille adoc pour le vecteur de travail
// au premier appel on défini la taille
ENTIER_POUR_CLAPACK lwork = -1; // pour demander la taille a doc de la zone de travail
dgetri_(&Msortie.nb_lign,Msortie.mat.v,&lda,ipiv,travail.v,&lwork,&info);
GestionErreurInverse(info,1,"dgetri_"); // gestion d'erreurs éventuelles
int dim_optimal=travail(1); // sgetri sauvegarde la taille optimale dans v[0]
travail.Change_taille(dim_optimal);
// appel de la triangulation
dgetrf_(&Msortie.nb_lign,&Msortie.nb_col,Msortie.mat.v,&lda,ipiv,&info);
GestionErreurInverse(info,2,"dgetrf_"); // gestion d'erreurs éventuelles
// calcul de l'inverse
lwork=MaX(1,dim_optimal);
dgetri_(&Msortie.nb_lign,Msortie.mat.v,&lda,ipiv,travail.v,&lwork,&info);
GestionErreurInverse(info,3,"dgetri_"); // gestion d'erreurs éventuelles
// retour
return Msortie;
break;
}
default:
{ cout << "\n erreur , methode non implante pour la matrice lapack: "
<< Nom_resolution(type_resolution)
<< "\n MatLapack::Inverse()"<< endl;
Sortie(1);
};
};
// pour taire le warning
return MatLapack();
};
#ifndef MISE_AU_POINT
inline
#endif
// determine l'inverse d'une matrice carre
// mais en retournant l'inverse dans la matrice passée en paramètre
// qui doit être de même taille
MatLapack& MatLapack::Inverse(MatLapack& Msortie)
{switch (type_resolution)
{case GAUSS:
{
#ifdef MISE_AU_POINT
// l'appel n'est possible que si la matrice est carré
if (nb_lign != nb_col)
{cout << "\n erreur la matrice n'est pas carree, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::Inverse(..." << endl;
Sortie(1);
};
// l'appel n'est pas possible si la matrice a des coefficients
if (nb_lign == 0)
{cout << "\n erreur la matrice n'a pas de coefficient, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::Inverse(..." << endl;
Sortie(1);
};
if (nb_lign != Msortie.nb_lign)
{cout << "\n erreur la matrice resultat n'a pas le meme nombre de ligne ("<< Msortie.nb_lign
<< ") que this (" << nb_lign << "), resolution impossible "
<< "\n MatLapack::Inverse(..." << endl;
Sortie(1);
}
else if (nb_col != Msortie.nb_col)
{cout << "\n erreur la matrice resultat n'a pas le meme nombre de colonne ("<< Msortie.nb_col
<< ") que this (" << nb_col << "), resolution impossible "
<< "\n MatLapack::Inverse(..." << endl;
Sortie(1);
};
#endif
ENTIER_POUR_CLAPACK info = 0; // info de sortie en fait c'est le retour de la fonction
// init général
if (ipiv == NULL) {ipiv = new ENTIER_POUR_CLAPACK [nb_lign];};
Msortie = (*this);
// def de la taille adoc pour le vecteur de travail
// au premier appel on défini la taille
ENTIER_POUR_CLAPACK lwork = -1; // pour demander la taille a doc de la zone de travail
dgetri_(&Msortie.nb_lign,Msortie.mat.v,&lda,ipiv,travail.v,&lwork,&info);
GestionErreurInverse(info,1,"dgetri_"); // gestion d'erreurs éventuelles
int dim_optimal=travail(1); // sgetri sauvegarde la taille optimale dans v[0]
travail.Change_taille(dim_optimal);
// appel de la triangulation
dgetrf_(&Msortie.nb_lign,&Msortie.nb_col,Msortie.mat.v,&lda,ipiv,&info);
GestionErreurInverse(info,2,"dgetrf_"); // gestion d'erreurs éventuelles
// calcul de l'inverse
lwork=MaX(1,dim_optimal);
dgetri_(&Msortie.nb_lign,Msortie.mat.v,&lda,ipiv,travail.v,&lwork,&info);
GestionErreurInverse(info,3,"dgetri_"); // gestion d'erreurs éventuelles
// retour
return Msortie;
break;
}
default:
{ cout << "\n erreur , methode non implante pour la matrice lapack: "
<< Nom_resolution(type_resolution)
<< "\n MatLapack::Inverse()"<< endl;
Sortie(1);
};
};
// pour taire le warning
return Msortie;
};
#ifndef MISE_AU_POINT
inline
#endif
// Surcharge de l'operateur + : addition de deux matrices
// il y a création d'une matrice de sortie
MatLapack MatLapack::operator + (const MatLapack& mat_pl) const
{
#ifdef MISE_AU_POINT
if ( ( nb_lign!=mat_pl.nb_lign )|| ( nb_col != mat_pl.nb_col ) )
{ cout << "Erreur : dimensions des matrices non egales\n"
<< " nb_ligne= " << nb_lign << " " << mat_pl.nb_lign
<< " nb_colonne= " << nb_col << " " << mat_pl.nb_col << " ";
cout << "MatLapack::OPERATOR+ (const MatLapack& )\n";
Sortie(1);
};
if (type_matrice != mat_pl.type_matrice)
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(mat_pl.type_matrice) << '\n';
cout << "MatLapack::operator+ (const MatLapack& mat_pl)" << endl;
Sortie(1);
};
#endif
MatLapack result(*this);
result.mat +=mat_pl.mat;
return result;
};
#ifndef MISE_AU_POINT
inline
#endif
// Surcharge de l'operateur - : soustraction entre deux matrices
MatLapack MatLapack::operator- (const MatLapack& mat_pl) const
{
#ifdef MISE_AU_POINT
if ( ( nb_lign!=mat_pl.nb_lign )|| ( nb_col != mat_pl.nb_col ) )
{ cout << "Erreur : dimensions des matrices non egales\n"
<< " nb_ligne= " << nb_lign << " " << mat_pl.nb_lign
<< " nb_colonne= " << nb_col << " " << mat_pl.nb_col << " ";
cout << "MatLapack::OPERATOR- (const MatLapack& )\n";
Sortie(1);
};
if (type_matrice != mat_pl.type_matrice)
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(mat_pl.type_matrice) << '\n';
cout << "MatLapack::operator- (const MatLapack& mat_pl)" << endl;
Sortie(1);
};
#endif
MatLapack result(*this);
// initialisation
result.mat -= mat_pl.mat;
return result;
};
#ifndef MISE_AU_POINT
inline
#endif
// Surcharge de l'operateur - : oppose d'une matrice
MatLapack MatLapack::operator- () const
{ MatLapack result(*this);
// initialisation
result.mat = - mat;
return result;
};
#ifndef MISE_AU_POINT
inline
#endif
MatLapack MatLapack::operator* (const MatLapack& mat_pl) const
// Surcharge de l'operateur * : multiplication de deux matrices
{
#ifdef MISE_AU_POINT
if ( nb_col!= mat_pl.nb_lign )
{ cout << "Erreur : dimensions des matrices non valables, "
<< " pour la multiplication le nombre de colonne de la premiere matrice "
<< " doit etre egale au nombre de ligne de la seconde alors qu'ici on a respectivement: "
<< nb_col << " " << mat_pl.nb_lign << "\n";
cout << "MatLapack::OPERATOR* (const MatLapack& )\n";
Sortie(1);
};
if (type_matrice != mat_pl.type_matrice)
{ cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(mat_pl.type_matrice) << '\n';
cout << "MatLapack::operator* (const MatLapack& mat_pl)" << endl;
Sortie(1);
};
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ // par défaut on initialise la matrice résultat en non symétrique (car le produit de deux matrices symétriques
// en en général non symétrique, et on ne renseigne pas la résolution
// la première matrice : n_lign x nb_col
// la deuxième matrice : mat_pl.n_lign x mat_pl.nb_col
// la matrice résultat : n_lign x mat_pl.nb_col
MatLapack result(nb_lign,mat_pl.nb_col,false,0.,RIEN_TYPE_RESOLUTION_MATRI,RIEN_PRECONDITIONNEMENT);
// utilisation de blas3
// void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,
// const enum CBLAS_TRANSPOSE TransB, const int M, const int N,
// const int K, const double alpha, const double *A,
// const int lda, const double *B, const int ldb,
// const double beta, double *C, const int ldc) __OSX_AVAILABLE_STARTING(__MAC_10_2,
// C := alpha*op( A )*op( B ) + beta*C,
// ici on prend alpha = 1. et beta = 0.
double alpha = 1.; double beta = 0.;
// MatLapack inter(nb_lign,mat_pl.nb_col,false,0.,RIEN_TYPE_RESOLUTION_MATRI,RIEN_PRECONDITIONNEMENT);
// le mat.v de la fin, ne sert à rien car beta = 0
cblas_dgemm(CblasRowMajor, CblasNoTrans,CblasNoTrans,nb_lign,mat_pl.nb_col,nb_col,alpha
,mat.v,nb_lign,mat_pl.mat.v,mat_pl.nb_lign,beta,result.mat.v,nb_col);
// for (int i=1;i<=nb_lign;i++)
// { for (int j=1;j<= nb_col;j++)
// for (int k=1;k<=nb_col;k++)
// (result.*Coor)(i,j) += (this->*Coor_const)(i,k) * (mat_pl.*Coor_const)(k,j);
// };
return result;
break;
}
// effectivement la suite n'est pas intéressante et ne sera pas utilisée, donc on laisse l'erreur s'afficher
// case BANDE_NON_SYMETRIQUE_LAPACK:
// { // dans le cas du produit de deux matrices bandes, les bandes s'ajoutent
// MatLapack result(type_matrice,2*nb_col,nb_lign,false,0.,RIEN_TYPE_RESOLUTION_MATRI,RIEN_PRECONDITIONNEMENT);
// // mais pour l'instant je ne suis pas sûr que cela serve à quelque chose donc je met un message d'erreur
// cout << "\n erreur **** le produit de deux matrices bandes n'est pas implante "
// << "\n MatLapack::operator* ( ... " << endl;
// Sortie(1);
// return result;
// break;
// }
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Colonne (.. "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Surcharge de l'operateur * : multiplication d'une matrice par un scalaire
MatLapack MatLapack::operator* (const double& coeff) const
{ MatLapack result(*this);
// on n'utilise pas blas, car cela devra être fait dans la classe vecteur
// et sera donc directement répercuté ici
result *=coeff;
return result;
};
#ifndef MISE_AU_POINT
inline
#endif
// Surcharge de l'operateur == : test d'egalite entre deux matrices
// Retourne 1 si les deux matrices sont egales
// 0 sinon
int MatLapack::operator== (const MatLapack& mat_pl) const
{
#ifdef MISE_AU_POINT
// dans le cas où les matrices ne sont pas de caractéristiques identiques
// il y a un message d'erreur
if (type_matrice != mat_pl.Type_matrice())
{cout << " erreur les matrices sont de types différents "
<< Nom_matrice(type_matrice) << " " << Nom_matrice(mat_pl.type_matrice) << '\n';
cout << "int MatLapack::operator== (..." << endl;
Sortie(1);
}
#endif
if ( ( nb_lign != mat_pl.nb_lign ) || ( nb_col != mat_pl.nb_col ) )
return 0;
if (mat != mat_pl.mat)
return 0;
return 1;
};
//met une valeur identique sur toute la ligne
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::MetValLigne(int i,double x)
{ switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ int le_max = nb_col+1;// +1 pour un test "inférieur pure" sur la ligne qui suit
for(int j=1; j < le_max; j++)
(this->*Coor)(i,j)=x;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ int lb=(nb_col-1)/2; int dim = nb_lign;
int maxJ = MiN(dim,i+lb)+1;// +1 pour un test "inférieur pure" sur la ligne qui suit
for (int j= MaX(1,i-lb);j< maxJ;j++)
(this->*Coor)(i,j) = x;
break;
}
case BANDE_SYMETRIQUE_LAPACK:
// même symétrique il faut imposer sur toute la ligne car au-dessus et en-dessous de la diagonale,
// on n'adresse pas des grandeurs identiques
{int lb=nb_col-1; int dim = nb_lign;
int le_max = MiN(dim,i+lb)+1;// +1 pour un test "inférieur pure" sur la ligne qui suit
int le_min = MaX(1,i-lb); // on fait comme pour MatBand
// for (int j= MaX(1,i);j< le_max;j++)
for (int j= le_min;j< le_max;j++)
(this->*Coor)(i,j)=x;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::MetValLigne (.. "<<endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne la jeme colonne de la matrice
Vecteur MatLapack::Colonne(int j) const
// j est entre 1 et dim
{ Vecteur ret(nb_lign);
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ int le_max = nb_lign+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
for (int i=1;i<le_max;i++)
ret(i)=(this->*Coor_const)(i,j);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ int lb=(nb_col-1)/2; int dim = nb_lign;
int maxI = MiN(dim,j+lb)+1;// +1 pour un test "inférieur pure" sur la ligne qui suit
for (int i= MaX(1,j-lb);i< maxI;i++)
ret(i) = (this->*Coor_const)(i,j);
break;
}
case BANDE_SYMETRIQUE_LAPACK: // bande supérieure
{int lb=nb_col-1; int dim = nb_lign;
int le_max = MiN(dim,j+lb)+1;// +1 pour un test "inférieur pure" sur la boucle qui suit
int le_min = MaX(1,j-lb);
for (int i= le_min;i< le_max;i++)
ret(i) = (this->*Coor_const)(i,j);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Colonne (.. "<<endl;
Sortie(1);
};
return ret;
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne la jeme colonne de la matrice
// sous le format de stokage propre a la matrice
// donc a n'utiliser que comme sauvegarde en parralele
// avec la fonction RemplaceColonne
Vecteur MatLapack::ColonneSpe(int j) const
{ switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ Vecteur ret(nb_lign);
for (int i=1;i<=nb_lign;i++)
ret(i)=(this->*Coor_const)(i,j);
return ret;
break;
}
case CARREE_SYMETRIQUE_LAPACK:
// on fait pareil pour la matrice symétrique, car la colonne complète adresse
// deux parties différentes de symétrie, donc il faut récupérer toute la colonne
{ Vecteur ret(nb_lign);
for (int i=1;i<=nb_lign;i++)
ret(i)=(this->*Coor_const)(i,j);
return ret;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ Vecteur col(nb_col); // mise a zero de ligne, nb_col = largeur totale de la bande
int lb=(nb_col-1)/2; int dim = nb_lign;
int maxI = MiN(dim,j+lb)+1; // +1 pour le test < sur le for qui suit
for (int i= MaX(1,j-lb);i< maxI;i++)
col(i-j+lb+1) = (this->*Coor_const)(i,j);
return col;
break;
}
case BANDE_SYMETRIQUE_LAPACK: // bande supérieure
{int lb=nb_col-1; int dim = nb_lign;
Vecteur col(1+2*lb); // mise a zero de ligne,
// méthode identique au cas de la matrice symétrique, car la colonne complète adresse
// deux parties différentes de symétrie, donc il faut récupérer toute la colonne
int le_max = MiN(dim,j+lb)+1;// +1 pour le test < sur le for qui suit
int le_min = MaX(1,j-lb);
for (int i= le_min;i < le_max;i++)
col(i-j+lb+1) = (this->*Coor_const)(i,j);
return col;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::ColonneSpe (.. "<<endl;
Sortie(1);
};
};
// remplace la Colonne de la matrice par la colonne fournie
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::RemplaceColonneSpe(int j, const Vecteur & v)
{
#ifdef MISE_AU_POINT
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ if (nb_lign != v.Taille())
{ cout << " \nla taille de la colonne j= " << j <<" a remplacer n est pas bonne " ;
cout << " taille = " << v.Taille() << " tailleColMatrice = " << nb_lign;
cout << " void MatLapack::RemplaceColonne(int j,Vecteur & v) " << endl;
Sortie (1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ if (v.Taille() != nb_col)
{cout << "\nerreur d affectation pour le vecteur";
cout << " dim vecteur = " << v.Taille() << " au lieu de " << nb_col << '\n';
cout << "void MatLapack::RemplaceColonne(int j,Vecteur & v)" << endl;
};
Sortie (1);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::RemplaceColonneSpe (.. "<<endl;
Sortie(1);
};
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:
{ for(int i=1; i <= nb_lign ; i++)
(this->*Coor)(i,j)=v(i);
break;
}
case CARREE_SYMETRIQUE_LAPACK:
// méthode identique au cas de la matrice non symétrique, car la colonne complète adresse
// deux parties différentes de symétrie, donc il faut récupérer toute la colonne
{ for(int i=1; i <= nb_lign ; i++)
(this->*Coor)(i,j)=v(i);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{ int lb=(nb_col-1)/2; int dim = nb_lign;
int maxI = MiN(dim,j+lb)+1;// +1 pour inférieur pure sur la ligne qui suit
for (int i= MaX(1,j-lb);i< maxI;i++)
(this->*Coor)(i,j)=v(i);
break;
}
case BANDE_SYMETRIQUE_LAPACK: // bande supérieure
{int lb=nb_col-1; int dim = nb_lign;
Vecteur col(1+2*lb); // mise a zero de ligne,
// méthode identique au cas de la matrice non symétrique, car la colonne complète adresse
// deux parties différentes de symétrie, donc il faut récupérer toute la colonne
int le_max = MiN(dim,j+lb)+1;// +1 pour le test < sur le for qui suit
int le_min = MaX(1,j-lb);
for (int i= le_min;i<le_max;i++)
(this->*Coor)(i,j) = col(i-j+lb+1);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::RemplaceColonneSpe (.. "<<endl;
Sortie(1);
};
};
//met une valeur identique sur toute la colonne
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::MetValColonne(int j,double y)
{ switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
// méthode identique entre symétrique et non symétrique, car pour le stockage symétrique
// la colonne complète adresse
// deux parties différentes de symétrie, donc il faut récupérer toute la colonne
{int le_maxi = nb_lign+1;
for(int i=1; i < le_maxi ; i++)
(this->*Coor)(i,j)=y;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:
{int lb=(nb_col-1)/2; int dim = nb_lign;
int maxI = MiN(dim,j+lb)+1;// +1 pour le test < sur le for qui suit
for (int i= MaX(1,j-lb);i< maxI;i++)
(this->*Coor)(i,j)=y;
break;
}
case BANDE_SYMETRIQUE_LAPACK: // bande supérieure
// méthode identique au cas de la matrice non symétrique, car la colonne complète adresse
// deux parties différentes de symétrie, donc il faut récupérer toute la colonne
{int lb=nb_col-1; int dim = nb_lign;
int maxI = MiN(dim,j+lb)+1;// +1 pour le test < sur le for qui suit
int le_min = MaX(1,j-lb); // on fait comme MatBand
for (int i= le_min;i<maxI;i++)
(this->*Coor)(i,j) = y;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::MetValColonne (.. "<<endl;
Sortie(1);
};
};
// Multiplication d'une ligne iligne de la matrice avec un vecteur de
// dimension = le nombre de colonne de la matrice
#ifndef MISE_AU_POINT
inline
#endif
double MatLapack::Prod_Ligne_vec ( int iligne, const Vecteur& vec) const
{
#ifdef MISE_AU_POINT
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{ if (nb_col != vec.Taille())
{ cout << " \n erreur la taille de la ligne i= " << iligne <<" n est pas correcte ";
cout << " tailleligneMatrice = " <<nb_col
<< " taillevecteur = " << vec.Taille();
cout << " double MatLapack::Prod_Ligne_vec ( int iligne,Vecteur& vec) " << endl;
Sortie (1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ if (vec.Taille() != nb_lign)
{cout << "\nerreur d affectation pour le vecteur";
cout << " dim vecteur = " << vec.Taille() << " au lieu de " << nb_lign << '\n';
cout << "void MatLapack::Prod_Ligne_vec(..." << endl;
};
Sortie (1);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Prod_Ligne_vec (.. "<<endl;
Sortie(1);
};
#endif
double res = 0;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{ for (int j=1;j <= nb_col;j++)
res += (this->*Coor_const)(iligne,j) * vec(j);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:case BANDE_SYMETRIQUE_LAPACK:
{int lb=(nb_col-1)/2; int dim = nb_lign;
int maxJ = MiN(dim,iligne+lb)+1;// +1 pour le test < sur le for qui suit
for (int j=MaX(1,iligne-lb);j< maxJ;j++)
res += (this->*Coor_const)(iligne,j) * vec(j);
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Prod_Ligne_vec (.. "<<endl;
Sortie(1);
};
return res;
};
// Multiplication d'un vecteur avec une colonne icol de la matrice
// dimension = le nombre de ligne de la matrice
#ifndef MISE_AU_POINT
inline
#endif
double MatLapack::Prod_vec_col( int jcol, const Vecteur& vec) const
{
#ifdef MISE_AU_POINT
if (nb_lign != vec.Taille())
{ cout << " \n erreur la taille de la colonne j= " << jcol <<" n est pas correcte ";
cout << " tailleColMatrice = " <<nb_lign
<< " taillevecteur = " << vec.Taille();
cout << " double MatLapack::Prod_vec_col( int jcol,Vecteur& vec) " << endl;
Sortie (1);
};
#endif
double res = 0;
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK: case CARREE_SYMETRIQUE_LAPACK:
{for (int i=1;i <= nb_lign;i++)
res += vec(i) * (this->*Coor_const)(i,jcol) ;
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{int lb=(nb_col-1)/2; int dim = nb_lign;
int maxI = MiN(jcol+lb,dim)+1;// +1 pour le test < sur le for qui suit
for (int i=MaX(1,jcol-lb);i< maxI;i++)
res += vec(i) * (this->*Coor_const)(i,jcol) ;
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::Prod_vec_col (.. "<<endl;
Sortie(1);
};
return res;
};
#ifndef MISE_AU_POINT
inline
#endif
// calcul du produit : (vec_1)^T * A * (vect_2)
double MatLapack::vectT_mat_vec(const Vecteur& vec1, const Vecteur& vec2) const
{ double resu=0.; // valeur de retour
#ifdef MISE_AU_POINT
if (vec1.Taille() != nb_lign)
{cout << "erreur de taille, la dimension de (vec1)^T= " << vec1.Taille() << " n'a pas la même dimension";
cout << " que le le nombre de ligne de la matrice= " << nb_lign
<< "\n MatLapack::vectT_mat_vec(const Vecteur& vec1, const Vecteur& vec2)" << endl;
Sortie(1);
}
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ if (vec2.Taille() != nb_col)
{ cout << "erreur de taille, la dimension de (vec2)= " << vec2.Taille() << " n'a pas la même dimension";
cout << " que le le nombre de colonne de la matrice= " << nb_col
<< "\n MatLapack::vectT_mat_vec(const Vecteur& vec1, const Vecteur& vec2)" << endl;
Sortie(1);
};
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK:case BANDE_SYMETRIQUE_LAPACK:
{ if (vec2.Taille() != nb_lign)
{ cout << "erreur de taille, la dimension de (vec2)= " << vec2.Taille() << " n'a pas la même dimension";
cout << " que le le nombre de colonne de la matrice= " << nb_lign
<< "\n MatLapack::vectT_mat_vec(const Vecteur& vec1, const Vecteur& vec2)" << endl;
Sortie(1);
};
break;
};
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::vectT_mat_vec (.. "<<endl;
Sortie(1);
};
#endif
switch (type_matrice)
{ case RECTANGLE_LAPACK: case CARREE_LAPACK:case CARREE_SYMETRIQUE_LAPACK:
{ for (int i=1;i<=nb_lign;i++)
for (int j= 1;j<= nb_col;j++)
resu += vec1(i) * (this->*Coor_const)(i,j) * vec2(j);
break;
}
case BANDE_NON_SYMETRIQUE_LAPACK: case BANDE_SYMETRIQUE_LAPACK:
{ int lb=(nb_col-1)/2; int dim = nb_lign;
for (int i=1;i<=dim;i++)
{ int maxJ = MiN(dim,i+lb)+1;// +1 pour inférieur pure sur la ligne qui suit
for (int j= MaX(1,i-lb);j< maxJ;j++)
resu += vec1(i) * (this->*Coor_const)(i,j) * vec2(j);
};
break;
}
default:
cout << "\n erreur: cas de type de matrice: "<< Nom_matrice(type_matrice)
<< " non implante "
<< "\n MatLapack::vectT_mat_vec (.. "<<endl;
Sortie(1);
};
return resu;
};
#ifndef MISE_AU_POINT
inline
#endif
// retourne la place que prend la matrice en entier
int MatLapack::Place() const
{switch (type_matrice)
{ case CARREE_SYMETRIQUE_LAPACK: return nb_lign*(nb_col-1)/2+nb_col;
case CARREE_LAPACK: return nb_lign*nb_col;
case RECTANGLE_LAPACK: return (2*(nb_lign * nb_col));break;
case BANDE_SYMETRIQUE_LAPACK: return lda*ldb;
case BANDE_NON_SYMETRIQUE_LAPACK: return (2*((nb_lign+(nb_lign-1)/2) * nb_col));break;
default: return 0;
};
};
// =================== méthodes protégées =======================
/*
// calcul de la matrice triangulée dans le cadre de la méthode de cholesky
// utilisation particulière : la matrice résultat B est défini dans le programme
// appelant.
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Triangulation (int N,MatLapack& B)
{ double somme;
// Determination des composantes de la matrice
// triangulaire inferieure B :
for (int k=1;k<=N;k++)
{
somme=0;
for (int j=1;j<=k-1;j++)
{
// somme=somme+ B(k,j)*B(k,j); // pow(B(k,j),2.0);
somme += B(k,j)*B(k,j); // pow(B(k,j),2.0);
};
B(k,k)=sqrt((*this)(k,k)-somme);
for (int i=k+1;i<=N;i++)
{
somme=0;
for (int j=1;j<=k-1;j++)
{
// somme=somme+(B(i,j)*B(k,j));
somme += (B(i,j)*B(k,j));
};
B(i,k)=((*this)(i,k)-somme)/B(k,k);
};
};
};
// résolution du problème triangularisé
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Resolution
(int N, const MatLapack& B,const Vecteur& b,Vecteur& resul) const
{ // Resolution du systeme B.y=b ( avec y=Bt.x )
// Les valeurs de y sont stockees dans le vecteur result
for (int i=1;i<=N;i++)
{
resul(i)=b(i);
// for (int j=1;j<=i-1;j++)
// resul(i)=resul(i)-B(i,j)*resul(j);
// resul(i)=resul(i)/B(i,i);
for (int j=1;j<=i-1;j++)
resul(i) -= B(i,j)*resul(j);
resul(i) /= B(i,i);
};
// Resolution du systeme Bt.x=y
// Les valeurs de x sont stockees dans le vecteur result
// B=B.Transpose();
// for (int i=N;i>=1;i--)
// {
// for (int j=i+1;j<=N;j++)
// result(i)=result(i)-B(j,i)*result(j);
// result(i)=result(i)/B(i,i);
// };
for (int i=N;i>=1;i--)
{
for (int j=i+1;j<=N;j++)
resul(i) -= B(j,i)*resul(j);
// resul(i)=resul(i)-B(j,i)*resul(j);
// resul(i)=resul(i)/B(i,i);
resul(i) /= B(i,i);
};
};
*/
// surcharge de l'operateur de lecture typée
#ifndef MISE_AU_POINT
inline
#endif
istream & operator >> (istream & entree, MatLapack & mat_pl)
{ // vérification du type
string typa;
entree >> typa;
if (typa != "MatLapack_NxM")
{cout << "\n erreur en lecture d'une matrice type lapack on attendait la chaine: MatLapack_NxM"
<< " et on a lue: " << typa
<< "\n operator >> (istream & entree ... ";
Sortie (1);
};
// on lit le nombre de ligne et de colonne
int nb_l,nb_c;
entree >> nb_l >> nb_c;
// on lit le type et on vérifie que la matrice à le même type que this
entree >> typa;
if (Id_nom_matrice(typa.c_str()) != mat_pl.type_matrice)
{cout << "\n erreur en lecture du type de la matrice on attendait " << Nom_matrice(mat_pl.type_matrice)
<< " et on a lue: " << typa
<< "\n operator >> (istream & entree ... ";
Sortie (1);
};
// on redimentionne en fonction du type
if ((nb_l != mat_pl.nb_lign) || (nb_c != mat_pl.nb_col))
{ mat_pl.Change_taille(nb_l,nb_c);}
else
{ // même si la place est ok on met à jour le nombre de ligne et de colonne
mat_pl.nb_lign=nb_l;mat_pl.nb_col=nb_c;
};
// maintenant on peut lire les coordonnées
entree >> typa; // pour passer le mot clé valeurs=
int nb=mat_pl.mat.Taille();
for(int j=1; j <= nb; j++)
entree >> mat_pl.mat(j);
return entree;
};
// surcharge de l'operateur d'ecriture typée
#ifndef MISE_AU_POINT
inline
#endif
ostream & operator << ( ostream & sort,const MatLapack & mat_pl)
{ // un indicateur donnant le type puis les datas
sort << "MatLapack_NxM " << mat_pl.nb_lign << " " << mat_pl.nb_col << " "
<< Nom_matrice(mat_pl.type_matrice) << " valeurs= " ;
int nb = mat_pl.mat.Taille();
for(int j=1; j <= nb; j++)
sort << setprecision(ParaGlob::NbdigdoCA()) << mat_pl.mat(j);
// retour
return sort;
};
// fonction interne de vérification des composantes
// arrêt si pb
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Verif_nb_composante(const Vecteur& b,string nom_routine) const
{
// l'appel n'est possible que si la matrice est carré
if (nb_lign != nb_col)
{cout << "\n erreur la matrice n'est pas carree, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::" << nom_routine << "(..." << endl;
Sortie(1);
}
// l'appel n'est pas possible si la matrice a des coefficients
if (nb_lign == 0)
{cout << "\n erreur la matrice n'a pas de coefficient, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::" << nom_routine << "(..." << endl;
Sortie(1);
}
// vérif du nombre de composante de b
if (b.Taille()!=nb_lign)
{cout << "\n erreur le nombre de composante du second membre: " << b.Taille()
<< " est differant du nombre de ligne de la matrice: " << nb_lign << " "
<< "\n MatLapack::" << nom_routine << "(..." << endl;
Sortie(1);
}
};
// fonction interne de vérification des composantes
// arrêt si pb
#ifndef MISE_AU_POINT
inline
#endif
void MatLapack::Verif_nb_composante(const Tableau <Vecteur>& b,string nom_routine) const
{
// l'appel n'est possible que si la matrice est carré
if (nb_lign != nb_col)
{cout << "\n erreur la matrice n'est pas carree, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::" << nom_routine << "(..." << endl;
Sortie(1);
};
// l'appel n'est pas possible si la matrice a des coefficients
if (nb_lign == 0)
{cout << "\n erreur la matrice n'a pas de coefficient, resolution impossible "
<< " nb_ligne= " << nb_lign << " nb_colonne= " << nb_col
<< "\n MatLapack::" << nom_routine << "(..." << endl;
Sortie(1);
};
// vérif du nombre de composante des seconds membres b
int nb_SM = b.Taille();
for (int i=1;i<=nb_SM;i++)
if (b(i).Taille()!=nb_lign)
{cout << "\n erreur le nombre de composante: " << b(i).Taille() << " du second membre numero: " << i
<< " est differant du nombre de ligne de la matrice: " << nb_lign << " "
<< "\n MatLapack::Resol_syst(const Tableau <Vecteur>&..." << endl;
Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// gestion erreur dgesv
void MatLapack::GestionErreurDg_sv(const int& info) const
{ if (info == 0)
{ return;}
else if (info < 0)
{ cout << "\n pb resolution Dg_sv, le " << -info << " argument de la fonction"
<< " a une valeur illegale "
<< "\n arguments: ( N, NRHS, A, LDA, IPIV, B, LDB, INFO ) "
<< " \n MatLapack::GestionErreurDg_sv(const int& info) ";
// on génère une exception
throw ErrResolve_system_lineaire(1);
Sortie(1);
}
else if (info > 0)
{ cout << "\n pb resolution Dg_sv, U(" << info << "," << info <<") est exactement null"
<< " (cf doc lapack) la factorisation est complete, mais U est exactement singuliere"
<< " donc la solution ne peut-etre calculee "
<< " \n MatLapack::GestionErreurDg_sv(const int& info) ";
// on génère une exception
throw ErrResolve_system_lineaire(1);
// cout << "\n corriger le debug de Matlapack "; // Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// gestion erreur dpbsv
void MatLapack::GestionErreurDpbsv(const int& info) const
{ if (info == 0)
{ return;}
else if (info < 0)
{ cout << "\n pb resolution Dpbsv, le " << -info << " argument de la fonction"
<< " a une valeur illegale "
<< "\n arguments: ( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) "
<< " \n MatLapack::GestionErreurDpbsv(const int& info) ";
// on génère une exception
throw ErrResolve_system_lineaire(1);
Sortie(1);
}
else if (info > 0)
{ cout << "\n pb resolution Dpbsv, le mineur prindipal d'ordre (" << info << ") de la matrice est non defini positif"
<< " (cf doc lapack) la factorisation complete ne peut-etre effectuee, "
<< " donc la solution ne peut-etre calculee "
<< " \n MatLapack::GestionErreurDpbsv(const int& info) ";
// on génère une exception
throw ErrResolve_system_lineaire(1);
// cout << "\n corriger le debug de Matlapack "; // Sortie(1);
};
};
#ifndef MISE_AU_POINT
inline
#endif
// gestion erreur Inverse
void MatLapack::GestionErreurInverse(const int& info,int cas,const string nom_routine_lapack) const
{ if (info == 0)
{ return;}; // cas pas de pb
// cas de pb éventuel
if (info < 0)
{ cout << "\n pb resolution, le " << -info << " argument de la fonction"
<< " a une valeur illegale (cf doc lapack)";
}
else if (info > 0)
{ cout << "\n pb resolution, U(" << info << "," << info <<") est exactement null"
<< " (cf doc lapack) la factorisation est complete, mais U est exactement singuliere"
<< " donc la solution ne peut-etre calculee ";
};
switch (cas)
{ case 2:
{cout << "\n arguments: ( N, A, LDA, IPIV, WORK, LWORK, INFO ) "; break;}
case 1: case 3:
{cout << "\n arguments: ( M, N, A, LDA, IPIV, INFO ) "; break;}
default:
{ cout << "\n **** erreur: cas= " << cas <<" non pris en compte"
<< "\n MatLapack::GestionErreurInverse(...";
// on génère une exception
throw ErrResolve_system_lineaire(1);
Sortie(1);
};
};
cout << " \n routine : " << nom_routine_lapack << " cas = " << cas
<< "\n MatLapack::GestionErreurInverse(... ";
// on génère une exception
throw ErrResolve_system_lineaire(1);
Sortie(1);
};
#endif