Math: ability to access also matrix row vectors.

doc/matrix-vector.dox

@@ -129,6 +129,12 @@ Vector<3, Int> b;
 b[1] = 1;       // second element
 @endcode
 
+Row vectors can be accessed too, but only for reading, and the access is slower
+due to the way the matrix is stored (see explanation below):
+@code
+Vector<2, Int> c = a.row(2); // third row
+@endcode
+
 Fixed-size vector subclasses have functions for accessing named components
 and subparts:
 @code

src/Math/Matrix.h

@@ -199,6 +199,9 @@ template<std::size_t size, class T> inline Corrade::Utility::Debug operator<<(Co
     }                                                                       \
     inline constexpr const VectorType<T> operator[](std::size_t col) const { \
         return VectorType<T>(Matrix<size, T>::operator[](col));             \
+    }                                                                       \
+    inline VectorType<T> row(std::size_t row) const {                       \
+        return VectorType<T>(Matrix<size, T>::row(row));                    \
     }                                                                       \
                                                                             \
     inline Type<T> operator*(const Matrix<size, T>& other) const {          \

src/Math/RectangularMatrix.h

@@ -154,7 +154,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
          * Float a = m[2][1];
          * @endcode
          *
-         * @see data()
+         * @see row(), data()
          */
         inline Vector<rows, T>& operator[](std::size_t col) {
             return _data[col];
@@ -164,6 +164,22 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
             return _data[col];
         }
 
+        /**
+         * @brief %Matrix row
+         *
+         * Consider using transposed() when accessing rows frequently, as this
+         * is slower than accessing columns due to the way the matrix is stored.
+         * @see operator[]()
+         */
+        inline Vector<cols, T> row(std::size_t row) const {
+            Vector<cols, T> out;
+
+            for(std::size_t i = 0; i != cols; ++i)
+                out[i] = _data[i][row];
+
+            return out;
+        }
+
         /** @brief Equality comparison */
         inline bool operator==(const RectangularMatrix<cols, rows, T>& other) const {
             for(std::size_t i = 0; i != cols; ++i)
@@ -336,7 +352,11 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
             return operator*(RectangularMatrix<1, rows, T>(other))[0];
         }
 
-        /** @brief Transposed matrix */
+        /**
+         * @brief Transposed matrix
+         *
+         * @see row()
+         */
         RectangularMatrix<rows, cols, T> transposed() const {
             RectangularMatrix<rows, cols, T> out;
 

src/Math/Test/RectangularMatrixTest.cpp

@@ -40,7 +40,9 @@ class RectangularMatrixTest: public Corrade::TestSuite::Tester {
         void constructFromData();
         void constructFromDiagonal();
         void constructCopy();
+
         void data();
+        void row();
 
         void compare();
 
@@ -79,7 +81,9 @@ RectangularMatrixTest::RectangularMatrixTest() {
               &RectangularMatrixTest::constructFromData,
               &RectangularMatrixTest::constructFromDiagonal,
               &RectangularMatrixTest::constructCopy,
+
               &RectangularMatrixTest::data,
+              &RectangularMatrixTest::row,
 
               &RectangularMatrixTest::compare,
 
@@ -199,6 +203,14 @@ void RectangularMatrixTest::data() {
     CORRADE_COMPARE(d, 3.0f);
 }
 
+void RectangularMatrixTest::row() {
+    const Matrix3x4 a(Vector4(1.0f,  2.0f,  3.0f,  4.0f),
+                      Vector4(5.0f,  6.0f,  7.0f,  8.0f),
+                      Vector4(9.0f, 10.0f, 11.0f, 12.0f));
+
+    CORRADE_COMPARE(a.row(1), Vector3(2.0f, 6.0f, 10.0f));
+}
+
 void RectangularMatrixTest::compare() {
     Matrix2 a(Vector2(1.0f, -3.0f),
               Vector2(5.0f, -10.0f));