OptIntp.h

Go to the documentation of this file.

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

 #ifndef CALC_OPTINTP_H
 #define CALC_OPTINTP_H

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

 #include <cstdlib>
 #include <iomanip>

 #include "Base.h"
 #include "NIntp.h"

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

 namespace calc {

/*****************************************************************************
 OptIntp CLASS TEMPLATE
 *****************************************************************************/


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

 public:

 // Enumerations

    enum VTYPE {
       GRID_AVG=0,    
       GRID_DEV,      
       GRID_MAX,      
       RANDOM_AVG,    
       RANDOM_DEV,    
       RANDOM_MAX,    
       VTYPE_CNT,     
    };

    enum PTYPE {
       GRID_SAMPLE=0,    
       RANDOM_COUNT,     
       RANDOM_SEED,      
       LOOP_MAXIMUM,     
       PTYPE_CNT,        
    };

 // Constructors

    OptIntp(yType (&rFn)(const xType*), NIntp<xType,yType> &ni);
    OptIntp(const OptIntp<xType,yType> &ei);
   ~OptIntp(void);

 // Member Functions

    yType   evalBasis      (const xType *vXn) const throw (IntpErr);
    yType   evalTable      (const xType *vXn) throw (IntpErr);
    bool    gridError      (xType **yErr=(xType**)(0));
    bool    randomError    (void);
    bool    update         (const xType *const *arXn=(xType**)(0), const yType *arYn=(yType*)(0));
    bool    setBasis       (yType (&rFn)(const xType*));
    bool    setParameter   (enum OptIntp<xType,yType>::PTYPE pType, int param);
    bool    setPrintStatus (bool flag);

    bool    optimize       (xType xTol, xType yTol);
    bool    optimize       (const xType *xTol, xType yTol);

    xType getError(enum OptIntp<xType,yType>::VTYPE vType) const
      {return ((vType>=0)&&(vType<VTYPE_CNT)?yErrVal[vType]:(xType)(-1));}
    int getParameter(enum OptIntp<xType,yType>::PTYPE pType) const
      {return ((pType>=0)&&(pType<PTYPE_CNT)?errParam[pType]:-1);}
    NIntp<xType,yType> *getNIntp(void) {return np;}
    yType (*getBasis(void))(const xType*) {return pFn;}
    bool getPrintStatus(void) const {return bPrg;}

    template <typename bType>
    static bool setSpanX (bType **arXn, bType vXLo, bType vXHi,
                   const int *arNn, int nDimen);
    template <typename bType>
    static bool setSpanX (bType **arXn, const bType *arXLo, const bType *arXHi,
                   const int *arNn, int nDimen);

    static const int DEF_GRID_SAMPLE;
    static const int DEF_RANDOM_COUNT;
    static const int DEF_RANDOM_SEED;
    static const int DEF_LOOP_MAX;

 private:

 // Member Functions

    static xType optIntvl (xType x, xType xEps);

    virtual void varInit (void);

    bool   varAlloc   (int nDimen);
    xType  errorPoint (void) throw (IntpErr);

    bool   optFactors  (xType **cDat, xType **yErr, xType *avErr, xType yEps);
    void   optEvalM1   (const xType *const *pXn, yType *pYn, int iDat, int iDim);
    void   optCopyM1   (const yType *aYn, yType *pYn, int iDat, int iDim);

    int iLocateX(int iDimen, int iDataY) const
       {return (iDataY/nItv[iDimen])%np->getArrayN(np->DIMENSION)[iDimen];}
    int iLocateDY(int iDimen, int iDataX) const {return iDataX*nItv[iDimen];}

 // Data Members

    yType   (*pFn)(const xType*);       
    NIntp<xType,yType>  *np;            
    xType    xTstCnt;                   
    xType    xVolSum;                   
    xType    yErrVal[VTYPE_CNT];        
    xType   *xVol;                      
    xType   *frac[Base::BOUND_CNT];     
    xType  **xTst;                      
    xType   *xVec;                      
    int     *mItv;                      
    int     *nItv;                      
    int     *tItv;                      
    int     *iVec;                      
    int      errParam[PTYPE_CNT];       
    int      nDim;                      
    int      nTst;                      
    int      mCnt;                      
    bool     bPrg;                      
 };}

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

 template <typename xType, typename yType>
 const int calc::OptIntp<xType,yType>::DEF_GRID_SAMPLE =1;
 template <typename xType, typename yType>
 const int calc::OptIntp<xType,yType>::DEF_RANDOM_COUNT=2000;
 template <typename xType, typename yType>
 const int calc::OptIntp<xType,yType>::DEF_RANDOM_SEED =1;
 template <typename xType, typename yType>
 const int calc::OptIntp<xType,yType>::DEF_LOOP_MAX=1000;

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

 #endif

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

 #include "OptIntp.cpp"

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

---