vector.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <concepts>
#include <stdexcept>
#include <type_traits>
#include <iostream>
#include <functional>
#include <vector>
 
#include "global.hpp" 
#include "function.hpp"  

 
namespace pbpt::math {

template<typename T, int N>
requires (N > 0) && std::is_floating_point_v<T>
class Vector {
private:
    std::array<T, N> m_data{};
 
public:
    // --- 静态工厂函数 (Static Factory Functions) ---

    static constexpr Vector filled(T value) noexcept {
        Vector vec;
        vec.m_data.fill(value);
        return vec;
    }

    static constexpr Vector zeros() noexcept { return filled(0.0); }

    static constexpr Vector ones() noexcept { return filled(1.0); }
 
    // --- 构造函数 (Constructors) ---

    constexpr Vector() noexcept = default;

    template<std::convertible_to<T>... Args>
    requires(sizeof...(Args) == N)
    constexpr explicit Vector(Args&&... args) noexcept  {
        m_data = {static_cast<T>(args)...};
    }
 
    // --- 访问器 (Accessors) ---

    constexpr T& x() noexcept requires(N > 0) { return m_data[0]; }
    constexpr T& y() noexcept requires(N > 1) { return m_data[1]; }
    constexpr T& z() noexcept requires(N > 2) { return m_data[2]; }
    constexpr T& w() noexcept requires(N > 3) { return m_data[3]; }

    constexpr const T& x() const noexcept requires(N > 0) { return m_data[0]; }
    constexpr const T& y() const noexcept requires(N > 1) { return m_data[1]; }
    constexpr const T& z() const noexcept requires(N > 2) { return m_data[2]; }
    constexpr const T& w() const noexcept requires(N > 3) { return m_data[3]; }

    constexpr int dims() const noexcept { return N; }
 
    // --- 下标访问 (Subscript Access) ---

    constexpr const T& operator[](int index) const {
        if (index < 0 || index >= N) {
            if (std::is_constant_evaluated()) {
                throw "Compile-time error: Index out of range";
            } else {
                throw std::out_of_range("Index out of range");
            }
        }
        return m_data[index];
    }

    constexpr T& operator[](int index) {
        if (index < 0 || index >= N) {
            if (std::is_constant_evaluated()) {
                throw "Compile-time error: Index out of range";
            } else {
                throw std::runtime_error("Index out of range");
            }
        }
        return m_data[index];
    }

    constexpr const T& at(int index) const {
        if (index < 0 || index >= N) {
            if (std::is_constant_evaluated()) {
                throw "Compile-time error: Index out of range";
            } else {
                throw std::out_of_range("Index out of range");
            }
        }
        return m_data[index];
    }
 
    // --- 一元运算符 (Unary Operators) ---

    constexpr Vector operator-() const noexcept {
        Vector result{};
        for (int i = 0; i < N; i++) result[i] = -m_data[i];
        return result;
    }
 
    // --- 复合赋值运算符 (Compound Assignment Operators) ---
    
    constexpr Vector& operator+=(const Vector& rhs) noexcept {
        for (int i = 0; i < N; i++) m_data[i] += rhs[i];
        return *this;
    }

    constexpr Vector& operator-=(const Vector& rhs) noexcept {
        for (int i = 0; i < N; i++) m_data[i] -= rhs[i];
        return *this;
    }

    constexpr Vector& operator*=(const T& rhs) noexcept {
        for (int i = 0; i < N; i++) m_data[i] *= rhs;
        return *this;
    }

    constexpr bool operator==(const Vector& rhs) const noexcept {
        for (int i = 0; i < N; i++) {
            if (!is_equal(m_data[i], rhs[i])) return false;
        }
        return true;
    }

    constexpr bool operator!=(const Vector& rhs) const noexcept {
        return !(*this == rhs);
    }

    constexpr bool is_normalized() const {
        return is_equal(length(), 1.0);
    }

    constexpr bool is_zero() const {
        for (int i = 0; i < N; i++) {
            if (!is_equal(m_data[i], 0.0)) return false;
        }
        return true;
    }
 

    constexpr bool has_nan() const {
        for (int i = 0; i < N; i++) {
            if (std::isnan(m_data[i])) return true;
        }
        return false;
    }

    template<std::convertible_to<T> U>
    constexpr Vector operator/=(const U& value) const noexcept {
        if (value == 0) {
            if (std::is_constant_evaluated()) {
                throw "Compile-time error: Division by zero";
            } else {
                throw std::runtime_error("Division by zero");
            }
        }
        Float inv = 1.0 / value;
        for (int i = 0; i < N; i++) m_data[i] *= inv;
        return *this;
    }
 
    // --- 向量数学运算 (Vector Math Operations) ---

    constexpr T length_squared() const noexcept {
        T result = 0;
        for (int i = 0; i < N; i++) 
            result += m_data[i] * m_data[i];
        return result;
    }

    constexpr T length() const {
        return pbpt::math::sqrt(length_squared());
    }

    constexpr Vector normalized() const {
        Vector result = *this;
        T len = length();
        if (len == 0) {
            if (std::is_constant_evaluated()) {
                throw "Compile-time error: Cannot normalize a zero vector";
            } else {
                throw std::runtime_error("Cannot normalize a zero vector");
            }
        }
        return result * (1.0 / len);
    }

    constexpr Vector& normalize() {
        T len = length();
        if (len == 0) {
            if (std::is_constant_evaluated()) {
                throw "Compile-time error: Cannot normalize a zero vector";
            } else {
                throw std::runtime_error("Cannot normalize a zero vector");
            }
        }
        return *this *= (1.0 / len);
    }
    
