Doc++

src/Math/Quaternion.h

@@ -117,10 +117,10 @@ template<class T> class Quaternion {
         }
 
         /** @brief Default constructor */
-        inline constexpr Quaternion(): _scalar(T(1)) {}
+        inline constexpr /*implicit*/ Quaternion(): _scalar(T(1)) {}
 
         /** @brief Create quaternion from vector and scalar */
-        inline constexpr Quaternion(const Vector3<T>& vector, T scalar): _vector(vector), _scalar(scalar) {}
+        inline constexpr /*implicit*/ Quaternion(const Vector3<T>& vector, T scalar): _vector(vector), _scalar(scalar) {}
 
         /** @brief Equality comparison */
         inline bool operator==(const Quaternion<T>& other) const {

src/Math/Vector.h

@@ -151,20 +151,12 @@ template<std::size_t size, class T> class Vector: public RectangularMatrix<1, si
             return true;
         }
 
-        /**
-         * @brief Multiply vector component-wise
-         *
-         * @see operator*=(const Vector<size, U>&)
-         */
-        template<class U> inline Vector<size, T> operator*(const Vector<size, U>& other) const {
-            return Vector<size, T>(*this)*=other;
-        }
-
         /**
          * @brief Multiply vector component-wise and assign
          *
-         * More efficient than operator*(const Vector<size, U>&) const,
-         * because it does the computation in-place.
+         * The computation is done in-place. @f[
+         *      \boldsymbol a_i = \boldsymbol a_i \boldsymbol b_i
+         * @f]
          */
         template<class U> Vector<size, T>& operator*=(const Vector<size, U>& other) {
             for(std::size_t i = 0; i != size; ++i)
@@ -174,19 +166,20 @@ template<std::size_t size, class T> class Vector: public RectangularMatrix<1, si
         }
 
         /**
-         * @brief Divide vector component-wise
+         * @brief Multiply vector component-wise
          *
-         * @see operator/=(const Vector<size, U>&)
+         * @see operator*=(const Vector<size, U>&)
          */
-        template<class U> inline Vector<size, T> operator/(const Vector<size, U>& other) const {
-            return Vector<size, T>(*this)/=other;
+        template<class U> inline Vector<size, T> operator*(const Vector<size, U>& other) const {
+            return Vector<size, T>(*this)*=other;
         }
 
         /**
          * @brief Divide vector component-wise and assign
          *
-         * More efficient than operator/(const Vector<size, U>&) const,
-         * because it does the computation in-place.
+         * The computation is done in-place. @f[
+         *      \boldsymbol a_i = \frac{\boldsymbol a_i}{\boldsymbol b_i}
+         * @f]
          */
         template<class U> Vector<size, T>& operator/=(const Vector<size, U>& other) {
             for(std::size_t i = 0; i != size; ++i)
@@ -195,6 +188,15 @@ template<std::size_t size, class T> class Vector: public RectangularMatrix<1, si
             return *this;
         }
 
+        /**
+         * @brief Divide vector component-wise
+         *
+         * @see operator/=(const Vector<size, U>&)
+         */
+        template<class U> inline Vector<size, T> operator/(const Vector<size, U>& other) const {
+            return Vector<size, T>(*this)/=other;
+        }
+
         /**
          * @brief Dot product of the vector
          *