9 template <
class T,
int Dim,
bool Packed>
13 for (
int i = 0; i < Dim; ++i) {
14 result[i] = lhs.data[i] * rhs.data[i];
18 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
19 result.simd = SimdT::mul(lhs.simd, rhs.simd);
24 template <
class T,
int Dim,
bool Packed>
28 for (
int i = 0; i < Dim; ++i) {
29 result[i] = lhs.data[i] / rhs.data[i];
33 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
34 result.simd = SimdT::div(lhs.simd, rhs.simd);
39 template <
class T,
int Dim,
bool Packed>
43 for (
int i = 0; i < Dim; ++i) {
44 result[i] = lhs.data[i] + rhs.data[i];
48 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
49 result.simd = SimdT::add(lhs.simd, rhs.simd);
54 template <
class T,
int Dim,
bool Packed>
58 for (
int i = 0; i < Dim; ++i) {
59 result[i] = lhs.data[i] - rhs.data[i];
63 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
64 result.simd = SimdT::sub(lhs.simd, rhs.simd);
71 template <
class T,
int Dim,
bool Packed>
74 for (
int i = 0; i < Dim; ++i) {
75 lhs.data[i] *= rhs.data[i];
79 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
80 lhs.simd = SimdT::mul(lhs.simd, rhs.simd);
86 template <
class T,
int Dim,
bool Packed>
89 for (
int i = 0; i < Dim; ++i) {
90 lhs.data[i] /= rhs.data[i];
94 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
95 lhs.simd = SimdT::div(lhs.simd, rhs.simd);
101 template <
class T,
int Dim,
bool Packed>
104 for (
int i = 0; i < Dim; ++i) {
105 lhs.data[i] += rhs.data[i];
109 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
110 lhs.simd = SimdT::add(lhs.simd, rhs.simd);
116 template <
class T,
int Dim,
bool Packed>
119 for (
int i = 0; i < Dim; ++i) {
120 lhs.data[i] -= rhs.data[i];
124 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
125 lhs.simd = SimdT::sub(lhs.simd, rhs.simd);
132 template <
class T,
int Dim,
bool Packed>
135 for (
int i = 0; i < Dim; ++i) {
140 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
141 lhs.simd = SimdT::mul(lhs.simd, rhs);
147 template <
class T,
int Dim,
bool Packed>
150 for (
int i = 0; i < Dim; ++i) {
155 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
156 lhs.simd = SimdT::div(lhs.simd, rhs);
162 template <
class T,
int Dim,
bool Packed>
165 for (
int i = 0; i < Dim; ++i) {
170 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
171 lhs.simd = SimdT::add(lhs.simd, rhs);
177 template <
class T,
int Dim,
bool Packed>
180 for (
int i = 0; i < Dim; ++i) {
185 using SimdT = decltype(VectorData<T, Dim, Packed>::simd);
186 lhs.simd = SimdT::sub(lhs.simd, rhs);
193 template <
class T,
int Dim,
bool Packed>
200 template <
class T,
int Dim,
bool Packed>
207 template <
class T,
int Dim,
bool Packed>
214 template <
class T,
int Dim,
bool Packed>
223 template <class T, int Dim, bool Packed, class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
226 template <class T, int Dim, bool Packed, class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
229 template <class T, int Dim, bool Packed, class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
232 template <class T, int Dim, bool Packed, class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
241 template <
class T,
int Dim,
bool Packed>
242 inline Vector<T, Dim, Packed> MultiplyAdd(
const Vector<T, Dim, Packed>& a,
const Vector<T, Dim, Packed>& b,
const Vector<T, Dim, Packed>& c) {
247 template <
class T,
int Dim,
bool Packed>
253 template <
class T,
int Dim,
bool Packed>
262 template <
class T,
int Dim,
bool Packed,
int... Indices>
264 return v * decltype(v)(s);
267 template <
class T,
int Dim,
bool Packed,
int... Indices>
269 return v / decltype(v)(s);
272 template <
class T,
int Dim,
bool Packed,
int... Indices>
274 return v + decltype(v)(s);
277 template <
class T,
int Dim,
bool Packed,
int... Indices>
279 return v - decltype(v)(s);
284 template <
class T,
int Dim,
bool Packed,
int... Indices>
286 return decltype(v)(s) * v;
289 template <
class T,
int Dim,
bool Packed,
int... Indices>
291 return decltype(v)(s) / v;
294 template <
class T,
int Dim,
bool Packed,
int... Indices>
296 return decltype(v)(s) + v;
299 template <
class T,
int Dim,
bool Packed,
int... Indices>
301 return decltype(v)(s) - v;
306 template <
class T,
int Dim,
bool Packed,
int... Indices>
308 return v *= decltype(v)(s);
311 template <
class T,
int Dim,
bool Packed,
int... Indices>
313 return v /= decltype(v)(s);
316 template <
class T,
int Dim,
bool Packed,
int... Indices>
318 return v += decltype(v)(s);
321 template <
class T,
int Dim,
bool Packed,
int... Indices>
323 return v -= decltype(v)(s);
Matrix< U, Rows, Columns, Order1, Layout1, Packed > & operator+=(Matrix< T, Rows, Columns, Order1, Layout1, Packed > &lhs, const Matrix< U, Rows, Columns, Order2, Layout2, Packed > &rhs)
Performs matrix addition and stores result in this.
Definition: MatrixArithmetic.hpp:287
Vector< T, Dim, Packed > MultiplyAdd(const Vector< T, Dim, Packed > &a, const Vector< T, Dim, Packed > &b, const Vector< T, Dim, Packed > &c)
Return (a*b)+c. Performs MAD or FMA if supported by target architecture.
Definition: VectorArithmetic.hpp:242
auto operator*(const Matrix< T, Rows1, Match, Order1, eMatrixLayout::ROW_MAJOR, Packed > &lhs, const Matrix< U, Match, Columns2, Order2, eMatrixLayout::ROW_MAJOR, Packed > &rhs) -> Matrix< V, Rows1, Columns2, Order1, eMatrixLayout::ROW_MAJOR, Packed >
Definition: MatrixArithmetic.hpp:78
Represents a vector in N-dimensional space.
Definition: Definitions.hpp:57
Enables element swizzling (reordering elements) for vectors.
Definition: Definitions.hpp:60
Definition: Approx.hpp:11
Matrix< T, Rows, Columns, Order, Layout, Packed > operator/(T s, const Matrix< T, Rows, Columns, Order, Layout, Packed > &mat)
Definition: MatrixArithmetic.hpp:333
Matrix< U, Rows, Columns, Order1, Layout1, Packed > & operator-=(Matrix< T, Rows, Columns, Order1, Layout1, Packed > &lhs, const Matrix< U, Rows, Columns, Order2, Layout2, Packed > &rhs)
Performs matrix subtraction and stores result in this.
Definition: MatrixArithmetic.hpp:296
Matrix< U, Rows, Columns, Order1, SameLayout, Packed > operator-(const Matrix< T, Rows, Columns, Order1, SameLayout, Packed > &lhs, const Matrix< U, Rows, Columns, Order2, SameLayout, Packed > &rhs)
Definition: MatrixArithmetic.hpp:239
Matrix< T1, Dim, Dim, Order1, Layout1, Packed > & operator*=(Matrix< T1, Dim, Dim, Order1, Layout1, Packed > &lhs, const Matrix< T2, Dim, Dim, Order2, Layout2, Packed > &rhs)
Definition: MatrixArithmetic.hpp:198
Matrix< T, Rows, Columns, Order, Layout, Packed > & operator/=(Matrix< T, Rows, Columns, Order, Layout, Packed > &mat, T s)
Divides all elements of the matrix by scalar.
Definition: MatrixArithmetic.hpp:321
Definition: Traits.hpp:218
Matrix< U, Rows, Columns, Order1, SameLayout, Packed > operator+(const Matrix< T, Rows, Columns, Order1, SameLayout, Packed > &lhs, const Matrix< U, Rows, Columns, Order2, SameLayout, Packed > &rhs)
Definition: MatrixArithmetic.hpp:222