Chebyshev.h

Go to the documentation of this file.

#ifndef CHEBYSHEV_H
#define CHEBYSHEV_H


// ----------------------------------------------------------------------
//
// Bridge object between C++ code and the gsl Chebyshev expansion code
//
// ----------------------------------------------------------------------

#ifndef ZMENVIRONMENT_H
#include "ZMutility/ZMenvironment.h"
#endif
#include <utility>
#include <vector>
#include <string>
#include "gsl/gsl_math.h"

#include "SpecialFunctions/checkStatus.h"
#include "SpecialFunctions/gsl_chebyshev.h"
USING(std::string)

ZM_BEGIN_NAMESPACE( zmsf )      /*  namespace zmsf  {  */

typedef std::vector<double> Dvector;
typedef std::pair<double,double> Dpair;



template<class UserFcnT>
struct UF { static UserFcnT* uf; };

template<class UserFcnT> UserFcnT* UF<UserFcnT>::uf = 0;

template<class UserFcnT>
double proxy( double x ) {
  return (*UF<UserFcnT>::uf)(x);
}

template<class UserFcnT >
double proxy2( double x, Dvector pars ) {
  return (*UF<UserFcnT>::uf)(x, pars);
}


class Chebyshev {

public:

  Chebyshev();

  Chebyshev( const int order );

  Chebyshev( const string& filename );
  

  template<class UserFcnT>
  Chebyshev( UserFcnT f, const double a, const double b, const int order )
  {
    string fName = "Chebyshev::Chebyshev( UserFcnT f, a, b, order )";
    _series = gsl_cheb_alloc( order );
    if( _series == 0 )  checkStatus( GSL_ENOMEM, fName );
    UF<UserFcnT>::uf = &f;
    checkStatus( gsl_cheb_init( _series, &proxy<UserFcnT>, a, b ), fName );
  }


  template<class UserFcnT>
  Chebyshev( UserFcnT f, Dvector pars,
             const double a, const double b, const int order )
  {
    string fName = "Chebyshev::Chebyshev( UserFcnT f, pars, a, b, order )";
    _series = gsl_cheb_alloc( order );
    if( _series == 0 )  checkStatus( GSL_ENOMEM, fName );
    UF<UserFcnT>::uf = &f;
    checkStatus( gsl_cheb_init( _series, &proxy2<UserFcnT>, pars, a, b ), fName );
  }

  Chebyshev( const Chebyshev& F );

  Chebyshev& operator=(const Chebyshev& F );

  ~Chebyshev();


  template<class UserFcnT>
  void Expand( UserFcnT f, const double a, const double b, const int order )
  {
    string fName = "Chebyshev::Expand";
    gsl_cheb_free( _series );
    _series = gsl_cheb_alloc( order );
    if( _series == 0 )  checkStatus( GSL_ENOMEM, fName );
    UF<UserFcnT>::uf = &f;
    checkStatus( gsl_cheb_init( _series, &proxy<UserFcnT>, a, b ), fName );
  }


  template<class UserFcnT>
  void Expand( UserFcnT f, Dvector pars,
               const double a, const double b, const int order )
  {
    string fName = "Chebyshev::Expand";
    gsl_cheb_free( _series );
    _series = gsl_cheb_alloc( order );
    if( _series == 0 )  checkStatus( GSL_ENOMEM, fName );
    UF<UserFcnT>::uf = &f;
    checkStatus( gsl_cheb_init( _series, &proxy2<UserFcnT>, pars, a, b ), fName );
  }

  double EvaluateF( const double x );

  double operator () ( const double x );

  Dpair EvaluateFErr( const double x );

  double EvaluateFSingle( const double x );

  double EvaluateFN( const int order, const double x );


  Dpair EvaluateFNErr( const int order, const double x );


  Chebyshev Differentiate();


  Chebyshev Integrate();

  int GetOrder();

  Dpair GetInterval();


  Dvector GetExpansion();

  void SaveExpansion( const string& filename );

private:

  static double fdummy( double x ) { return (1.0+x); };

  gsl_cheb_series *     _series;

};  // Chebyshev


ZM_END_NAMESPACE( zmsf )        /*  }  // namespace zmsf  */

#endif  /* CHEBYSHEV_H */

---