148 lines
5.2 KiB
C++
Executable file
148 lines
5.2 KiB
C++
Executable file
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
/* ******** *** SparseLib++ */
|
|
/* ******* ** *** *** *** v. 1.5c */
|
|
/* ***** *** ******** ******** */
|
|
/* ***** *** ******** ******** R. Pozo */
|
|
/* ** ******* *** ** *** *** K. Remington */
|
|
/* ******** ******** A. Lumsdaine */
|
|
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
/* */
|
|
/* */
|
|
/* SparseLib++ : Sparse Matrix Library */
|
|
/* */
|
|
/* National Institute of Standards and Technology */
|
|
/* University of Notre Dame */
|
|
/* Authors: R. Pozo, K. Remington, A. Lumsdaine */
|
|
/* */
|
|
/* NOTICE */
|
|
/* */
|
|
/* Permission to use, copy, modify, and distribute this software and */
|
|
/* its documentation for any purpose and without fee is hereby granted */
|
|
/* provided that the above notice appear in all copies and supporting */
|
|
/* documentation. */
|
|
/* */
|
|
/* Neither the Institutions (National Institute of Standards and Technology, */
|
|
/* University of Notre Dame) nor the Authors make any representations about */
|
|
/* the suitability of this software for any purpose. This software is */
|
|
/* provided ``as is'' without expressed or implied warranty. */
|
|
/* */
|
|
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
// modification GR
|
|
// 1) on utilise une interface unique pour tous les préconditionneurs
|
|
// d'où l'héritage d'une classe virtuelle
|
|
// 2) on utilise sytématiquement les classes templates MV++
|
|
|
|
#ifndef ILUPRE_GR_H
|
|
#define ILUPRE_GR_H
|
|
|
|
//#include "vecdefs.h"
|
|
#include "vecdefs_GR.h" // modif GR
|
|
//#include VECTOR_H // modif GR
|
|
#include "comprow_double.h"
|
|
#include "compcol_double.h"
|
|
|
|
#include "pre_cond_double.h"
|
|
#include "Mat_abstraite.h"
|
|
|
|
class CompCol_ILUPreconditioner_double : public Pre_cond_double
|
|
{
|
|
|
|
private:
|
|
VECTOR_double l_val_;
|
|
VECTOR_int l_colptr_;
|
|
VECTOR_int l_rowind_;
|
|
int l_nz_;
|
|
|
|
VECTOR_double u_val_;
|
|
VECTOR_int u_colptr_;
|
|
VECTOR_int u_rowind_;
|
|
int u_nz_;
|
|
|
|
int dim_[2];
|
|
|
|
public:
|
|
CompCol_ILUPreconditioner_double(const CompCol_Mat_double &A);
|
|
// cas d'une matrice abstraite
|
|
CompCol_ILUPreconditioner_double(const Mat_abstraite &A);
|
|
~CompCol_ILUPreconditioner_double(void){};
|
|
|
|
// méthodes-------
|
|
|
|
VECTOR_double solve(const VECTOR_double &x) const;
|
|
VECTOR_double trans_solve(const VECTOR_double &x) const;
|
|
|
|
//====================== protégée ========================
|
|
|
|
protected :
|
|
// fonction interne d'initialisation pour éviter la recopie
|
|
void Init_CompCol_Mat_double(const CompCol_Mat_double &A);
|
|
void Init_Mat_creuse_CompCol(const Mat_abstraite &A);
|
|
|
|
};
|
|
|
|
|
|
class CompRow_ILUPreconditioner_double : public Pre_cond_double
|
|
{
|
|
|
|
private:
|
|
VECTOR_double l_val_;
|
|
VECTOR_int l_rowptr_;
|
|
VECTOR_int l_colind_;
|
|
int l_nz_;
|
|
|
|
VECTOR_double u_val_;
|
|
VECTOR_int u_rowptr_;
|
|
VECTOR_int u_colind_;
|
|
int u_nz_;
|
|
|
|
int dim_[2];
|
|
|
|
public:
|
|
CompRow_ILUPreconditioner_double(const CompRow_Mat_double &A);
|
|
// cas d'une matrice abstraite
|
|
CompRow_ILUPreconditioner_double(const Mat_abstraite &A);
|
|
~CompRow_ILUPreconditioner_double(void){};
|
|
|
|
// méthodes-------
|
|
|
|
VECTOR_double solve(const VECTOR_double &x) const;
|
|
VECTOR_double trans_solve(const VECTOR_double &x) const;
|
|
|
|
//====================== protégée ========================
|
|
|
|
protected :
|
|
// fonction interne d'initialisation pour éviter la recopie
|
|
void Init_CompRow_Mat_double(const CompRow_Mat_double &A);
|
|
|
|
};
|
|
|
|
// introduction d'une classe qui regroupe les différentes possibilités de
|
|
// stockage matricielle
|
|
|
|
class ILUPreconditioner_double : public Pre_cond_double
|
|
{
|
|
public:
|
|
// CONSTRUCTEUR
|
|
|
|
// cas d'une matrice abstraite
|
|
ILUPreconditioner_double(const Mat_abstraite &A);
|
|
// destructeur
|
|
~ILUPreconditioner_double(void);
|
|
|
|
// méthodes-------
|
|
|
|
VECTOR_double solve(const VECTOR_double &x) const
|
|
{ return preCond_mat->solve(x);};
|
|
VECTOR_double trans_solve(const VECTOR_double &x) const
|
|
{ return preCond_mat->trans_solve(x);};
|
|
|
|
//====================== protégée ========================
|
|
|
|
private:
|
|
// pour l'instant deux types de matrices possibles
|
|
Pre_cond_double * preCond_mat;
|
|
};
|
|
|
|
#endif
|