ortho_poly.h

/*
 * Declaration of class Ortho_poly 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: ortho_poly.h,v 1.1 2005/11/14 01:57:00 e_gourgoulhon Exp $
 * $Log: ortho_poly.h,v $
 * Revision 1.1  2005/11/14 01:57:00  e_gourgoulhon
 * First version
 *
 *
 * $Header: /cvsroot/Lorene/School05/Monday/ortho_poly.h,v 1.1 2005/11/14 01:57:00 e_gourgoulhon Exp $
 *
 */

#ifndef __ORTHO_POLY_H_ 
#define __ORTHO_POLY_H_ 

class Grid ; 

            //----------------------------------//
            //          class Ortho_poly        //
            //----------------------------------//

class Ortho_poly {

    // Data : 
    // -----
    protected:
        const int nn ; 
        
        mutable const Grid* p_gauss_nodes ; 

        mutable double* p_gauss_weights ; 

        mutable double* p_gauss_gamma ; 

        mutable const Grid* p_gauss_lobatto_nodes ; 
        
        mutable double* p_gauss_lobatto_weights ; 

        mutable double* p_gauss_lobatto_gamma ; 

        
    // Constructors - Destructor
    // -------------------------
    protected:
        Ortho_poly(const Ortho_poly& ) ; 
        
        Ortho_poly(int ni) ;
         
    public:
        virtual ~Ortho_poly() ;         
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Ortho_poly&)  ;    
    
    // Accessors
    // ---------
    public:
        int n() const ; 
        
    // Computation
    // -----------
    public: 
        virtual double weight(double x) const = 0 ; 

        virtual double operator()(int i, double x) const = 0 ; 
        
        virtual const Grid& gauss_nodes() const = 0 ;
        
        virtual double gauss_weight(int i) const = 0 ;
        
        virtual double gauss_gamma(int i) const = 0 ;

        virtual const Grid& gauss_lobatto_nodes() const = 0 ;
        
        virtual double gauss_lobatto_weight(int i) const = 0 ;
        
        virtual double gauss_lobatto_gamma(int i) const = 0 ;

        void coef_interpolant_Gauss(double (*f)(double), double* cf) const ;  

        void coef_interpolant_GL(double (*f)(double), double* cf) const ;  

        virtual void coef_projection(double (*f)(double), double* cf) const = 0 ;  

        double series(const double* a, double x) const ;  

};
    
            //----------------------------------//
            //      class Chebyshev_poly        //
            //----------------------------------//

class Chebyshev_poly : public Ortho_poly {
        
    // Constructors - Destructor
    // -------------------------
    public:
        Chebyshev_poly(int ni ) ; 
        
        Chebyshev_poly(const Chebyshev_poly& ) ; 
        
    public:
        virtual ~Chebyshev_poly() ;         
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Chebyshev_poly&) ; 
    
            
    // Computation
    // -----------
    public: 
        virtual double weight(double x) const ; 

        virtual double operator()(int i, double x) const ; 

        virtual const Grid& gauss_nodes() const ;
        
        virtual double gauss_weight(int i) const ;
        
        virtual double gauss_gamma(int i) const ;

        virtual const Grid& gauss_lobatto_nodes() const ;
        
        virtual double gauss_lobatto_weight(int i) const ;
        
        virtual double gauss_lobatto_gamma(int i) const ;

        void coef_interpolant_GL_FFT(double (*f)(double), double* cf) const ;  

        virtual void coef_projection(double (*f)(double), double* cf) const  ;  

};
    
ostream& operator<<(ostream& , const Chebyshev_poly& ) ;    


            //----------------------------------//
            //      class Legendre_poly        //
            //----------------------------------//

class Legendre_poly : public Ortho_poly {
        
    // Constructors - Destructor
    // -------------------------
    public:
        Legendre_poly(int ni ) ; 
        
        Legendre_poly(const Legendre_poly& ) ; 
        
    public:
        virtual ~Legendre_poly() ;          
 
    // Mutators / assignment
    // ---------------------
    public:
        void operator=(const Legendre_poly&) ;  
    
            
    // Computation
    // -----------
    public: 
        virtual double weight(double x) const ; 

        virtual double operator()(int i, double x) const ; 

        virtual const Grid& gauss_nodes() const ;
        
        virtual double gauss_weight(int i) const ;
        
        virtual double gauss_gamma(int i) const ;

        virtual const Grid& gauss_lobatto_nodes() const ;
        
        virtual double gauss_lobatto_weight(int i) const ;
        
        virtual double gauss_lobatto_gamma(int i) const ;

        virtual void coef_projection(double (*f)(double), double* cf) const  ;  

};
    
ostream& operator<<(ostream& , const Legendre_poly& ) ; 


#endif

---