S1.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



/* @{ */


#ifndef __S1_H_
#define __S1_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <stdio.h>
#include <math.h>
#include <vector>
#include <iostream>
#include <string>
#include <sstream>
#include <sys/time.h>
#include <sys/select.h>
#include <assert.h>

#ifdef FOUND_BOOST_SER
 #include <boost/serialization/vector.hpp>
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
#endif

#include <Types.h>
#include <numTools.h>

using namespace std;

class S1{
 private:
  Decimal _value;   
  Decimal _halfModule; 
  Decimal _module;   
  Decimal normalize(Decimal a) const {
   if (a >= _module || a < 0.0 ){
    a=fmod(a,_module);            //in [-2*_halfModule,2*_halfModule]
    if (a<0.0)      a+=_module;   //in [0,2*_halfModule]
    if (a>=_module) a-=_module;
   }
   return a;
  }
  Decimal zeroCentreNormalize(Decimal a) const {
   if (a > _halfModule || a <= -_halfModule ){
    a=fmod(a,_module);         //in [-2*_halfModule,2*_halfModule]
    if (a<=-_halfModule) a+=_module;
    if (a>_halfModule)  a-=_module;
   }
   return a;
  }
 public:
//   S1() : _value(0.0) { };
  S1(const Decimal& m,const Decimal& t) {
   assert(m>0);
   _module   = m;
   _halfModule = _module/2.0;
   _value   = normalize(t);
  };
  S1(const S1& s){
   _module   = s._module;
   _halfModule = _module/2.0;
   _value    = normalize(s._value);
  };
  S1& operator=(const S1& s) {
   if (this != &s){      // Not necessary in this case but it is useful to don't forget it
    _module   = s._module;
    _halfModule = _module/2.0;
    _value   = normalize(s._value);
   }
   return *this;
  }
  S1& operator+=(const S1& a) {
   _value = normalize(_value + a._value);
   return *this;
  }
  S1& operator-=(const S1& a) {
   _value = normalize(_value - a._value);
   return *this;
  }
  S1& operator*=(const S1& a) {
   _value = normalize(_value * a._value);
   return *this;
  }
  S1 operator+(const S1 &other) const {
   return S1(*this) += other;
  }
  S1 operator-(const S1 &other) const {
   return S1(*this) -= other;
  }
  S1 operator*(const S1 &other) const {
   return S1(*this) *= other;
  }
  bool operator==(const S1 &other) const {
   if( ((Decimal) other ) == _value) return true;
   else return false;
  }
  bool operator!=(const S1 &other) const {
   return !(*this == other);
  }
  operator Decimal() const {
   return _value;
  }
  Decimal alDiff(const S1 &other) const {
   return zeroCentreNormalize(other._value - _value);
  }
  
  string print(int precision=2) const {
   stringstream s;
   s.precision(precision);
   s.setf(ios::fixed,ios::floatfield);
   s << _value;
   return s.str();
  }
};

class Angle{
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & theta; 
  }
#endif
  
  Decimal theta;
  static const Decimal M_2PI; /*for efficency*/
  
  Decimal norm2Pi(Decimal a) const{
   if (a >= M_2PI || a < 0.0 ){
    a=fmod(a,M_2PI);            //in [-2*M_PI,2*M_PI]
    if (a<0.0)      a+=M_2PI;   //in [0,2*M_PI]
    if (a>=M_2PI) a-=M_2PI;
   }
   return a;
  }
  Decimal normPi(Decimal a,int opt=0) const{
   if (a > M_PI || a <= -M_PI ){
    a=fmod(a,M_2PI);         //in [-2*M_PI,2*M_PI]
    
                                if(opt==0) {if (a<=-M_PI) a+=M_2PI;}
                                if(opt==1) {if (a<-M_PI) a+=M_2PI;}
    if (a>M_PI)  a-=M_2PI;
   }
   return a;
  }
  Decimal normMinus2Pi(Decimal a) const {
   if (a >=0.0  || a < -M_2PI ){
    a=fmod(a,M_2PI);            //in [-2*M_PI,2*M_PI]
    if (a<-M_2PI) a+=M_2PI;   //in [0,2*M_PI]
    if (a>=0.0)   a-=M_2PI;
   }
   return a;
  }
 public:
  Angle() {
   theta = 0.0;
  };
  Angle(const Decimal& t) {
   theta = norm2Pi(t);
  };
  Angle(const Angle& rhs) {
   theta = norm2Pi(rhs.dCast2Pi());
  };
  Angle& operator=(const Angle& rhs){
   if (this != &rhs){      // Not necessary in this case but it is useful to don't forget it
    theta = norm2Pi(rhs.dCast2Pi());
   }
   return *this;
  }
  Angle& operator+=(const Angle& a) {
   theta = norm2Pi(theta + a.theta);
   return *this;
  }
  Angle& operator-=(const Angle& other) {
   Decimal myTheta = theta >= other.theta ? theta : theta + 2.0*M_PI;
   theta = norm2Pi(myTheta - other.theta);
   return *this;
  }
  Angle& operator*=(const Angle& a) {
   theta = norm2Pi(theta * a.theta);
   return *this;
  }
  Angle& operator*=(const Decimal& d) {
   theta = norm2Pi(theta * d);
   return *this;
  }
  Angle operator+(const Angle &other) const {
   return Angle(*this) += other;
  }
  Angle operator-(const Angle &other) const {
   return Angle(*this) -= other;
  }
  Angle operator*(const Angle &other) const {
   return Angle(*this) *= other;
  }
  Angle operator*(const Decimal& d) const {
   return (Angle(*this) *= d);
  }
  bool operator==(const Angle &other) const {
   if( (other.dCast2Pi()) == theta) return true;
   else return false;
  }
  bool operator!=(const Angle &other) const {
   return !(*this == other);
  }
  
  Decimal dCast() const {
   return norm2Pi(theta);
  }
  
  Decimal dCast2Pi() const {
   return norm2Pi(theta);
  }
  
  Decimal dCastPi(int opt=0) const {
   if(opt==0) return normPi(theta);
   if(opt==1) return normPi(theta,1);
  }
  Decimal dCastDeg() const {
   return (theta*180.0)/M_PI;
  }
  
  UCoordmm dCastHDeg() const {
   return (UCoordmm)((theta*18000.0)/M_PI);
  }
  Decimal alDiff(const Angle &other) const;
  
  Decimal ccwDiff(const Angle &other) const;
  
  Decimal cwDiff(const Angle &other) const;
  
  bool almostEqual(const Angle& A, const Decimal& toll) const;
  
  Angle nearestMean(const Angle &other, Decimal w1 = 0.5) const;
  
  Angle ccwMean(const Angle &other) const;
  
  Angle cwMean(const Angle &other) const;
  
  string print(int precision=2) const;
};



#endif



/* @} */