ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Math: initial implementation of dual complex numbers.

pull/278/head
Vladimír Vondruš 13 years ago
parent
e522293c22
commit
f6d1a158f8
7 changed files with 262 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/CMakeLists.txt
  2. 1
      src/Math/CMakeLists.txt
  3. 27
      src/Math/DualComplex.cpp
  4. 125
      src/Math/DualComplex.h
  5. 1
      src/Math/Math.h
  6. 1
      src/Math/Test/CMakeLists.txt
  7. 106
      src/Math/Test/DualComplexTest.cpp

1
src/CMakeLists.txt
Unescape View File

@ -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

1
src/Math/CMakeLists.txt
Unescape View File

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

27
src/Math/DualComplex.cpp
Unescape View File

@ -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
}}

125
src/Math/DualComplex.h
Unescape View File

@ -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

1
src/Math/Math.h
Unescape View File

@ -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;

1
src/Math/Test/CMakeLists.txt
Unescape View File

@ -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)

106
src/Math/Test/DualComplexTest.cpp
Unescape View File

@ -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)
Write Preview
Loading…
Cancel
Save