Added component-wise multiplication and division to Vector.

src/Math/Test/VectorTest.cpp

@@ -38,6 +38,7 @@ VectorTest::VectorTest() {
              &VectorTest::copy,
              &VectorTest::dot,
              &VectorTest::multiplyDivide,
+             &VectorTest::multiplyDivideComponentWise,
              &VectorTest::addSubtract,
              &VectorTest::dotSelf,
              &VectorTest::length,
@@ -114,6 +115,15 @@ void VectorTest::multiplyDivide() {
     CORRADE_COMPARE(multipliedChar/-1.5f, vecChar);
 }
 
+void VectorTest::multiplyDivideComponentWise() {
+    Vector4 vec(1.0f, 2.0f, 3.0f, 4.0f);
+    Vector4 multiplier(7.0f, -4.0f, -1.5f, 1.0f);
+    Vector4 multiplied(7.0f, -8.0f, -4.5f, 4.0f);
+
+    CORRADE_COMPARE(vec*multiplier, multiplied);
+    CORRADE_COMPARE(multiplied/multiplier, vec);
+}
+
 void VectorTest::addSubtract() {
     Vector4 a(0.5f, -7.5f, 9.0f, -11.0f);
     Vector4 b(-0.5, 1.0f, 0.0f, 7.5f);

src/Math/Test/VectorTest.h

@@ -29,6 +29,7 @@ class VectorTest: public Corrade::TestSuite::Tester<VectorTest> {
         void copy();
         void dot();
         void multiplyDivide();
+        void multiplyDivideComponentWise();
         void addSubtract();
         void dotSelf();
         void length();

src/Math/Vector.h

@@ -205,6 +205,28 @@ template<size_t size, class T> class Vector {
             return *this;
         }
 
+        /**
+         * @brief Multiply vector component-wise
+         *
+         * @see operator*=(const Vector<size, T>&)
+         */
+        Vector<size, T> operator*(const Vector<size, T>& other) const {
+            return Vector<size, T>(*this)*=other;
+        }
+
+        /**
+         * @brief Multiply vector component-wise and assign
+         *
+         * More efficient than operator*(const Vector<size, T>&) const,
+         * because it does the computation in-place.
+         */
+        Vector<size, T>& operator*=(const Vector<size, T>& other) {
+            for(size_t i = 0; i != size; ++i)
+                (*this)[i] *= other[i];
+
+            return *this;
+        }
+
         /**
          * @brief Divide vector
          *
@@ -227,6 +249,28 @@ template<size_t size, class T> class Vector {
             return *this;
         }
 
+        /**
+         * @brief Divide vector component-wise
+         *
+         * @see operator/=(const Vector<size, T>&)
+         */
+        Vector<size, T> operator/(const Vector<size, T>& other) const {
+            return Vector<size, T>(*this)/=other;
+        }
+
+        /**
+         * @brief Divide vector component-wise and assign
+         *
+         * More efficient than operator/(const Vector<size, T>&) const,
+         * because it does the computation in-place.
+         */
+        Vector<size, T>& operator/=(const Vector<size, T>& other) {
+            for(size_t i = 0; i != size; ++i)
+                (*this)[i] /= other[i];
+
+            return *this;
+        }
+
         /** @brief Add two vectors */
         inline Vector<size, T> operator+(const Vector<size, T>& other) const {
             return Vector<size, T>(*this)+=other;
@@ -382,12 +426,26 @@ template<class T, size_t size> Corrade::Utility::Debug operator<<(Corrade::Utili
         Vector<size, T>::operator*=(number);                                \
         return *this;                                                       \
     }                                                                       \
+    inline Type<T> operator*(const Vector<size, T>& other) const {          \
+        return Vector<size, T>::operator*(other);                           \
+    }                                                                       \
+    inline Type<T>& operator*=(const Vector<size, T>& other) {              \
+        Vector<size, T>::operator*=(other);                                 \
+        return *this;                                                       \
+    }                                                                       \
     template<class U> inline Type<T> operator/(U number) const {            \
         return Vector<size, T>::operator/(number);                          \
     }                                                                       \
     template<class U> inline Type<T>& operator/=(U number) {                \
         Vector<size, T>::operator/=(number);                                \
         return *this;                                                       \
+    }                                                                       \
+    inline Type<T> operator/(const Vector<size, T>& other) const {          \
+        return Vector<size, T>::operator/(other);                           \
+    }                                                                       \
+    inline Type<T>& operator/=(const Vector<size, T>& other) {              \
+        Vector<size, T>::operator/=(other);                                 \
+        return *this;                                                       \
     }                                                                       \
                                                                             \
     inline Type<T> operator+(const Vector<size, T>& other) const {          \