Intg.h

Go to the documentation of this file.

/*****************************************************************************
 $RCSfile: Intg.h,v $ --- $Date: 2006/07/19 13:21:43 $ --- $Revision: 1.3 $
 *****************************************************************************
 PREPROCESSOR DIRECTIVES
 *****************************************************************************/

 #ifndef CALC_INTG_H
 #define CALC_INTG_H

/*****************************************************************************
 INCLUDE FILES
 *****************************************************************************/

 #include "Base.h"

/*****************************************************************************
 NAMESPACE IDENTIFICATIONS
 *****************************************************************************/

 namespace calc {

/*****************************************************************************
 IntgErr CLASS
 *****************************************************************************/


 class IntgErr:public Err {

 public:

 // Enumerations

    enum ERR_ENUM {
       INIT=0,    
       MEMORY,    
       LOOP,      
       ERR_CNT,   
    };

 // Constructors

    IntgErr(enum IntgErr::ERR_ENUM indErr):
    Err() {
       const char* const CLASS_NAME="Intg";
       const char* const ERR_STR[ERR_CNT]={
          "object initialization error",   // text for index INIT
          "memory allocation error",       // text for index MEMORY
          "maximum loop count exceeded",   // text for index LOOP
       };
       setError(indErr,CLASS_NAME,ERR_STR[indErr]);
    }
 };

/*****************************************************************************
 Intg CLASS TEMPLATE
 *****************************************************************************/

 template <typename xType, typename yType>
 class Intg:public Base {

 public:

 // Member Enumerations

    enum CTYPE {
       TRAPEZOID=0,    
       SIMPSON,        
       ROMBERG,        
       CTYPE_CNT,      
    };

    enum VTYPE {
       LOOP_CURRENT=0,   
       LOOP_MAXIMUM,     
       VTYPE_CNT,        
    };

 // Member Functions

    yType  eval       (xType x1, xType x2) throw (IntgErr);
    bool   setEpsilon (xType dEps);

    virtual bool setCount (int nMaximum);

    yType evalIntegrand(xType x) const {return (*pFn)(x);}
    xType getError(void) const {return eps;}
    enum Intg<xType,yType>::CTYPE getMethod(void) const {return cTyp;}
    int getCount(enum Intg<xType,yType>::VTYPE vType) const
       {return ((!nogo)&&(vType>=0)&&(vType<VTYPE_CNT)?nCount[vType]:-1);}

    static const int DEF_LOOP_MAX;

 protected:

 // Constructors

    Intg(yType (&rFn)(xType), xType dEps);
    Intg(const Intg &ig);

    ~Intg(void) {}

 // Member Functions

    yType refine(int ninc);

    virtual yType intgMethod(void) throw (IntgErr)=0;

 // Data Members

    xType      eps;                
    int        nCount[VTYPE_CNT];  
    enum Intg<xType,yType>::CTYPE cTyp;  
 private:

 // Member Functions

    virtual void varInit(void);

 // Data Members

    yType (*pFn)(xType);              
    xType xBnd[Base::BOUND_CNT];      
    xType xDel;                       
    yType iintg;                      
 };

/*****************************************************************************/

 template <typename xType, typename yType>
 const int calc::Intg<xType,yType>::DEF_LOOP_MAX=20;

/*****************************************************************************
 Trap CLASS TEMPLATE
 *****************************************************************************/

 template <typename xType, typename yType>
 class Trap:public Intg<xType,yType> {

 // Inherited Member Functions & Data Members

    using Intg<xType,yType>::refine;
    using Intg<xType,yType>::eps;
    using Intg<xType,yType>::nCount;
    using Intg<xType,yType>::cTyp;
    using Intg<xType,yType>::TRAPEZOID;
    using Intg<xType,yType>::LOOP_CURRENT;
    using Intg<xType,yType>::LOOP_MAXIMUM;

 public:

 // Constructors

    Trap(yType (&rFn)(xType), xType dEps):
    Intg<xType,yType>(rFn,dEps) {cTyp=TRAPEZOID;}
    Trap(const Trap &tr):
    Intg<xType,yType>(tr) {}
    Trap(const Intg<xType,yType> &ig):
    Intg<xType,yType>(ig) {cTyp=TRAPEZOID;}
   ~Trap(void) {}

 private:

 // Member Functions

    virtual yType intgMethod(void) throw (IntgErr);
 };

/*****************************************************************************
 Simp CLASS TEMPLATE
 *****************************************************************************/

 template <typename xType, typename yType>
 class Simp:public Intg<xType,yType> {

 // Inherited Member Functions & Data Members

    using Intg<xType,yType>::refine;
    using Intg<xType,yType>::eps;
    using Intg<xType,yType>::nCount;
    using Intg<xType,yType>::cTyp;
    using Intg<xType,yType>::SIMPSON;
    using Intg<xType,yType>::LOOP_CURRENT;
    using Intg<xType,yType>::LOOP_MAXIMUM;

 public:

 // Constructors

    Simp(yType (&rFn)(xType), xType dEps):
    Intg<xType,yType>(rFn,dEps) {cTyp=SIMPSON;}
    Simp(const Simp &si):
    Intg<xType,yType>(si) {}
    Simp(const Intg<xType,yType> &ig):
    Intg<xType,yType>(ig) {cTyp=SIMPSON;}
   ~Simp(void) {}

 private:

 // Member Functions

    virtual yType intgMethod(void) throw (IntgErr);
 };

/*****************************************************************************
 Romb CLASS TEMPLATE
 *****************************************************************************/

 template <typename xType, typename yType>
 class Romb:public Intg<xType,yType> {

 // Inherited Member Functions & Data Members

    using Intg<xType,yType>::refine;
    using Intg<xType,yType>::nogo;
    using Intg<xType,yType>::eps;
    using Intg<xType,yType>::nCount;
    using Intg<xType,yType>::cTyp;
    using Intg<xType,yType>::ROMBERG;
    using Intg<xType,yType>::LOOP_CURRENT;
    using Intg<xType,yType>::LOOP_MAXIMUM;
    using Intg<xType,yType>::LO;
    using Intg<xType,yType>::HI;
    using Intg<xType,yType>::BOUND_CNT;
    using Intg<xType,yType>::memCopy;

 public:

 // Constructors

   ~Romb(void);

    Romb(yType (&rFn)(xType), xType dEps):
    Intg<xType,yType>(rFn,dEps)
       {varInit(); cTyp=ROMBERG; if(!nogo) nogo=varAlloc(nCount[LOOP_MAXIMUM]);}
    Romb(const Romb &ro):
    Intg<xType,yType>(ro)
       {varInit(); if(!nogo) nogo=varAlloc(nCount[LOOP_MAXIMUM]);} 
    Romb(const Intg<xType,yType> &ig):
    Intg<xType,yType>(ig)
       {varInit(); cTyp=ROMBERG; if(!nogo) nogo=varAlloc(nCount[LOOP_MAXIMUM]);} 

    static const int DEF_POL_CNT;

 // Member Functions

    virtual bool setCount(int nMaximum);

 private:

 // Member Functions

    virtual void varInit     (void);
    virtual yType intgMethod (void) throw (IntgErr);

    bool varAlloc (int nLoops);
    void evalPoly (const yType *arY, const double *arX, yType &yIntg, xType &yError);

 // Data Members

    double *romStep;               
    yType  *romIntg;               
    yType  *yDel[Base::BOUND_CNT]; 
 };}

/*****************************************************************************/

 template <typename xType, typename yType>
 const int calc::Romb<xType,yType>::DEF_POL_CNT=5;

/*****************************************************************************
 PREPROCESSOR DIRECTIVES
 *****************************************************************************/

 #endif

/*****************************************************************************
 CLASS TEMPLATE SOURCE
 *****************************************************************************/

 #include "Intg.cpp"
 #include "Trap.cpp"
 #include "Simp.cpp"
 #include "Romb.cpp"

/*****************************************************************************/

---