Math: initial implementation of dual complex numbers.

src/CMakeLists.txt

@@ -100,6 +100,7 @@ add_library(MagnumObjects OBJECT ${Magnum_SRCS})
 set(MagnumMath_SRCS
     Math/Angle.cpp
     Math/Complex.cpp
+    Math/DualComplex.cpp
     Math/DualQuaternion.cpp
     Math/Functions.cpp
     Math/Quaternion.cpp

src/Math/CMakeLists.txt

@@ -4,6 +4,7 @@ set(MagnumMath_HEADERS
     Complex.h
     Constants.h
     Dual.h
+    DualComplex.h
     DualQuaternion.h
     Functions.h
     Math.h

src/Math/DualComplex.cpp

@@ -0,0 +1,27 @@
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+#include "DualComplex.h"
+
+namespace Magnum { namespace Math {
+
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template Corrade::Utility::Debug operator<<(Corrade::Utility::Debug, const DualComplex<float>&);
+#ifndef MAGNUM_TARGET_GLES
+template Corrade::Utility::Debug operator<<(Corrade::Utility::Debug, const DualComplex<double>&);
+#endif
+#endif
+
+}}

src/Math/DualComplex.h

@@ -0,0 +1,125 @@
+#ifndef Magnum_Math_DualComplex_h
+#define Magnum_Math_DualComplex_h
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+/** @file
+ * @brief Class Magnum::Math::DualComplex
+ */
+
+#include "Math/Dual.h"
+#include "Math/Complex.h"
+
+namespace Magnum { namespace Math {
+
+/**
+@brief %Dual complex number
+@tparam T   Underlying data type
+
+Represents 2D rotation and translation.
+@see Dual, Complex, Matrix3
+*/
+template<class T> class DualComplex: public Dual<Complex<T>> {
+    public:
+        typedef T Type;                         /**< @brief Underlying data type */
+
+        /**
+         * @brief Default constructor
+         *
+         * Creates unit dual complex number. @f[
+         *      \hat c = (0 + i1) + \epsilon (0 + i0)
+         * @f]
+         * @todoc Remove workaround when Doxygen is predictable
+         */
+        #ifdef DOXYGEN_GENERATING_OUTPUT
+        inline constexpr /*implicit*/ DualComplex();
+        #else
+        inline constexpr /*implicit*/ DualComplex(): Dual<Complex<T>>({}, {T(0), T(0)}) {}
+        #endif
+
+        /**
+         * @brief Construct dual complex number from real and dual part
+         *
+         * @f[
+         *      \hat c = c_0 + \epsilon c_\epsilon
+         * @f]
+         */
+        inline constexpr /*implicit*/ DualComplex(const Complex<T>& real, const Complex<T>& dual): Dual<Complex<T>>(real, dual) {}
+
+        /**
+         * @brief Complex-conjugated dual complex number
+         *
+         * @f[
+         *      \hat c^* = c^*_0 + c^*_\epsilon
+         * @f]
+         * @see dualConjugated(), conjugated(), Complex::conjugated()
+         */
+        inline DualComplex<T> complexConjugated() const {
+            return {this->real().conjugated(), this->dual().conjugated()};
+        }
+
+        /**
+         * @brief Dual-conjugated dual complex number
+         *
+         * @f[
+         *      \overline{\hat c} = c_0 - \epsilon c_\epsilon
+         * @f]
+         * @see complexConjugated(), conjugated(), Dual::conjugated()
+         */
+        inline DualComplex<T> dualConjugated() const {
+            return Dual<Complex<T>>::conjugated();
+        }
+
+        /**
+         * @brief Conjugated dual complex number
+         *
+         * Both complex and dual conjugation. @f[
+         *      \overline{\hat c^*} = c^*_0 - \epsilon c^*_\epsilon = c^*_0 + \epsilon(-a_\epsilon + ib_\epsilon)
+         * @f]
+         * @see complexConjugated(), dualConjugated(), Complex::conjugated(),
+         *      Dual::conjugated()
+         */
+        inline DualComplex<T> conjugated() const {
+            return {this->real().conjugated(), {-this->dual().real(), this->dual().imaginary()}};
+        }
+
+        MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(DualComplex, Complex)
+
+    private:
+        /* Used by Dual operators and dualConjugated() */
+        inline constexpr DualComplex(const Dual<Complex<T>>& other): Dual<Complex<T>>(other) {}
+};
+
+/** @debugoperator{Magnum::Math::DualQuaternion} */
+template<class T> Corrade::Utility::Debug operator<<(Corrade::Utility::Debug debug, const DualComplex<T>& value) {
+    debug << "DualComplex({";
+    debug.setFlag(Corrade::Utility::Debug::SpaceAfterEachValue, false);
+    debug << value.real().real() << ", " << value.real().imaginary() << "}, {"
+          << value.dual().real() << ", " << value.dual().imaginary() << "})";
+    debug.setFlag(Corrade::Utility::Debug::SpaceAfterEachValue, true);
+    return debug;
+}
+
+/* Explicit instantiation for commonly used types */
+#ifndef DOXYGEN_GENERATING_OUTPUT
+extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const DualComplex<float>&);
+#ifndef MAGNUM_TARGET_GLES
+extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const DualComplex<double>&);
+#endif
+#endif
+
+}}
+
+#endif

