utilities.hpp

Go to the documentation of this file.

#include "firefly/vector.hpp"
 
namespace firefly::utilities::vector {
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto angle_between(firefly::vector<T, Length> const &v1, firefly::vector<U, Length> const &v2,
                                           double delta = 1e-6) {
  static_assert(std::is_arithmetic_v<T> && std::is_arithmetic_v<U>, "Only arithmetic types are allowed.");
  if (v1.norm() == 0 || v2.norm() == 0) {
    return M_PI_2;
  }
 
  auto rad = std::acos(std::clamp((v1.to_normalized() * v2.to_normalized()) / 1, -1.0, 1.0));
  return rad < delta ? 0.0 : rad;
}
 
template <vector_type T, vector_type U, std::size_t Length>
bool are_anti_parallel(firefly::vector<T, Length> const &v1, firefly::vector<U, Length> const &v2) {
  static_assert(std::is_arithmetic_v<T> && std::is_arithmetic_v<U>, "Only arithmetic types are allowed.");
  return v1.to_normalized() == -v2.to_normalized();
}
 
template <vector_type T, vector_type U, std::size_t Length>
bool are_parallel(firefly::vector<T, Length> const &v1, firefly::vector<U, Length> const &v2) {
  static_assert(std::is_arithmetic_v<T> && std::is_arithmetic_v<U>, "Only arithmetic types are allowed.");
  return (v1.to_normalized() == v2.to_normalized()) || are_anti_parallel(v1, v2);
}
 
template <vector_type T, vector_type U, std::size_t Length>
bool are_orthogonal(firefly::vector<T, Length> const &v1, firefly::vector<U, Length> const &v2, double delta = 1e-6) {
  static_assert(std::is_arithmetic_v<T> && std::is_arithmetic_v<U>, "Only arithmetic types are allowed.");
  return std::fabs(angle_between(v1, v2) - M_PI_2) < delta;
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto area_parallelogram(firefly::vector<T, Length> const &v1,
                                                firefly::vector<U, Length> const &v2) {
  static_assert(std::is_arithmetic_v<T> && std::is_arithmetic_v<U>, "Only arithmetic types are allowed.");
  return v1.cross(v2).norm();
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto area_triangle(firefly::vector<T, Length> const &v1, firefly::vector<U, Length> const &v2) {
  static_assert(std::is_arithmetic_v<T> && std::is_arithmetic_v<U>, "Only arithmetic types are allowed.");
  return area_parallelogram(v1, v2) / 2;
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto projection(firefly::vector<T, Length> const &source_vector,
                                        firefly::vector<U, Length> const &target_vector) {
  return target_vector * ((source_vector * target_vector) / (target_vector * target_vector));
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto rejection(firefly::vector<T, Length> const &source_vector,
                                       firefly::vector<U, Length> const &target_vector) {
  return source_vector - projection(source_vector, target_vector);
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto distance(firefly::vector<T, Length> const &vector_a,
                                      firefly::vector<U, Length> const &vector_b) {
  return (vector_a - vector_b).norm();
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto reflection(firefly::vector<T, Length> const &source_vector,
                                        firefly::vector<U, Length> const &target_vector) {
  return projection(source_vector, target_vector) * 2 - source_vector;
}
 
template <vector_type T>
[[nodiscard]] constexpr auto rotate_2d(firefly::vector<T, 2> const &vector, double angle_rad) {
  T x = vector[0] * std::cos(angle_rad) - vector[1] * std::sin(angle_rad);
  T y = vector[0] * std::sin(angle_rad) + vector[1] * std::cos(angle_rad);
  return firefly::vector<T, 2>{x, y};
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto scalar_projection(firefly::vector<T, Length> const &source_vector,
                                               firefly::vector<U, Length> const &target_vector) {
  return source_vector.dot(target_vector) / target_vector.norm();
}
 
template <vector_type T, vector_type U, std::size_t Length>
[[nodiscard]] constexpr auto lerp(firefly::vector<T, Length> const &vector_a,
                                  firefly::vector<U, Length> const &vector_b, double t) {
  return vector_a * (1 - t) + vector_b * t;
}
 
} // namespace firefly::utilities::vector