assignment ops

README.md

@@ -78,3 +78,4 @@ None.
 
 * Benchmark how compile times are affected by includes / templates
 * Add tests that verify optimal assembly generated
+* Fractional and bigint data types

src/tg/detail/macros.hh

@@ -215,3 +215,19 @@
         return ((a.TG_IMPL_MEMBER(TYPE_A, 0) OP b.TG_IMPL_MEMBER(TYPE_B, 0))REDUCE(a.TG_IMPL_MEMBER(TYPE_A, 1) OP b.TG_IMPL_MEMBER(TYPE_B, 1)))REDUCE( \
             (a.TG_IMPL_MEMBER(TYPE_A, 2) OP b.TG_IMPL_MEMBER(TYPE_B, 2))REDUCE(a.TG_IMPL_MEMBER(TYPE_A, 3) OP b.TG_IMPL_MEMBER(TYPE_B, 3)));           \
     }
+
+#define TG_IMPL_DEFINE_ASSIGNMENT_OP(TYPE_THIS, TYPE_THAT, OP)                                                                                    \
+    template <int D, class ScalarA, class ScalarB>                                                                                                \
+    constexpr auto operator OP##=(TYPE_THIS<D, ScalarA>& lhs, TYPE_THAT<D, ScalarB> const& rhs)->decltype(TYPE_THIS<D, ScalarA>(lhs OP rhs), lhs) \
+    {                                                                                                                                             \
+        lhs = TYPE_THIS<D, ScalarA>(lhs OP rhs);                                                                                                  \
+        return lhs;                                                                                                                               \
+    }
+
+#define TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(TYPE_THIS, OP)                                                                          \
+    template <int D, class ScalarA, class ScalarB>                                                                                  \
+    constexpr auto operator OP##=(TYPE_THIS<D, ScalarA>& lhs, ScalarB const& rhs)->decltype(TYPE_THIS<D, ScalarA>(lhs OP rhs), lhs) \
+    {                                                                                                                               \
+        lhs = TYPE_THIS<D, ScalarA>(lhs OP rhs);                                                                                    \
+        return lhs;                                                                                                                 \
+    }

src/tg/detail/operators/ops_pos.hh

@@ -29,4 +29,15 @@ TG_IMPL_DEFINE_BINARY_OP_SCALAR(pos, +);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR(pos, *);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR_DIV(pos);
 
+// assignment ops
+TG_IMPL_DEFINE_ASSIGNMENT_OP(pos, vec, +);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(pos, vec, -);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(pos, size, *);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(pos, size, /);
+
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(pos, +);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(pos, -);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(pos, *);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(pos, /);
+
 } // namespace tg

src/tg/detail/operators/ops_size.hh

@@ -23,4 +23,15 @@ TG_IMPL_DEFINE_BINARY_OP_SCALAR(size, -);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR(size, +);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR(size, *);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR_DIV(size);
+
+// assignment ops
+TG_IMPL_DEFINE_ASSIGNMENT_OP(size, size, +);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(size, size, -);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(size, size, *);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(size, size, /);
+
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(size, +);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(size, -);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(size, *);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(size, /);
 } // namespace tg

src/tg/detail/operators/ops_vec.hh

 #pragma once
 
 #include "../../types/vec.hh"
+#include "../macros.hh"
 #include "../traits.hh"
 
 namespace tg
@@ -22,4 +23,15 @@ TG_IMPL_DEFINE_BINARY_OP_SCALAR(vec, -);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR(vec, +);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR(vec, *);
 TG_IMPL_DEFINE_BINARY_OP_SCALAR_DIV(vec);
+
+// assignment ops
+TG_IMPL_DEFINE_ASSIGNMENT_OP(vec, vec, +);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(vec, vec, -);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(vec, size, *);
+TG_IMPL_DEFINE_ASSIGNMENT_OP(vec, size, /);
+
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(vec, +);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(vec, -);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(vec, *);
+TG_IMPL_DEFINE_ASSIGNMENT_OP_SCALAR(vec, /);
 } // namespace tg