Math: renamed {rotationAngle, rotationAxis}() -> {rotation, angle, axis}().

DualQuaternion and DualComplex has now only rotation() which returns
full rotation part, rotationAngle() and rotationAxis() on Quaternion and
Complex were renamed to angle() and axis().

doc/transformations.dox

@@ -243,18 +243,18 @@ Matrix3 c = Matrix3::from(rotation, {1.0f, 3.0f});
 @endcode
 
 %Complex numbers and quaternions are far better in this regard and they allow
-you to extract rotation angle using Complex::rotationAngle(), Quaternion::rotationAngle(),
+you to extract rotation angle using Complex::angle() or Quaternion::angle() or
-DualComplex::rotationAngle() or DualQuaternion::rotationAngle(), and rotation
+rotation axis in 3D using Quaternion::axis(). Their dual versions allow to
-axis in 3D using Quaternion::rotationAxis() or DualQuaternion::rotationAxis().
+extract both rotation and translation part using DualComplex::rotation() const,
-It is also possible to extract translation from their dual versions using
+DualQuaternion::rotation() const, DualComplex::translation() const and
-DualComplex::translation() const and DualQuaternion::translation() const.
+DualQuaternion::translation() const.
 @code
 DualComplex a;
-Rad rotation = a.rotationAngle();
+Rad rotationAngle = a.rotation().angle();
 Vector2 translation = a.translation();
 
 Quaternion b;
-Vector3 rotationAxis = b.rotationAxis();
+Vector3 rotationAxis = b.axis();
 @endcode
 
 You can convert Complex and Quaternion to rotation matrix using Complex::toMatrix()

src/Math/Complex.h

