Vector.hpp

//
// Definition of iSeeML::geom::Vector, class of ISeeML' 2D geometric 
// vectors.
//

// For Borland C++
#ifdef __BORLANDC__
#pragma warn -8022  // to remove some stupid warnings
#endif

// To only include this definition once
#ifndef ISEEML_GEOM_VECTOR_HH
#define ISEEML_GEOM_VECTOR_HH


// This class needs the definition of iSeeML::geom::BasicObject. 
#include <iSeeML/geom/BasicObject.hpp>


class iSeeML::geom::Vector : public iSeeML::geom::BasicObject {
  // === Object's Fields ==========================================

  double XCoord;   
  double YCoord;   

public:
  static const string ClassName; 


  // === Constructors and Destructors =============================

  Vector() : XCoord(0), YCoord(0) {}

  Vector(const double& theta) :
    XCoord( cos(theta) ), YCoord( sin(theta) ) {} 

  Vector(const double& x, const double& y) : 
    XCoord(x), YCoord(y) {}

  // The default copy constructor is OK. 


  // === Description Methods ======================================

  iSeeML::Object& clone() const 
  { return *( (iSeeML::Object*) (new Vector(*this)) ); } 


  void writeTo(ostream& O) const { algWriteTo(O); } 


  const double& xCoord() const { return XCoord; } 

  const double& yCoord() const { return YCoord; } 


  double orientation() const 
  { return
      // if XCoord is positive, direct computation using atan
      ( isPositive(XCoord) ? atan(YCoord / XCoord) : 
    // if XCoord is negative, atan value is corrected 
    // wrt YCoord precise sign 
    isNegative(XCoord) ? ( YCoord < 0 ? 
                   atan(YCoord / XCoord) - M_PI : 
                   atan(YCoord / XCoord) + M_PI ) : 
    // if XCoord is zero, result can be 0 or +/- pi / 2
    sign(YCoord) * M_PI_2 ); }
        
  double length() const    { return sqrt(sqrLength()); }

  double sqrLength() const { return( (*this) * (*this) ); }

protected:
  int algDimension() const { return 2; } 

  double algCoord(const int i) const { 
    switch (i) {  case 1 : return xCoord(); 
    case 2 : return yCoord();  default: 
#ifdef ISEEML_CHECK_GEOM_VECT_PRECOND
      cerr << ClassName << "::coord: parameter " << i << endl
       << " outside allowed values (1 or 2), returning zero..." 
       << endl; 
#endif
      return 0; } } 

public:
  // === Modification Methods =====================================

  Vector& moveTo(const double& x, const double& y) 
  { XCoord = x;  YCoord = y;  return *this; } 

  Vector& translate(const Vector& v) { return( add(v) ); } 


  Vector& rotate(const double& theta) { 
    const double x = XCoord, y = YCoord, 
      ct = cos(theta), st = sin(theta); 
    XCoord = x * ct - y * st; YCoord = x * st + y * ct; 
    return *this; } 


  Vector& add(const Vector& v) 
  { XCoord += v.xCoord();  YCoord += v.yCoord();  return *this; } 


  Vector& multiply(const double& f) 
  { XCoord *= f;  YCoord *= f;  return *this; } 

  Vector& divide(const double& f) { 
#ifdef ISEEML_CHECK_GEOM_VECT_PRECOND
    if ( isZero(f) ) 
      cerr << ClassName << "::divide: zero factor!!!" << endl; 
#endif
    return multiply(1 / f); } 


  Vector& symmetryOx() { YCoord *= -1; return *this; } 

  Vector& symmetryOy() { XCoord *= -1; return *this; } 


  // === Operators ================================================

  bool operator==(const Vector& other) const 
  { return( isZero( xCoord() - other.xCoord() ) &&
        isZero( yCoord() - other.yCoord() ) ); } 


  Vector operator+(const Vector& v) const
  { Vector res(*this); return res.add(v); } 

  Vector operator-(const Vector& v) const
  { return( *this + (-v) ); } 


  Vector operator-() const
  { Vector res(*this); return( res.multiply(-1) ); } 


  Vector operator*(const double& f) const
  { Vector res(*this); return res.multiply(f); } 

  friend Vector operator*(const double& f, const Vector& v) 
  { return(v * f); } 

  Vector operator/(const double& f) const
  { Vector res(*this); return res.divide(f); } 

  friend Vector operator/(const double& f, const Vector& v) 
  { return(v / f); } 


  double operator*(const Vector& v) const
  { return( xCoord() * v.xCoord() + yCoord() * v.yCoord() ); }

  double operator^(const Vector& v) const
  { return( xCoord() * v.yCoord() - yCoord() * v.xCoord() ); }


  // === Various Methods ==========================================

  static double FresnelCos(const double& s) 
  { return( FresnelInt(s).xCoord() ); } 

  static double FresnelSin(const double& s) 
  { return( FresnelInt(s).yCoord() ); } 

  static Vector FresnelInt(const double& s); 

}; // end of class iSeeML::geom::Vector

#endif  // end of definition