grid.h

/*
 * Declaration of class Grid and derived classes
 */

/*
 *   Copyright (c) 2005 Eric Gourgoulhon
 *
 *   This file is part of LORENE.
 *
 *   LORENE 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 2 of the License, or
 *   (at your option) any later version.
 *
 *   LORENE 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 LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*
 * $Id: grid.h,v 1.1 2005/11/14 01:56:58 e_gourgoulhon Exp $
 * $Log: grid.h,v $
 * Revision 1.1  2005/11/14 01:56:58  e_gourgoulhon
 * First version
 *
 *
 * $Header: /cvsroot/Lorene/School05/Monday/grid.h,v 1.1 2005/11/14 01:56:58 e_gourgoulhon Exp $
 *
 */


#ifndef __GRID_H_ 
#define __GRID_H_ 

            //----------------------------------//
            //          class Grid              //
            //----------------------------------//

class Grid {

    // Data : 
    // -----
    protected:
        const int nn ; 
        double* xx ;  

    // Constructors - Destructor
    // -------------------------
    public:
    Grid(int nb_nodes, double* xi) ;
        
    Grid(const Grid& ) ;        
        
    protected:
        Grid(int nb_nodes) ;
         
    public:
    virtual ~Grid() ;           
 
    // Mutators / assignment
    // ---------------------
    public:
    void operator=(const Grid&) ;   
    
    // Accessors
    // ---------
    public:
        int n() const ; 

        double operator()(int i) const ; 

        void plot(int color = 1, int nfig = 0, double ymin = -1., 
                  double ymax = 1., const char* title = 0x0, 
                  const char* label_y = 0x0, const char* device = 0x0) const ;
                        
    // Computation
    // -----------
    public: 
        double lagrange(int i, double x) const ; 
         
        double nodal_polynomial(double x) const ; 
          
        double interpole(double (*f)(double), double x) const ;  
        
        double lebesgue_constant() const ; 
    
};

ostream& operator<<(ostream& , const Grid& ) ;  


            //----------------------------------//
            //          class Grid_uniform      //
            //----------------------------------//



class Grid_uniform : public Grid {

    // Constructors - Destructor
    // -------------------------
    public:
    Grid_uniform(int nb_nodes) ;
        
    Grid_uniform(const Grid_uniform& ) ;        
        
    virtual ~Grid_uniform() ;           
 
    // Mutators / assignment
    // ---------------------
    public:
    void operator=(const Grid_uniform&) ;   
    
                       
};

ostream& operator<<(ostream& , const Grid_uniform& ) ;  


            //----------------------------------//
            //    class Grid_Legendre_Gauss    //
            //----------------------------------//


class Grid_Legendre_Gauss : public Grid {

    // Constructors - Destructor
    // -------------------------
    public:
        Grid_Legendre_Gauss(int nb_nodes) ;
        
        Grid_Legendre_Gauss(const Grid_Legendre_Gauss& ) ;  
        
        virtual ~Grid_Legendre_Gauss() ;            
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Grid_Legendre_Gauss&) ;    
    
                       
};

ostream& operator<<(ostream& , const Grid_Legendre_Gauss& ) ;   


            //----------------------------------//
            //     class Grid_Legendre_GL      //
            //----------------------------------//


class Grid_Legendre_GL : public Grid {

    // Constructors - Destructor
    // -------------------------
    public:
        Grid_Legendre_GL(int nb_nodes) ;
        
        Grid_Legendre_GL(const Grid_Legendre_GL& ) ;    
        
        virtual ~Grid_Legendre_GL() ;           
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Grid_Legendre_GL&) ;   
    
                       
};

ostream& operator<<(ostream& , const Grid_Legendre_GL& ) ;  



            //----------------------------------//
            //    class Grid_Chebyshev_Gauss    //
            //----------------------------------//


class Grid_Chebyshev_Gauss : public Grid {

    // Constructors - Destructor
    // -------------------------
    public:
        Grid_Chebyshev_Gauss(int nb_nodes) ;
        
        Grid_Chebyshev_Gauss(const Grid_Chebyshev_Gauss& ) ;    
        
        virtual ~Grid_Chebyshev_Gauss() ;           
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Grid_Chebyshev_Gauss&) ;   
    
                       
};

ostream& operator<<(ostream& , const Grid_Chebyshev_Gauss& ) ;  


            //----------------------------------//
            //     class Grid_Chebyshev_GL      //
            //----------------------------------//


class Grid_Chebyshev_GL : public Grid {

    // Constructors - Destructor
    // -------------------------
    public:
        Grid_Chebyshev_GL(int nb_nodes) ;
        
        Grid_Chebyshev_GL(const Grid_Chebyshev_GL& ) ;  
        
        virtual ~Grid_Chebyshev_GL() ;          
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Grid_Chebyshev_GL&) ;  
    
                       
};

ostream& operator<<(ostream& , const Grid_Chebyshev_GL& ) ; 

#endif

---