Math: added RectangularMatrix::flipped{Cols,Rows}().

src/Magnum/Math/RectangularMatrix.h

@@ -342,10 +342,30 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /**
          * @brief Transposed matrix
          *
-         * @see @ref row()
+         * @see @ref row(), @ref flippedCols(), @ref flippedRows()
          */
         RectangularMatrix<rows, cols, T> transposed() const;
 
+        /**
+         * @brief Matrix with flipped cols
+         *
+         * The order of columns is reversed.
+         * @see @ref transposed(), @ref flippedRows(), @ref Vector::flipped()
+         */
+        constexpr RectangularMatrix<cols, rows, T> flippedCols() const {
+            return flippedColsInternal(typename Implementation::GenerateReverseSequence<cols>::Type{});
+        }
+
+        /**
+         * @brief Matrix with flipped rows
+         *
+         * The order of rows is reversed.
+         * @see @ref transposed(), @ref flippedCols(), @ref Vector::flipped()
+         */
+        constexpr RectangularMatrix<cols, rows, T> flippedRows() const {
+            return flippedRowsInternal(typename Implementation::GenerateSequence<cols>::Type{});
+        }
+
         /**
          * @brief Values on diagonal
          *
@@ -382,6 +402,14 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /* MSVC 2015 can't handle {} here */
         template<class U, std::size_t ...sequence> constexpr explicit RectangularMatrix(Implementation::Sequence<sequence...>, U): _data{Vector<rows, T>((static_cast<void>(sequence), U{typename U::Init{}}))...} {}
 
+        template<std::size_t ...sequence> constexpr RectangularMatrix<cols, rows, T> flippedColsInternal(Implementation::Sequence<sequence...>) const {
+            return {(*this)[sequence]...};
+        }
+
+        template<std::size_t ...sequence> constexpr RectangularMatrix<cols, rows, T> flippedRowsInternal(Implementation::Sequence<sequence...>) const {
+            return {(*this)[sequence].flipped()...};
+        }
+
         template<std::size_t ...sequence> constexpr Vector<DiagonalSize, T> diagonalInternal(Implementation::Sequence<sequence...>) const;
 
         Vector<rows, T> _data[cols];
