V2D.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/V3D.h"
#include <array>
#include <cmath>
#include <iosfwd>
#include <limits>
 
namespace Mantid {
namespace Kernel {
 
class MANTID_KERNEL_DLL V2D {
public:
  inline V2D() noexcept : m_pt{{0.0, 0.0}} {}
  inline V2D(double x, double y) noexcept : m_pt{{x, y}} {}
 
  inline double X() const { return m_pt[0]; }
  inline double Y() const { return m_pt[1]; }
 
  inline double &X() { return m_pt[0]; }
  inline double &Y() { return m_pt[1]; }
 
  inline const double &operator[](const size_t index) const { return m_pt[index]; }
 
  inline V2D operator+(const V2D &rhs) const { return V2D(X() + rhs.X(), Y() + rhs.Y()); }
  inline V2D &operator+=(const V2D &rhs) {
    X() += rhs.X();
    Y() += rhs.Y();
    return *this;
  }
  inline V2D operator-(const V2D &rhs) const { return V2D(X() - rhs.X(), Y() - rhs.Y()); }
  inline V2D &operator-=(const V2D &rhs) {
    X() -= rhs.X();
    Y() -= rhs.Y();
    return *this;
  }
  inline V2D operator*(const double factor) const { return V2D(X() * factor, Y() * factor); }
  V2D &operator*=(const double factor) {
    X() *= factor;
    Y() *= factor;
    return *this;
  }
  inline V2D operator/(const double d) const noexcept { return V2D(X() / d, Y() / d); }
  V2D &operator/=(const double d) {
    X() /= d;
    Y() /= d;
    return *this;
  }
  inline V2D operator-() const noexcept { return V2D{-X(), -Y()}; }
 
 
 
  inline bool operator==(const V2D &rhs) const {
    return (std::fabs(X() - rhs.X()) < std::numeric_limits<double>::epsilon() &&
            std::fabs(Y() - rhs.Y()) < std::numeric_limits<double>::epsilon());
  }
  inline bool operator!=(const V2D &rhs) const { return !(rhs == *this); }
 
  double normalize();
  inline double norm() const { return std::sqrt(norm2()); }
 
  inline double norm2() const { return X() * X() + Y() * Y(); }
 
  inline double scalar_prod(const V2D &other) const { return X() * other.X() + Y() * other.Y(); }
 
  inline V3D cross_prod(const V2D &other) const { return V3D(0.0, 0.0, X() * other.Y() - Y() * other.X()); }
 
  inline double distance(const V2D &other) const { return V2D(X() - other.X(), Y() - other.Y()).norm(); }
 
  // Angle between this and another vector
  double angle(const V2D &other) const;
 
private:
  // X,Y
  std::array<double, 2> m_pt;
};
 
// Overload operator <<
MANTID_KERNEL_DLL std::ostream &operator<<(std::ostream &, const V2D &);
 
} // namespace Kernel
} // namespace Mantid