vec.hpp

浏览该文件的文档.

 
#pragma once
#ifndef VEC_H
#define VEC_H
 
#ifdef _MSVC_VER
#include <vcruntime_typeinfo.h>
#endif
 
#include <assert.h>
 
#include <cmath>
#include <concepts>
#include <cstddef>
#include <type_traits>
 
#include "../utils/compiling.hpp"
#include "./declaration.hpp"
 
namespace xcmath {
template <typename _Tp, size_t _length>
    requires(_length > 0 && std::is_default_constructible_v<_Tp>)
class vec;
template <class T>
concept Vec = requires(T a) {
    typename T::DataType;
    typename T::ItemType;
    std::is_same_v<typename T::template Self<typename T::DataType>, T>;
    T::datatype;
    T::itemtype;
    { T::dim } -> std::same_as<const size_t&>;
    { T::length } -> std::same_as<const size_t&>;
    { a[T::length - 1] } -> std::same_as<typename T::ItemType&>;
};
 
template <class vec, class _Item>
concept VecItem = requires {
    requires(Vec<vec>);
    requires(std::convertible_to<typename vec::ItemType, _Item>);
};
template <class Arg, class... Args>
constexpr size_t VecConstructPackSize =
    VecConstructPackSize<Arg> + VecConstructPackSize<Args...>;
template <class Arg>
inline constexpr size_t VecConstructPackSize<Arg> = []() -> size_t {
    if constexpr (Vec<Arg>)
        return Arg::length;
    else
        return 1;
}();
template <class _Tp>
struct VecInfo {
#ifdef _MSVC_VER
    static constexpr size_t Dim = []() -> size_t {
        if constexpr (Vec<_Tp>) return VecInfo<_Tp::ItemType>::Dim + 1;
        return 0;
    }();
    static constexpr auto Zero = []() {
        if constexpr (Vec<_Tp>)
            return VecInfo<_Tp::ItemType>::Zero;
        else
            return _Tp{};
    }();
    using DataType = decltype(Zero);
#else
 
    static constexpr size_t dim = []() -> size_t {
        if constexpr (Vec<_Tp>) return VecInfo<typename _Tp::ItemType>::dim + 1;
        return 0;
    }();
 
    static constexpr auto Zero = []() {
        if constexpr (Vec<_Tp>)
            return VecInfo<typename _Tp::ItemType>::Zero;
        else
            return _Tp{};
    }();
    using DataType = decltype([]() {
        if constexpr (Vec<_Tp>)
            return VecInfo<typename _Tp::ItemType>::Zero;
        else
            return _Tp{};
    }());
 
#endif
    template <class _Sl, class... _Sls>
    static constexpr auto SubVecZero = []() constexpr {
        if constexpr (sizeof...(_Sls))
            return int{};
        else
            return std::declval<float>();
    }();
    template <class _Sl, class... _Sls>
    using SubVec = decltype(SubVecZero<_Sl, _Sls...>);
};
template <class T, size_t len, size_t... lens>
struct __batchHelper {
    using Type = vec<typename __batchHelper<T, lens...>::Type, len>;
};
template <class T, size_t len>
struct __batchHelper<T, len> {
    using Type = vec<T, len>;
};
 
template <class T, size_t... lens>
using batch = __batchHelper<T, lens...>::Type;
template <typename _Tp, size_t _length>
    requires(_length > 0 && std::is_default_constructible_v<_Tp>)
class vec {
   protected:
    _Tp data[_length];
 
   public:
    using ItemType = _Tp;
 
    using DataType = typename VecInfo<ItemType>::DataType;
    static constexpr size_t dim = VecInfo<ItemType>::dim + 1;
 
    template <class __Tp, size_t __len, size_t... __lens>
    struct __subVecHelper {};
 
    template <size_t __len, size_t... __lens>
    struct __subVecHelper<size_t, __len, __lens...> {
        using Type = vec<typename ItemType::template SubVec<__lens...>, __len>;
    };
    template <size_t __len>
    struct __subVecHelper<size_t, __len> {
        using Type = vec<ItemType, __len>;
    };
 
