inlined basic constructors, getters and setters, typedef -> using

Author: TomSaw

src/modm/math/geometry/geometric_traits.hpp

@@ -49,8 +49,8 @@ namespace modm
 	{
 		static const bool isValidType = true;
 
-		typedef float FloatType;
-		typedef int16_t WideType;
+		using FloatType = float;
+		using WideType = int16_t;
 
 		static inline int8_t
 		round(float value)
@@ -65,8 +65,8 @@ namespace modm
 	{
 		static const bool isValidType = true;
 
-		typedef float FloatType;
-		typedef int16_t WideType;
+		using FloatType = float;
+		using WideType = int16_t;
 
 		static inline uint8_t
 		round(float value)
@@ -80,8 +80,8 @@ namespace modm
 	{
 		static const bool isValidType = true;
 
-		typedef float FloatType;
-		typedef int32_t WideType;
+		using FloatType = float;
+		using WideType = int32_t;
 
 		static inline int16_t
 		round(float value)
@@ -95,12 +95,14 @@ namespace modm
 	{
 		static const bool isValidType = true;
 
-		typedef float FloatType;
+		using FloatType = float;
+		// using WideType = int64_t;
 
+		// OPTIMIZE only fall back to int32_t on avr architecture
 		// Usually the range of a int32_t is big enough so that no
 		// conversion to int64_t is required. This exception is made because
 		// 64-bit operations are very, very slow on an AVR.
-		typedef int32_t WideType;
+		using WideType = int32_t;
 
 		static inline int32_t
 		round(float value)
@@ -114,8 +116,8 @@ namespace modm
 	{
 		static const bool isValidType = true;
 
-		typedef float FloatType;
-		typedef float WideType;
+		using FloatType = float;
+		using WideType = float;
 
 		static inline float
 		round(float value)

src/modm/math/geometry/vector1.hpp

@@ -40,18 +40,16 @@ namespace modm
 
 		// basic constructors
 		constexpr Vector() = default;
-		constexpr Vector(T inX);
+		constexpr Vector(T x) : x(x) {}
 		constexpr Vector(const Matrix<T, 1, 1> &rhs);
 
-		inline void
-		set(const T& x);
+		// getters and setters
+		void set(T x) { this->x = x; }
+		void setX(T x) { this->x = x; }
 
-		inline void
-		setX(const T& value);
-
-		inline const T&
-		getX() const;
+		T getX() const { return x; }
 
+		// other methods
 		Vector& operator = (const Matrix<T, 1, 1> &rhs);
 
 		auto operator<=>(const Vector &) const = default;
@@ -99,8 +97,8 @@ namespace modm
 		return rhs * lhs;
 	}
 
-	typedef Vector<float, 1> 	Vector1f;
-	typedef Vector<int16_t, 1> 	Vector1i;
+	using Vector1f = Vector<float, 1>;
+	using Vector1i = Vector<int16_t, 1>;
 }
 
 #include "vector1_impl.hpp"

src/modm/math/geometry/vector1_impl.hpp

@@ -12,32 +12,11 @@
 #pragma once
 #include "vector1.hpp"
 
-template<typename T>
-constexpr modm::Vector<T, 1>::Vector(T inX) :
-	x(inX)
-{}
-
 template<typename T>
 constexpr modm::Vector<T, 1>::Vector(const modm::Matrix<T, 1, 1> &rhs) :
 	x(*reinterpret_cast<const T*>(&rhs))
 {}
 
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 1>::set(const T& value)
-{ this->x = value; }
-
-template<typename T>
-void
-modm::Vector<T, 1>::setX(const T& value)
-{ this->x = value; }
-
-template<typename T>
-const T&
-modm::Vector<T, 1>::getX() const
-{ return this->x; }
-
 // ----------------------------------------------------------------------------
 template<typename T>
 modm::Vector<T, 1>&

src/modm/math/geometry/vector2.hpp

@@ -52,65 +52,40 @@ namespace modm
 	template<typename T>
 	class Vector<T, 2>
 	{
-		friend class Location2D<T>;
-
 	public:
-		typedef typename GeometricTraits<T>::WideType WideType;
-		typedef typename GeometricTraits<T>::FloatType FloatType;
+		using WideType = GeometricTraits<T>::WideType;
+		using FloatType = GeometricTraits<T>::FloatType;
 
 		T x = 0, y = 0;
 
 		// basic constructors
 		constexpr Vector() = default;
-		constexpr Vector(const T& inX, const T& inY);
-		constexpr Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY);
-		constexpr Vector(const T &inX, const Vector<T, 1> &inY);
-		constexpr Vector(const Vector<T, 1> &inX, const T &inY);
-		constexpr explicit Vector(T inVal);
-		constexpr Vector(const Matrix<T, 2, 1> &rhs);
-
-		inline void
-		setX(const T& value);
+		constexpr explicit Vector(T xy) : x(xy), y(xy) {}
+		constexpr Vector(T x, T y) : x(x), y(y) {}
 
-		inline void
-		setY(const T& value);
+		template<typename U>
+		constexpr Vector(const Vector<U, 2> &v) : x(v.x), y(v.y) {}
 
-		inline void
-		set(const T& x, const T& y);
+		constexpr Vector(Vector<T, 1> vx, Vector<T, 1> vy) : x(vx.x), y(vy.x) {}
+		constexpr Vector(T x, Vector<T, 1> vy) : x(x), y(vy.x) {}
+		constexpr Vector(Vector<T, 1> vx, T y) : x(vx.x), y(y) {}
 
+		// advanced constructors
+		constexpr Vector(const Matrix<T, 2, 1> &rhs);
 
-		inline const T&
-		getX() const;
+		// getters and setters
+		void set(const T x, const T y) { this->x = x; this->y = y; }
+		void setX(const T x) { this->x = x; }
+		void setY(const T y) { this->y = y; }
 
-		inline const T&
-		getY() const;
+		T getX() const { return x; }
+		T getY() const { return y; }
 
-		/**
-		 * \brief	Calculate length of the vector
-		 */
-		T
-		getLength() const;
+		// other methods
+		T getLength() const;
+		WideType getLengthSquared() const;
 
-		/**
-		 * \brief	Calculate squared length of the vector
-		 *
-		 * This method is considerably faster than getLength() because it
-		 * doesn't need to calculate the square root.
-		 *
-		 * \return	squared length (x*x + y*y)
-		 */
-		WideType
-		getLengthSquared() const;
-
-		/**
-		 * \brief	Calculate the absolute angle
-		 *
-		 * \code
-		 * atan2(y, x)
-		 * \endcode
-		 */
-		float
-		getAngle() const;
+		float getAngle() const;
 
 		/**
 		 * \brief	Normalize length to 1
@@ -291,9 +266,9 @@ namespace modm
 		operator * (float scale, const Vector<U, 2> &vector);
 	};
 
-	typedef Vector<float, 2> 		Vector2f;
-	typedef Vector<int16_t, 2> 		Vector2i;
-	typedef Vector<uint16_t, 2> 	Vector2u;
+	using Vector2f = Vector<float, 2>;
+	using Vector2i = Vector<int16_t, 2>;
+	using Vector2u = Vector<uint16_t, 2>;
 
 	// ------------------------------------------------------------------------
 	// Global functions