embed.hpp

Go to the documentation of this file.

 
#ifndef INCLUDE_SVECTOR_EMBED_HPP_
#define INCLUDE_SVECTOR_EMBED_HPP_
 
#include <cmath>  // std::acos, std::atan2, std::cos, std::sin, std::sqrt
#include <string> // std::string
 
namespace svector {
struct Vec2D {
  Vec2D() : x{0}, y{0} {};
 
  Vec2D(const double xOther, const double yOther) : x{xOther}, y{yOther} {}
 
  Vec2D(const Vec2D &other) = default;
 
  Vec2D(Vec2D &&) noexcept = default;
 
  Vec2D &operator=(const Vec2D &other) {
    // check if assigning to self
    if (this == &other) {
      return *this;
    }
 
    x = other.x;
    y = other.y;
    return *this;
  }
 
  Vec2D &operator=(Vec2D &&) noexcept = default;
 
  virtual ~Vec2D() = default;
 
  Vec2D &operator+=(const Vec2D &other) {
    x += other.x;
    y += other.y;
    return *this;
  }
 
  Vec2D &operator-=(const Vec2D &other) {
    x -= other.x;
    y -= other.y;
    return *this;
  }
 
  Vec2D &operator*=(const double &other) {
    x *= other;
    y *= other;
    return *this;
  }
 
  Vec2D &operator/=(const double &other) {
    x /= other;
    y /= other;
    return *this;
  }
 
  double x; 
  double y; 
};
 
struct Vec3D {
  Vec3D() : x{0}, y{0}, z{0} {}
 
  Vec3D(const double xOther, const double yOther, const double zOther)
      : x{xOther}, y{yOther}, z{zOther} {}
 
  Vec3D(const Vec3D &other) = default;
 
  Vec3D(Vec3D &&) noexcept = default;
 
  Vec3D &operator=(const Vec3D &other) {
    // check if assigning to self
    if (this == &other) {
      return *this;
    }
 
    x = other.x;
    y = other.y;
    z = other.z;
    return *this;
  }
 
  Vec3D &operator=(Vec3D &&) noexcept = default;
 
  virtual ~Vec3D() = default;
 
  Vec3D &operator+=(const Vec3D &other) {
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
  }
 
  Vec3D &operator-=(const Vec3D &other) {
    x -= other.x;
    y -= other.y;
    z -= other.z;
    return *this;
  }
 
  Vec3D &operator*=(const double &other) {
    x *= other;
    y *= other;
    z *= other;
    return *this;
  }
 
  Vec3D &operator/=(const double &other) {
    x /= other;
    y /= other;
    z /= other;
    return *this;
  }
 
