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; } 

  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