vector.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#ifndef LIBSBX_MATH_VECTOR_HPP_
#define LIBSBX_MATH_VECTOR_HPP_
 
#include <algorithm>
#include <array>
#include <cmath>
#include <concepts>
#include <ranges>
#include <utility>
 
#include <libsbx/utility/make_array.hpp>
#include <libsbx/utility/assert.hpp>
#include <libsbx/utility/zip.hpp>
#include <libsbx/utility/hash.hpp>
 
#include <libsbx/math/concepts.hpp>
#include <libsbx/math/traits.hpp>
#include <libsbx/math/constants.hpp>
#include <libsbx/math/algorithm.hpp>
 
namespace sbx::math {
 
template<std::size_t Size, scalar Type>
requires (Size > 1u)
class basic_vector {
 
  template<std::size_t S, scalar T>
  requires (S > 1u)
  friend class basic_vector;
 
public:
 
  using value_type = Type;
  using reference = value_type&;
  using const_reference = const value_type&;
  using size_type = std::size_t;
  using length_type = std::float_t;
 
  template<scalar Other = value_type>
  constexpr basic_vector(Other value = Other{0}) noexcept;
 
  template<scalar Other = value_type>
  constexpr basic_vector(const basic_vector<Size, Other>& other) noexcept;
 
  constexpr basic_vector(const basic_vector& other) noexcept = default;
  constexpr basic_vector(basic_vector&& other) noexcept = default;
 
  auto operator=(const basic_vector& other) noexcept -> basic_vector& = default;
  auto operator=(basic_vector&& other) noexcept -> basic_vector& = default;
 
  static constexpr auto min(const basic_vector& vector) noexcept -> value_type;
 
  template<scalar Lhs = value_type, scalar Rhs = value_type>
  static constexpr auto min(const basic_vector<Size, Lhs>& lhs, const basic_vector<Size, Rhs>& rhs) noexcept -> basic_vector;
 
  static constexpr auto max(const basic_vector& vector) noexcept -> value_type;
 
  template<scalar Lhs = value_type, scalar Rhs = value_type>
  static constexpr auto max(const basic_vector<Size, Lhs>& lhs, const basic_vector<Size, Rhs>& rhs) noexcept -> basic_vector;
 
  template<scalar Lhs = value_type>
  static constexpr auto abs(const basic_vector<Size, Lhs>& vector) noexcept -> basic_vector;
 
  template<size_type Axis, scalar Other = value_type>
  requires (Axis < Size)
  [[nodiscard]] static constexpr auto splat(const basic_vector<Size, Other>& vector) noexcept -> basic_vector<Size, Other>;
 
  [[nodiscard]] static constexpr auto lerp(const basic_vector& x, const basic_vector& y, const value_type a) noexcept -> basic_vector;
 
  constexpr auto data() noexcept -> value_type*;
 
  constexpr auto data() const noexcept -> const value_type*;
 
  [[nodiscard]] constexpr auto operator[](size_type index) noexcept -> reference;
 
  [[nodiscard]] constexpr auto operator[](size_type index) const noexcept -> const_reference;
 
  template<scalar Other>
  constexpr auto operator+=(const basic_vector<Size, Other>& other) noexcept -> basic_vector&;
 
  template<scalar Other>
  constexpr auto operator-=(const basic_vector<Size, Other>& other) noexcept -> basic_vector&;
 
  template<scalar Other>
  constexpr auto operator*=(Other scalar) noexcept -> basic_vector&;
 
  template<scalar Other>
  constexpr auto operator*=(const basic_vector<Size, Other>& other) noexcept -> basic_vector&;
 
  template<scalar Other>
  constexpr auto operator/=(Other scalar) noexcept -> basic_vector&;
 
  [[nodiscard]] constexpr auto length_squared() const noexcept -> length_type;
 
  [[nodiscard]] constexpr auto length() const noexcept -> length_type;
 
  constexpr auto normalize() noexcept -> basic_vector&;
 
protected:
 
  template<std::convertible_to<value_type>... Args>
  requires (sizeof...(Args) == Size)
  constexpr basic_vector(Args&&... args) noexcept;
 
  constexpr basic_vector(std::array<value_type, Size>&& components) noexcept;
 
  template<scalar Other>
  [[nodiscard]] static constexpr auto fill(Other value) noexcept -> basic_vector;
 
  template<std::size_t Index, scalar Other>
  [[nodiscard]] static constexpr auto axis(Other value) noexcept -> basic_vector;
 
private:
 
  std::array<Type, Size> _components;
 
}; // class basic_vector
 
template<std::size_t Size, scalar Lhs, scalar Rhs>
[[nodiscard]] constexpr auto operator==(const basic_vector<Size, Lhs>& lhs, const basic_vector<Size, Rhs>& rhs) noexcept -> bool;
 
template<std::size_t Size, scalar Lhs, scalar Rhs>
[[nodiscard]] constexpr auto operator+(basic_vector<Size, Lhs> lhs, const basic_vector<Size, Rhs>& rhs) noexcept -> basic_vector<Size, Lhs>;
 
template<std::size_t Size, scalar Lhs, scalar Rhs>
[[nodiscard]] constexpr auto operator-(basic_vector<Size, Lhs> lhs, const basic_vector<Size, Rhs>& rhs) noexcept -> basic_vector<Size, Lhs>;
 
template<std::size_t Size, scalar Lhs, scalar Rhs>
[[nodiscard]] constexpr auto operator*(basic_vector<Size, Lhs> lhs, Rhs scalar) noexcept -> basic_vector<Size, Lhs>;
 
template<std::size_t Size, scalar Lhs, scalar Rhs>
[[nodiscard]] constexpr auto operator/(basic_vector<Size, Lhs> lhs, Rhs scalar) noexcept -> basic_vector<Size, Lhs>;
 
} // namespace sbx::math
 
#include <libsbx/math/vector.ipp>
 
#endif // LIBSBX_MATH_VECTOR_HPP_