From 2a25c6eafd66278447e9d640f5fea58a34c0f758 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Sat, 16 Feb 2013 19:03:52 +0100
Subject: [PATCH] Math: return proper type from Dual operators in subclasses.

---
 src/Math/Dual.h | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/Math/Dual.h b/src/Math/Dual.h
index 5e3b6f884..45cc4f344 100644
--- a/src/Math/Dual.h
+++ b/src/Math/Dual.h
@@ -155,6 +155,33 @@ template<class T> class Dual {
         T _real, _dual;
 };
 
+#ifndef DOXYGEN_GENERATING_OUTPUT
+#define MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(Type, Underlying)               \
+    inline Type<T> operator-() const {                                      \
+        return Dual<Underlying<T>>::operator-();                            \
+    }                                                                       \
+    inline Type<T>& operator+=(const Dual<Underlying<T>>& other) {          \
+        Dual<Underlying<T>>::operator+=(other);                             \
+        return *this;                                                       \
+    }                                                                       \
+    inline Type<T> operator+(const Dual<Underlying<T>>& other) const {      \
+        return Dual<Underlying<T>>::operator+(other);                       \
+    }                                                                       \
+    inline Type<T>& operator-=(const Dual<Underlying<T>>& other) {          \
+        Dual<Underlying<T>>::operator-=(other);                             \
+        return *this;                                                       \
+    }                                                                       \
+    inline Type<T> operator-(const Dual<Underlying<T>>& other) const {      \
+        return Dual<Underlying<T>>::operator-(other);                       \
+    }                                                                       \
+    inline Type<T> operator*(const Dual<Underlying<T>>& other) const {      \
+        return Dual<Underlying<T>>::operator*(other);                       \
+    }                                                                       \
+    template<class U> inline Type<T> operator/(const Dual<U>& other) const { \
+        return Dual<Underlying<T>>::operator/(other);                       \
+    }
+#endif
+
 /** @debugoperator{Magnum::Math::Dual} */
 template<class T> Corrade::Utility::Debug operator<<(Corrade::Utility::Debug debug, const Dual<T>& value) {
     debug << "Dual(";