Object.hpp

// 
// Definition of iSeeML::Object, superclass of every other ISeeML 
// objects' class. 
//
 
 
// To only include this definition once
#ifndef ISEEML_OBJECT_HH
#define ISEEML_OBJECT_HH
 
 
// === Inclusion of standart definitions ===
// Some classes need the definition of input/output streams.
#include <iostream>
using namespace std;  // to avoid writing std::...
// Some classes need the definition of strings.
#include <string>
// Some classes need the definition of mathematical functions.
#define _USE_MATH_DEFINES
#include <math.h>
// === Inclusion of iSeeML' definitions ===
// Definition of relations between ISeeML compilation flags.
#include <iSeeML/CompilerFlags.h>
// Definition of ISeeML' namespaces.
#include <iSeeML/NameSpaces.hpp>
 
 
class iSeeML::Object {
  // === Object's Fields ==========================================
 
  static const double smallDouble; 
 
  static const string ClassName; 
 
public:
  // === Constructors and Destructors =============================
 
  virtual ~Object() {} 
 
 
  // === Description Methods ======================================
 
  virtual const string className() const { return ClassName; } 
 
 
  virtual iSeeML::Object& clone() const = 0; 
 
 
  virtual void writeTo(ostream& O) const = 0; 
 
protected:
  virtual int algDimension() const { return 0; } 
 
  virtual double algCoord(const int) const { 
#ifdef ISEEML_CHECK_OBJECT_PRECOND
    cerr << ClassName << "::algCoord: empty algebraic vector," 
     << endl << " returning zero..." << endl; 
#endif
    return 0; } 
 
  virtual void algWriteTo(ostream& O) const { 
    int i; O << '('; for(i = 1; i <= algDimension(); i++)  
      O << algCoord(i) << (i == algDimension() ? ")" : ", "); } 
 
  // === Modification Methods =====================================
 
  // === Operators ================================================
 
public:
  // === Various Methods ==========================================
 
  bool sameClass(const iSeeML::Object& other) 
  { return( className() == other.className() ); }
 
 
  template <class T>
  static const T& min(const T& a, const T& b) 
  { return( a < b ? a : b ); } 
 
  template <class T>
  static const T& max(const T& a, const T& b) 
  { return( a > b ? a : b ); } 
 
 
  static double sqr(const double& x)  { return( x * x ); } 
 
 
  static double mod2pi(const double& theta) { 
    double res = theta; const double PIx2 = 2 * M_PI; 
    while  (res > M_PI)
      res -= PIx2; 
    while (res <= - M_PI)
      res += PIx2;
    return res;
  } // end of static double mod2pi(const double&)
 
  static double rad2deg(const double& theta) 
  { return theta * 180 / M_PI; } 
 
  static double deg2rad(const double& theta) 
  { return theta * M_PI / 180; } 
 
 
  static bool isPositive(const double& x) 
  { return( x > smallDouble ); } 
 
  static bool isNegative(const double& x) 
  { return( isPositive(- x) ); } 
 
  static bool isZero(const double& x) 
  { return( fabs(x) < smallDouble ); } 
 
 
  static int sign(const double& x) 
  { return( isZero(x) ? 0 : ( x < 0 ? -1 : 1) ); } 
 
}; // end of class iSeeML::Object
 
 
inline ostream& operator<<(ostream& O, const iSeeML::Object& o) 
{ o.writeTo(O); return O; } 
 
 
#endif  // end of definition