  double x; 
  double y; 
  double z; 
};
 
inline double x(const Vec2D &v) { return v.x; }
 
inline void x(Vec2D &v, const double xValue) { v.x = xValue; }
 
inline double x(const Vec3D &v) { return v.x; }
 
inline void x(Vec3D &v, const double xValue) { v.x = xValue; }
 
inline double y(const Vec2D &v) { return v.y; }
 
inline void y(Vec2D &v, const double yValue) { v.y = yValue; }
 
inline double y(const Vec3D &v) { return v.y; }
 
inline void y(Vec3D &v, const double yValue) { v.y = yValue; }
 
inline double z(const Vec3D &v) { return v.z; }
 
inline void z(Vec3D &v, const double zValue) { v.z = zValue; }
 
inline std::string toString(const Vec2D &vec) {
  std::string s{"<"};
  s = s + std::to_string(vec.x) + ", " + std::to_string(vec.y) + ">";
  return s;
}
 
inline Vec2D operator+(const Vec2D &lhs, const Vec2D &rhs) {
  return Vec2D{lhs.x + rhs.x, lhs.y + rhs.y};
}
 
inline Vec2D operator-(const Vec2D &lhs, const Vec2D &rhs) {
  return Vec2D{lhs.x - rhs.x, lhs.y - rhs.y};
}
 
inline Vec2D operator-(const Vec2D &vec) { return Vec2D{-vec.x, -vec.y}; }
 
inline Vec2D operator+(const Vec2D &vec) { return Vec2D{+vec.x, +vec.y}; }
 
inline Vec2D operator*(const Vec2D &lhs, const double rhs) {
  return Vec2D{lhs.x * rhs, lhs.y * rhs};
}
 
inline Vec2D operator/(const Vec2D &lhs, const double rhs) {
  return Vec2D{lhs.x / rhs, lhs.y / rhs};
}
 
inline bool operator==(const Vec2D &lhs, const Vec2D &rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y;
}
 
inline bool operator!=(const Vec2D &lhs, const Vec2D &rhs) {
  return !(lhs == rhs);
}
 
inline double dot(const Vec2D &lhs, const Vec2D &rhs) {
  return lhs.x * rhs.x + lhs.y * rhs.y;
}
 
inline double magn(const Vec2D &vec) {
  return std::sqrt(vec.x * vec.x + vec.y * vec.y);
}
 
inline double angle(const Vec2D &vec) { return std::atan2(vec.y, vec.x); }
 
inline Vec2D normalize(const Vec2D &vec) { return vec / magn(vec); }
 
inline bool isZero(const Vec2D &vec) { return magn(vec) == 0; }
 
inline Vec2D rotate(const Vec2D &vec, const double ang) {
  //
  // Rotation matrix:
  //
  // | cos(ang)   -sin(ang) | |x|
  // | sin(ang)    cos(ang) | |y|
  //
 
  const double xPrime = vec.x * std::cos(ang) - vec.y * std::sin(ang);
  const double yPrime = vec.x * std::sin(ang) + vec.y * std::cos(ang);
 
  return Vec2D{xPrime, yPrime};
}
 
inline std::string toString(const Vec3D &vec) {
  std::string s{"<"};
  s = s + std::to_string(vec.x) + ", " + std::to_string(vec.y) + ", " +
      std::to_string(vec.z) + ">";
  return s;
}
 
inline Vec3D operator+(const Vec3D &lhs, const Vec3D &rhs) {
  return Vec3D{lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z};
}
 
inline Vec3D operator-(const Vec3D &lhs, const Vec3D &rhs) {
  return Vec3D{lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z};
}
 
inline Vec3D operator-(const Vec3D &vec) {
  return Vec3D{-vec.x, -vec.y, -vec.z};
}
 
inline Vec3D operator+(const Vec3D &vec) {
  return Vec3D{+vec.x, +vec.y, +vec.z};
}
 
inline Vec3D operator*(const Vec3D &lhs, const double rhs) {
  return Vec3D{lhs.x * rhs, lhs.y * rhs, lhs.z * rhs};
}
 
inline Vec3D operator/(const Vec3D &lhs, const double rhs) {
  return Vec3D{lhs.x / rhs, lhs.y / rhs, lhs.z / rhs};
}
 
inline bool operator==(const Vec3D &lhs, const Vec3D &rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z;
}
 
inline bool operator!=(const Vec3D &lhs, const Vec3D &rhs) {
  return !(lhs == rhs);
}
 
inline double dot(const Vec3D &lhs, const Vec3D &rhs) {
  return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
}
 
inline Vec3D cross(const Vec3D &lhs, const Vec3D &rhs) {
  const double newx = lhs.y * rhs.z - lhs.z * rhs.y;
  const double newy = lhs.z * rhs.x - lhs.x * rhs.z;
  const double newz = lhs.x * rhs.y - lhs.y * rhs.x;
 
  return Vec3D{newx, newy, newz};
}
 
inline double magn(const Vec3D &vec) {
  return std::sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
}
 
inline Vec3D normalize(const Vec3D &vec) { return vec / magn(vec); }
 
inline bool isZero(const Vec3D &vec) { return magn(vec) == 0; }
 
inline double alpha(const Vec3D &vec) { return std::acos(vec.x / magn(vec)); }
 
inline double beta(const Vec3D &vec) { return std::acos(vec.y / magn(vec)); }
 
inline double gamma(const Vec3D &vec) { return std::acos(vec.z / magn(vec)); }
 
inline Vec3D rotateAlpha(const Vec3D &vec, const double ang) {
  //
  // Rotation matrix:
  //
  // |1   0           0     | |x|
  // |0  cos(ang)  −sin(ang)| |y|
  // |0  sin(ang)   cos(ang)| |z|
  //
 
  const double xPrime = vec.x;
  const double yPrime = vec.y * std::cos(ang) - vec.z * std::sin(ang);
  const double zPrime = vec.y * std::sin(ang) + vec.z * std::cos(ang);
 
  return Vec3D{xPrime, yPrime, zPrime};
}
 
inline Vec3D rotateBeta(const Vec3D &vec, const double ang) {
  //
  // Rotation matrix:
  //
  // | cos(ang)  0  sin(ang)| |x|
  // |   0       1      0   | |y|
  // |−sin(ang)  0  cos(ang)| |z|
  //
 
  const double xPrime = vec.x * std::cos(ang) + vec.z * std::sin(ang);
  const double yPrime = vec.y;
  const double zPrime = -vec.x * std::sin(ang) + vec.z * std::cos(ang);
 
  return Vec3D{xPrime, yPrime, zPrime};
}
 
inline Vec3D rotateGamma(const Vec3D &vec, const double ang) {
  //
  // Rotation matrix:
  //
  // |cos(ang)  −sin(ang)  0| |x|
  // |sin(ang)  cos(ang)   0| |y|
  // |  0         0        1| |z|
  //
 
  const double xPrime = vec.x * std::cos(ang) - vec.y * std::sin(ang);
  const double yPrime = vec.x * std::sin(ang) + vec.y * std::cos(ang);
  const double zPrime = vec.z;
 
  return Vec3D{xPrime, yPrime, zPrime};
}
} // namespace svector
 
#endif