Math: added data() accessors to all remaining types.

doc/changelog.dox

@@ -121,6 +121,10 @@ See also:
 -   Ability to use @ref Math::Complex, @ref Math::DualComplex,
     @ref Math::Quaternion, @ref Math::DualQuaternion with
     @ref Corrade::Utility::Configuration and @ref Corrade::Utility::Arguments
+-   Added @ref Math::Complex::data(), @ref Math::Quaternion::data(),
+    @ref Math::DualComplex::data(), @ref Math::DualQuaternion::data(),
+    @ref Math::Bezier::data() and @ref Math::CubicHermite::data() for simple
+    access to underlying memory like with other math types
 -   New @ref Math::min(), @ref Math::max() and @ref Math::minmax() overloads
     taking plain C arrays
 

src/Magnum/Math/Bezier.h

@@ -140,6 +140,15 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
             return Implementation::BezierConverter<order, dimensions, T, U>::to(*this);
         }
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of @cpp order + 1 @ce elements
+         *
+         * @see @ref operator[]()
+         */
+        Vector<dimensions, T>* data() { return _data; }
+        constexpr const Vector<dimensions, T>* data() const { return _data; } /**< @overload */
+
         /** @brief Equality comparison */
         bool operator==(const Bezier<order, dimensions, T>& other) const {
             for(std::size_t i = 0; i != order + 1; ++i)

src/Magnum/Math/Complex.h

@@ -172,6 +172,15 @@ template<class T> class Complex {
             return Implementation::ComplexConverter<T, U>::to(*this);
         }
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of two elements
+         *
+         * @see @ref real(), @ref imaginary()
+         */
+        T* data() { return &_real; }
+        constexpr const T* data() const { return &_real; } /**< @overload */
+
         /** @brief Equality comparison */
         bool operator==(const Complex<T>& other) const {
             return TypeTraits<T>::equals(_real, other._real) &&
@@ -195,11 +204,19 @@ template<class T> class Complex {
             return Implementation::isNormalizedSquared(dot());
         }
 
-        /** @brief Real part (@f$ a_0 @f$) */
+        /**
+         * @brief Real part (@f$ a_0 @f$)
+         *
+         * @see @ref data()
+         */
         T& real() { return _real; }
         constexpr T real() const { return _real; } /**< @overload */
 
-        /** @brief Imaginary part (@f$ a_i @f$) */
+        /**
+         * @brief Imaginary part (@f$ a_i @f$)
+         *
+         * @see @ref data()
+         */
         T& imaginary() { return _imaginary; }
         constexpr T imaginary() const { return _imaginary; } /**< @overload */
 

src/Magnum/Math/CubicHermite.h

@@ -144,6 +144,15 @@ template<class T> class CubicHermite {
          */
         template<class U> constexpr explicit CubicHermite(const CubicHermite<U>& other) noexcept: _inTangent{T(other._inTangent)}, _point{T(other._point)}, _outTangent{T(other._outTangent)} {}
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of three elements
+         *
+         * @see @ref inTangent(), @ref point(), @ref outTangent()
+         */
+        T* data() { return &_inTangent; }
+        constexpr const T* data() const { return &_inTangent; } /**< @overload */
+
         /** @brief Equality comparison */
         bool operator==(const CubicHermite<T>& other) const;
 

src/Magnum/Math/Dual.h

@@ -115,6 +115,15 @@ template<class T> class Dual {
         /** @brief Copy constructor */
         constexpr /*implicit*/ Dual(const Dual<T>&) noexcept = default;
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of two elements
+         *
+         * @see @ref real(), @ref dual()
+         */
+        T* data() { return &_real; }
+        constexpr const T* data() const { return &_real; } /**< @overload */
+
         /** @brief Equality comparison */
         bool operator==(const Dual<T>& other) const {
             return TypeTraits<T>::equals(_real, other._real) &&
@@ -126,13 +135,21 @@ template<class T> class Dual {
             return !operator==(other);
         }
 
-        /** @brief Real part (@f$ a_0 @f$) */
+        /**
+         * @brief Real part (@f$ a_0 @f$)
+         *
+         * @see @ref data()
+         */
         T& real() { return _real; }
         /* Returning const so it's possible to call constexpr functions on the
            result. WTF, C++?! */
         constexpr const T real() const { return _real; } /**< @overload */
 
-        /** @brief Dual part (@f$ a_\epsilon @f$) */
+        /**
+         * @brief Dual part (@f$ a_\epsilon @f$)
+         *
+         * @see @ref data()
+         */
         T& dual() { return _dual; }
         /* Returning const so it's possible to call constexpr functions on the
            result. WTF, C++?! */

src/Magnum/Math/DualComplex.h

@@ -180,6 +180,15 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
             return Implementation::DualComplexConverter<T, U>::to(*this);
         }
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of four elements
+         *
+         * @see @ref real(), @ref dual()
+         */
+        T* data() { return Dual<Complex<T>>::data()->data(); }
+        constexpr const T* data() const { return Dual<Complex<T>>::data()->data(); } /**< @overload */
+
         /**
          * @brief Whether the dual complex number is normalized
          *

src/Magnum/Math/DualQuaternion.h

@@ -329,6 +329,15 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
             return Implementation::DualQuaternionConverter<T, U>::to(*this);
         }
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of eight elements
+         *
+         * @see @ref real(), @ref dual()
+         */
+        T* data() { return Dual<Quaternion<T>>::data()->data(); }
+        constexpr const T* data() const { return Dual<Quaternion<T>>::data()->data(); } /**< @overload */
+
         /**
          * @brief Whether the dual quaternion is normalized
          *

src/Magnum/Math/Quaternion.h

@@ -318,6 +318,15 @@ template<class T> class Quaternion {
             return Implementation::QuaternionConverter<T, U>::to(*this);
         }
 
+        /**
+         * @brief Raw data
+         * @return One-dimensional array of four elements
+         *
+         * @see @ref vector(), @ref scalar()
+         */
+        T* data() { return _vector.data(); }
+        constexpr const T* data() const { return _vector.data(); } /**< @overload */
+
         /** @brief Equality comparison */
         bool operator==(const Quaternion<T>& other) const {
             return _vector == other._vector && TypeTraits<T>::equals(_scalar, other._scalar);

src/Magnum/Math/Test/BezierTest.cpp

@@ -221,6 +221,11 @@ void BezierTest::data() {
     #endif
     Vector2 c = b[2];
     CORRADE_COMPARE(c, (Vector2{0.0f, -1.2f}));
+
+    constexpr Vector2 d = *b.data();
+    Vector2 e = a.data()[2];
+    CORRADE_COMPARE(d, (Vector2{3.5f, 0.1f}));
+    CORRADE_COMPARE(e, (Vector2{0.7f, 20.3f}));
 }
 
 void BezierTest::compare() {

src/Magnum/Math/Test/ComplexTest.cpp

@@ -267,6 +267,11 @@ void ComplexTest::data() {
     a.real() = 2.0f;
     a.imaginary() = -3.5f;
     CORRADE_COMPARE(a, (Complex{2.0f, -3.5f}));
+
+    constexpr Float b = *ca.data();
+    Float c = a.data()[1];
+    CORRADE_COMPARE(b, 1.5f);
+    CORRADE_COMPARE(c, -3.5f);
 }
 
 void ComplexTest::compare() {

src/Magnum/Math/Test/CubicHermiteTest.cpp

@@ -600,8 +600,13 @@ void CubicHermiteTest::dataScalar() {
     CubicHermite1D a{2.0f, -2.0f, -0.5f};
     a.inTangent() = 3.0f;
     a.point() = 1.0f;
-    a.outTangent() = 2.0f;
-    CORRADE_COMPARE(a, (CubicHermite1D{3.0f, 1.0f, 2.0f}));
+    a.outTangent() = 2.1f;
+    CORRADE_COMPARE(a, (CubicHermite1D{3.0f, 1.0f, 2.1f}));
+
+    constexpr Float b = *ca.data();
+    Float c = a.data()[2];
+    CORRADE_COMPARE(b, 2.0f);
+    CORRADE_COMPARE(c, 2.1f);
 }
 
 void CubicHermiteTest::dataVector() {
@@ -618,6 +623,11 @@ void CubicHermiteTest::dataVector() {
     a.point().x() = 1.0f;
     a.outTangent().y() = 2.0f;
     CORRADE_COMPARE(a, (CubicHermite2D{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}));
+
+    constexpr Vector2 b = *ca.data();
+    Vector2 c = a.data()[2];
+    CORRADE_COMPARE(b, (Vector2{1.0f, 2.0f}));
+    CORRADE_COMPARE(c, (Vector2{3.0f, 2.0f}));
 }
 
 void CubicHermiteTest::dataComplex() {
@@ -634,6 +644,11 @@ void CubicHermiteTest::dataComplex() {
     a.point().real() = 1.0f;
     a.outTangent().imaginary() = 2.0f;
     CORRADE_COMPARE(a, (CubicHermiteComplex{{1.0f, 3.0f}, {1.0f, -2.0f}, {3.0f, 2.0f}}));
+
+    constexpr Complex b = *ca.data();
+    Complex c = a.data()[2];
+    CORRADE_COMPARE(b, (Complex{1.0f, 2.0f}));
+    CORRADE_COMPARE(c, (Complex{3.0f, 2.0f}));
 }
 
 void CubicHermiteTest::dataQuaternion() {
@@ -660,6 +675,11 @@ void CubicHermiteTest::dataQuaternion() {
         {{1.0f, 3.0f, -1.0f}, 3.0f},
         {{1.5f, -2.0f, 0.1f}, 1.0f},
         {{3.0f, -0.5f, 2.0f}, 0.3f}}));
+
+    constexpr Quaternion b = *ca.data();
+    Quaternion c = a.data()[2];
+    CORRADE_COMPARE(b, (Quaternion{{1.0f, 2.0f, -1.0f}, 3.0f}));
+    CORRADE_COMPARE(c, (Quaternion{{3.0f, -0.5f, 2.0f}, 0.3f}));
 }
 
 void CubicHermiteTest::compareScalar() {

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -64,6 +64,8 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
     void constructCopy();
     void convert();
 
+    void data();
+
     void isNormalized();
     template<class T> void isNormalizedEpsilonRotation();
     template<class T> void isNormalizedEpsilonTranslation();
@@ -109,6 +111,8 @@ DualComplexTest::DualComplexTest() {
               &DualComplexTest::constructCopy,
               &DualComplexTest::convert,
 
+              &DualComplexTest::data,
+
               &DualComplexTest::isNormalized,
               &DualComplexTest::isNormalizedEpsilonRotation<Float>,
               &DualComplexTest::isNormalizedEpsilonRotation<Double>,
@@ -144,14 +148,11 @@ DualComplexTest::DualComplexTest() {
 void DualComplexTest::construct() {
     constexpr DualComplex a = {{-1.0f, 2.5f}, {3.0f, -7.5f}};
     CORRADE_COMPARE(a, DualComplex({-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));
 
-    constexpr Complex b = a.real();
-    constexpr Complex c = a.dual();
-    CORRADE_COMPARE(b, Complex(-1.0f, 2.5f));
-    CORRADE_COMPARE(c, Complex(3.0f, -7.5f));
-
-    constexpr DualComplex d(Complex(-1.0f, 2.5f));
-    CORRADE_COMPARE(d, DualComplex({-1.0f, 2.5f}, {0.0f, 0.0f}));
+    constexpr DualComplex b(Complex(-1.0f, 2.5f));
+    CORRADE_COMPARE(b, DualComplex({-1.0f, 2.5f}, {0.0f, 0.0f}));
 
     CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, Complex, Complex>::value));
 }
@@ -247,6 +248,22 @@ void DualComplexTest::convert() {
     CORRADE_VERIFY(!(std::is_convertible<DualComplex, DualCmpl>::value));
 }
 
+void DualComplexTest::data() {
+    constexpr DualComplex ca{{-1.0f, 2.5f}, {3.0f, -7.5f}};
+
+    constexpr Complex b = ca.real();
+    constexpr Complex c = ca.dual();
+    CORRADE_COMPARE(b, Complex(-1.0f, 2.5f));
+    CORRADE_COMPARE(c, Complex(3.0f, -7.5f));
+
+    DualComplex a{{-1.0f, 2.5f}, {3.0f, -7.5f}};
+
+    constexpr Float d = *ca.data();
+    Float e = a.data()[3];
+    CORRADE_COMPARE(d, -1.0f);
+    CORRADE_COMPARE(e, -7.5f);
+}
+
 void DualComplexTest::isNormalized() {
     CORRADE_VERIFY(!DualComplex({2.0f, 1.0f}, {}).isNormalized());
     CORRADE_VERIFY((DualComplex::rotation(Deg(23.0f))*DualComplex::translation({6.0f, 3.0f})).isNormalized());

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -67,6 +67,8 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
     void constructCopy();
     void convert();
 
+    void data();
+
     void isNormalized();
     template<class T> void isNormalizedEpsilonRotation();
     template<class T> void isNormalizedEpsilonTranslation();
@@ -117,6 +119,8 @@ DualQuaternionTest::DualQuaternionTest() {
               &DualQuaternionTest::constructCopy,
               &DualQuaternionTest::convert,
 
+              &DualQuaternionTest::data,
+
               &DualQuaternionTest::isNormalized,
               &DualQuaternionTest::isNormalizedEpsilonRotation<Float>,
               &DualQuaternionTest::isNormalizedEpsilonRotation<Double>,
@@ -154,15 +158,11 @@ DualQuaternionTest::DualQuaternionTest() {
 void DualQuaternionTest::construct() {
     constexpr DualQuaternion a = {{{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}};
     CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}));
+    CORRADE_COMPARE(a.real(), Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
+    CORRADE_COMPARE(a.dual(), Quaternion({0.5f, -3.1f, 3.3f}, 2.0f));
 
-    constexpr Quaternion b = a.real();
-    CORRADE_COMPARE(b, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
-
-    constexpr Quaternion c = a.dual();
-    CORRADE_COMPARE(c, Quaternion({0.5f, -3.1f, 3.3f}, 2.0f));
-
-    constexpr DualQuaternion d({{1.0f, 2.0f, 3.0f}, -4.0f});
-    CORRADE_COMPARE(d, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
+    constexpr DualQuaternion b({{1.0f, 2.0f, 3.0f}, -4.0f});
+    CORRADE_COMPARE(b, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.0f, 0.0f, 0.0f}, 0.0f}));
 
     CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Quaternion, Quaternion>::value));
 }
@@ -275,6 +275,23 @@ void DualQuaternionTest::convert() {
     CORRADE_VERIFY(!(std::is_convertible<DualQuaternion, DualQuat>::value));
 }
 
+void DualQuaternionTest::data() {
+    constexpr DualQuaternion ca{{{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}};
+
+    constexpr Quaternion b = ca.real();
+    CORRADE_COMPARE(b, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
+
+    constexpr Quaternion c = ca.dual();
+    CORRADE_COMPARE(c, Quaternion({0.5f, -3.1f, 3.3f}, 2.0f));
+
+    DualQuaternion a{{{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}};
+
+    constexpr Float d = *ca.data();
+    Float e = a.data()[7];
+    CORRADE_COMPARE(d, 1.0f);
+    CORRADE_COMPARE(e, 2.0f);
+}
+
 void DualQuaternionTest::isNormalized() {
     CORRADE_VERIFY(!DualQuaternion({{1.0f, 2.0f, 3.0f}, 4.0f}, {}).isNormalized());
     CORRADE_VERIFY((DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis())*DualQuaternion::translation({0.9f, -1.0f, -0.5f})).isNormalized());

src/Magnum/Math/Test/DualTest.cpp

@@ -189,6 +189,11 @@ void DualTest::data() {
     a.real() = 2.0f;
     a.dual() = -3.5f;
     CORRADE_COMPARE(a, (Dual{2.0f, -3.5f}));
+
+    constexpr Float b = *ca.data();
+    Float c = a.data()[1];
+    CORRADE_COMPARE(b, 1.5f);
+    CORRADE_COMPARE(c, -3.5f);
 }
 
 void DualTest::compare() {

src/Magnum/Math/Test/QuaternionTest.cpp

@@ -283,6 +283,11 @@ void QuaternionTest::data() {
     a.vector().y() = 4.3f;
     a.scalar() = 1.1f;
     CORRADE_COMPARE(a, (Quaternion{{1.0f, 4.3f, 3.0f}, 1.1f}));
+
+    constexpr Float b = *ca.data();
+    Float c = a.data()[3];
+    CORRADE_COMPARE(b, 1.0f);
+    CORRADE_COMPARE(c, 1.1f);
 }
 
 void QuaternionTest::compare() {