@@ -90,7 +90,7 @@ template<class T> class Complex {
          * @f[
          *      c = cos \theta + i sin \theta
          * @f]
-         * @see rotationAngle(), Matrix3::rotation(), Quaternion::rotation()
+         * @see angle(), Matrix3::rotation(), Quaternion::rotation()
          */
         inline static Complex<T> rotation(Rad<T> angle) {
             return {std::cos(T(angle)), std::sin(T(angle))};
@@ -182,9 +182,9 @@ template<class T> class Complex {
          * @f[
          *      \theta = atan2(b, a)
          * @f]
-         * @see rotation(), DualComplex::rotationAngle()
+         * @see rotation()
          */
-        inline Rad<T> rotationAngle() const {
+        inline Rad<T> angle() const {
             return Rad<T>(std::atan2(_imaginary, _real));
         }
 

src/Math/DualComplex.h

@@ -55,7 +55,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
          * @f[
          *      \hat c = (cos \theta + i sin \theta) + \epsilon (0 + i0)
          * @f]
-         * @see rotationAngle(), Complex::rotation(), Matrix3::rotation(),
+         * @see angle(), Complex::rotation(), Matrix3::rotation(),
          *      DualQuaternion::rotation()
          */
         inline static DualComplex<T> rotation(Rad<T> angle) {
@@ -139,15 +139,12 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
         }
 
         /**
-         * @brief Rotation angle of dual complex number
+         * @brief Rotation part of dual complex number
          *
-         * @f[
+         * @see Complex::angle()
-         *      \theta = atan2(b_0, a_0)
-         * @f]
-         * @see rotation(), Complex::rotationAngle()
          */
-        inline Rad<T> rotationAngle() const {
+        inline constexpr Complex<T> rotation() const {
-            return this->real().rotationAngle();
+            return this->real();
         }
 
         /**

src/Math/DualQuaternion.h

@@ -54,9 +54,9 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
          * Expects that the rotation axis is normalized. @f[
          *      \hat q = [\boldsymbol a \cdot sin \frac \theta 2, cos \frac \theta 2] + \epsilon [\boldsymbol 0, 0]
          * @f]
-         * @see rotationAngle(), rotationAxis(), Quaternion::rotation(),
+         * @see rotation() const, Quaternion::rotation(), Matrix4::rotation(),
-         *      Matrix4::rotation(), DualComplex::rotation(), Vector3::xAxis(),
+         *      DualComplex::rotation(), Vector3::xAxis(), Vector3::yAxis(),
-         *      Vector3::yAxis(), Vector3::zAxis(), Vector::isNormalized()
+         *      Vector3::zAxis(), Vector::isNormalized()
          */
         inline static DualQuaternion<T> rotation(Rad<T> angle, const Vector3<T>& normalizedAxis) {
             return {Quaternion<T>::rotation(angle, normalizedAxis), {{}, T(0)}};
@@ -145,29 +145,12 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
         }
 
         /**
-         * @brief Rotation angle of unit dual quaternion
+         * @brief Rotation part of unit dual quaternion
          *
-         * Expects that the real part of the quaternion is normalized. @f[
+         * @see Quaternion::angle(), Quaternion::axis()
-         *      \theta = 2 \cdot acos q_{S 0}
-         * @f]
-         * @see rotationAxis(), rotation(), Quaternion::rotationAngle()
-         */
-        inline Math::Rad<T> rotationAngle() const {
-            return this->real().rotationAngle();
-        }
-
-        /**
-         * @brief Rotation axis of unit dual quaternion
-         *
-         * Expects that the quaternion is normalized. Returns either unit-length
-         * vector for valid rotation quaternion or NaN vector for
-         * default-constructed quaternion. @f[
-         *      \boldsymbol a = \frac{\boldsymbol q_{V 0}}{\sqrt{1 - q_{S 0}^2}}
-         * @f]
-         * @see rotationAngle(), rotation(), Quaternion::rotationAxis()
          */
-        inline Vector3<T> rotationAxis() const {
+        inline constexpr Quaternion<T> rotation() const {
-            return this->real().rotationAxis();
+            return this->real();
         }
 
         /**

src/Math/Quaternion.h

@@ -162,7 +162,7 @@ template<class T> class Quaternion {
          * Expects that the rotation axis is normalized. @f[
          *      q = [\boldsymbol a \cdot sin \frac \theta 2, cos \frac \theta 2]
          * @f]
-         * @see rotationAngle(), rotationAxis(), DualQuaternion::rotation(),
+         * @see angle(), axis(), DualQuaternion::rotation(),
          *      Matrix4::rotation(), Complex::rotation(), Vector3::xAxis(),
          *      Vector3::yAxis(), Vector3::zAxis(), Vector::isNormalized()
          */
@@ -247,12 +247,11 @@ template<class T> class Quaternion {
          * Expects that the quaternion is normalized. @f[
          *      \theta = 2 \cdot acos q_S
          * @f]
-         * @see isNormalized(), rotationAxis(), rotation(),
+         * @see isNormalized(), axis(), rotation()
-         *      DualQuaternion::rotationAngle()
          */
-        inline Rad<T> rotationAngle() const {
+        inline Rad<T> angle() const {
             CORRADE_ASSERT(isNormalized(),
-                           "Math::Quaternion::rotationAngle(): quaternion must be normalized",
+                           "Math::Quaternion::angle(): quaternion must be normalized",
                            Rad<T>(std::numeric_limits<T>::quiet_NaN()));
             return Rad<T>(T(2)*std::acos(_scalar));
         }
@@ -265,11 +264,11 @@ template<class T> class Quaternion {
          * default-constructed quaternion. @f[
          *      \boldsymbol a = \frac{\boldsymbol q_V}{\sqrt{1 - q_S^2}}
          * @f]
-         * @see isNormalized(), rotationAngle(), rotation()
+         * @see isNormalized(), angle(), rotation()
          */
-        inline Vector3<T> rotationAxis() const {
+        inline Vector3<T> axis() const {
             CORRADE_ASSERT(isNormalized(),
-                           "Math::Quaternion::rotationAxis(): quaternion must be normalized",
+                           "Math::Quaternion::axis(): quaternion must be normalized",
                            {});
             return _vector/std::sqrt(1-pow2(_scalar));
         }

src/Math/Test/ComplexTest.cpp

@@ -273,15 +273,15 @@ void ComplexTest::rotation() {
     Complex a = Complex::rotation(Deg(120.0f));
     CORRADE_COMPARE(a.length(), 1.0f);
     CORRADE_COMPARE(a, Complex(-0.5f, 0.8660254f));
-    CORRADE_COMPARE_AS(a.rotationAngle(), Deg(120.0f), Rad);
+    CORRADE_COMPARE_AS(a.angle(), Deg(120.0f), Rad);
 
     /* Verify negative angle */
     Complex b = Complex::rotation(Deg(-240.0f));
     CORRADE_COMPARE(b, Complex(-0.5f, 0.8660254f));
-    CORRADE_COMPARE_AS(b.rotationAngle(), Deg(120.0f), Rad);
+    CORRADE_COMPARE_AS(b.angle(), Deg(120.0f), Rad);
 
     /* Default-constructed complex number has zero angle */
-    CORRADE_COMPARE_AS(Complex().rotationAngle(), Deg(0.0f), Rad);
+    CORRADE_COMPARE_AS(Complex().angle(), Deg(0.0f), Rad);
 }
 
 void ComplexTest::matrix() {

src/Math/Test/DualComplexTest.cpp

@@ -207,7 +207,12 @@ void DualComplexTest::rotation() {
     DualComplex a = DualComplex::rotation(Deg(120.0f));
     CORRADE_COMPARE(a.length(), 1.0f);
     CORRADE_COMPARE(a, DualComplex({-0.5f, 0.8660254f}, {0.0f, 0.0f}));
-    CORRADE_COMPARE_AS(a.rotationAngle(), Deg(120.0f), Rad);
+    CORRADE_COMPARE_AS(a.rotation().angle(), Deg(120.0f), Rad);
+
+    /* Constexpr access to rotation */
+    constexpr DualComplex b({-1.0f, 2.0f}, {});
+    constexpr Complex c = b.rotation();
+    CORRADE_COMPARE(c, Complex(-1.0f, 2.0f));
 }
 
 void DualComplexTest::translation() {
@@ -223,8 +228,8 @@ void DualComplexTest::combinedTransformParts() {
     DualComplex a = DualComplex::translation(translation)*DualComplex::rotation(Deg(23.0f));
     DualComplex b = DualComplex::rotation(Deg(23.0f))*DualComplex::translation(translation);
 
-    CORRADE_COMPARE_AS(a.rotationAngle(), Deg(23.0f), Rad);
+    CORRADE_COMPARE_AS(a.rotation().angle(), Deg(23.0f), Rad);
-    CORRADE_COMPARE_AS(b.rotationAngle(), Deg(23.0f), Rad);
+    CORRADE_COMPARE_AS(b.rotation().angle(), Deg(23.0f), Rad);
     CORRADE_COMPARE(a.translation(), translation);
     CORRADE_COMPARE(b.translation(), Complex::rotation(Deg(23.0f)).transformVector(translation));
 }

src/Math/Test/DualQuaternionTest.cpp

@@ -210,8 +210,13 @@ void DualQuaternionTest::rotation() {
     DualQuaternion q = DualQuaternion::rotation(Deg(120.0f), axis);
     CORRADE_COMPARE(q.length(), 1.0f);
     CORRADE_COMPARE(q, DualQuaternion({Vector3(0.5f, 0.5f, 0.5f), 0.5f}, {{}, 0.0f}));
-    CORRADE_COMPARE_AS(q.rotationAngle(), Deg(120.0f), Deg);
+    CORRADE_COMPARE_AS(q.rotation().angle(), Deg(120.0f), Deg);
-    CORRADE_COMPARE(q.rotationAxis(), axis);
+    CORRADE_COMPARE(q.rotation().axis(), axis);
+
+    /* Constexpr access to rotation */
+    constexpr DualQuaternion b({{-1.0f, 2.0f, 3.0f}, 4.0f}, {});
+    constexpr Quaternion c = b.rotation();
+    CORRADE_COMPARE(c, Quaternion({-1.0f, 2.0f, 3.0f}, 4.0f));
 }
 
 void DualQuaternionTest::translation() {
@@ -227,10 +232,10 @@ void DualQuaternionTest::combinedTransformParts() {
     DualQuaternion a = DualQuaternion::translation(translation)*DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis());
     DualQuaternion b = DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis())*DualQuaternion::translation(translation);
 
-    CORRADE_COMPARE(a.rotationAxis(), Vector3::xAxis());
+    CORRADE_COMPARE(a.rotation().axis(), Vector3::xAxis());
-    CORRADE_COMPARE(b.rotationAxis(), Vector3::xAxis());
+    CORRADE_COMPARE(b.rotation().axis(), Vector3::xAxis());
-    CORRADE_COMPARE_AS(a.rotationAngle(), Deg(23.0f), Rad);
+    CORRADE_COMPARE_AS(a.rotation().angle(), Deg(23.0f), Rad);
-    CORRADE_COMPARE_AS(b.rotationAngle(), Deg(23.0f), Rad);
+    CORRADE_COMPARE_AS(b.rotation().angle(), Deg(23.0f), Rad);
 
     CORRADE_COMPARE(a.translation(), translation);
     CORRADE_COMPARE(b.translation(), Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).transformVector(translation));

src/Math/Test/QuaternionTest.cpp

@@ -255,19 +255,19 @@ void QuaternionTest::rotation() {
     Quaternion q = Quaternion::rotation(Deg(120.0f), axis);
     CORRADE_COMPARE(q.length(), 1.0f);
     CORRADE_COMPARE(q, Quaternion(Vector3(0.5f, 0.5f, 0.5f), 0.5f));
-    CORRADE_COMPARE_AS(q.rotationAngle(), Deg(120.0f), Deg);
+    CORRADE_COMPARE_AS(q.angle(), Deg(120.0f), Deg);
-    CORRADE_COMPARE(q.rotationAxis(), axis);
+    CORRADE_COMPARE(q.axis(), axis);
-    CORRADE_COMPARE(q.rotationAxis().length(), 1.0f);
+    CORRADE_COMPARE(q.axis().length(), 1.0f);
 
     /* Verify negative angle */
     Quaternion q2 = Quaternion::rotation(Deg(-120.0f), axis);
     CORRADE_COMPARE(q2, Quaternion(Vector3(-0.5f, -0.5f, -0.5f), 0.5f));
-    CORRADE_COMPARE_AS(q2.rotationAngle(), Deg(120.0f), Deg);
+    CORRADE_COMPARE_AS(q2.angle(), Deg(120.0f), Deg);
-    CORRADE_COMPARE(q2.rotationAxis(), -axis);
+    CORRADE_COMPARE(q2.axis(), -axis);
 
     /* Default-constructed quaternion has zero angle and NaN axis */
-    CORRADE_COMPARE_AS(Quaternion().rotationAngle(), Deg(0.0f), Deg);
+    CORRADE_COMPARE_AS(Quaternion().angle(), Deg(0.0f), Deg);
-    CORRADE_VERIFY(Quaternion().rotationAxis() != Quaternion().rotationAxis());
+    CORRADE_VERIFY(Quaternion().axis() != Quaternion().axis());
 }
 
 void QuaternionTest::angle() {