Vector2DBase.h

Go to the documentation of this file.

#ifndef GeometryVector_Vector2DBase_h
#define GeometryVector_Vector2DBase_h
 
#include "DataFormats/GeometryVector/interface/VectorTag.h"
#include "DataFormats/GeometryVector/interface/PV2DBase.h"
 
template <class T, class FrameTag>
class Vector2DBase : public PV2DBase<T, VectorTag, FrameTag> {
public:
  typedef PV2DBase<T, VectorTag, FrameTag> BaseClass;
  typedef Basic2DVector<T> BasicVectorType;
  typedef typename BaseClass::Polar Polar;
 
  Vector2DBase() {}
 
  template <class U>
  Vector2DBase(const Vector2DBase<U, FrameTag>& p) : BaseClass(p.basicVector()) {}
 
  Vector2DBase(const T& x, const T& y) : BaseClass(x, y) {}
 
  explicit Vector2DBase(const Polar& set) : BaseClass(set) {}
 
  template <class U>
  explicit Vector2DBase(const Basic2DVector<U>& v) : BaseClass(v) {}
 
  Vector2DBase unit() const { return Vector2DBase(this->basicVector().unit()); }
 
  template <class U>
  Vector2DBase& operator+=(const Vector2DBase<U, FrameTag>& v) {
    this->basicVector() += v.basicVector();
    return *this;
  }
 
  template <class U>
  Vector2DBase& operator-=(const Vector2DBase<U, FrameTag>& v) {
    this->basicVector() -= v.basicVector();
    return *this;
  }
 
  Vector2DBase operator-() const { return Vector2DBase(-this->basicVector()); }
 
  Vector2DBase& operator*=(const T& t) {
    this->basicVector() *= t;
    return *this;
  }
 
  Vector2DBase& operator/=(const T& t) {
    this->basicVector() /= t;
    return *this;
  }
 
  template <class U>
  typename PreciseFloatType<T, U>::Type dot(const Vector2DBase<U, FrameTag>& v) const {
    return this->basicVector().dot(v.basicVector());
  }
};
 
template <class T, class U, class FrameTag>
inline Vector2DBase<typename PreciseFloatType<T, U>::Type, FrameTag> operator+(const Vector2DBase<T, FrameTag>& v1,
                                                                               const Vector2DBase<U, FrameTag>& v2) {
  typedef Vector2DBase<typename PreciseFloatType<T, U>::Type, FrameTag> RT;
  return RT(v1.basicVector() + v2.basicVector());
}
 
template <class T, class U, class FrameTag>
inline Vector2DBase<typename PreciseFloatType<T, U>::Type, FrameTag> operator-(const Vector2DBase<T, FrameTag>& v1,
                                                                               const Vector2DBase<U, FrameTag>& v2) {
  typedef Vector2DBase<typename PreciseFloatType<T, U>::Type, FrameTag> RT;
  return RT(v1.basicVector() - v2.basicVector());
}
 
template <class T, class U, class FrameTag>
inline typename PreciseFloatType<T, U>::Type operator*(const Vector2DBase<T, FrameTag>& v1,
                                                       const Vector2DBase<U, FrameTag>& v2) {
  return v1.basicVector() * v2.basicVector();
}
 
template <class T, class FrameTag, class Scalar>
inline Vector2DBase<T, FrameTag> operator*(const Vector2DBase<T, FrameTag>& v, const Scalar& s) {
  return Vector2DBase<T, FrameTag>(v.basicVector() * s);
}
 
template <class T, class FrameTag, class Scalar>
inline Vector2DBase<T, FrameTag> operator*(const Scalar& s, const Vector2DBase<T, FrameTag>& v) {
  return Vector2DBase<T, FrameTag>(v.basicVector() * s);
}
 
template <class T, class FrameTag, class Scalar>
inline Vector2DBase<T, FrameTag> operator/(const Vector2DBase<T, FrameTag>& v, const Scalar& s) {
  return Vector2DBase<T, FrameTag>(v.basicVector() / s);
}
 
#endif  // GeometryVector_Vector2DBase_h