@@ -583,7 +611,13 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
     }                                                                       \
     __VA_ARGS__ operator/(T number) const {                                 \
         return Math::RectangularMatrix<cols, rows, T>::operator/(number);   \
-    }
+    }                                                                       \
+    constexpr __VA_ARGS__ flippedCols() const {                             \
+        return Math::RectangularMatrix<cols, rows, T>::flippedCols();       \
+    }                                                                       \
+    constexpr __VA_ARGS__ flippedRows() const {                             \
+        return Math::RectangularMatrix<cols, rows, T>::flippedRows();       \
+    }                                                                       \
 
 #define MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(...)                          \
     template<std::size_t size, class T> inline __VA_ARGS__ operator*(typename std::common_type<T>::type number, const __VA_ARGS__& matrix) { \

src/Magnum/Math/Test/RectangularMatrixTest.cpp

@@ -81,6 +81,8 @@ struct RectangularMatrixTest: Corrade::TestSuite::Tester {
     void multiplyVector();
 
     void transposed();
+    void flippedCols();
+    void flippedRows();
     void diagonal();
 
     void vector();
@@ -128,6 +130,8 @@ RectangularMatrixTest::RectangularMatrixTest() {
               &RectangularMatrixTest::multiplyVector,
 
               &RectangularMatrixTest::transposed,
+              &RectangularMatrixTest::flippedCols,
+              &RectangularMatrixTest::flippedRows,
               &RectangularMatrixTest::diagonal,
 
               &RectangularMatrixTest::vector,
@@ -409,6 +413,36 @@ void RectangularMatrixTest::transposed() {
     CORRADE_COMPARE(original.transposed(), transposed);
 }
 
+void RectangularMatrixTest::flippedCols() {
+    constexpr Matrix4x3 original{Vector3{ 0.0f,  1.0f,  3.0f},
+                                 Vector3{ 4.0f,  5.0f,  7.0f},
+                                 Vector3{ 8.0f,  9.0f, 11.0f},
+                                 Vector3{12.0f, 13.0f, 15.0f}};
+    constexpr Matrix4x3 flipped = original.flippedCols();
+
+    Matrix4x3 expectedFlipped{Vector3{12.0f, 13.0f, 15.0f},
+                              Vector3{ 8.0f,  9.0f, 11.0f},
+                              Vector3{ 4.0f,  5.0f,  7.0f},
+                              Vector3{ 0.0f,  1.0f,  3.0f}};
+
+    CORRADE_COMPARE(flipped, expectedFlipped);
+}
+
+void RectangularMatrixTest::flippedRows() {
+    constexpr Matrix4x3 original{Vector3{ 0.0f,  1.0f,  3.0f},
+                                 Vector3{ 4.0f,  5.0f,  7.0f},
+                                 Vector3{ 8.0f,  9.0f, 11.0f},
+                                 Vector3{12.0f, 13.0f, 15.0f}};
+    constexpr Matrix4x3 flipped = original.flippedRows();
+
+    Matrix4x3 expectedFlipped{Vector3{ 3.0f,  1.0f,  0.0f},
+                              Vector3{ 7.0f,  5.0f,  4.0f},
+                              Vector3{11.0f,  9.0f,  8.0f},
+                              Vector3{15.0f, 13.0f, 12.0f}};
+
+    CORRADE_COMPARE(flipped, expectedFlipped);
+}
+
 void RectangularMatrixTest::diagonal() {
     Vector3 diagonal(-1.0f, 5.0f, 11.0f);
 
@@ -500,6 +534,10 @@ void RectangularMatrixTest::subclassTypes() {
     CORRADE_VERIFY((std::is_same<decltype(1.0f*c2), BasicMat<3, Float>>::value));
     CORRADE_VERIFY((std::is_same<decltype(1.0f/c2), BasicMat<3, Float>>::value));
     CORRADE_VERIFY((std::is_same<decltype(Vector3()*Math::RectangularMatrix<3, 1, Float>()), BasicMat<3, Float>>::value));
+
+    /* Functions */
+    CORRADE_VERIFY((std::is_same<decltype(a.flippedCols()), Mat2x2>::value));
+    CORRADE_VERIFY((std::is_same<decltype(a.flippedRows()), Mat2x2>::value));
 }
 
 void RectangularMatrixTest::subclass() {
@@ -560,6 +598,16 @@ void RectangularMatrixTest::subclass() {
     const Math::Vector<1, Float> i(2.0f);
     const Math::RectangularMatrix<1, 1, Float> j(3.0f);
     CORRADE_COMPARE(i*j, (BasicMat<1, Float>(6.0f)));
+
+    /* Functions */
+    constexpr Mat2x2 flippedCols = Mat2x2{Vector2{-1.0f,  5.0f},
+                                          Vector2{ 7.0f, -2.0f}}.flippedCols();
+    CORRADE_COMPARE(flippedCols, (Mat2x2{Vector2{ 7.0f, -2.0f},
+                                         Vector2{-1.0f,  5.0f}}));
+    constexpr Mat2x2 flippedRows = Mat2x2{Vector2{-1.0f,  5.0f},
+                                          Vector2{ 7.0f, -2.0f}}.flippedRows();
+    CORRADE_COMPARE(flippedRows, (Mat2x2{Vector2{ 5.0f, -1.0f},
+                                         Vector2{-2.0f,  7.0f}}));
 }
 
 void RectangularMatrixTest::debug() {

src/Magnum/Math/Vector.h

@@ -540,6 +540,8 @@ template<std::size_t size, class T> class Vector {
          * @brief Flipped vector
          *
          * Returns the vector with components in reverse order.
+         * @see @ref RectangularMatrix::flippedCols(),
+         *      @ref RectangularMatrix::flippedRows()
          */
         constexpr Vector<size, T> flipped() const {
             return flippedInternal(typename Implementation::GenerateReverseSequence<size>::Type{});