extBasic2DVector.h

Go to the documentation of this file.

#ifndef GeometryVector_newBasic2DVector_h
#define GeometryVector_newBasic2DVector_h
 
#include "DataFormats/GeometryVector/interface/Phi.h"
#include "DataFormats/GeometryVector/interface/PreciseFloatType.h"
#include "DataFormats/GeometryVector/interface/CoordinateSets.h"
#include "DataFormats/Math/interface/ExtVec.h"
 
 
#include <cmath>
#include <iosfwd>
 
 
template < class T> 
class Basic2DVector {
public:
 
  typedef T    ScalarType;
  typedef Vec2<T> VectorType;
  typedef Vec2<T> MathVector;
  typedef Geom::Polar2Cartesian<T>        Polar;
 
  Basic2DVector() : v{0,0} {}
 
  Basic2DVector( const Basic2DVector & p) : v(p.v) {}
 
  template<typename U>
  Basic2DVector( const Basic2DVector<U> & p) : v{T(p.v[0]),T(p.v[1])} {}
 
 
  template <class Other> 
  explicit Basic2DVector( const Other& p) : v{T(p.x()),T(p.y())} {}
 
  Basic2DVector( const T& x, const T& y) : v{x,y} {}
 
  // constructor from Vec2 or vec4
  Basic2DVector(MathVector const& iv) : v(iv){}
  template<typename U>
  Basic2DVector(Vec2<U> const& iv) : v{iv[0],iv[1]}{}
  template<typename U>
  Basic2DVector(Vec4<U> const& iv) : v{iv[0],iv[1]}{}
 
  MathVector const & mathVector() const { return v;}
  MathVector & mathVector() { return v;}
 
  T operator[](int i) const { return v[i];}
  T & operator[](int i) { return v[i];}
 
 
  T x() const { return v[0];}
 
  T y() const { return v[1];}
 
  T mag2() const { return ::dot(v,v);}
 
  T mag() const  { return std::sqrt( mag2());}
 
  T r() const    { return mag();}
 
  T barePhi() const {return std::atan2(y(),x());}
  Geom::Phi<T> phi() const {return Geom::Phi<T>(atan2(y(),x()));}
 
  Basic2DVector unit() const {
    T my_mag = mag();
    return my_mag == 0 ? *this : *this / my_mag;
  }
 
  template <class U> 
  Basic2DVector& operator+= ( const Basic2DVector<U>& p) {
    v = v + p.v;
    return *this;
  } 
 
  template <class U> 
  Basic2DVector& operator-= ( const Basic2DVector<U>& p) {
    v = v - p.v;
    return *this;
  } 
 
  Basic2DVector operator-() const { return Basic2DVector(-v);}
 
  Basic2DVector& operator*= ( T t) {
    v = v*t;
    return *this;
  } 
 
  Basic2DVector& operator/= ( T t) {
    t = T(1)/t;
    v = v*t;
    return *this;
  } 
 
  T dot( const Basic2DVector& lh) const { return ::dot(v,lh.v);}
 
  template <class U> 
  typename PreciseFloatType<T,U>::Type dot( const Basic2DVector<U>& lh) const { 
    return Basic2DVector<typename PreciseFloatType<T,U>::Type>(*this)
      .dot(Basic2DVector<typename PreciseFloatType<T,U>::Type>(lh));
  }
 
  T cross( const Basic2DVector& lh) const { return ::cross2(v,lh.v);}
 
  template <class U> 
  typename PreciseFloatType<T,U>::Type cross( const Basic2DVector<U>& lh) const { 
    return Basic2DVector<typename PreciseFloatType<T,U>::Type>(*this)
      .cross(Basic2DVector<typename PreciseFloatType<T,U>::Type>(lh));
  }
 
 
public:
 
  Vec2<T> v;
 
};
 
 
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>
inline Basic2DVector<T>
operator+( const Basic2DVector<T>& a, const Basic2DVector<T>& b) {
  return a.v+b.v;
}
template <class T>
inline Basic2DVector<T>
operator-( const Basic2DVector<T>& a, const Basic2DVector<T>& b) {
  return a.v-b.v;
}
 
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) + RT(b);
}
 
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)-RT(b);
}
 
 
 
 
// 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.dot(v2);
}
 
 
template <class T>
inline Basic2DVector<T> operator*( const Basic2DVector<T>& v, T t) {
  return v.v*t;
}
 
template <class T>
inline Basic2DVector<T> operator*(T t, const Basic2DVector<T>& v) {
  return v.v*t;
}
 
 
 
template <class T, class Scalar>
inline Basic2DVector<T> operator*( const Basic2DVector<T>& v, const Scalar& s) {
  T t = static_cast<T>(s);
  return v*t;
}
 
template <class T, class Scalar>
inline Basic2DVector<T> operator*( const Scalar& s, const Basic2DVector<T>& v) {
  T t = static_cast<T>(s);
  return v*t;
}
 
template <class T>
inline Basic2DVector<T> operator/(const Basic2DVector<T>& v, T t) {
  return v.v/t;
}
 
template <class T, class Scalar>
inline Basic2DVector<T> operator/( const Basic2DVector<T>& v, const Scalar& s) {
  //   T t = static_cast<T>(Scalar(1)/s); return v*t;
   T t = static_cast<T>(s);
  return v/t;
}
 
typedef Basic2DVector<float> Basic2DVectorF;
typedef Basic2DVector<double> Basic2DVectorD;
 
 
#endif // GeometryVector_Basic2DVector_h