    template <size_t __len, size_t... __lens>
    using SubVec = __subVecHelper<size_t, __len, __lens...>::Type;
 
    // template <size_t __len>
    // using SubVec<__len> = vec<ItemType, __len>;
 
    template <class _T>
    using Self = vec<_T, _length>;
 
    constexpr static auto datatype = TypeName<DataType>;
 
    constexpr static auto itemtype = TypeName<ItemType>;
 
    constexpr static auto length = _length;
 
    constexpr vec()
        requires(std::is_default_constructible_v<_Tp>)
        : data{_Tp{}} {}
 
    template <class _Tp1, class... _T>
        requires(std::is_convertible_v<_Tp1, _Tp> &&
                 (std::is_convertible_v<_T, _Tp> && ...))
    constexpr vec(const _Tp1& arg1, const _T&... args) {
        size_t i = 0;
        data[0] = arg1;
        ((data[++i] = args), ...);
    }
 
    template <typename... _Args>
        requires((VecConstructPackSize<_Args...> <= _length &&
                  VecConstructPackSize<_Args...> > 1) &&
                 ((VecItem<_Args, ItemType> ||
                   std::is_convertible_v<_Args, ItemType>) &&
                  ...))
    constexpr explicit vec(const _Args&... args) {
        size_t n = 0;
        (([&]<class _Arg>(_Arg _arg) {
             if constexpr (std::is_convertible_v<_Arg, ItemType>)
                 data[n++] = _arg;
             else {
                 for (auto& i : _arg) data[n++] = i;
             }
         }(args)),
         ...);
    }
 
    template <class T>
        requires(std::is_convertible_v<T, ItemType>)
    constexpr explicit vec(const T& fill_value) {
        for (size_t i = 0; i < length; i++) {
            data[i] = fill_value;
        }
    }
 
    constexpr vec(const vec<_Tp, _length>& other) {
        for (size_t i = 0; i < _length; i++) {
            data[i] = other[i];
        }
    }
 
    constexpr vec(vec<_Tp, _length>&& o) {
        for (size_t i = 0; i < _length; i++) {
            data[i] = o[i];
        }
    }
 
    constexpr vec(const std::initializer_list<ItemType>& list) {
        size_t i = 0;
        for (auto it : list) {
            assert(i < _length);
            data[i++] = it;
        }
    }
 
    constexpr const _Tp* begin() const { return data; }
 
    constexpr const _Tp* end() const { return data + length; }
 
    constexpr _Tp& operator[](size_t index) { return data[index]; }
 
    constexpr const _Tp& operator[](size_t index) const {
        assert(index < length);
        return data[index];
    }
 
    constexpr vec<_Tp, _length>& operator=(const vec<_Tp, _length>& o) {
        for (size_t i = 0; i < _length; i++) {
            data[i] = o[i];
        }
        return *this;
    }
 
    constexpr vec<_Tp, _length>& operator=(vec<_Tp, _length>&& o) {
        for (size_t i = 0; i < _length; i++) {
            data[i] = o[i];
        }
        return *this;
    }
 
    template <size_t... idx, class... _Ss>
        requires(sizeof...(_Ss) < dim)
    constexpr SubVec<sizeof...(idx), (_Ss::length, ...)> operator()(
        Slice<idx...>, _Ss... ns) const {
        return {(data[idx](ns...))...};
    }
 
    template <size_t... idx>
    constexpr vec<ItemType, sizeof...(idx)> operator()(Slice<idx...> s) const {
        return {data[idx]...};
    }
 
    constexpr _Tp& x()
        requires(_length < 5)
    {
        return this->data[0];
    }
 
    constexpr _Tp& y()
        requires(_length < 5 && _length > 1)
    {
        return this->data[1];
    }
 
    constexpr _Tp& z()
        requires(_length < 5 && _length > 2)
    {
        return this->data[2];
    }
 
