template<class T>
Magnum::Math::DualComplex class

Dual complex number.

Template parameters
T Underlying data type

Represents 2D rotation and translation. Usually denoted as the following in equations, with $ q_0 $ being the real() part and $ q_\epsilon $ the dual() part:

\[ \hat q = q_0 + \epsilon q_\epsilon \]

See Dual and Complex for further notation description and 2D and 3D transformations for brief introduction.

Base classes

template<class T>
class Dual<Complex<T>>
Dual number.

Public types

using Type = T
Underlying data type.

Public static functions

static auto rotation(Rad<T> angle) -> DualComplex<T>
Rotation dual complex number.
static auto translation(const Vector2<T>& vector) -> DualComplex<T>
Translation dual complex number.
static auto fromMatrix(const Matrix3<T>& matrix) -> DualComplex<T>
Create dual complex number from rotation matrix.
static auto from(const Complex<T>& rotation, const Vector2<T>& translation) -> DualComplex<T> new in Git master
Create dual complex from rotation complex and translation vector.

Constructors, destructors, conversion operators

DualComplex() constexpr noexcept
Default constructor.
DualComplex(IdentityInitT) explicit constexpr noexcept
Identity constructor.
DualComplex(ZeroInitT) explicit constexpr noexcept
Construct zero-initialized dual complex number.
DualComplex(Magnum::NoInitT) explicit noexcept
Construct without initializing the contents.
DualComplex(const Complex<T>& real, const Complex<T>& dual = Complex<T>(T(0), T(0))) constexpr noexcept
Construct dual complex number from real and dual part.
DualComplex(const Vector2<T>& vector) explicit constexpr noexcept
Construct dual complex number from vector.
template<class U>
DualComplex(const DualComplex<U>& other) explicit constexpr noexcept
Construct dual complex number from another of different type.
template<class U, class V = decltype(Implementation::DualComplexConverter<T, U>::from(std::declval<U>()))>
DualComplex(const U& other) explicit constexpr
Construct dual complex number from external representation.
DualComplex(const Dual<Complex<T>>& other) constexpr noexcept
Copy constructor.
template<class U, class V = decltype(Implementation::DualComplexConverter<T, U>::to(std::declval<DualComplex<T>>()))>
operator U() const explicit constexpr
Convert dual complex number to external representation.

Public functions

auto data() -> T*
Raw data.
auto data() const -> const T* constexpr
auto isNormalized() const -> bool
Whether the dual complex number is normalized.
auto rotation() const -> Complex<T> constexpr
Rotation part of dual complex number.
auto translation() const -> Vector2<T>
Translation part of dual complex number.
auto toMatrix() const -> Matrix3<T>
Convert dual complex number to transformation matrix.
auto operator*(const DualComplex<T>& other) const -> DualComplex<T>
Multiply with dual complex number.
auto complexConjugated() const -> DualComplex<T>
Complex-conjugated dual complex number.
auto dualConjugated() const -> DualComplex<T>
Dual-conjugated dual complex number.
auto conjugated() const -> DualComplex<T>
Conjugated dual complex number.
auto lengthSquared() const -> T
Complex number length squared.
auto length() const -> T
Dual quaternion length.
auto normalized() const -> DualComplex<T>
Normalized dual complex number (of unit length)
auto inverted() const -> DualComplex<T>
Inverted dual complex number.
auto invertedNormalized() const -> DualComplex<T>
Inverted normalized dual complex number.
auto transformVector(const Vector2<T>& vector) const -> Vector2<T> new in 2020.06
Rotate a vector with a dual complex number.
auto transformPoint(const Vector2<T>& vector) const -> Vector2<T>
Rotate and translate point with dual complex number.

Function documentation

template<class T>
static DualComplex<T> Magnum::Math::DualComplex<T>::rotation(Rad<T> angle)

Rotation dual complex number.

Parameters
angle Rotation angle (counterclockwise)
\[ \hat c = (\cos(\theta) + i \sin(\theta)) + \epsilon (0 + i0) \]

For creating a dual complex number from a rotation Complex, use the implicit conversion provided by DualComplex(const Complex<T>&, const Complex<T>&).

template<class T>
static DualComplex<T> Magnum::Math::DualComplex<T>::translation(const Vector2<T>& vector)

Translation dual complex number.

Parameters
vector Translation vector
\[ \hat c = (0 + i1) + \epsilon (v_x + iv_y) \]

template<class T>
static DualComplex<T> Magnum::Math::DualComplex<T>::fromMatrix(const Matrix3<T>& matrix)

Create dual complex number from rotation matrix.

Expects that the matrix represents rigid transformation.

template<class T>
static DualComplex<T> Magnum::Math::DualComplex<T>::from(const Complex<T>& rotation, const Vector2<T>& translation) new in Git master

Create dual complex from rotation complex and translation vector.

