sv_embed.hpp

Go to the documentation of this file.

 
#ifndef INCLUDE_SVECTOR_EMBED_HPP_
#define INCLUDE_SVECTOR_EMBED_HPP_
 
#include <math.h> // acosf, atan2f, cosf, sinf, sqrtf
 
namespace svector {
struct EmbVec2D {
  EmbVec2D() : x{0}, y{0} {};
 
  EmbVec2D(const float xOther, const float yOther) : x{xOther}, y{yOther} {}
 
  EmbVec2D(const EmbVec2D &other) = default;
 
  EmbVec2D(EmbVec2D &&) noexcept = default;
 
  EmbVec2D &operator=(const EmbVec2D &other) {
    // check if assigning to self
    if (this == &other) {
      return *this;
    }
 
    x = other.x;
    y = other.y;
    return *this;
  }
 
  EmbVec2D &operator=(EmbVec2D &&) noexcept = default;
 
  virtual ~EmbVec2D() = default;
 
  EmbVec2D &operator+=(const EmbVec2D &other) {
    x += other.x;
    y += other.y;
    return *this;
  }
 
  EmbVec2D &operator-=(const EmbVec2D &other) {
    x -= other.x;
    y -= other.y;
    return *this;
  }
 
  EmbVec2D &operator*=(const float &other) {
    x *= other;
    y *= other;
    return *this;
  }
 
  EmbVec2D &operator/=(const float &other) {
    x /= other;
    y /= other;
    return *this;
  }
 
  float x; 
  float y; 
};
 
struct EmbVec3D {
  EmbVec3D() : x{0}, y{0}, z{0} {}
 
  EmbVec3D(const float xOther, const float yOther, const float zOther)
      : x{xOther}, y{yOther}, z{zOther} {}
 
  EmbVec3D(const EmbVec3D &other) = default;
 
  EmbVec3D(EmbVec3D &&) noexcept = default;
 
  EmbVec3D &operator=(const EmbVec3D &other) {
    // check if assigning to self
    if (this == &other) {
      return *this;
    }
 
    x = other.x;
    y = other.y;
    z = other.z;
    return *this;
  }
 
  EmbVec3D &operator=(EmbVec3D &&) noexcept = default;
 
  virtual ~EmbVec3D() = default;
 
  EmbVec3D &operator+=(const EmbVec3D &other) {
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
  }
 
  EmbVec3D &operator-=(const EmbVec3D &other) {
    x -= other.x;
    y -= other.y;
    z -= other.z;
    return *this;
  }
 
  EmbVec3D &operator*=(const float &other) {
    x *= other;
    y *= other;
    z *= other;
    return *this;
  }
 
  EmbVec3D &operator/=(const float &other) {
    x /= other;
    y /= other;
    z /= other;
    return *this;
  }
 