    constexpr T dot(const Vector& rhs) const noexcept {
        T result = 0;
        for (int i = 0; i < N; i++) result += m_data[i] * rhs.m_data[i];
        return result;
    }

    constexpr Vector cross(const Vector& rhs) const noexcept requires(N == 3) {
        return Vector(
            y() * rhs.z() - z() * rhs.y(),
            z() * rhs.x() - x() * rhs.z(),
            x() * rhs.y() - y() * rhs.x()
        );
    }
 
    constexpr T product() const noexcept {
        T result = 1;
        for (int i = 0; i < N; i++) result *= m_data[i];
        return result;
    }

    void apply(const std::function<void(T&, int)>& func) {
        for (int i = 0; i < N; ++i) func(m_data[i], i);
    }

    constexpr Vector operator+(const Vector<T, N>& rhs) const noexcept {
        auto result = *this;
        result += rhs;
        return result;
    }

    constexpr Vector operator-(const Vector<T, N>& rhs) const noexcept {
        auto result = *this;
        result -= rhs;
        return result;
    }

    template<std::convertible_to<T> U>
    constexpr Vector operator*(U value) const noexcept {
        auto result = *this;
        result *= static_cast<T>(value);
        return result;
    }

    template<std::convertible_to<T> U>
    friend constexpr Vector operator*(U lhs, const Vector<T, N>& rhs) noexcept {
        return rhs * static_cast<T>(lhs);
    }

    constexpr Vector operator*(const Vector<T, N>& rhs) const noexcept {
        Vector<T, N> result{};
        for (int i = 0; i < N; i++) result[i] = (*this)[i] * rhs[i];
        return result;
    }

    template <std::convertible_to<T> U>
    constexpr Vector operator/(U rhs) const {
        Vector result = *this;
        result /= static_cast<T>(rhs);
        return result;
    }

    friend std::ostream& operator<<(std::ostream& os, const Vector& vec) {
        os << "Vec" << N << "(";
        for (int i = 0; i < N; ++i) {
            os << vec[i] << (i == N - 1 ? "" : ", ");
        }
        os << ')';
        return os;
    }

    constexpr int max_dim() const {
        return std::max_element(m_data.begin(), m_data.end()) - m_data.begin();
    }

    constexpr T max() const {
        return *std::max_element(m_data.begin(), m_data.end());
    }

    constexpr int min_dim() const {
        return std::min_element(m_data.begin(), m_data.end()) - m_data.begin();
    }

    constexpr T min() const {
        return *std::min_element(m_data.begin(), m_data.end());
    }

    template<typename ...Args>
    requires (sizeof...(Args) == N)
    constexpr Vector permuted(Args ...args) const {
        Vector result;
        int i = 0;
        ((result[i++] = (*this)[args]), ...);
        return result;
    }

    template<typename ...Args>
    requires (sizeof...(Args) == N)
    constexpr Vector& permute(Args ...args) {
        *this = permuted(args...);
        return *this;
    }
    
    
};

 
template<typename T, int N>
constexpr inline std::vector<Vector<T, N>> get_orthogonal_bases(const Vector<T, N>& base) {
     if constexpr (base.is_zero()) {
        if (std::is_constant_evaluated()) {
            throw "Base vector is zero, orthogonal bases are undefined.";
        } else {
            throw std::invalid_argument("Base vector is zero, orthogonal bases are undefined.");
        }
    }
    //TODO
    return {};
}

template<typename T>
constexpr inline std::vector<Vector<T, 2>> get_orthogonal_bases(const Vector<T, 2>& base) {
    if (base.is_zero()) {
        if (std::is_constant_evaluated()) {
            throw "Base vector is zero, orthogonal bases are undefined.";
        } else {
            throw std::invalid_argument("Base vector is zero, orthogonal bases are undefined.");
        }
    }
    Vector<T, 2> u, v;
    u = base.normalized();
    v = Vector<T, 2>(-u.y(), u.x());
    return {u, v};
}

template<typename T>
constexpr inline std::vector<Vector<T, 3>> get_orthogonal_bases(const Vector<T, 3>& base) {
    if (base.is_zero()) {
        if (std::is_constant_evaluated()) {
            throw "Base vector is zero, orthogonal bases are undefined.";
        } else {
            throw std::invalid_argument("Base vector is zero, orthogonal bases are undefined.");
        }
    }
    
    Vector<T, 3> u, v, w;
    u = base.normalized();
    if (std::abs(u.x()) > std::abs(u.y())) {
        T inv_len = T(1) / std::sqrt(u.x() * u.x() + u.z() * u.z());
        v = Vector<T, 3>(-u.z() * inv_len, T(0), u.x() * inv_len);
    } else {
        T inv_len = T(1) / std::sqrt(u.y() * u.y() + u.z() * u.z());
        v = Vector<T, 3>(T(0), u.z() * inv_len, -u.y() * inv_len);
    }
    w = u.cross(v);
    return {u, v, w};
}
 
// --- 类型别名 (Type Aliases) ---

using Vec2 = Vector<Float, 2>;
using Vec3 = Vector<Float, 3>;
using Vec4 = Vector<Float, 4>;
 
template <typename T, int N>
class Normal : public Vector<T, N> {
public:
    using Vector<T, N>::Vector;
    constexpr Normal(const Vector<T, N>& vec) : Vector<T, N>(vec.normalized()) {}
};

using Normal2 = Normal<Float, 2>;
using Normal3 = Normal<Float, 3>;
using Normal4 = Normal<Float, 4>;
 
 
} // namespace math