\[ \hat c = r + \epsilon (v_x + iv_y) \]

template<class T>
Magnum::Math::DualComplex<T>::DualComplex() constexpr noexcept

Default constructor.

Equivalent to DualComplex(IdentityInitT).

template<class T>
Magnum::Math::DualComplex<T>::DualComplex(IdentityInitT) explicit constexpr noexcept

Identity constructor.

Creates unit dual complex number.

\[ \hat c = (0 + i1) + \epsilon (0 + i0) \]

template<class T>
Magnum::Math::DualComplex<T>::DualComplex(const Complex<T>& real, const Complex<T>& dual = Complex<T>(T(0), T(0))) constexpr noexcept

Construct dual complex number from real and dual part.

\[ \hat c = c_0 + \epsilon c_\epsilon \]

This constructor can be also used to implicitly convert a rotation complex number to a rotation dual complex number.

template<class T>
Magnum::Math::DualComplex<T>::DualComplex(const Vector2<T>& vector) explicit constexpr noexcept

Construct dual complex number from vector.

To be used in transformations later.

\[ \hat c = (0 + i1) + \epsilon(v_x + iv_y) \]

template<class T> template<class U>
Magnum::Math::DualComplex<T>::DualComplex(const DualComplex<U>& other) explicit constexpr noexcept

Construct dual complex number from another of different type.

Performs only default casting on the values, no rounding or anything else.

template<class T>
T* Magnum::Math::DualComplex<T>::data()

Raw data.

Returns One-dimensional array of four elements

template<class T>
const T* Magnum::Math::DualComplex<T>::data() const constexpr

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class T>
bool Magnum::Math::DualComplex<T>::isNormalized() const

Whether the dual complex number is normalized.

Dual complex number is normalized if its real part has unit length:

\[ |c_0|^2 = |c_0| = 1 \]

template<class T>
Complex<T> Magnum::Math::DualComplex<T>::rotation() const constexpr

Rotation part of dual complex number.

template<class T>
Vector2<T> Magnum::Math::DualComplex<T>::translation() const

Translation part of dual complex number.

\[ \boldsymbol a = (c_\epsilon c_0^*) \]

template<class T>
Matrix3<T> Magnum::Math::DualComplex<T>::toMatrix() const

Convert dual complex number to transformation matrix.

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::operator*(const DualComplex<T>& other) const

Multiply with dual complex number.

\[ \hat a \hat b = a_0 b_0 + \epsilon (a_0 b_\epsilon + a_\epsilon) \]

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::complexConjugated() const

Complex-conjugated dual complex number.

\[ \hat c^* = c^*_0 + c^*_\epsilon \]

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::dualConjugated() const

Dual-conjugated dual complex number.

\[ \overline{\hat c} = c_0 - \epsilon c_\epsilon \]

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::conjugated() const

Conjugated dual complex number.

Both complex and dual conjugation.

\[ \overline{\hat c^*} = c^*_0 - \epsilon c^*_\epsilon = c^*_0 + \epsilon(-a_\epsilon + ib_\epsilon) \]

template<class T>
T Magnum::Math::DualComplex<T>::lengthSquared() const

Complex number length squared.

Should be used instead of length() for comparing complex number length with other values, because it doesn't compute the square root.

\[ |\hat c|^2 = c_0 \cdot c_0 = |c_0|^2 \]

template<class T>
T Magnum::Math::DualComplex<T>::length() const

Dual quaternion length.

See lengthSquared() which is faster for comparing length with other values.

\[ |\hat c| = \sqrt{c_0 \cdot c_0} = |c_0| \]

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::normalized() const

Normalized dual complex number (of unit length)

\[ c' = \frac{c_0}{|c_0|} \]

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::inverted() const

Inverted dual complex number.

See invertedNormalized() which is faster for normalized dual complex numbers.

\[ \hat c^{-1} = c_0^{-1} - \epsilon c_\epsilon \]

template<class T>
DualComplex<T> Magnum::Math::DualComplex<T>::invertedNormalized() const

Inverted normalized dual complex number.

Expects that the complex number is normalized.

\[ \hat c^{-1} = c_0^{-1} - \epsilon c_\epsilon = c_0^* - \epsilon c_\epsilon \]

template<class T>
Vector2<T> Magnum::Math::DualComplex<T>::transformVector(const Vector2<T>& vector) const new in 2020.06

Rotate a vector with a dual complex number.

Calls Complex::transformVector() on the real() part, see its documentation for more information.

template<class T>
Vector2<T> Magnum::Math::DualComplex<T>::transformPoint(const Vector2<T>& vector) const

Rotate and translate point with dual complex number.

\[ v' = \hat c v = \hat c ((0 + i) + \epsilon(v_x + iv_y)) \]

template<class T> template<class T>
Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualComplex<T>& value)

Debug output operator.