    constexpr _Tp& w()
        requires(_length < 5 && _length > 3)
    {
        return this->data[3];
    }
 
    constexpr const _Tp& x() const
        requires(_length < 5)
    {
        return this->data[0];
    }
 
    constexpr const _Tp& y() const
        requires(_length < 5 && _length > 1)
    {
        return this->data[1];
    }
 
    constexpr const _Tp& z() const
        requires(_length < 5 && _length > 2)
    {
        return this->data[2];
    }
 
    constexpr const _Tp& w() const
        requires(_length < 5 && _length > 3)
    {
        return this->data[3];
    }
 
    constexpr const vec<_Tp, 2>& xy() const
        requires(_length < 5 && _length > 1)
    {
        return *reinterpret_cast<const vec<_Tp, 2>*>(data);
    }
    constexpr vec<_Tp, 2>& xy()
        requires(_length < 5 && _length > 1)
    {
        return *reinterpret_cast<vec<_Tp, 2>*>(data);
    }
 
    constexpr const vec<_Tp, 2>& yz() const
        requires(_length < 5 && _length > 2)
    {
        return *reinterpret_cast<const vec<_Tp, 2>*>(data + 1);
    }
    constexpr vec<_Tp, 2>& yz()
        requires(_length < 5 && _length > 2)
    {
        return *reinterpret_cast<vec<_Tp, 2>*>(data + 1);
    }
 
    constexpr const vec<_Tp, 2>& zw() const
        requires(_length < 5 && _length > 3)
    {
        return *reinterpret_cast<const vec<_Tp, 2>*>(data + 2);
    }
    constexpr vec<_Tp, 2>& zw()
        requires(_length < 5 && _length > 3)
    {
        return *reinterpret_cast<vec<_Tp, 2>*>(data + 2);
    }
 
    constexpr const vec<_Tp, 3>& xyz() const
        requires(_length < 5 && _length > 2)
    {
        return *reinterpret_cast<const vec<_Tp, 3>*>(data);
    }
    constexpr vec<_Tp, 3>& xyz()
        requires(_length < 5 && _length > 2)
    {
        return *reinterpret_cast<vec<_Tp, 3>*>(data);
    }
    constexpr const vec<_Tp, 3>& yzw() const
        requires(_length < 5 && _length > 2)
    {
        return *reinterpret_cast<const vec<_Tp, 3>*>(data + 1);
    }
    constexpr vec<_Tp, 3>& yzw()
        requires(_length < 5 && _length > 2)
    {
        return *reinterpret_cast<vec<_Tp, 3>*>(data + 1);
    }
 
    constexpr vec<_Tp, 2> xz() const
        requires(_length < 5 && _length > 2)
    {
        return {data[0], data[2]};
    }
    constexpr vec<_Tp, 2> xw() const
        requires(_length < 5 && _length > 3)
    {
        return {data[0], data[3]};
    }
    constexpr vec<_Tp, 2> yw() const
        requires(_length < 5 && _length > 3)
    {
        return {data[1], data[3]};
    }
 
    constexpr vec<_Tp, _length> cross(const vec<_Tp, _length>& other) const {
        vec<_Tp, _length> res;
        res[0] = data[1] * other[2] - data[2] * other[1];
        res[1] = data[2] * other[0] - data[0] * other[2];
        res[2] = data[0] * other[1] - data[1] * other[0];
        return res;
    }
 
    constexpr _Tp dot(const vec<_Tp, _length>& other) const {
        _Tp res = _Tp{};
        for (size_t i = 0; i < _length; i++) {
            res += data[i] * other[i];
        }
        return res;
    }
 
    constexpr vec<_Tp, _length> normalize() const {
        vec<_Tp, _length> res;
        auto disten = distance({});
        for (size_t i = 0; i < _length; i++) {
            res[i] = data[i] / disten;
        }
        return res;
    }
 