src/Math/Math.h

@@ -29,6 +29,7 @@ namespace Magnum { namespace Math {
 
 template<class> class Complex;
 template<class> class Dual;
+template<class> class DualComplex;
 template<class> class DualQuaternion;
 
 template<std::size_t, class> class Matrix;

src/Math/Test/CMakeLists.txt

@@ -19,6 +19,7 @@ corrade_add_test(MathAngleTest AngleTest.cpp LIBRARIES MagnumMathTestLib)
 
 corrade_add_test(MathDualTest DualTest.cpp)
 corrade_add_test(MathComplexTest ComplexTest.cpp LIBRARIES MagnumMathTestLib)
+corrade_add_test(MathDualComplexTest DualComplexTest.cpp LIBRARIES MagnumMathTestLib)
 corrade_add_test(MathQuaternionTest QuaternionTest.cpp LIBRARIES MagnumMathTestLib)
 corrade_add_test(MathDualQuaternionTest DualQuaternionTest.cpp LIBRARIES MagnumMathTestLib)
 

src/Math/Test/DualComplexTest.cpp

@@ -0,0 +1,106 @@
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+#include <sstream>
+#include <TestSuite/Tester.h>
+
+#include "Math/DualComplex.h"
+
+namespace Magnum { namespace Math { namespace Test {
+
+class DualComplexTest: public Corrade::TestSuite::Tester {
+    public:
+        explicit DualComplexTest();
+
+        void construct();
+        void constructDefault();
+
+        void constExpressions();
+
+        void complexConjugated();
+        void dualConjugated();
+        void conjugated();
+
+        void debug();
+};
+
+typedef Math::Complex<float> Complex;
+typedef Math::DualComplex<float> DualComplex;
+
+DualComplexTest::DualComplexTest() {
+    addTests(&DualComplexTest::construct,
+             &DualComplexTest::constructDefault,
+
+             &DualComplexTest::constExpressions,
+
+             &DualComplexTest::complexConjugated,
+             &DualComplexTest::dualConjugated,
+             &DualComplexTest::conjugated,
+
+             &DualComplexTest::debug);
+}
+
+void DualComplexTest::construct() {
+    DualComplex a({-1.0f, 2.5f}, {3.0f, -7.5f});
+    CORRADE_COMPARE(a.real(), Complex(-1.0f, 2.5f));
+    CORRADE_COMPARE(a.dual(), Complex(3.0f, -7.5f));
+}
+
+void DualComplexTest::constructDefault() {
+    CORRADE_COMPARE(DualComplex(), DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
+}
+
+void DualComplexTest::constExpressions() {
+    /* Default constructor */
+    constexpr DualComplex a;
+    CORRADE_COMPARE(a, DualComplex({1.0f, 0.0f}, {0.0f, 0.0f}));
+
+    /* Value constructor */
+    constexpr DualComplex b({-1.0f, 2.5f}, {3.0f, -7.5f});
+    CORRADE_COMPARE(b, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
+
+    /* Copy constructor */
+    constexpr DualComplex d(b);
+    CORRADE_COMPARE(d, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
+}
+
+void DualComplexTest::complexConjugated() {
+    DualComplex a({-1.0f,  2.5f}, {3.0f, -7.5f});
+    DualComplex b({-1.0f, -2.5f}, {3.0f,  7.5f});
+    CORRADE_COMPARE(a.complexConjugated(), b);
+}
+
+void DualComplexTest::dualConjugated() {
+    DualComplex a({-1.0f, 2.5f}, { 3.0f, -7.5f});
+    DualComplex b({-1.0f, 2.5f}, {-3.0f,  7.5f});
+    CORRADE_COMPARE(a.dualConjugated(), b);
+}
+
+void DualComplexTest::conjugated() {
+    DualComplex a({-1.0f,  2.5f}, { 3.0f, -7.5f});
+    DualComplex b({-1.0f, -2.5f}, {-3.0f, -7.5f});
+    CORRADE_COMPARE(a.conjugated(), b);
+}
+
+void DualComplexTest::debug() {
+    std::ostringstream o;
+
+    Debug(&o) << DualComplex({-1.0f, -2.5f}, {-3.0f, -7.5f});
+    CORRADE_COMPARE(o.str(), "DualComplex({-1, -2.5}, {-3, -7.5})\n");
+}
+
+}}}
+
+CORRADE_TEST_MAIN(Magnum::Math::Test::DualComplexTest)