S1m.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 __S1M_H_
#define __S1M_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>


#define MPIm  18000
// #define M2PIm 36000

// inline UCoordmm fmod(UCoordmm a, UCoordmm b){
//  return (UCoordmm)fmod((double)a, (double)b);
// }

inline double cos(UCoordmm a){
 return cos((double)a*M_PI/MPIm);
}

inline double sin(UCoordmm a){
 return sin((double)a*M_PI/MPIm);
}

using namespace std;



class Anglem{
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & theta; 
  }
#endif
  
  UCoordmm theta;
  static const UCoordmm M2PIm=2*MPIm; /*for efficency*/

  UCoordmm norm2Pi(UCoordmm a){
   if (a >= M2PIm){
    a-=M2PIm;
   }
   return a;
  }
  UCoordmm norm2Pi(Coordmm a){
   if (a >= 0){
    return a;
   } else {
    // TEMP not used
//     int b = ((int)a) + M2PIm;
    return (UCoordmm)a;
   }
  }
  UCoordmm norm2Pi(int a){
   a = a%M2PIm;
   if (a < 0){
    a+=M2PIm;
   }
   return a;
  }
  Coordmm normPi(Coordmm a){
   if (a<=-MPIm) {
    a+=MPIm;
    a+=MPIm;
   }
   if (a>MPIm) {
    a-=MPIm;
    a-=MPIm;
   }
   return a;
  }
  Coordmm normPi(UCoordmm a){
   UCoordmm b = norm2Pi(a);
   if (b>MPIm){ // in questo caso b è tra MPIm e M2PIm
    UCoordmm c = b - MPIm; // c è certamente compreso tra 1 e 17999
    return -MPIm + c;
   } else { // in questo caso b è certamente compreso tra 0 e 18000
    return b;
   }
  }
  Coordmm normPi(int a){
   a = norm2Pi(a);
   if (a > MPIm){
    a-=MPIm;
   }
   return a;
  }
 public:
  Anglem() {
   theta = 0;
  };
  Anglem(UCoordmm t) {
   theta = norm2Pi(t);
  };
  Anglem(const Anglem& rhs) {
   theta = norm2Pi(rhs.dCast());
  };
  Anglem& operator=(const Anglem& rhs){
   if (this != &rhs){      // Not necessary in this case but it is useful to don't forget it
    theta = norm2Pi(rhs.dCast());
   }
   return *this;
  }
  Anglem& operator+=(const Anglem& a) {
   theta = norm2Pi( (int)theta + (int)(a.theta) );
   return *this;
  }
  Anglem& operator-=(const Anglem& a) {
   if (theta >= a.theta){
    theta = theta - a.theta;
   } else {
    int th = (int)theta - (int)(a.theta);
    theta = th + M2PIm;
   }
/*   Coordmm myTheta = theta >= other.theta ? theta : theta + 2.0*MPIm;
   theta = norm2Pi(myTheta - other.theta);*/
   return *this;
  }
//  /**compound assignment operator *= */
//   Anglem& operator*=(const Anglem& a) {
//    theta = norm2Pi( (int)theta * (int)(a.theta) );
//    return *this;
//   }
  Anglem& operator*=(const Coordmm& d) {
   theta = norm2Pi( (int)theta*(int)d );
   return *this;
  }
  Anglem& operator*=(const UCoordmm& d) {
   theta = norm2Pi( (int)theta*(int)d );
   return *this;
  }
  Anglem& operator*=(const int& d) {
   theta = norm2Pi( (int)theta * d);
   return *this;
  }
  const Anglem operator+(const Anglem &other) const {
   return Anglem(*this) += other;
  }
  const Anglem operator-(const Anglem &other) const {
   return Anglem(*this) -= other;
  }
//  /** binary arithmetic operator * */
//   const Anglem operator*(const Anglem &other) const {
//    return Anglem(*this) *= other;
//   }
  const Anglem operator*(const Coordmm& d) const {
   return (Anglem(*this) *= d);
  }
  const Anglem operator*(const UCoordmm& d) const {
   return (Anglem(*this) *= d);
  }
  const Anglem operator*(const int& d) const {
   return (Anglem(*this) *= d);
  }
  bool operator==(const Anglem &other) const {
   if( (other.dCast()) == theta) return true;
   else return false;
  }
  bool operator!=(const Anglem &other) const {
   return !(*this == other);
  }
  UCoordmm dCast() const {
   return theta;
  }
  Coordmm dCastPi() {
   return normPi(theta);
  }
  Coordmm dCastDeg() {
   return ((int)theta*180)/MPIm;
  }
  Decimal dCastPiDecimal() {
   return ((Decimal)theta)/100.0;
  }
  
  Coordmm alDiff(const Anglem &other); 
  
  Coordmm ccwDiff(const Anglem &other);
  
  Coordmm cwDiff(const Anglem &other);
  
  bool almostEqual(Anglem A, Coordmm toll);
  
   Anglem mean(const Anglem &other);
  
  Anglem ccwMean(const Anglem &other);
  
  Anglem cwMean(const Anglem &other);
  
  string print();
};



#endif



/* @} */