V3R.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidGeometry/Crystal/V3R.h"
namespace Mantid::Geometry {
 
V3R::V3R() : m_x(0), m_y(0), m_z(0) {}
 
V3R::V3R(const RationalNumber &x, const RationalNumber &y, const RationalNumber &z) : m_x(x), m_y(y), m_z(z) {}
 
V3R::V3R(const std::vector<int> &vector) {
  if (vector.size() != 3) {
    throw Kernel::Exception::MisMatch<size_t>(vector.size(), 3, "V3R(const std::vector<int> &vector)");
  }
 
  m_x = vector[0];
  m_y = vector[1];
  m_z = vector[2];
}
 
const RationalNumber &V3R::x() const { return m_x; }
 
void V3R::setX(const RationalNumber &newX) { m_x = newX; }
 
const RationalNumber &V3R::y() const { return m_y; }
 
void V3R::setY(const RationalNumber &newY) { m_y = newY; }
 
const RationalNumber &V3R::z() const { return m_z; }
 
void V3R::setZ(const RationalNumber &newZ) { m_z = newZ; }
 
RationalNumber &V3R::operator[](size_t index) {
  switch (index) {
  case 0:
    return m_x;
  case 1:
    return m_y;
  case 2:
    return m_z;
  default:
    throw Kernel::Exception::IndexError(index, 2, "V3R::operator [] index out of range.");
  }
}
 
const RationalNumber &V3R::operator[](size_t index) const {
  switch (index) {
  case 0:
    return m_x;
  case 1:
    return m_y;
  case 2:
    return m_z;
  default:
    throw Kernel::Exception::IndexError(index, 2, "V3R::operator [] index out of range.");
  }
}
 
// Operations with other vectors
V3R V3R::operator+(const V3R &other) const {
  V3R result(*this);
  return result += other;
}
 
V3R &V3R::operator+=(const V3R &other) {
  m_x += other.m_x;
  m_y += other.m_y;
  m_z += other.m_z;
 
  return *this;
}
 
V3R V3R::operator-() const { return V3R(-m_x, -m_y, -m_z); }
 
V3R V3R::operator-(const V3R &other) const {
  V3R result(*this);
  return result -= other;
}
 
V3R &V3R::operator-=(const V3R &other) {
  m_x -= other.m_x;
  m_y -= other.m_y;
  m_z -= other.m_z;
 
  return *this;
}
 
// Operations with int
V3R V3R::operator+(int other) const {
  V3R result(*this);
  return result += other;
}
 
V3R &V3R::operator+=(int other) {
  m_x += other;
  m_y += other;
  m_z += other;
 
  return *this;
}
 
V3R V3R::operator-(int other) const {
  V3R result(*this);
  return result -= other;
}
 
V3R &V3R::operator-=(int other) {
  m_x -= other;
  m_y -= other;
  m_z -= other;
 
  return *this;
}
 
V3R V3R::operator*(int other) const {
  V3R result(*this);
  return result *= other;
}
 
V3R &V3R::operator*=(int other) {
  m_x *= other;
  m_y *= other;
  m_z *= other;
 
  return *this;
}
 
V3R V3R::operator/(int other) const {
  V3R result(*this);
  return result /= other;
}
 
V3R &V3R::operator/=(int other) {
  m_x /= other;
  m_y /= other;
  m_z /= other;
 
  return *this;
}
 
// Operations with rational numbers
V3R V3R::operator+(const RationalNumber &other) const {
  V3R result(*this);
  return result += other;
}
 
V3R &V3R::operator+=(const RationalNumber &other) {
  m_x += other;
  m_y += other;
  m_z += other;
 
  return *this;
}
 
V3R V3R::operator-(const RationalNumber &other) const {
  V3R result(*this);
  return result -= other;
}
 
V3R &V3R::operator-=(const RationalNumber &other) {
  m_x -= other;
  m_y -= other;
  m_z -= other;
 
  return *this;
}
 
V3R V3R::operator*(const RationalNumber &other) const {
  V3R result(*this);
  return result *= other;
}
 
V3R &V3R::operator*=(const RationalNumber &other) {
  m_x *= other;
  m_y *= other;
  m_z *= other;
 
  return *this;
}
 
V3R V3R::operator/(const RationalNumber &other) const {
  V3R result(*this);
  return result /= other;
}
 
V3R &V3R::operator/=(const RationalNumber &other) {
  m_x /= other;
  m_y /= other;
  m_z /= other;
 
  return *this;
}
 
V3R::operator Kernel::V3D() const {
  return Kernel::V3D(boost::rational_cast<double>(m_x), boost::rational_cast<double>(m_y),
                     boost::rational_cast<double>(m_z));
}
 
Kernel::V3D V3R::operator+(const Kernel::V3D &other) const { return other + static_cast<Kernel::V3D>(*this); }
 
Kernel::V3D V3R::operator-(const Kernel::V3D &other) const { return static_cast<Kernel::V3D>(*this) - other; }
 
bool V3R::operator==(const V3R &other) const { return m_x == other.m_x && m_y == other.m_y && m_z == other.m_z; }
 
bool V3R::operator!=(const V3R &other) const { return !(this->operator==(other)); }
 
bool V3R::operator<(const V3R &other) const {
  if (m_x != other.m_x) {
    return m_x < other.m_x;
  }
 
  if (m_y != other.m_y) {
    return m_y < other.m_y;
  }
 
  return m_z < other.m_z;
}
 
bool V3R::operator==(int other) const { return m_x == other && m_y == other && m_z == other; }
 
bool V3R::operator!=(int other) const { return !(this->operator==(other)); }
 
V3R V3R::getPositiveVector() const { return V3R(boost::abs(m_x), boost::abs(m_y), boost::abs(m_z)); }
 
V3R::operator std::vector<double>() const {
  std::vector<double> vector;
  vector.emplace_back(boost::rational_cast<double>(m_x));
  vector.emplace_back(boost::rational_cast<double>(m_y));
  vector.emplace_back(boost::rational_cast<double>(m_z));
 
  return vector;
}
 
} // namespace Mantid::Geometry