    constexpr _Tp distance(const vec<_Tp, _length>& other) const {
        _Tp res = _Tp{};
        for (size_t i = 0; i < _length; i++) {
            res += (data[i] - other[i]) * (data[i] - other[i]);
        }
        return std::sqrt(res);
    }
 
    constexpr _Tp mod() const {
        _Tp res = _Tp{};
        for (size_t i = 0; i < _length; i++) {
            res += data[i] * data[i];
        }
        return sqrt(res);
    }
 
    constexpr _Tp angle(const vec<_Tp, _length>& other) const {
        _Tp cos_theta = dot(other) / (mod() * other.mod());
        return std::acos(cos_theta);
    }
 
    constexpr bool any() const
        requires(std::is_convertible_v<DataType, bool>)
    {
        if constexpr (std::is_convertible_v<ItemType, bool>) {
            for (size_t i = 0; i < _length; i++)
                if (data[i]) {
                    return true;
                }
            return false;
        } else if constexpr (Vec<ItemType>) {
            for (size_t i = 0; i < _length; i++) {
                if (data[i].any()) {
                    return true;
                }
            }
            return false;
        }
    }
 
    constexpr bool every() const
        requires(std::is_convertible_v<DataType, bool>)
    {
        if constexpr (std::is_convertible_v<ItemType, bool>) {
            for (size_t i = 0; i < _length; i++)
                if (!data[i]) {
                    return false;
                }
            return true;
        } else if constexpr (Vec<ItemType>) {
            for (size_t i = 0; i < _length; i++) {
                if (!data[i].every()) {
                    return false;
                }
            }
            return true;
        }
    }
 
    constexpr inline bool all() const
        requires(std::is_convertible_v<DataType, bool>)
    {
        return every();
    }
 
    template <typename _OTp>
        requires(std::is_convertible_v<ItemType, _OTp>)
    constexpr inline operator Self<_OTp>() const {
        Self<_OTp> ret;
        for (size_t i = 0; i < _length; i++)
            ret[i] = static_cast<_OTp>(data(i));
        return ret;
    }
 
    auto operator-() const {
        Self<decltype(-data[0])> res;
        for (size_t i = 0; i < _length; i++) {
            res[i] = -data[i];
        }
        return res;
    }
 
    auto operator+() const {
        Self<decltype(+data[0])> res;
        for (size_t i = 0; i < _length; i++) {
            res[i] = +data[i];
        }
        return res;
    }
 
    auto operator--() {
        auto tmp = *this;
        for (size_t i = 0; i < _length; i++) {
            data[i]--;
        }
        return tmp;
    }
 
    auto& operator--(int) {
        for (size_t i = 0; i < _length; i++) {
            --data[i];
        }
        return *this;
    }
 
    auto operator++() {
        auto tmp = *this;
        for (size_t i = 0; i < _length; i++) {
            data[i]++;
        }
        return tmp;
    }
 
