---

Phi.h

Go to the documentation of this file.

//===============================================
//                Phi class
//===============================================
//
//  A utility class to implement the cyclic nature
//  of the phi variable in the range  -Pi <-> Pi
// 
//  The constructor uses a double number, which is reduced to
//  the required range by repeated addition or subtraction of 2*Pi
// 
//  The operation in any arithmetic expression involving Phi and
//  double numbers is understood in this way:
//
//  - wherever any double number is used then it is implicitly converted
//    to a Phi as per the constructor. The operation then proceeds exactly
//    as if the expression contained only 
//
// -  The user can add and subtract Phi objects and the result is automatically
//  kept within a cyclic range.
//
//  -The difference between two PHI objects always represents the smallest 
//   angle between them, signed according to whether this is clockwise
//   or anticlockwise.
//
// - Most operations are convertable to use a double arguments where sensible. 
//


#ifndef ___phiutility__
#define ___phiutility__

#include <iostream>
#include <cmath>

class Phi {
  
 private:
  
  double m_val ;
  
  void reduce() {
    while( m_val >  UPPER_LIMIT )  { m_val -= RANGE ; }
    while( m_val <= LOWER_LIMIT  ) { m_val += RANGE ; }
  }
  
  
 public:
  
  static const double UPPER_LIMIT;
  static const double LOWER_LIMIT;
  static const double RANGE;

  // Constructors:
  Phi() { this->m_val = 0. ;  }
  Phi( const double init ) { this->m_val = init ; this->reduce() ; }
  Phi( Phi& src ) { this->m_val = src.m_val ; } 
  
  // Arithmetic:
  
  Phi& operator= ( const Phi& rhs ) { 
    this->m_val = rhs.m_val; 
    return *this; 
  }
  
  Phi& operator+= ( Phi& rhs )  { 
    this->m_val += rhs.m_val ; 
    reduce() ;
    return *this; 
  }
  
  Phi& operator-= ( Phi& in )  { 
    this->m_val -= in.m_val;
    reduce() ;
    return *this; 
  }
  
  Phi operator+ ( Phi& in )  const { 
    Phi result( this->m_val + in.m_val ) ;
    return result ;
  }
  
  Phi operator- ( Phi& in )  const { 
    Phi result(this->m_val - in.m_val ) ;
    return result ;
  }
  
  // boolean 
  bool operator< ( Phi& in ) const { return this->m_val < in.m_val ; }
  bool operator> ( Phi& in ) const { return this->m_val > in.m_val ; }
  
  // Conversions
  operator double() const { return this->m_val ; }
  
};

#endif

---