/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*             ********   ***                                 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