    auto& operator++(int) {
        for (size_t i = 0; i < _length; i++) {
            --data[i];
        }
        return *this;
    }
 
#define __VEC_OP_VEC_ON_EQ_LENGTH(op)                                    \
    template <class _OTp>                                                \
        requires(dim == VecInfo<_OTp>::dim)                              \
    auto operator op(const _OTp& o) const {                              \
        Self<decltype(data[0] op o[0])> res;                             \
        auto length = (_length > _OTp::length) ? _OTp::length : _length; \
        for (size_t i = 0; i < length; i++) {                            \
            res[i] = data[i] op o[i];                                    \
        }                                                                \
        return res;                                                      \
    }
    __VEC_OP_VEC_ON_EQ_LENGTH(+)
    __VEC_OP_VEC_ON_EQ_LENGTH(-)
    __VEC_OP_VEC_ON_EQ_LENGTH(*)
    __VEC_OP_VEC_ON_EQ_LENGTH(/)
    __VEC_OP_VEC_ON_EQ_LENGTH(%)
    __VEC_OP_VEC_ON_EQ_LENGTH(&)
    __VEC_OP_VEC_ON_EQ_LENGTH(|)
    __VEC_OP_VEC_ON_EQ_LENGTH(^)
    __VEC_OP_VEC_ON_EQ_LENGTH(==)
    __VEC_OP_VEC_ON_EQ_LENGTH(!=)
    __VEC_OP_VEC_ON_EQ_LENGTH(>)
    __VEC_OP_VEC_ON_EQ_LENGTH(<)
    __VEC_OP_VEC_ON_EQ_LENGTH(>=)
    __VEC_OP_VEC_ON_EQ_LENGTH(<=)
#undef __VEC_OP_VEC_ON_EQ_LENGTH
 
#define __VEC_OP_ITEM_ON_OP_ABLE(op)                                       \
    template <class _OTp>                                                  \
        requires(VecInfo<_OTp>::dim == 0 || dim == VecInfo<_OTp>::dim + 1) \
    inline constexpr auto operator op(const _OTp& o) const {               \
        Self<decltype(data[0] op o)> res;                                  \
        for (size_t i = 0; i < _length; i++) {                             \
            res[i] = data[i] op o;                                         \
        }                                                                  \
        return res;                                                        \
    }
    __VEC_OP_ITEM_ON_OP_ABLE(+)
    __VEC_OP_ITEM_ON_OP_ABLE(-)
    __VEC_OP_ITEM_ON_OP_ABLE(*)
    __VEC_OP_ITEM_ON_OP_ABLE(/)
    __VEC_OP_ITEM_ON_OP_ABLE(%)
    __VEC_OP_ITEM_ON_OP_ABLE(&)
    __VEC_OP_ITEM_ON_OP_ABLE(|)
    __VEC_OP_ITEM_ON_OP_ABLE(^)
    __VEC_OP_ITEM_ON_OP_ABLE(==)
    __VEC_OP_ITEM_ON_OP_ABLE(!=)
    __VEC_OP_ITEM_ON_OP_ABLE(>)
    __VEC_OP_ITEM_ON_OP_ABLE(<)
    __VEC_OP_ITEM_ON_OP_ABLE(>=)
    __VEC_OP_ITEM_ON_OP_ABLE(<=)
#undef __VEC_OP_ITEM_ON_OP_ABLE
};
 
#define __ITEM_OP_VEC_ON_OP_ENABLE(op)                                   \
    template <class _OTp, Vec _Tp>                                       \
        requires(VecInfo<_OTp>::dim == 0 ||                              \
                 (VecInfo<_OTp>::dim == _Tp::dim - 1))                   \
    inline constexpr auto operator op(const _OTp& other, const _Tp& o) { \
        typename _Tp::template Self<decltype(other op o[0])> res;        \
        for (size_t i = 0; i < _Tp::length; i++) res[i] = other op o[i]; \
        return res;                                                      \
    }
 
__ITEM_OP_VEC_ON_OP_ENABLE(+)
__ITEM_OP_VEC_ON_OP_ENABLE(-)
__ITEM_OP_VEC_ON_OP_ENABLE(*)
__ITEM_OP_VEC_ON_OP_ENABLE(/)
__ITEM_OP_VEC_ON_OP_ENABLE(%)
__ITEM_OP_VEC_ON_OP_ENABLE(&)
__ITEM_OP_VEC_ON_OP_ENABLE(|)
__ITEM_OP_VEC_ON_OP_ENABLE(^) __ITEM_OP_VEC_ON_OP_ENABLE(==)
    __ITEM_OP_VEC_ON_OP_ENABLE(!=) __ITEM_OP_VEC_ON_OP_ENABLE(>)
        __ITEM_OP_VEC_ON_OP_ENABLE(<) __ITEM_OP_VEC_ON_OP_ENABLE(>=)
            __ITEM_OP_VEC_ON_OP_ENABLE(<=)
#undef __ITEM_OP_VEC_ON_OP_ENABLE
}  // namespace xcmath
#endif  // VEC_H