global.h

Go to the documentation of this file.

#ifndef ABA_GLOBAL_H
#define ABA_GLOBAL_H

#include "abacus/abacusroot.h"
#include "abacus/ostream.h"
#include "abacus/hash.h"
#include "abacus/string.h"

  class  ABA_GLOBAL :  public ABA_ABACUSROOT  { 
    public:

      ABA_GLOBAL(double eps = 1.0e-4, double machineEps = 1.0e-7,
                 double infinity = 1.0e32);

      virtual ~ABA_GLOBAL();

      friend ostream &operator<<(ostream &out, const ABA_GLOBAL &rhs);

      virtual ABA_OSTREAM& out(int nTab = 0);

      virtual ABA_OSTREAM& err(int nTab = 0);

      double eps() const;

      void eps(double e);

      double machineEps() const;

      void machineEps(double e);

      double infinity() const;

      void infinity(double x);

      bool isInfinity(double x) const;

      bool isMinusInfinity(double x) const;

      bool equal(double x, double y) const;

      bool isInteger(double x) const;

      bool isInteger(double x, double eps) const;

      virtual char enter(istream &in);

      void readParameters(const char *fileName);

      void insertParameter(const char *name, const char *value);

      int  getParameter(const char *name, int &param);
      int  getParameter(const char *name, unsigned int &param); 
      int  getParameter(const char *name, double &param);
      int  getParameter(const char *name, ABA_STRING &param);
      int  getParameter(const char *name, bool &param);
      int  getParameter(const char *name, char &param);

      void  assignParameter(int &param, const char *name, 
                            int minVal, int maxVal);

      void  assignParameter(unsigned &param, const char *name, 
                            unsigned minVal,unsigned maxVal);

      void  assignParameter(double &param, const char *name, 
                            double minVal, double maxVal);

      void  assignParameter(bool &param, const char *name);

      void  assignParameter(ABA_STRING &param, const char *name, 
                            unsigned nFeasible=0, const char *feasible[]=0);
      void  assignParameter(char &param, const char *name, 
                            const char *feasible=0);

      void  assignParameter(int &param, const char *name, 
                            int minVal, int maxVal, int defVal);

      void  assignParameter(unsigned &param, const char *name, 
                            unsigned minVal,unsigned maxVal, unsigned defVal);

      void  assignParameter(double &param, const char *name, 
                            double minVal, double maxVal, double defVal);

      void  assignParameter(bool &param, const char *name, bool defVal);

      void  assignParameter(ABA_STRING &param, const char *name, 
                            unsigned nFeasible, const char *feasible[], 
                            const char *defVal);

      void  assignParameter(char &param, const char *name, 
                            const char *feasible, char defVal);

      int findParameter(const char *name,
                        unsigned nFeasible, const int *feasible);

      int findParameter(const char *name,
                        unsigned nFeasible, const char *feasible[]);

      int findParameter(const char *name,const char *feasible);
                                                        
    private: 

      /*mutable*/ ABA_OSTREAM   out_;

      /*mutable*/ ABA_OSTREAM   err_;

      double eps_;

      double machineEps_;

      double infinity_;

      char  *tab_;
      ABA_HASH<ABA_STRING, ABA_STRING> paramTable_;
      ABA_GLOBAL(const ABA_GLOBAL &rhs);
      const ABA_GLOBAL &operator=(const ABA_GLOBAL &rhs);
  };


inline double ABA_GLOBAL::eps() const
  {
    return eps_;
  }

inline void ABA_GLOBAL::eps(double e)
  {
    eps_ = e;
  }

inline double ABA_GLOBAL::machineEps() const
  {
    return  machineEps_;
  }

inline void ABA_GLOBAL::machineEps(double e)
  {
    machineEps_ = e;
  }

inline double ABA_GLOBAL::infinity() const
  {
    return infinity_;
  }

inline void ABA_GLOBAL::infinity(double x)
  {
    infinity_ = x;
  }

inline bool ABA_GLOBAL::isInfinity(double x) const
  {
#ifdef ABACUS_NO_BOOL
    if (x >= infinity_) return true;
    else                return false;
#else
    return x >= infinity_;
#endif
  }

inline bool ABA_GLOBAL::isMinusInfinity(double x) const
  {
#ifdef ABACUS_NO_BOOL
    if (x <= -infinity_) return true;
    else                 return false;
#else
    return x <= -infinity_;
#endif
  }

inline bool ABA_GLOBAL::equal(double x, double y) const
  {
    if (fabs(x-y) < machineEps_) return true;
    else                         return false;
  }

inline bool ABA_GLOBAL::isInteger(double x) const
  {
    return isInteger(x, machineEps_);
  }


#endif  // ABA_GLOBAL_H

---