oldBasic2DVector.h

Go to the documentation of this file.

#ifndef GeometryVector_oldBasic2DVector_h
#define GeometryVector_oldBasic2DVector_h

#include "DataFormats/GeometryVector/interface/Phi.h"
#include "DataFormats/GeometryVector/interface/PreciseFloatType.h"
#include "DataFormats/GeometryVector/interface/CoordinateSets.h"
#if (!defined(IN_DICTBUILD))
#include "DataFormats/Math/interface/SIMDVec.h"
#endif


#include <cmath>
#include <iosfwd>


template < class T> 
class Basic2DVector {
public:
  typedef  Basic2DVector<T> MathVector;

  typedef T    ScalarType;
  typedef Geom::Polar2Cartesian<T>        Polar;

  Basic2DVector() : theX(0), theY(0) {}

  Basic2DVector( const Basic2DVector & p) : 
    theX(p.x()), theY(p.y()) {}

  template <class Other> 
  explicit Basic2DVector( const Other& p) : theX(p.x()), theY(p.y()) {}

  Basic2DVector( const T& x, const T& y) : theX(x), theY(y) {}


#if  defined(USE_EXTVECT)
  // constructor from Vec2 or vec4
  template<typename U>
  Basic2DVector(Vec2<U> const& iv) :
    theX(iv[0]), theY(iv[1]) {}
  template<typename U>
  Basic2DVector(Vec4<U> const& iv) :
    theX(iv.arr[0]), theY(iv.arr[1]) {}
#elif  defined(USE_SSEVECT)
  // constructor from Vec2 or vec4
  template<typename U>
  Basic2DVector(mathSSE::Vec2<U> const& iv) :
    theX(iv.arr[0]), theY(iv.arr[1]) {}
  template<typename U>
  Basic2DVector(mathSSE::Vec4<U> const& iv) :
    theX(iv.arr[0]), theY(iv.arr[1]) {}
#endif  

  T operator[](int i) const { return i==0 ?  theX : theY ;}
  T & operator[](int i) { return i==0 ?  theX : theY ;}

  T x() const { return theX;}

  T y() const { return theY;}

  T mag2() const { return theX*theX + theY*theY;}

  T mag() const  { return std::sqrt( mag2());}

  T r() const    { return mag();}

  T barePhi() const {return std::atan2(theY,theX);}
  Geom::Phi<T> phi() const {return Geom::Phi<T>(atan2(theY,theX));}

  Basic2DVector unit() const {
    T my_mag = mag();
    return my_mag == 0 ? *this : *this / my_mag;
  }

  template <class U> 
  Basic2DVector& operator+= ( const Basic2DVector<U>& p) {
    theX += p.x();
    theY += p.y();
    return *this;
  } 

  template <class U> 
  Basic2DVector& operator-= ( const Basic2DVector<U>& p) {
    theX -= p.x();
    theY -= p.y();
    return *this;
  } 

  Basic2DVector operator-() const { return Basic2DVector(-x(),-y());}

  Basic2DVector& operator*= ( const T& t) {
    theX *= t;
    theY *= t;
    return *this;
  } 

  Basic2DVector& operator/= ( const T& t) {
    theX /= t;
    theY /= t;
    return *this;
  } 

  T dot( const Basic2DVector& v) const { return x()*v.x() + y()*v.y();}

  template <class U> 
  typename PreciseFloatType<T,U>::Type dot( const Basic2DVector<U>& v) const { 
    return x()*v.x() + y()*v.y();
  }



  T cross( const Basic2DVector& v) const { return x()*v.y() - y()*v.x();}

  template <class U> 
  typename PreciseFloatType<T,U>::Type cross( const Basic2DVector<U>& v) const { 
    return x()*v.y() - y()*v.x();
  }


private:
  T theX;
  T theY;
};


namespace geometryDetails {
  std::ostream & print2D(std::ostream& s, double x, double y);

}

template <class T>
inline std::ostream & operator<<( std::ostream& s, const Basic2DVector<T>& v) {
  return geometryDetails::print2D(s, v.x(),v.y());
}


template <class T, class U>
inline Basic2DVector<typename PreciseFloatType<T,U>::Type>
operator+( const Basic2DVector<T>& a, const Basic2DVector<U>& b) {
  typedef Basic2DVector<typename PreciseFloatType<T,U>::Type> RT;
  return RT(a.x()+b.x(), a.y()+b.y());
}

template <class T, class U>
inline Basic2DVector<typename PreciseFloatType<T,U>::Type>
operator-( const Basic2DVector<T>& a, const Basic2DVector<U>& b) {
  typedef Basic2DVector<typename PreciseFloatType<T,U>::Type> RT;
  return RT(a.x()-b.x(), a.y()-b.y());
}




// scalar product of vectors of same precision
template <class T>
inline T operator*( const Basic2DVector<T>& v1, const Basic2DVector<T>& v2) {
  return v1.dot(v2);
}

template <class T, class U>
inline typename PreciseFloatType<T,U>::Type operator*( const Basic2DVector<T>& v1, 
                               const Basic2DVector<U>& v2) {
  return v1.x()*v2.x() + v1.y()*v2.y();
}

template <class T, class Scalar>
inline Basic2DVector<T> operator*( const Basic2DVector<T>& v, const Scalar& s) {
  T t = static_cast<T>(s);
  return Basic2DVector<T>(v.x()*t, v.y()*t);
}

template <class T, class Scalar>
inline Basic2DVector<T> operator*( const Scalar& s, const Basic2DVector<T>& v) {
  T t = static_cast<T>(s);
  return Basic2DVector<T>(v.x()*t, v.y()*t);
}

template <class T, class Scalar>
inline Basic2DVector<T> operator/( const Basic2DVector<T>& v, const Scalar& s) {
  T t = static_cast<T>(s);
  return Basic2DVector<T>(v.x()/t, v.y()/t);
}


typedef Basic2DVector<float> Basic2DVectorF;
typedef Basic2DVector<double> Basic2DVectorD;

#endif // GeometryVector_Basic2DVector_h