rvec2.inl

Go to the documentation of this file.

#pragma once
#include "rvec2.hpp"
namespace mal_math::_detail
{
    template <Primitive T>
    constexpr void rvec<2, T>::reset() noexcept { x = y = 0; }
 
    template <Primitive T>
    [[nodiscard]] constexpr rvec<2, T> const &rvec<2, T>::operator+() const noexcept
    {
        return *this;
    }
    [[nodiscard]] constexpr rvec<2, T> const &rvec<2, T>::operator+() const noexcept {…}
 
    template <Primitive T>
    [[nodiscard]] constexpr vec<2, T> rvec<2, T>::operator-() const noexcept
    {
        return vec<2, T>(-static_cast<T>(x), -static_cast<T>(y));
    }
    [[nodiscard]] constexpr vec<2, T> rvec<2, T>::operator-() const noexcept {…}
 
    template <Primitive T>
    template <Primitive U>
    constexpr rvec<2, T> &rvec<2, T>::operator+=(U const value) noexcept
    {
        x = static_cast<T>(x + value);
        y = static_cast<T>(y + value);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator+=(U const value) noexcept {…}
    template <Primitive T>
    template <Primitive U>
    constexpr rvec<2, T> &rvec<2, T>::operator-=(U const value) noexcept
    {
        x = static_cast<T>(x - value);
        y = static_cast<T>(y - value);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator-=(U const value) noexcept {…}
    template <Primitive T>
    template <Primitive U>
    constexpr rvec<2, T> &rvec<2, T>::operator*=(U const value) noexcept
    {
        x = static_cast<T>(x * value);
        y = static_cast<T>(y * value);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator*=(U const value) noexcept {…}
    template <Primitive T>
    template <Primitive U>
    constexpr rvec<2, T> &rvec<2, T>::operator/=(U const value) noexcept
    {
        x = static_cast<T>(x / value);
        y = static_cast<T>(y / value);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator/=(U const value) noexcept {…}
    template <Primitive T>
    template <Primitive U>
    constexpr rvec<2, T> &rvec<2, T>::operator%=(U const value) noexcept
    {
        x = static_cast<T>(x % value);
        y = static_cast<T>(y % value);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator%=(U const value) noexcept {…}
    template <Primitive T>
    template <AnyVec U>
    constexpr rvec<2, T> &rvec<2, T>::operator+=(U const &other) noexcept requires(size == U::size)
    {
        x = static_cast<T>(x + other.x);
        y = static_cast<T>(y + other.y);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator+=(U const &other) noexcept requires(size == U::size) {…}
    template <Primitive T>
    template <AnyVec U>
    constexpr rvec<2, T> &rvec<2, T>::operator-=(U const &other) noexcept requires(size == U::size)
    {
        x = static_cast<T>(x - other.x);
        y = static_cast<T>(y - other.y);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator-=(U const &other) noexcept requires(size == U::size) {…}
    template <Primitive T>
    template <AnyVec U>
    constexpr rvec<2, T> &rvec<2, T>::operator*=(U const &other) noexcept requires(size == U::size)
    {
        x = static_cast<T>(x * other.x);
        y = static_cast<T>(y * other.y);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator*=(U const &other) noexcept requires(size == U::size) {…}
    template <Primitive T>
    template <AnyVec U>
    constexpr rvec<2, T> &rvec<2, T>::operator/=(U const &other) noexcept requires(size == U::size)
    {
        x = static_cast<T>(x / other.x);
        y = static_cast<T>(y / other.y);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator/=(U const &other) noexcept requires(size == U::size) {…}
    template <Primitive T>
    template <AnyVec U>
    constexpr rvec<2, T> &rvec<2, T>::operator%=(U const &other) noexcept requires(size == U::size)
    {
        x = static_cast<T>(x % other.x);
        y = static_cast<T>(y % other.y);
        return *this;
    }
    constexpr rvec<2, T> &rvec<2, T>::operator%=(U const &other) noexcept requires(size == U::size) {…}
    template <Primitive T>
    [[nodiscard]] constexpr T &rvec<2, T>::operator[](size_t i)
    {
        assert(i < size);
        return data[i];
    }
    [[nodiscard]] constexpr T &rvec<2, T>::operator[](size_t i) {…}
    template <Primitive T>
    [[nodiscard]] constexpr T const &rvec<2, T>::operator[](size_t i) const
    {
        assert(i < size);
        return data[i];
    }
    [[nodiscard]] constexpr T const &rvec<2, T>::operator[](size_t i) const {…}
} // namespace mal_math