  float x; 
  float y; 
  float z; 
};
 
inline float x(const EmbVec2D &v) { return v.x; }
 
inline void x(EmbVec2D &v, const float xValue) { v.x = xValue; }
 
inline float x(const EmbVec3D &v) { return v.x; }
 
inline void x(EmbVec3D &v, const float xValue) { v.x = xValue; }
 
inline float y(const EmbVec2D &v) { return v.y; }
 
inline void y(EmbVec2D &v, const float yValue) { v.y = yValue; }
 
inline float y(const EmbVec3D &v) { return v.y; }
 
inline void y(EmbVec3D &v, const float yValue) { v.y = yValue; }
 
inline float z(const EmbVec3D &v) { return v.z; }
 
inline void z(EmbVec3D &v, const float zValue) { v.z = zValue; }
 
inline EmbVec2D operator+(const EmbVec2D &lhs, const EmbVec2D &rhs) {
  return EmbVec2D{lhs.x + rhs.x, lhs.y + rhs.y};
}
 
inline EmbVec2D operator-(const EmbVec2D &lhs, const EmbVec2D &rhs) {
  return EmbVec2D{lhs.x - rhs.x, lhs.y - rhs.y};
}
 
inline EmbVec2D operator-(const EmbVec2D &vec) {
  return EmbVec2D{-vec.x, -vec.y};
}
 
inline EmbVec2D operator+(const EmbVec2D &vec) {
  return EmbVec2D{+vec.x, +vec.y};
}
 
inline EmbVec2D operator*(const EmbVec2D &lhs, const float rhs) {
  return EmbVec2D{lhs.x * rhs, lhs.y * rhs};
}
 
inline EmbVec2D operator/(const EmbVec2D &lhs, const float rhs) {
  return EmbVec2D{lhs.x / rhs, lhs.y / rhs};
}
 
inline bool operator==(const EmbVec2D &lhs, const EmbVec2D &rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y;
}
 
inline bool operator!=(const EmbVec2D &lhs, const EmbVec2D &rhs) {
  return !(lhs == rhs);
}
 
inline float dot(const EmbVec2D &lhs, const EmbVec2D &rhs) {
  return lhs.x * rhs.x + lhs.y * rhs.y;
}
 
inline float magn(const EmbVec2D &vec) {
  return sqrtf(vec.x * vec.x + vec.y * vec.y);
}
 
inline float angle(const EmbVec2D &vec) { return atan2f(vec.y, vec.x); }
 
inline EmbVec2D normalize(const EmbVec2D &vec) { return vec / magn(vec); }
 
inline bool isZero(const EmbVec2D &vec) { return magn(vec) == 0; }
 
inline EmbVec2D rotate(const EmbVec2D &vec, const float ang) {
  //
  // Rotation matrix:
  //
  // | cos(ang)   -sin(ang) | |x|
  // | sin(ang)    cos(ang) | |y|
  //
 
  const auto xPrime = vec.x * cosf(ang) - vec.y * sinf(ang);
  const auto yPrime = vec.x * sinf(ang) + vec.y * cosf(ang);
 
  return EmbVec2D{xPrime, yPrime};
}
 
inline EmbVec3D operator+(const EmbVec3D &lhs, const EmbVec3D &rhs) {
  return EmbVec3D{lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z};
}
 
inline EmbVec3D operator-(const EmbVec3D &lhs, const EmbVec3D &rhs) {
  return EmbVec3D{lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z};
}
 
inline EmbVec3D operator-(const EmbVec3D &vec) {
  return EmbVec3D{-vec.x, -vec.y, -vec.z};
}
 
inline EmbVec3D operator+(const EmbVec3D &vec) {
  return EmbVec3D{+vec.x, +vec.y, +vec.z};
}
 
inline EmbVec3D operator*(const EmbVec3D &lhs, const float rhs) {
  return EmbVec3D{lhs.x * rhs, lhs.y * rhs, lhs.z * rhs};
}
 
inline EmbVec3D operator/(const EmbVec3D &lhs, const float rhs) {
  return EmbVec3D{lhs.x / rhs, lhs.y / rhs, lhs.z / rhs};
}
 
inline bool operator==(const EmbVec3D &lhs, const EmbVec3D &rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z;
}
 
inline bool operator!=(const EmbVec3D &lhs, const EmbVec3D &rhs) {
  return !(lhs == rhs);
}
 
inline float dot(const EmbVec3D &lhs, const EmbVec3D &rhs) {
  return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
}
 
inline EmbVec3D cross(const EmbVec3D &lhs, const EmbVec3D &rhs) {
  const float newx = lhs.y * rhs.z - lhs.z * rhs.y;
  const float newy = lhs.z * rhs.x - lhs.x * rhs.z;
  const float newz = lhs.x * rhs.y - lhs.y * rhs.x;
 
  return EmbVec3D{newx, newy, newz};
}
 
inline float magn(const EmbVec3D &vec) {
  return sqrtf(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
}
 
inline EmbVec3D normalize(const EmbVec3D &vec) { return vec / magn(vec); }
 
inline bool isZero(const EmbVec3D &vec) { return magn(vec) == 0; }
 
inline float alpha(const EmbVec3D &vec) { return acosf(vec.x / magn(vec)); }
 
inline float beta(const EmbVec3D &vec) { return acosf(vec.y / magn(vec)); }
 
inline float gamma(const EmbVec3D &vec) { return acosf(vec.z / magn(vec)); }
 
inline EmbVec3D rotateAlpha(const EmbVec3D &vec, const float ang) {
  //
  // Rotation matrix:
  //
  // |1   0           0     | |x|
  // |0  cos(ang)  −sin(ang)| |y|
  // |0  sin(ang)   cos(ang)| |z|
  //
 
  const auto xPrime = vec.x;
  const auto yPrime = vec.y * cosf(ang) - vec.z * sinf(ang);
  const auto zPrime = vec.y * sinf(ang) + vec.z * cosf(ang);
 
  return EmbVec3D{xPrime, yPrime, zPrime};
}
 
inline EmbVec3D rotateBeta(const EmbVec3D &vec, const float ang) {
  //
  // Rotation matrix:
  //
  // | cos(ang)  0  sin(ang)| |x|
  // |   0       1      0   | |y|
  // |−sin(ang)  0  cos(ang)| |z|
  //
 
  const auto xPrime = vec.x * cosf(ang) + vec.z * sinf(ang);
  const auto yPrime = vec.y;
  const auto zPrime = -vec.x * sinf(ang) + vec.z * cosf(ang);
 
  return EmbVec3D{xPrime, yPrime, zPrime};
}
 
inline EmbVec3D rotateGamma(const EmbVec3D &vec, const float ang) {
  //
  // Rotation matrix:
  //
  // |cos(ang)  −sin(ang)  0| |x|
  // |sin(ang)  cos(ang)   0| |y|
  // |  0         0        1| |z|
  //
 
  const auto xPrime = vec.x * cosf(ang) - vec.y * sinf(ang);
  const auto yPrime = vec.x * sinf(ang) + vec.y * cosf(ang);
  const auto zPrime = vec.z;
 
  return EmbVec3D{xPrime, yPrime, zPrime};
}
} // namespace svector
 
#endif