BlackMATov/vmath.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/vmath.hpp.git synced 2025-12-16 14:11:28 +07:00
Code Issues Packages Projects Releases Wiki Activity

operators non-arithmetic T support

Browse Source
This commit is contained in:
BlackMATov
2021-02-21 01:27:12 +07:00
parent 8e971073af
commit 2a19b789eb
4 changed files with 146 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
README.md
View File

@@ -460,33 +460,33 @@ using qdouble = qua<double>;
// +operator // +operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator+(const vec<T, Size>& xs); constexpr auto operator+(const vec<T, Size>& xs);
// -operator // -operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator-(const vec<T, Size>& xs); constexpr auto operator-(const vec<T, Size>& xs);
// ~operator // ~operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator~(const vec<T, Size>& xs); constexpr auto operator~(const vec<T, Size>& xs);
// !operator // !operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator!(const vec<T, Size>& xs); constexpr auto operator!(const vec<T, Size>& xs);
// operator+ // operator+
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator+(const vec<T, Size>& xs, T y); constexpr auto operator+(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator+(T x, const vec<T, Size>& ys); constexpr auto operator+(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator+(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator+(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator+= // operator+=
@@ -499,13 +499,13 @@ constexpr vec<T, Size>& operator+=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator- // operator-
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator-(const vec<T, Size>& xs, T y); constexpr auto operator-(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator-(T x, const vec<T, Size>& ys); constexpr auto operator-(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator-(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator-(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator-= // operator-=
@@ -518,13 +518,13 @@ constexpr vec<T, Size>& operator-=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator* // operator*
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator*(const vec<T, Size>& xs, T y); constexpr auto operator*(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator*(T x, const vec<T, Size>& ys); constexpr auto operator*(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator*(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator*(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator*= // operator*=
@@ -537,13 +537,13 @@ constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator/ // operator/
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator/(const vec<T, Size>& xs, T y); constexpr auto operator/(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator/(T x, const vec<T, Size>& ys); constexpr auto operator/(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator/(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator/(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator/= // operator/=
@@ -556,13 +556,13 @@ constexpr vec<T, Size>& operator/=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator& // operator&
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator&(const vec<T, Size>& xs, T y); constexpr auto operator&(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator&(T x, const vec<T, Size>& ys); constexpr auto operator&(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator&(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator&(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator&= // operator&=
@@ -575,13 +575,13 @@ constexpr vec<T, Size>& operator&=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator| // operator|
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator|(const vec<T, Size>& xs, T y); constexpr auto operator|(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator|(T x, const vec<T, Size>& ys); constexpr auto operator|(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator|(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator|(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator|= // operator|=
@@ -594,13 +594,13 @@ constexpr vec<T, Size>& operator|=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator^ // operator^
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator^(const vec<T, Size>& xs, T y); constexpr auto operator^(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator^(T x, const vec<T, Size>& ys); constexpr auto operator^(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator^(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator^(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator^= // operator^=
@@ -613,24 +613,24 @@ constexpr vec<T, Size>& operator^=(vec<T, Size>& xs, const vec<T, Size>& ys);
// operator&& // operator&&
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator&&(const vec<T, Size>& xs, T y); constexpr auto operator&&(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator&&(T x, const vec<T, Size>& ys); constexpr auto operator&&(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator&&(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator&&(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator|| // operator||
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator||(const vec<T, Size>& xs, T y); constexpr auto operator||(const vec<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator||(T x, const vec<T, Size>& ys); constexpr auto operator||(T x, const vec<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<bool, Size> operator||(const vec<T, Size>& xs, const vec<T, Size>& ys); constexpr auto operator||(const vec<T, Size>& xs, const vec<T, Size>& ys);
// operator== // operator==
@@ -654,33 +654,33 @@ constexpr bool operator<(const vec<T, Size>& xs, const vec<T, Size>& ys);
// +operator // +operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator+(const mat<T, Size>& xs); constexpr auto operator+(const mat<T, Size>& xs);
// -operator // -operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator-(const mat<T, Size>& xs); constexpr auto operator-(const mat<T, Size>& xs);
// ~operator // ~operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator~(const mat<T, Size>& xs); constexpr auto operator~(const mat<T, Size>& xs);
// !operator // !operator
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator!(const mat<T, Size>& xs); constexpr auto operator!(const mat<T, Size>& xs);
// operator+ // operator+
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator+(const mat<T, Size>& xs, T y); constexpr auto operator+(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator+(T x, const mat<T, Size>& ys); constexpr auto operator+(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator+(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator+(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator+= // operator+=
@@ -693,13 +693,13 @@ constexpr mat<T, Size>& operator+=(mat<T, Size>& xs, const mat<T, Size>& ys);
// operator- // operator-
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator-(const mat<T, Size>& xs, T y); constexpr auto operator-(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator-(T x, const mat<T, Size>& ys); constexpr auto operator-(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator-(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator-(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator-= // operator-=
@@ -712,16 +712,16 @@ constexpr mat<T, Size>& operator-=(mat<T, Size>& xs, const mat<T, Size>& ys);
// operator* // operator*
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator*(const mat<T, Size>& xs, T y); constexpr auto operator*(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator*(T x, const mat<T, Size>& ys); constexpr auto operator*(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr vec<T, Size> operator*(const vec<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator*(const vec<T, Size>& xs, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator*(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator*(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator*= // operator*=
@@ -737,10 +737,10 @@ constexpr mat<T, Size>& operator*=(mat<T, Size>& xs, const mat<T, Size>& ys);
// operator/ // operator/
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator/(const mat<T, Size>& xs, T y); constexpr auto operator/(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator/(T x, const mat<T, Size>& ys); constexpr auto operator/(T x, const mat<T, Size>& ys);
// operator/= // operator/=
@@ -750,13 +750,13 @@ constexpr mat<T, Size>& operator/=(mat<T, Size>& xs, T y);
// operator& // operator&
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator&(const mat<T, Size>& xs, T y); constexpr auto operator&(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator&(T x, const mat<T, Size>& ys); constexpr auto operator&(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator&(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator&(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator&= // operator&=
@@ -769,13 +769,13 @@ constexpr mat<T, Size>& operator&=(mat<T, Size>& xs, const mat<T, Size>& ys);
// operator| // operator|
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator|(const mat<T, Size>& xs, T y); constexpr auto operator|(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator|(T x, const mat<T, Size>& ys); constexpr auto operator|(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator|(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator|(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator|= // operator|=
@@ -788,13 +788,13 @@ constexpr mat<T, Size>& operator|=(mat<T, Size>& xs, const mat<T, Size>& ys);
// operator^ // operator^
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator^(const mat<T, Size>& xs, T y); constexpr auto operator^(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator^(T x, const mat<T, Size>& ys); constexpr auto operator^(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<T, Size> operator^(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator^(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator^= // operator^=
@@ -807,24 +807,24 @@ constexpr mat<T, Size>& operator^=(mat<T, Size>& xs, const mat<T, Size>& ys);
// operator&& // operator&&
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator&&(const mat<T, Size>& xs, T y); constexpr auto operator&&(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator&&(T x, const mat<T, Size>& ys); constexpr auto operator&&(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator&&(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator&&(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator|| // operator||
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator||(const mat<T, Size>& xs, T y); constexpr auto operator||(const mat<T, Size>& xs, T y);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator||(T x, const mat<T, Size>& ys); constexpr auto operator||(T x, const mat<T, Size>& ys);
template < typename T, size_t Size > template < typename T, size_t Size >
constexpr mat<bool, Size> operator||(const mat<T, Size>& xs, const mat<T, Size>& ys); constexpr auto operator||(const mat<T, Size>& xs, const mat<T, Size>& ys);
// operator== // operator==
@@ -848,17 +848,17 @@ constexpr bool operator<(const mat<T, Size>& xs, const mat<T, Size>& ys);
// +operator // +operator
template < typename T > template < typename T >
constexpr qua<T> operator+(const qua<T>& xs); constexpr auto operator+(const qua<T>& xs);
// -operator // -operator
template < typename T > template < typename T >
constexpr qua<T> operator-(const qua<T>& xs); constexpr auto operator-(const qua<T>& xs);
// operator+ // operator+
template < typename T > template < typename T >
constexpr qua<T> operator+(const qua<T>& xs, const qua<T>& ys); constexpr auto operator+(const qua<T>& xs, const qua<T>& ys);
// operator+= // operator+=
@@ -868,7 +868,7 @@ constexpr qua<T>& operator+=(qua<T>& xs, const qua<T>& ys);
// operator- // operator-
template < typename T > template < typename T >
constexpr qua<T> operator-(const qua<T>& xs, const qua<T>& ys); constexpr auto operator-(const qua<T>& xs, const qua<T>& ys);
// operator-= // operator-=
@@ -878,16 +878,16 @@ constexpr qua<T>& operator-=(qua<T>& xs, const qua<T>& ys);
// operator* // operator*
template < typename T > template < typename T >
constexpr qua<T> operator*(const qua<T>& xs, T y); constexpr auto operator*(const qua<T>& xs, T y);
template < typename T > template < typename T >
constexpr qua<T> operator*(T x, const qua<T>& ys); constexpr auto operator*(T x, const qua<T>& ys);
template < typename T > template < typename T >
constexpr vec<T, 3> operator*(const vec<T, 3>& xs, const qua<T>& ys); constexpr auto operator*(const vec<T, 3>& xs, const qua<T>& ys);
template < typename T > template < typename T >
constexpr qua<T> operator*(const qua<T>& xs, const qua<T>& ys); constexpr auto operator*(const qua<T>& xs, const qua<T>& ys);
// operator*= // operator*=
@@ -903,10 +903,10 @@ constexpr qua<T>& operator*=(qua<T>& xs, const qua<T>& ys);
// operator/ // operator/
template < typename T > template < typename T >
constexpr qua<T> operator/(const qua<T>& xs, T y); constexpr auto operator/(const qua<T>& xs, T y);
template < typename T > template < typename T >
constexpr qua<T> operator/(T x, const qua<T>& ys); constexpr auto operator/(T x, const qua<T>& ys);
// operator/= // operator/=

62
headers/vmath.hpp/vmath_mat_fun.hpp
View File

@@ -195,45 +195,45 @@ namespace vmath_hpp
// +operator // +operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator+(const mat<T, Size>& xs) { [[nodiscard]] constexpr auto operator+(const mat<T, Size>& xs) {
return xs; return xs;
} }
// -operator // -operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator-(const mat<T, Size>& xs) { [[nodiscard]] constexpr auto operator-(const mat<T, Size>& xs) {
return map_join([](const vec<T, Size>& x){ return -x; }, xs); return map_join([](const vec<T, Size>& x){ return -x; }, xs);
} }
// ~operator // ~operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator~(const mat<T, Size>& xs) { [[nodiscard]] constexpr auto operator~(const mat<T, Size>& xs) {
return map_join([](const vec<T, Size>& x){ return ~x; }, xs); return map_join([](const vec<T, Size>& x){ return ~x; }, xs);
} }
// !operator // !operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator!(const mat<T, Size>& xs) { [[nodiscard]] constexpr auto operator!(const mat<T, Size>& xs) {
return map_join([](const vec<T, Size>& x){ return !x; }, xs); return map_join([](const vec<T, Size>& x){ return !x; }, xs);
} }
// operator+ // operator+
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator+(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator+(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x + y; }, xs); return map_join([y](const vec<T, Size>& x){ return x + y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator+(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator+(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x + y; }, ys); return map_join([x](const vec<T, Size>& y){ return x + y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator+(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator+(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x + y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x + y; }, xs, ys);
} }
@@ -252,17 +252,17 @@ namespace vmath_hpp
// operator- // operator-
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator-(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator-(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x - y; }, xs); return map_join([y](const vec<T, Size>& x){ return x - y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator-(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator-(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x - y; }, ys); return map_join([x](const vec<T, Size>& y){ return x - y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator-(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator-(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x - y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x - y; }, xs, ys);
} }
@@ -281,24 +281,24 @@ namespace vmath_hpp
// operator* // operator*
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator*(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator*(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x * y; }, xs); return map_join([y](const vec<T, Size>& x){ return x * y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator*(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator*(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x * y; }, ys); return map_join([x](const vec<T, Size>& y){ return x * y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator*(const vec<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, const mat<T, Size>& ys) {
return fold_join([](const vec<T, Size>& acc, T x, const vec<T, Size>& y){ return fold_join([](const vec<T, Size>& acc, T x, const vec<T, Size>& y){
return acc + x * y; return acc + x * y;
}, vec<T, Size>{}, xs, ys); }, vec<T, Size>{}, xs, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator*(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator*(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([&ys](const vec<T, Size>& x){ return map_join([&ys](const vec<T, Size>& x){
return x * ys; return x * ys;
}, xs); }, xs);
@@ -324,12 +324,12 @@ namespace vmath_hpp
// operator/ // operator/
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator/(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator/(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x / y; }, xs); return map_join([y](const vec<T, Size>& x){ return x / y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator/(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator/(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x / y; }, ys); return map_join([x](const vec<T, Size>& y){ return x / y; }, ys);
} }
@@ -343,17 +343,17 @@ namespace vmath_hpp
// operator& // operator&
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator&(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator&(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x & y; }, xs); return map_join([y](const vec<T, Size>& x){ return x & y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator&(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator&(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x & y; }, ys); return map_join([x](const vec<T, Size>& y){ return x & y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator&(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator&(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x & y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x & y; }, xs, ys);
} }
@@ -372,17 +372,17 @@ namespace vmath_hpp
// operator| // operator|
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator|(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator|(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x | y; }, xs); return map_join([y](const vec<T, Size>& x){ return x | y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator|(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator|(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x | y; }, ys); return map_join([x](const vec<T, Size>& y){ return x | y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator|(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator|(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x | y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x | y; }, xs, ys);
} }
@@ -401,17 +401,17 @@ namespace vmath_hpp
// operator^ // operator^
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator^(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator^(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x ^ y; }, xs); return map_join([y](const vec<T, Size>& x){ return x ^ y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator^(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator^(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x ^ y; }, ys); return map_join([x](const vec<T, Size>& y){ return x ^ y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<T, Size> operator^(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator^(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x ^ y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x ^ y; }, xs, ys);
} }
@@ -430,34 +430,34 @@ namespace vmath_hpp
// operator&& // operator&&
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator&&(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator&&(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x && y; }, xs); return map_join([y](const vec<T, Size>& x){ return x && y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator&&(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator&&(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x && y; }, ys); return map_join([x](const vec<T, Size>& y){ return x && y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator&&(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator&&(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x && y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x && y; }, xs, ys);
} }
// operator|| // operator||
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator||(const mat<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator||(const mat<T, Size>& xs, T y) {
return map_join([y](const vec<T, Size>& x){ return x || y; }, xs); return map_join([y](const vec<T, Size>& x){ return x || y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator||(T x, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator||(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x || y; }, ys); return map_join([x](const vec<T, Size>& y){ return x || y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr mat<bool, Size> operator||(const mat<T, Size>& xs, const mat<T, Size>& ys) { [[nodiscard]] constexpr auto operator||(const mat<T, Size>& xs, const mat<T, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x || y; }, xs, ys); return map_join([](const vec<T, Size>& x, const vec<T, Size>& y){ return x || y; }, xs, ys);
} }

24
headers/vmath.hpp/vmath_qua_fun.hpp
View File

@@ -23,21 +23,21 @@ namespace vmath_hpp
// +operator // +operator
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator+(const qua<T>& xs) { [[nodiscard]] constexpr auto operator+(const qua<T>& xs) {
return xs; return xs;
} }
// -operator // -operator
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator-(const qua<T>& xs) { [[nodiscard]] constexpr auto operator-(const qua<T>& xs) {
return qua(-vec<T, 4>{xs}); return qua(-vec<T, 4>{xs});
} }
// operator+ // operator+
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator+(const qua<T>& xs, const qua<T>& ys) { [[nodiscard]] constexpr auto operator+(const qua<T>& xs, const qua<T>& ys) {
return qua(vec{xs} + vec{ys}); return qua(vec{xs} + vec{ys});
} }
@@ -51,7 +51,7 @@ namespace vmath_hpp
// operator- // operator-
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator-(const qua<T>& xs, const qua<T>& ys) { [[nodiscard]] constexpr auto operator-(const qua<T>& xs, const qua<T>& ys) {
return qua(vec{xs} - vec{ys}); return qua(vec{xs} - vec{ys});
} }
@@ -65,30 +65,30 @@ namespace vmath_hpp
// operator* // operator*
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator*(const qua<T>& xs, T y) { [[nodiscard]] constexpr auto operator*(const qua<T>& xs, T y) {
return qua(vec{xs} * y); return qua(vec{xs} * y);
} }
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator*(T x, const qua<T>& ys) { [[nodiscard]] constexpr auto operator*(T x, const qua<T>& ys) {
return qua(x * vec{ys}); return qua(x * vec{ys});
} }
template < typename T > template < typename T >
[[nodiscard]] constexpr vec<T, 3> operator*(const vec<T, 3>& xs, const qua<T>& ys) { [[nodiscard]] constexpr auto operator*(const vec<T, 3>& xs, const qua<T>& ys) {
/// REFERENCE: /// REFERENCE:
/// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/ /// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/
const vec qv2 = cross(ys.v, xs) * T(2); const vec qv2 = cross(ys.v, xs) * T{2};
return xs + qv2 * ys.s + cross(ys.v, qv2); return xs + qv2 * ys.s + cross(ys.v, qv2);
} }
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator*(const qua<T>& xs, const qua<T>& ys) { [[nodiscard]] constexpr auto operator*(const qua<T>& xs, const qua<T>& ys) {
/// REFERENCE: /// REFERENCE:
/// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/arithmetic/ /// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/arithmetic/
return { return qua{
cross(ys.v, xs.v) + ys.s * xs.v + xs.s * ys.v, cross(ys.v, xs.v) + ys.s * xs.v + xs.s * ys.v,
ys.s * xs.s - dot(ys.v, xs.v)}; ys.s * xs.s - dot(ys.v, xs.v)};
} }
@@ -113,12 +113,12 @@ namespace vmath_hpp
// operator/ // operator/
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator/(const qua<T>& xs, T y) { [[nodiscard]] constexpr auto operator/(const qua<T>& xs, T y) {
return qua(vec{xs} / y); return qua(vec{xs} / y);
} }
template < typename T > template < typename T >
[[nodiscard]] constexpr qua<T> operator/(T x, const qua<T>& ys) { [[nodiscard]] constexpr auto operator/(T x, const qua<T>& ys) {
return qua(x / vec{ys}); return qua(x / vec{ys});
} }

62
headers/vmath.hpp/vmath_vec_fun.hpp
View File

@@ -199,45 +199,45 @@ namespace vmath_hpp
// +operator // +operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator+(const vec<T, Size>& xs) { [[nodiscard]] constexpr auto operator+(const vec<T, Size>& xs) {
return xs; return xs;
} }
// -operator // -operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator-(const vec<T, Size>& xs) { [[nodiscard]] constexpr auto operator-(const vec<T, Size>& xs) {
return map_join([](T x){ return -x; }, xs); return map_join([](T x){ return -x; }, xs);
} }
// ~operator // ~operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator~(const vec<T, Size>& xs) { [[nodiscard]] constexpr auto operator~(const vec<T, Size>& xs) {
return map_join([](T x){ return ~x; }, xs); return map_join([](T x){ return ~x; }, xs);
} }
// !operator // !operator
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator!(const vec<T, Size>& xs) { [[nodiscard]] constexpr auto operator!(const vec<T, Size>& xs) {
return map_join([](T x){ return !x; }, xs); return map_join([](T x){ return !x; }, xs);
} }
// operator+ // operator+
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator+(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator+(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x + y; }, xs); return map_join([y](T x){ return x + y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator+(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator+(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x + y; }, ys); return map_join([x](T y){ return x + y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator+(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator+(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x + y; }, xs, ys); return map_join([](T x, T y){ return x + y; }, xs, ys);
} }
@@ -256,17 +256,17 @@ namespace vmath_hpp
// operator- // operator-
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator-(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator-(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x - y; }, xs); return map_join([y](T x){ return x - y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator-(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator-(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x - y; }, ys); return map_join([x](T y){ return x - y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator-(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator-(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x - y; }, xs, ys); return map_join([](T x, T y){ return x - y; }, xs, ys);
} }
@@ -285,17 +285,17 @@ namespace vmath_hpp
// operator* // operator*
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator*(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x * y; }, xs); return map_join([y](T x){ return x * y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator*(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator*(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x * y; }, ys); return map_join([x](T y){ return x * y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator*(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x * y; }, xs, ys); return map_join([](T x, T y){ return x * y; }, xs, ys);
} }
@@ -314,17 +314,17 @@ namespace vmath_hpp
// operator/ // operator/
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator/(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator/(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x / y; }, xs); return map_join([y](T x){ return x / y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator/(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator/(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x / y; }, ys); return map_join([x](T y){ return x / y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator/(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator/(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x / y; }, xs, ys); return map_join([](T x, T y){ return x / y; }, xs, ys);
} }
@@ -343,17 +343,17 @@ namespace vmath_hpp
// operator& // operator&
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator&(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator&(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x & y; }, xs); return map_join([y](T x){ return x & y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator&(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator&(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x & y; }, ys); return map_join([x](T y){ return x & y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator&(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator&(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x & y; }, xs, ys); return map_join([](T x, T y){ return x & y; }, xs, ys);
} }
@@ -372,17 +372,17 @@ namespace vmath_hpp
// operator| // operator|
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator|(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator|(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x | y; }, xs); return map_join([y](T x){ return x | y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator|(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator|(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x | y; }, ys); return map_join([x](T y){ return x | y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator|(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator|(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x | y; }, xs, ys); return map_join([](T x, T y){ return x | y; }, xs, ys);
} }
@@ -401,17 +401,17 @@ namespace vmath_hpp
// operator^ // operator^
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator^(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator^(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x ^ y; }, xs); return map_join([y](T x){ return x ^ y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator^(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator^(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x ^ y; }, ys); return map_join([x](T y){ return x ^ y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<T, Size> operator^(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator^(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x ^ y; }, xs, ys); return map_join([](T x, T y){ return x ^ y; }, xs, ys);
} }
@@ -430,34 +430,34 @@ namespace vmath_hpp
// operator&& // operator&&
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator&&(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator&&(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x && y; }, xs); return map_join([y](T x){ return x && y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator&&(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator&&(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x && y; }, ys); return map_join([x](T y){ return x && y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator&&(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator&&(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x && y; }, xs, ys); return map_join([](T x, T y){ return x && y; }, xs, ys);
} }
// operator|| // operator||
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator||(const vec<T, Size>& xs, T y) { [[nodiscard]] constexpr auto operator||(const vec<T, Size>& xs, T y) {
return map_join([y](T x){ return x || y; }, xs); return map_join([y](T x){ return x || y; }, xs);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator||(T x, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator||(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x || y; }, ys); return map_join([x](T y){ return x || y; }, ys);
} }
template < typename T, std::size_t Size > template < typename T, std::size_t Size >
[[nodiscard]] constexpr vec<bool, Size> operator||(const vec<T, Size>& xs, const vec<T, Size>& ys) { [[nodiscard]] constexpr auto operator||(const vec<T, Size>& xs, const vec<T, Size>& ys) {
return map_join([](T x, T y){ return x || y; }, xs, ys); return map_join([](T x, T y){ return x || y; }, xs, ys);
} }