From 2c34110aa91efd3df8bd391ca78517b5105cf73e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Tue, 20 Oct 2015 20:26:20 +0200
Subject: [PATCH] Math: better qualification of types in Dual subclass
 implementation macro.

---
 src/Magnum/Math/Dual.h | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index 9e9af7d05..3979af08b 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -186,27 +186,27 @@ template<class T> class Dual {
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #define MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(Type, Underlying)               \
     Type<T> operator-() const {                                             \
-        return Dual<Underlying<T>>::operator-();                            \
+        return Math::Dual<Underlying<T>>::operator-();                      \
     }                                                                       \
-    Type<T>& operator+=(const Dual<Underlying<T>>& other) {                 \
-        Dual<Underlying<T>>::operator+=(other);                             \
+    Type<T>& operator+=(const Math::Dual<Underlying<T>>& other) {           \
+        Math::Dual<Underlying<T>>::operator+=(other);                       \
         return *this;                                                       \
     }                                                                       \
-    Type<T> operator+(const Dual<Underlying<T>>& other) const {             \
-        return Dual<Underlying<T>>::operator+(other);                       \
+    Type<T> operator+(const Math::Dual<Underlying<T>>& other) const {       \
+        return Math::Dual<Underlying<T>>::operator+(other);                 \
     }                                                                       \
-    Type<T>& operator-=(const Dual<Underlying<T>>& other) {                 \
-        Dual<Underlying<T>>::operator-=(other);                             \
+    Type<T>& operator-=(const Math::Dual<Underlying<T>>& other) {           \
+        Math::Dual<Underlying<T>>::operator-=(other);                       \
         return *this;                                                       \
     }                                                                       \
-    Type<T> operator-(const Dual<Underlying<T>>& other) const {             \
-        return Dual<Underlying<T>>::operator-(other);                       \
+    Type<T> operator-(const Math::Dual<Underlying<T>>& other) const {       \
+        return Math::Dual<Underlying<T>>::operator-(other);                 \
     }                                                                       \
-    template<class U> Type<T> operator*(const Dual<U>& other) const {       \
-        return Dual<Underlying<T>>::operator*(other);                       \
+    template<class U> Type<T> operator*(const Math::Dual<U>& other) const { \
+        return Math::Dual<Underlying<T>>::operator*(other);                 \
     }                                                                       \
-    template<class U> Type<T> operator/(const Dual<U>& other) const {       \
-        return Dual<Underlying<T>>::operator/(other);                       \
+    template<class U> Type<T> operator/(const Math::Dual<U>& other) const { \
+        return Math::Dual<Underlying<T>>::operator/(other);                 \
     }
 #endif