Moved unary operator- from Vector to RectangularMatrix.

src/Math/RectangularMatrix.h

@@ -183,6 +183,16 @@ template<size_t c, size_t r, class T> class RectangularMatrix {
             return *this;
         }
 
+        /** @brief Negative matrix */
+        RectangularMatrix<cols, rows, T> operator-() const {
+            RectangularMatrix<cols, rows, T> out;
+
+            for(size_t i = 0; i != cols*rows; ++i)
+                out._data[i] = -_data[i];
+
+            return out;
+        }
+
         /**
          * @brief Subtract matrix
          *
@@ -379,6 +389,9 @@ template<size_t cols, size_t rows, class T> Corrade::Utility::Debug operator<<(C
     }
 
 #define MAGNUM_RECTANGULARMATRIX_SUBCLASS_OPERATOR_IMPLEMENTATION(cols, rows, ...) \
+    inline __VA_ARGS__ operator-() const {                                  \
+        return Math::RectangularMatrix<cols, rows, T>::operator-();         \
+    }                                                                       \
     inline __VA_ARGS__ operator+(const Math::RectangularMatrix<cols, rows, T>& other) const { \
         return Math::RectangularMatrix<cols, rows, T>::operator+(other);    \
     }                                                                       \

src/Math/Test/RectangularMatrixTest.cpp

@@ -37,6 +37,7 @@ RectangularMatrixTest::RectangularMatrixTest() {
              &RectangularMatrixTest::constructZero,
              &RectangularMatrixTest::data,
 
+             &RectangularMatrixTest::negative,
              &RectangularMatrixTest::addSubtract,
              &RectangularMatrixTest::multiplyDivide,
              &RectangularMatrixTest::multiply,
@@ -111,6 +112,10 @@ void RectangularMatrixTest::data() {
     CORRADE_COMPARE(m, expected);
 }
 
+void RectangularMatrixTest::negative() {
+    CORRADE_COMPARE(-Matrix2(1.0f, -3.0f, 5.0f, -10.0f), Matrix2(-1.0f, 3.0f, -5.0f, 10.0f));
+}
+
 void RectangularMatrixTest::addSubtract() {
     Matrix4x3 a(0.0f,   1.0f,   3.0f,
                 4.0f,   5.0f,   7.0f,

src/Math/Test/RectangularMatrixTest.h

@@ -28,6 +28,7 @@ class RectangularMatrixTest: public Corrade::TestSuite::Tester<RectangularMatrix
         void constructZero();
         void data();
 
+        void negative();
         void addSubtract();
         void multiplyDivide();
         void multiply();

src/Math/Test/VectorTest.cpp

@@ -44,7 +44,6 @@ VectorTest::VectorTest() {
              &VectorTest::min,
              &VectorTest::max,
              &VectorTest::angle,
-             &VectorTest::negative,
              &VectorTest::debug,
              &VectorTest::configuration);
 }
@@ -117,10 +116,6 @@ void VectorTest::angle() {
     CORRADE_COMPARE(Vector3::angle(Vector3(2.0f, 3.0f, 4.0f).normalized(), Vector3(1.0f, -2.0f, 3.0f).normalized()), rad(1.162514f));
 }
 
-void VectorTest::negative() {
-    CORRADE_COMPARE(-Vector4(1.0f, -3.0f, 5.0f, -10.0f), Vector4(-1.0f, 3.0f, -5.0f, 10.0f));
-}
-
 void VectorTest::debug() {
     ostringstream o;
     Debug(&o) << Vector4(0.5f, 15.0f, 1.0f, 1.0f);

src/Math/Test/VectorTest.h

@@ -35,7 +35,6 @@ class VectorTest: public Corrade::TestSuite::Tester<VectorTest> {
         void min();
         void max();
         void angle();
-        void negative();
 
         void debug();
         void configuration();

src/Math/Vector.h

@@ -169,16 +169,6 @@ template<size_t s, class T> class Vector: public RectangularMatrix<1, s, T> {
             return *this;
         }
 
-        /** @brief Negative vector */
-        Vector<size, T> operator-() const {
-            Vector<size, T> out;
-
-            for(size_t i = 0; i != size; ++i)
-                out[i] = -(*this)[i];
-
-            return out;
-        }
-
         /**
          * @brief Dot product of the vector
          *
@@ -321,7 +311,6 @@ template<size_t size, class T> Corrade::Utility::Debug operator<<(Corrade::Utili
         return *this;                                                       \
     }                                                                       \
                                                                             \
-    inline Type<T> operator-() const { return Math::Vector<size, T>::operator-(); } \
     inline Type<T> normalized() const { return Math::Vector<size, T>::normalized(); }
 
 #define MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(Type, size)          \