simplevectors.hpp

Go to the documentation of this file.

 
#ifndef INCLUDE_SVECTORS_SIMPLEVECTORS_HPP_
#define INCLUDE_SVECTORS_SIMPLEVECTORS_HPP_
 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <string>
#include <type_traits>
#include <vector>
 
namespace svector {
enum AngleDir {
  ALPHA, 
  BETA,  
  GAMMA  
};
template <std::size_t D, typename T = double> class Vector {
public:
  // makes sure that type is numeric
  static_assert(std::is_arithmetic<T>::value, "Vector type must be numeric");
 
#ifdef SVECTOR_EXPERIMENTAL_COMPARE
  template <std::size_t D1, std::size_t D2, typename T1, typename T2>
  friend bool operator<(const Vector<D1, T1> &, const Vector<D2, T2> &);
 
  template <std::size_t D1, std::size_t D2, typename T1, typename T2>
  friend bool operator<=(const Vector<D1, T1> &, const Vector<D2, T2> &);
 
  template <std::size_t D1, std::size_t D2, typename T1, typename T2>
  friend bool operator>(const Vector<D1, T1> &, const Vector<D2, T2> &);
 
  template <std::size_t D1, std::size_t D2, typename T1, typename T2>
  friend bool operator>=(const Vector<D1, T1> &, const Vector<D2, T2> &);
#endif
 
  typedef
      typename std::array<T, D>::iterator iterator; 
  typedef typename std::array<T, D>::const_iterator
      const_iterator; 
  typedef typename std::array<T, D>::reverse_iterator
      reverse_iterator; 
  typedef typename std::array<T, D>::const_reverse_iterator
      const_reverse_iterator; 
 
  Vector() { this->m_components.fill(0); }
 
  Vector(const std::initializer_list<T> args) {
    // in case length of args < dimensions
    this->m_components.fill(0);
 
    std::size_t counter = 0;
    for (const auto &num : args) {
      if (counter >= D) {
        break;
      }
 
      this->m_components[counter] = num;
      counter++;
    }
  }
 
  Vector(const Vector<D, T> &other) {
    for (std::size_t i = 0; i < D; i++) {
      this->m_components[i] = other[i];
    }
  }
 
  Vector(Vector<D, T> &&) noexcept = default;
 
  Vector<D, T> &operator=(const Vector<D, T> &other) {
    // check if assigning to self
    if (this == &other) {
      return *this;
    }
 
    for (std::size_t i = 0; i < D; i++) {
      this->m_components[i] = other[i];
    }
 
    return *this;
  }
 
  Vector<D, T> &operator=(Vector<D, T> &&) noexcept = default;
 
  virtual ~Vector() = default;
 
  virtual std::string toString() const {
    std::string str = "<";
    for (std::size_t i = 0; i < D - 1; i++) {
      str += std::to_string(this->m_components[i]);
      str += ", ";
    }
 
    str += std::to_string(this->m_components[D - 1]);
    str += ">";
 
    return str;
  }
 
#ifdef SVECTOR_USE_CLASS_OPERATORS
  Vector<D, T> operator+(const Vector<D, T> &other) const {
    Vector<D, T> tmp;
    for (std::size_t i = 0; i < D; i++) {
      tmp[i] = this->m_components[i] + other[i];
    }
 
    return tmp;
  }
 
  Vector<D, T> operator-(const Vector<D, T> &other) const {
    Vector<D, T> tmp;
    for (std::size_t i = 0; i < D; i++) {
      tmp[i] = this->m_components[i] - other[i];
    }
 
    return tmp;
  }
 
  Vector<D, T> operator*(const T other) const {
    Vector<D, T> tmp;
    for (std::size_t i = 0; i < D; i++) {
      tmp[i] = this->m_components[i] * other;
    }
 
    return tmp;
  }
 
  Vector<D, T> operator/(const T other) const {
    Vector<D, T> tmp;
    for (std::size_t i = 0; i < D; i++) {
      tmp[i] = this->m_components[i] / other;
    }
 
    return tmp;
  }
 
  bool operator==(const Vector<D, T> &other) const {
    for (std::size_t i = 0; i < D; i++) {
      if (this->m_components[i] != other[i]) {
        return false;
      }
    }
 
    return true;
  }
 
  bool operator!=(const Vector<D, T> &other) const {
    return !((*this) == other);
  }
#endif
 
  Vector<D, T> operator-() const {
    Vector<D, T> tmp;
    for (std::size_t i = 0; i < D; i++) {
      tmp[i] = -this->m_components[i];
    }
 
    return tmp;
  }
 
  Vector<D, T> operator+() const {
    Vector<D, T> tmp;
    for (std::size_t i = 0; i < D; i++) {
      tmp[i] = +this->m_components[i];
    }
 
    return tmp;
  }
 
  Vector<D, T> &operator+=(const Vector<D, T> &other) {
    for (std::size_t i = 0; i < D; i++) {
      this->m_components[i] += other[i];
    }
 
    return *this;
  }
 
  Vector<D, T> &operator-=(const Vector<D, T> &other) {
    for (std::size_t i = 0; i < D; i++) {
      this->m_components[i] -= other[i];
    }
 
    return *this;
  }
 
  Vector<D, T> &operator*=(const T other) {
    for (std::size_t i = 0; i < D; i++) {
      this->m_components[i] *= other;
    }
 
    return *this;
  }
 
  Vector<D, T> &operator/=(const T other) {
    for (std::size_t i = 0; i < D; i++) {
      this->m_components[i] /= other;
    }
 
    return *this;
  }
 
  T dot(const Vector<D, T> &other) const {
    T result = 0;
 
    for (std::size_t i = 0; i < D; i++) {
      result += this->m_components[i] * other[i];
    }
 
    return result;
  }
 
  T magn() const {
    T sum_of_squares = 0;
 
    for (const auto &i : this->m_components) {
      sum_of_squares += i * i;
    }
 
    return std::sqrt(sum_of_squares);
  };
 
  Vector<D, T> normalize() const { return (*this) / this->magn(); }
 
  constexpr std::size_t numDimensions() const { return D; }
 
  bool isZero() const { return this->magn() == 0; }
 
  const T &operator[](const std::size_t index) const {
    return this->m_components[index];
  }
 
  T &operator[](const std::size_t index) { return this->m_components[index]; }
 
  const T &at(const std::size_t index) const {
    return this->m_components.at(index);
  }
 
  T &at(const std::size_t index) { return this->m_components.at(index); }
 
  iterator begin() noexcept { return iterator{this->m_components.begin()}; }
 
  const_iterator begin() const noexcept {
    return const_iterator{this->m_components.begin()};
  }
 
  iterator end() noexcept { return iterator{this->m_components.end()}; }
 
  const_iterator end() const noexcept {
    return const_iterator{this->m_components.end()};
  }
 
  reverse_iterator rbegin() noexcept {
    return reverse_iterator{this->m_components.rbegin()};
  }
 
  const_reverse_iterator rbegin() const noexcept {
    return const_reverse_iterator{this->m_components.rbegin()};
  }
 
  reverse_iterator rend() noexcept {
    return reverse_iterator{this->m_components.rend()};
  }
 
  const_reverse_iterator rend() const noexcept {
    return const_reverse_iterator{this->m_components.rend()};
  }
 
protected:
  std::array<T, D> m_components; 
 
#ifdef SVECTOR_EXPERIMENTAL_COMPARE
private:
  template <std::size_t D2, typename T2>
  std::int8_t compare(const Vector<D2, T2> &other) const noexcept {
    std::size_t min_dim = std::min(D, D2);
    std::size_t counter = 0;
 
// to suppress MSVC warning
#ifdef _MSC_VER
    if constexpr (D != D2) {
#else
    if (D != D2) {
#endif
      // check dimensions first
      return D < D2 ? -1 : 1;
    }
 
    // compare one by one
    for (std::size_t i = 0; i < min_dim; i++) {
      if (this->m_components[i] == other[i]) {
        counter++;
      } else if (this->m_components[i] < other[i]) {
        return -1;
      } else {
        return 1;
      }
    }
 
    if (counter != D || counter != D2) {
      return -1;
    }
 
    // means two vectors are equal
    return 0;
  }
#endif
};
 
typedef Vector<2> Vec2_; 
 
class Vector2D : public Vec2_ {
public:
  using Vec2_::Vector;
 
  Vector2D(const double x, const double y) {
    this->m_components[0] = x;
    this->m_components[1] = y;
  }
 
  Vector2D(const Vec2_ &other) {
    this->m_components[0] = other[0];
    this->m_components[1] = other[1];
  }
 
  double x() const { return this->m_components[0]; }
 
  void x(const double &newX) { this->m_components[0] = newX; }
 
  double y() const { return this->m_components[1]; }
 
  void y(const double &newY) { this->m_components[1] = newY; }
 
  double angle() const { return std::atan2(this->y(), this->x()); }
 
  Vector2D rotate(const double ang) const {
    //
    // Rotation matrix:
    //
    // | cos(ang)   -sin(ang) | |x|
    // | sin(ang)    cos(ang) | |y|
    //
 
    const double xPrime = this->x() * std::cos(ang) - this->y() * std::sin(ang);
    const double yPrime = this->x() * std::sin(ang) + this->y() * std::cos(ang);
 
    return Vector2D{xPrime, yPrime};
  }
 
  template <typename T> T componentsAs() const {
    return T{this->x(), this->y()};
  }
};
 
typedef Vector<3> Vec3_; 
 
class Vector3D : public Vec3_ {
public:
  using Vec3_::Vector;
 
  Vector3D(const double x, const double y, const double z) {
    this->m_components[0] = x;
    this->m_components[1] = y;
    this->m_components[2] = z;
  }
 
  Vector3D(const Vec3_ &other) {
    this->m_components[0] = other[0];
    this->m_components[1] = other[1];
    this->m_components[2] = other[2];
  }
 
  double x() const { return this->m_components[0]; }
 
  void x(const double &newX) { this->m_components[0] = newX; }
 
  double y() const { return this->m_components[1]; }
 
  void y(const double &newY) { this->m_components[1] = newY; }
 
  double z() const { return this->m_components[2]; }
 
  void z(const double &newZ) { this->m_components[2] = newZ; }
 
  Vector3D cross(const Vector3D &other) const {
    const double newx = this->y() * other.z() - this->z() * other.y();
    const double newy = this->z() * other.x() - this->x() * other.z();
    const double newz = this->x() * other.y() - this->y() * other.x();
 
    return Vector3D{newx, newy, newz};
  }
 
  template <typename T> T componentsAs() const {
    return T{this->x(), this->y(), this->z()};
  }
 
  template <typename T> T anglesAs() const {
    return T{this->getAlpha(), this->getBeta(), this->getGamma()};
  }
 
  template <AngleDir D> double angle() const {
    switch (D) {
    case ALPHA:
      return this->getAlpha();
    case BETA:
      return this->getBeta();
    default:
      return this->getGamma();
    }
  }
 
  template <AngleDir D> Vector3D rotate(const double &ang) const {
    switch (D) {
    case ALPHA:
      return this->rotateAlpha(ang);
    case BETA:
      return this->rotateBeta(ang);
    default:
      return this->rotateGamma(ang);
    }
  }
 
private:
  double getAlpha() const { return std::acos(this->x() / this->magn()); }
 
  double getBeta() const { return std::acos(this->y() / this->magn()); }
 
  double getGamma() const { return std::acos(this->z() / this->magn()); }
 
  Vector3D rotateAlpha(const double &ang) const {
    const double xPrime = this->x();
    const double yPrime = this->y() * std::cos(ang) - this->z() * std::sin(ang);
    const double zPrime = this->y() * std::sin(ang) + this->z() * std::cos(ang);
 
    return Vector3D{xPrime, yPrime, zPrime};
  }
 
  Vector3D rotateBeta(const double &ang) const {
    const double xPrime = this->x() * std::cos(ang) + this->z() * std::sin(ang);
    const double yPrime = this->y();
    const double zPrime =
        -this->x() * std::sin(ang) + this->z() * std::cos(ang);
 
    return Vector3D{xPrime, yPrime, zPrime};
  }
 
  Vector3D rotateGamma(const double &ang) const {
    const double xPrime = this->x() * std::cos(ang) - this->y() * std::sin(ang);
    const double yPrime = this->x() * std::sin(ang) + this->y() * std::cos(ang);
    const double zPrime = this->z();
 
    return Vector3D{xPrime, yPrime, zPrime};
  }
};
 
template <std::size_t D, typename T>
Vector<D, T> makeVector(std::array<T, D> array) {
  Vector<D, T> vec;
  for (std::size_t i = 0; i < D; i++) {
    vec[i] = array[i];
  }
 
  return vec;
}
 
template <std::size_t D, typename T>
Vector<D, T> makeVector(std::vector<T> vector) {
  Vector<D, T> vec;
  for (std::size_t i = 0; i < std::min(D, vector.size()); i++) {
    vec[i] = vector[i];
  }
 
  return vec;
}
 
template <std::size_t D, typename T>
Vector<D, T> makeVector(const std::initializer_list<T> args) {
  Vector<D, T> vec(args);
  return vec;
}
 
inline double x(const Vector2D &v) { return v[0]; }
 
inline void x(Vector2D &v, const double xValue) { v[0] = xValue; }
 
inline double x(const Vector3D &v) { return v[0]; }
 
inline void x(Vector3D &v, const double xValue) { v[0] = xValue; }
 
inline double y(const Vector2D &v) { return v[1]; }
 
inline void y(Vector2D &v, const double yValue) { v[1] = yValue; }
 
inline double y(const Vector3D &v) { return v[1]; }
 
inline void y(Vector3D &v, const double yValue) { v[1] = yValue; }
 
inline double z(const Vector3D &v) { return v[2]; }
 
inline void z(Vector3D &v, const double zValue) { v[2] = zValue; }
 
template <typename T, std::size_t D>
inline T dot(const Vector<D, T> &lhs, const Vector<D, T> &rhs) {
  T result = 0;
 
  for (std::size_t i = 0; i < D; i++) {
    result += lhs[i] * rhs[i];
  }
 
  return result;
}
 
template <typename T, std::size_t D> inline T magn(const Vector<D, T> &v) {
  T sum_of_squares = 0;
 
  for (std::size_t i = 0; i < D; i++) {
    sum_of_squares += v[i] * v[i];
  }
 
  return std::sqrt(sum_of_squares);
}
 
template <typename T, std::size_t D>
inline Vector<D, T> normalize(const Vector<D, T> &v) {
  return v / magn(v);
}
 
template <typename T, std::size_t D> inline bool isZero(const Vector<D, T> &v) {
  return magn(v) == 0;
}
 
inline double angle(const Vector2D &v) { return std::atan2(y(v), x(v)); }
 
inline Vector2D rotate(const Vector2D &v, const double ang) {
  //
  // Rotation matrix:
  //
  // | cos(ang)   -sin(ang) | |x|
  // | sin(ang)    cos(ang) | |y|
  //
 
  const double xPrime = x(v) * std::cos(ang) - y(v) * std::sin(ang);
  const double yPrime = x(v) * std::sin(ang) + y(v) * std::cos(ang);
 
  return Vector2D{xPrime, yPrime};
}
 
inline Vector3D cross(const Vector3D &lhs, const Vector3D &rhs) {
  const double newx = y(lhs) * z(rhs) - z(lhs) * y(rhs);
  const double newy = z(lhs) * x(rhs) - x(lhs) * z(rhs);
  const double newz = x(lhs) * y(rhs) - y(lhs) * x(rhs);
 
  return Vector3D{newx, newy, newz};
}
 
inline double alpha(const Vector3D &v) { return std::acos(x(v) / magn(v)); }
 
inline double beta(const Vector3D &v) { return std::acos(y(v) / magn(v)); }
 
inline double gamma(const Vector3D &v) { return std::acos(z(v) / magn(v)); }
 
inline Vector3D rotateAlpha(const Vector3D &v, const double &ang) {
  //
  // Rotation matrix:
  //
  // |1   0           0     | |x|
  // |0  cos(ang)  −sin(ang)| |y|
  // |0  sin(ang)   cos(ang)| |z|
  //
 
  const double xPrime = x(v);
  const double yPrime = y(v) * std::cos(ang) - z(v) * std::sin(ang);
  const double zPrime = y(v) * std::sin(ang) + z(v) * std::cos(ang);
 
  return Vector3D{xPrime, yPrime, zPrime};
}
 
inline Vector3D rotateBeta(const Vector3D &v, const double &ang) {
  //
  // Rotation matrix:
  //
  // | cos(ang)  0  sin(ang)| |x|
  // |   0       1      0   | |y|
  // |−sin(ang)  0  cos(ang)| |z|
  //
 
  const double xPrime = x(v) * std::cos(ang) + z(v) * std::sin(ang);
  const double yPrime = y(v);
  const double zPrime = -x(v) * std::sin(ang) + z(v) * std::cos(ang);
 
  return Vector3D{xPrime, yPrime, zPrime};
}
 
inline Vector3D rotateGamma(const Vector3D &v, const double &ang) {
  //
  // Rotation matrix:
  //
  // |cos(ang)  −sin(ang)  0| |x|
  // |sin(ang)  cos(ang)   0| |y|
  // |  0         0        1| |z|
  //
 
  const double xPrime = x(v) * std::cos(ang) - y(v) * std::sin(ang);
  const double yPrime = x(v) * std::sin(ang) + y(v) * std::cos(ang);
  const double zPrime = z(v);
 
  return Vector3D{xPrime, yPrime, zPrime};
}
 
#ifndef SVECTOR_USE_CLASS_OPERATORS
template <typename T, std::size_t D>
inline Vector<D, T> operator+(const Vector<D, T> &lhs,
                              const Vector<D, T> &rhs) {
  Vector<D, T> tmp;
  for (std::size_t i = 0; i < D; i++) {
    tmp[i] = lhs[i] + rhs[i];
  }
 
  return tmp;
}
 
template <typename T, std::size_t D>
inline Vector<D, T> operator-(const Vector<D, T> &lhs,
                              const Vector<D, T> &rhs) {
  Vector<D, T> tmp;
  for (std::size_t i = 0; i < D; i++) {
    tmp[i] = lhs[i] - rhs[i];
  }
 
  return tmp;
}
 
template <typename T, typename T2, std::size_t D>
inline Vector<D, T> operator*(const Vector<D, T> &lhs, const T2 rhs) {
  Vector<D, T> tmp;
  for (std::size_t i = 0; i < D; i++) {
    tmp[i] = lhs[i] * rhs;
  }
 
  return tmp;
}
 
template <typename T, typename T2, std::size_t D>
inline Vector<D, T> operator/(const Vector<D, T> &lhs, const T2 rhs) {
  Vector<D, T> tmp;
  for (std::size_t i = 0; i < D; i++) {
    tmp[i] = lhs[i] / rhs;
  }
 
  return tmp;
}
 
template <typename T, std::size_t D>
inline bool operator==(const Vector<D, T> &lhs, const Vector<D, T> &rhs) {
  for (std::size_t i = 0; i < D; i++) {
    if (lhs[i] != rhs[i]) {
      return false;
    }
  }
 
  return true;
}
 
template <typename T, std::size_t D>
inline bool operator!=(const Vector<D, T> &lhs, const Vector<D, T> &rhs) {
  return !(lhs == rhs);
}
#endif
 
#ifdef SVECTOR_EXPERIMENTAL_COMPARE
template <std::size_t D1, std::size_t D2, typename T1, typename T2>
bool operator<(const Vector<D1, T1> &lhs, const Vector<D2, T2> &rhs) {
  return lhs.compare(rhs) < 0;
}
 
template <std::size_t D1, std::size_t D2, typename T1, typename T2>
bool operator>(const Vector<D1, T1> &lhs, const Vector<D2, T2> &rhs) {
  return lhs.compare(rhs) > 0;
}
 
template <std::size_t D1, std::size_t D2, typename T1, typename T2>
bool operator<=(const Vector<D1, T1> &lhs, const Vector<D2, T2> &rhs) {
  return lhs.compare(rhs) <= 0;
}
 
template <std::size_t D1, std::size_t D2, typename T1, typename T2>
bool operator>=(const Vector<D1, T1> &lhs, const Vector<D2, T2> &rhs) {
  return lhs.compare(rhs) >= 0;
}
#endif
} // namespace svector
 
#endif