sseBasic2DVector.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/SSEVec.h"

#include <cmath>
#include <iosfwd>

template <class T>
class Basic2DVector {
public:
  typedef T ScalarType;
  typedef mathSSE::Vec2<T> VectorType;
  typedef mathSSE::Vec2<T> MathVector;
  typedef Geom::Polar2Cartesian<T> Polar;

  Basic2DVector() {}

  Basic2DVector(const Basic2DVector& p) : v(p.v) {}

  Basic2DVector& operator=(const Basic2DVector&) = default;

  template <typename U>
  Basic2DVector(const Basic2DVector<U>& p) : v(p.v) {}

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

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

  // constructor from Vec2 or vec4
  template <typename U>
  Basic2DVector(mathSSE::Vec2<U> const& iv) : v(iv) {}
  template <typename U>
  Basic2DVector(mathSSE::Vec4<U> const& iv) : v(iv.xy()) {}

  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 ::cross(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:
  mathSSE::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