math_vector2.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_MATH_VECTOR2_H_
#define DESIGNLAB_MATH_VECTOR2_H_
 
#include <cmath>
#include <string>
 
#include "math_util.h"
 
 
namespace designlab
{
struct Vector2 final
{
    constexpr Vector2() : x(0), y(0) {}
    constexpr Vector2(float x_pos, float y_pos) : x(x_pos), y(y_pos) {}
    constexpr Vector2(const Vector2& other) = default;
    constexpr Vector2(Vector2&& other) noexcept = default;
    constexpr Vector2& operator =(const Vector2& other) = default;
 
    constexpr Vector2 operator +() const { return *this; }
    constexpr Vector2 operator -() const { return{ -x, -y }; }
 
    constexpr Vector2 operator +(const Vector2& other) const
    {
        return{ x + other.x, y + other.y };
    }
 
    constexpr Vector2 operator -(const Vector2& other) const
    {
        return{ x - other.x, y - other.y };
    }
 
    constexpr Vector2 operator *(float s) const { return{ x * s, y * s }; }
    constexpr Vector2 operator /(float s) const { return{ x / s, y / s }; }
 
    Vector2& operator +=(const Vector2& other);
    Vector2& operator -=(const Vector2& other);
    Vector2& operator *=(float s);
    Vector2& operator /=(float s);
 
    constexpr bool operator==(const Vector2& other) const
    {
        return math_util::IsEqual(x, other.x) && math_util::IsEqual(y, other.y);
    }
 
    constexpr bool operator!=(const Vector2& other) const
    {
        return !(*this == other);
    }
 
 
    [[nodiscard]]
    constexpr float GetSquaredLength() const noexcept { return Dot(*this); }
 
    [[nodiscard]]
    float GetLength() const { return std::sqrt(GetSquaredLength()); }
 
    [[nodiscard]]
    constexpr float Dot(const Vector2& other) const noexcept
    {
        return x * other.x + y * other.y;
    }
 
    [[nodiscard]]
    constexpr float Cross(const Vector2& other) const noexcept
    {
        return x * other.y - y * other.x;
    }
 
    [[nodiscard]]
    float GetDistanceFrom(const Vector2& other) const noexcept
    {
        return (other - *this).GetLength();
    }
 
    [[nodiscard]]
    Vector2 GetNormalized() const;
 
    [[nodiscard]]
    constexpr bool IsZero() const noexcept
    {
        return math_util::IsEqual(x, 0.0f) && math_util::IsEqual(y, 0.0f);
    }
 
    void Normalize() noexcept { *this = GetNormalized(); }
 
 
    [[nodiscard]]
    constexpr static Vector2 GetZeroVec() noexcept { return Vector2(0.f, 0.f); }
 
    [[nodiscard]] std::string ToString() const;
 
    [[nodiscard]] std::string ToCsvString() const;
 
 
    float x;
    float y;
};
 
 
constexpr Vector2 operator *(float s, const Vector2& v)
{
    return { s * v.x, s * v.y };
}
 
template <class Char>
std::basic_ostream<Char>& operator <<(std::basic_ostream<Char>& os, const Vector2& v)
{
    return os << math_util::FloatingPointNumToString(v.x) <<
        Char(',') << math_util::FloatingPointNumToString(v.y);
}
 
template <class Char>
inline std::basic_istream<Char>& operator >>(
    std::basic_istream<Char>& is, Vector2& v)
{
    Char unused = 0;
    return is >> unused >> v.x >> unused >> v.y >> unused;
}
 
}  // namespace designlab
 
 
#endif  // DESIGNLAB_MATH_VECTOR2_H_