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

two-type + - * / operators

Browse Source
This commit is contained in:
BlackMATov
2021-02-24 07:32:14 +07:00
parent f0b616aa09
commit 08051bcc4a
7 changed files with 201 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -192,19 +192,19 @@ namespace vmath_hpp
// operator+
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator+(const mat<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator+(const mat<T, Size>& xs, U y) {
return map_join([y](const vec<T, Size>& x){ return x + y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator+(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x + y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator+(T x, const mat<U, Size>& ys) {
return map_join([x](const vec<U, Size>& y){ return x + y; }, ys);
}
template < typename T, std::size_t Size >
[[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);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator+(const mat<T, Size>& xs, const mat<U, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<U, Size>& y){ return x + y; }, xs, ys);
}
// operator+=
@@ -221,19 +221,19 @@ namespace vmath_hpp
// operator-
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator-(const mat<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator-(const mat<T, Size>& xs, U y) {
return map_join([y](const vec<T, Size>& x){ return x - y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator-(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x - y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator-(T x, const mat<U, Size>& ys) {
return map_join([x](const vec<U, Size>& y){ return x - y; }, ys);
}
template < typename T, std::size_t Size >
[[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);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator-(const mat<T, Size>& xs, const mat<U, Size>& ys) {
return map_join([](const vec<T, Size>& x, const vec<U, Size>& y){ return x - y; }, xs, ys);
}
// operator-=
@@ -250,25 +250,26 @@ namespace vmath_hpp
// operator*
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const mat<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const mat<T, Size>& xs, U y) {
return map_join([y](const vec<T, Size>& x){ return x * y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator*(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x * y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(T x, const mat<U, Size>& ys) {
return map_join([x](const vec<U, Size>& y){ return x * y; }, ys);
}
template < typename T, std::size_t Size >
[[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){
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, const mat<U, Size>& ys) {
using V = decltype(std::declval<T>() * std::declval<U>());
return fold_join([](const vec<V, Size>& acc, T x, const vec<U, Size>& y){
return acc + x * y;
}, vec<T, Size>{}, xs, ys);
}, vec<V, Size>{}, xs, ys);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const mat<T, Size>& xs, const mat<T, Size>& ys) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const mat<T, Size>& xs, const mat<U, Size>& ys) {
return map_join([&ys](const vec<T, Size>& x){
return x * ys;
}, xs);
@@ -293,14 +294,14 @@ namespace vmath_hpp
// operator/
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator/(const mat<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator/(const mat<T, Size>& xs, U y) {
return map_join([y](const vec<T, Size>& x){ return x / y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator/(T x, const mat<T, Size>& ys) {
return map_join([x](const vec<T, Size>& y){ return x / y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator/(T x, const mat<U, Size>& ys) {
return map_join([x](const vec<U, Size>& y){ return x / y; }, ys);
}
// operator/=

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

@@ -81,8 +81,8 @@ namespace vmath_hpp
// operator+
template < typename T >
[[nodiscard]] constexpr auto operator+(const qua<T>& xs, const qua<T>& ys) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator+(const qua<T>& xs, const qua<U>& ys) {
return qua(vec{xs} + vec{ys});
}
@@ -95,8 +95,8 @@ namespace vmath_hpp
// operator-
template < typename T >
[[nodiscard]] constexpr auto operator-(const qua<T>& xs, const qua<T>& ys) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator-(const qua<T>& xs, const qua<U>& ys) {
return qua(vec{xs} - vec{ys});
}
@@ -109,18 +109,18 @@ namespace vmath_hpp
// operator*
template < typename T >
[[nodiscard]] constexpr auto operator*(const qua<T>& xs, T y) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator*(const qua<T>& xs, U y) {
return qua(vec{xs} * y);
}
template < typename T >
[[nodiscard]] constexpr auto operator*(T x, const qua<T>& ys) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator*(T x, const qua<U>& ys) {
return qua(x * vec{ys});
}
template < typename T >
[[nodiscard]] constexpr auto operator*(const vec<T, 3>& xs, const qua<T>& ys) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator*(const vec<T, 3>& xs, const qua<U>& ys) {
/// REFERENCE:
/// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/
@@ -128,8 +128,8 @@ namespace vmath_hpp
return xs + qv2 * ys.s + cross(ys.v, qv2);
}
template < typename T >
[[nodiscard]] constexpr auto operator*(const qua<T>& xs, const qua<T>& ys) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator*(const qua<T>& xs, const qua<U>& ys) {
/// REFERENCE:
/// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/arithmetic/
@@ -157,13 +157,13 @@ namespace vmath_hpp
// operator/
template < typename T >
[[nodiscard]] constexpr auto operator/(const qua<T>& xs, T y) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator/(const qua<T>& xs, U y) {
return qua(vec{xs} / y);
}
template < typename T >
[[nodiscard]] constexpr auto operator/(T x, const qua<T>& ys) {
template < typename T, typename U >
[[nodiscard]] constexpr auto operator/(T x, const qua<U>& ys) {
return qua(x / vec{ys});
}

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

@@ -175,19 +175,19 @@ namespace vmath_hpp
// operator+
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator+(const vec<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator+(const vec<T, Size>& xs, U y) {
return map_join([y](T x){ return x + y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator+(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x + y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator+(T x, const vec<U, Size>& ys) {
return map_join([x](U y){ return x + y; }, ys);
}
template < typename T, std::size_t Size >
[[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);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator+(const vec<T, Size>& xs, const vec<U, Size>& ys) {
return map_join([](T x, U y){ return x + y; }, xs, ys);
}
// operator+=
@@ -204,19 +204,19 @@ namespace vmath_hpp
// operator-
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator-(const vec<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator-(const vec<T, Size>& xs, U y) {
return map_join([y](T x){ return x - y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator-(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x - y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator-(T x, const vec<U, Size>& ys) {
return map_join([x](U y){ return x - y; }, ys);
}
template < typename T, std::size_t Size >
[[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);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator-(const vec<T, Size>& xs, const vec<U, Size>& ys) {
return map_join([](T x, U y){ return x - y; }, xs, ys);
}
// operator-=
@@ -233,19 +233,19 @@ namespace vmath_hpp
// operator*
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, U y) {
return map_join([y](T x){ return x * y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator*(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x * y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(T x, const vec<U, Size>& ys) {
return map_join([x](U y){ return x * y; }, ys);
}
template < typename T, std::size_t Size >
[[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);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator*(const vec<T, Size>& xs, const vec<U, Size>& ys) {
return map_join([](T x, U y){ return x * y; }, xs, ys);
}
// operator*=
@@ -262,19 +262,19 @@ namespace vmath_hpp
// operator/
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator/(const vec<T, Size>& xs, T y) {
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator/(const vec<T, Size>& xs, U y) {
return map_join([y](T x){ return x / y; }, xs);
}
template < typename T, std::size_t Size >
[[nodiscard]] constexpr auto operator/(T x, const vec<T, Size>& ys) {
return map_join([x](T y){ return x / y; }, ys);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator/(T x, const vec<U, Size>& ys) {
return map_join([x](U y){ return x / y; }, ys);
}
template < typename T, std::size_t Size >
[[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);
template < typename T, typename U, std::size_t Size >
[[nodiscard]] constexpr auto operator/(const vec<T, Size>& xs, const vec<U, Size>& ys) {
return map_join([](T x, U y){ return x / y; }, xs, ys);
}
// operator/=