From 76794b26e906b805ae1efec3784fc6e912bb9ca6 Mon Sep 17 00:00:00 2001
From: Thomas Sommer <thomas@tomsaw.de>
Date: Fri, 14 Jan 2022 10:38:37 +0100
Subject: [PATCH 1/3] Added tests for Vector basetype conversion
---
test/modm/math/geometry/vector4_test.cpp | 2 +-
test/modm/math/geometry/vector5_test.cpp | 223 +++++++++++++++++++++++
test/modm/math/geometry/vector5_test.hpp | 35 ++++
test/modm/math/geometry/vector_test.cpp | 26 +++
4 files changed, 285 insertions(+), 1 deletion(-)
create mode 100644 test/modm/math/geometry/vector5_test.cpp
create mode 100644 test/modm/math/geometry/vector5_test.hpp
diff --git a/test/modm/math/geometry/vector4_test.cpp b/test/modm/math/geometry/vector4_test.cpp
index 51856af84b..05f500256a 100644
--- a/test/modm/math/geometry/vector4_test.cpp
+++ b/test/modm/math/geometry/vector4_test.cpp
@@ -356,7 +356,7 @@ Vector4Test::testOperators()
TEST_ASSERT_EQUALS(a.x, 1-4);
TEST_ASSERT_EQUALS(a.y, 2-5);
TEST_ASSERT_EQUALS(a.z, 3-6);
- TEST_ASSERT_EQUALS(a.z, 4-7);
+ TEST_ASSERT_EQUALS(a.w, 4-7);
a -= b;
TEST_ASSERT_EQUALS(a.x, 1);
TEST_ASSERT_EQUALS(a.y, 2);
diff --git a/test/modm/math/geometry/vector5_test.cpp b/test/modm/math/geometry/vector5_test.cpp
new file mode 100644
index 0000000000..1ca7f42333
--- /dev/null
+++ b/test/modm/math/geometry/vector5_test.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2011, Fabian Greif
+ * Copyright (c) 2011-2012, Niklas Hauser
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#include <modm/math/geometry/vector.hpp>
+#include "vector5_test.hpp"
+
+void
+Vector5Test::testConstructor()
+{
+ int16_t array[5] = {1, 2, 3, 4, 5};
+
+ modm::Vector<int16_t, 5> a;
+ TEST_ASSERT_EQUALS(a[0], 0);
+ TEST_ASSERT_EQUALS(a[1], 0);
+ TEST_ASSERT_EQUALS(a[2], 0);
+ TEST_ASSERT_EQUALS(a[3], 0);
+ TEST_ASSERT_EQUALS(a[4], 0);
+
+ modm::Vector<int16_t, 5> b(array);
+ TEST_ASSERT_EQUALS(b[0], 1);
+ TEST_ASSERT_EQUALS(b[1], 2);
+ TEST_ASSERT_EQUALS(b[2], 3);
+ TEST_ASSERT_EQUALS(b[3], 4);
+ TEST_ASSERT_EQUALS(b[4], 5);
+
+ modm::Vector<int16_t, 5> c(7);
+ TEST_ASSERT_EQUALS(c[0], 7);
+ TEST_ASSERT_EQUALS(c[1], 7);
+ TEST_ASSERT_EQUALS(c[2], 7);
+ TEST_ASSERT_EQUALS(c[3], 7);
+ TEST_ASSERT_EQUALS(c[4], 7);
+
+ modm::Vector<int16_t, 5> d(3.6);
+ TEST_ASSERT_EQUALS(d[0], 4);
+ TEST_ASSERT_EQUALS(d[1], 4);
+ TEST_ASSERT_EQUALS(d[2], 4);
+ TEST_ASSERT_EQUALS(d[3], 4);
+ TEST_ASSERT_EQUALS(d[4], 4);
+}
+
+// void
+// Vector5Test::testAssign()
+// {
+// modm::Vector4i a(1,2,3,4);
+
+// int16_t array[4] = {5,6,7,8};
+// modm::Matrix<int16_t, 4, 1> m(array);
+
+// modm::Vector4i b;
+
+// b = a;
+// TEST_ASSERT_EQUALS(b.x, 1);
+// TEST_ASSERT_EQUALS(b.y, 2);
+// TEST_ASSERT_EQUALS(b.z, 3);
+// TEST_ASSERT_EQUALS(b.w, 4);
+
+// b = m;
+// TEST_ASSERT_EQUALS(b.x, 5);
+// TEST_ASSERT_EQUALS(b.y, 6);
+// TEST_ASSERT_EQUALS(b.z, 7);
+// TEST_ASSERT_EQUALS(b.w, 8);
+// }
+
+// void
+// Vector5Test::testCompare()
+// {
+// modm::Vector4i a(4,5,2,1);
+// modm::Vector4i b(4,5,2,3);
+// modm::Vector4i c(4,5,2,3);
+// // ==
+// TEST_ASSERT_TRUE(b == c);
+// TEST_ASSERT_FALSE(a == c);
+// // !=
+// TEST_ASSERT_TRUE(a != c);
+// TEST_ASSERT_FALSE(b != c);
+// // <
+// TEST_ASSERT_TRUE(a < c);
+// TEST_ASSERT_FALSE(b < c);
+// TEST_ASSERT_FALSE(c < a);
+// // <=
+// TEST_ASSERT_TRUE(a <= c);
+// TEST_ASSERT_TRUE(b <= c);
+// TEST_ASSERT_FALSE(c <= a);
+// // >
+// TEST_ASSERT_TRUE(c > a);
+// TEST_ASSERT_FALSE(b > c);
+// TEST_ASSERT_FALSE(a > c);
+// // >=
+// TEST_ASSERT_TRUE(c >= a);
+// TEST_ASSERT_TRUE(b >= c);
+// TEST_ASSERT_FALSE(a >= c);
+// }
+
+// void
+// Vector5Test::testRawDataAccess()
+// {
+// modm::Vector4i a(0,1,2,3);
+// int16_t *pointer = a.ptr();
+
+// TEST_ASSERT_EQUALS(a[0], 0);
+// TEST_ASSERT_EQUALS(a[1], 1);
+// TEST_ASSERT_EQUALS(a[2], 2);
+// TEST_ASSERT_EQUALS(a[3], 3);
+// TEST_ASSERT_EQUALS(pointer[0], 0);
+// TEST_ASSERT_EQUALS(pointer[1], 1);
+// TEST_ASSERT_EQUALS(pointer[2], 2);
+// TEST_ASSERT_EQUALS(pointer[3], 3);
+// }
+
+void
+Vector5Test::testOperators()
+{
+ modm::Vector<int16_t, 5> a({1, 2, 3, 4, 5});
+ modm::Vector<int16_t, 5> b({4, 5, 6, 7, 8});
+
+ TEST_ASSERT_EQUALS((a + b)[0], 1+4);
+ TEST_ASSERT_EQUALS((a + b)[1], 2+5);
+ TEST_ASSERT_EQUALS((a + b)[2], 3+6);
+ TEST_ASSERT_EQUALS((a + b)[3], 4+7);
+ TEST_ASSERT_EQUALS((a + b)[4], 5+8);
+
+ TEST_ASSERT_EQUALS((a - b)[0], 1-4);
+ TEST_ASSERT_EQUALS((a - b)[1], 2-5);
+ TEST_ASSERT_EQUALS((a - b)[2], 3-6);
+ TEST_ASSERT_EQUALS((a - b)[3], 4-7);
+ TEST_ASSERT_EQUALS((a - b)[4], 5-8);
+
+ TEST_ASSERT_EQUALS((a * b), 1*4+2*5+3*6+4*7+5*8);
+
+ TEST_ASSERT_EQUALS((a * 3)[0], 1*3);
+ TEST_ASSERT_EQUALS((a * 3)[1], 2*3);
+ TEST_ASSERT_EQUALS((a * 3)[2], 3*3);
+ TEST_ASSERT_EQUALS((a * 3)[3], 4*3);
+ TEST_ASSERT_EQUALS((a * 3)[4], 5*3);
+
+ // TODO
+ // TEST_ASSERT_EQUALS((3 * a)[0], 3*1);
+ // TEST_ASSERT_EQUALS((3 * a)[1], 3*2);
+ // TEST_ASSERT_EQUALS((3 * a)[2], 3*3);
+ // TEST_ASSERT_EQUALS((3 * a)[3], 3*4);
+ // TEST_ASSERT_EQUALS((3 * a)[4], 3*5);
+
+ TEST_ASSERT_EQUALS((b / 2)[0], 4/2);
+ TEST_ASSERT_EQUALS((b / 2)[1], 5/2);
+ TEST_ASSERT_EQUALS((b / 2)[2], 6/2);
+ TEST_ASSERT_EQUALS((b / 2)[3], 7/2);
+ TEST_ASSERT_EQUALS((b / 2)[4], 8/2);
+
+ -b;
+ TEST_ASSERT_EQUALS(b[0], 4);
+ TEST_ASSERT_EQUALS(b[1], 5);
+ TEST_ASSERT_EQUALS(b[2], 6);
+ TEST_ASSERT_EQUALS(b[3], 7);
+ TEST_ASSERT_EQUALS(b[4], 8);
+ b = -b;
+ TEST_ASSERT_EQUALS(b[0], -4);
+ TEST_ASSERT_EQUALS(b[1], -5);
+ TEST_ASSERT_EQUALS(b[2], -6);
+ TEST_ASSERT_EQUALS(b[3], -7);
+ TEST_ASSERT_EQUALS(b[4], -8);
+ a += b;
+ TEST_ASSERT_EQUALS(a[0], 1-4);
+ TEST_ASSERT_EQUALS(a[1], 2-5);
+ TEST_ASSERT_EQUALS(a[2], 3-6);
+ TEST_ASSERT_EQUALS(a[3], 4-7);
+ TEST_ASSERT_EQUALS(a[4], 5-8);
+ a -= b;
+ TEST_ASSERT_EQUALS(a[0], 1);
+ TEST_ASSERT_EQUALS(a[1], 2);
+ TEST_ASSERT_EQUALS(a[2], 3);
+ TEST_ASSERT_EQUALS(a[3], 4);
+ TEST_ASSERT_EQUALS(a[4], 5);
+ a *= 2;
+ TEST_ASSERT_EQUALS(a[0], 1*2);
+ TEST_ASSERT_EQUALS(a[1], 2*2);
+ TEST_ASSERT_EQUALS(a[2], 3*2);
+ TEST_ASSERT_EQUALS(a[3], 4*2);
+ TEST_ASSERT_EQUALS(a[4], 5*2);
+ b /= 2;
+ TEST_ASSERT_EQUALS(b[0], -4/2);
+ TEST_ASSERT_EQUALS(b[1], -5/2);
+ TEST_ASSERT_EQUALS(b[2], -6/2);
+ TEST_ASSERT_EQUALS(b[3], -7/2);
+ TEST_ASSERT_EQUALS(b[4], -8/2);
+}
+
+void
+Vector5Test::testLength()
+{
+ modm::Vector<float, 5> a({1.f,2.f,3.f,4.f,5.f});
+
+ TEST_ASSERT_EQUALS_FLOAT(a.getLengthSquared(), 1.f*1.f+2.f*2.f+3.f*3.f+4.f*4.f+5.f*5.f);
+ // TEST_ASSERT_EQUALS_FLOAT(a.getLength(), 5.477225575);
+
+ // TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).x, 0.3651483717);
+ // TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).y, 0.7302967433);
+ // TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).z, 1.095445115);
+ // TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).w, 1.4605934867);
+ // a.scale(2.f);
+ // TEST_ASSERT_EQUALS_FLOAT(a.x, 0.3651483717);
+ // TEST_ASSERT_EQUALS_FLOAT(a.y, 0.7302967433);
+ // TEST_ASSERT_EQUALS_FLOAT(a.z, 1.095445115);
+ // TEST_ASSERT_EQUALS_FLOAT(a.w, 1.4605934867);
+
+ // TEST_ASSERT_EQUALS_FLOAT(a.normalized().x, 0.1825741858);
+ // TEST_ASSERT_EQUALS_FLOAT(a.normalized().y, 0.3651483717);
+ // TEST_ASSERT_EQUALS_FLOAT(a.normalized().z, 0.5477225575);
+ // TEST_ASSERT_EQUALS_FLOAT(a.normalized().w, 0.7302967433);
+ // a.normalize();
+ // TEST_ASSERT_EQUALS_FLOAT(a.x, 0.1825741858);
+ // TEST_ASSERT_EQUALS_FLOAT(a.y, 0.3651483717);
+ // TEST_ASSERT_EQUALS_FLOAT(a.z, 0.5477225575);
+ // TEST_ASSERT_EQUALS_FLOAT(a.w, 0.7302967433);
+}
diff --git a/test/modm/math/geometry/vector5_test.hpp b/test/modm/math/geometry/vector5_test.hpp
new file mode 100644
index 0000000000..5116001f36
--- /dev/null
+++ b/test/modm/math/geometry/vector5_test.hpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022, Thomas Sommer
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#include <unittest/testsuite.hpp>
+
+/// @ingroup modm_test_test_math
+class Vector5Test : public unittest::TestSuite
+{
+public:
+ void
+ testConstructor();
+
+ // void
+ // testAssign();
+
+ // void
+ // testCompare();
+
+ // void
+ // testRawDataAccess();
+
+ void
+ testOperators();
+
+ void
+ testLength();
+};
diff --git a/test/modm/math/geometry/vector_test.cpp b/test/modm/math/geometry/vector_test.cpp
index 28ff164253..9e2ada7597 100644
--- a/test/modm/math/geometry/vector_test.cpp
+++ b/test/modm/math/geometry/vector_test.cpp
@@ -193,3 +193,29 @@ VectorTest::testLength()
TEST_ASSERT_EQUALS_FLOAT(a.getLengthSquared(), 1.f*1.f + 2.f*2.f + 3.f*3.f + 4.f*4.f);
TEST_ASSERT_EQUALS_FLOAT(a.getLength(), 5.477225575);
}
+
+void VectorTest::testConvert()
+{
+ modm::Vector<float, 2> f(1.3, 2.7);
+ modm::Vector<double, 2> d(1.3, 2.7);
+
+ modm::Vector<uint8_t, 2> u8(1.3, 2.7);
+ TEST_ASSERT_EQUALS(u8.x, 1);
+ TEST_ASSERT_EQUALS(u8.y, 3);
+
+ modm::Vector<int8_t, 2> i8(1.3, 2.7);
+ TEST_ASSERT_EQUALS(i8.x, 1);
+ TEST_ASSERT_EQUALS(i8.y, 3);
+
+ modm::Vector<uint16_t, 2> u16(1.3, 2.7);
+ TEST_ASSERT_EQUALS(u16.x, 1);
+ TEST_ASSERT_EQUALS(u16.y, 3);
+
+ modm::Vector<int16_t, 2> i16(1.3, 2.7);
+ TEST_ASSERT_EQUALS(i16.x, 1);
+ TEST_ASSERT_EQUALS(i16.y, 3);
+
+ modm::Vector<double, 2> d2 = f.convert<double>();
+
+ modm::Vector<float, 2> f2 = f.convert<float>();
+}
From ea018d9f3399d6dcf34030db273108fc38f5beaa Mon Sep 17 00:00:00 2001
From: Thomas Sommer <thomas@tomsaw.de>
Date: Wed, 17 Nov 2021 08:32:59 +0100
Subject: [PATCH 2/3] household/refactor modm::Vector and co
---
src/modm/math/geometry/geometric_traits.hpp | 124 +--
src/modm/math/geometry/line_2d.hpp | 9 +-
src/modm/math/geometry/line_2d_impl.hpp | 15 +-
src/modm/math/geometry/line_segment_2d.hpp | 195 +++--
.../math/geometry/line_segment_2d_impl.hpp | 144 +---
src/modm/math/geometry/location_2d.hpp | 252 +++---
src/modm/math/geometry/location_2d_impl.hpp | 170 ----
src/modm/math/geometry/polygon_2d.hpp | 2 +-
src/modm/math/geometry/polygon_2d_impl.hpp | 2 +-
src/modm/math/geometry/quaternion.hpp | 15 +-
src/modm/math/geometry/quaternion_impl.hpp | 7 +-
src/modm/math/geometry/ray_2d.hpp | 6 +-
src/modm/math/geometry/ray_2d_impl.hpp | 19 +-
src/modm/math/geometry/vector.hpp | 570 ++++++++++---
src/modm/math/geometry/vector1.hpp | 113 ---
src/modm/math/geometry/vector1_impl.hpp | 285 -------
src/modm/math/geometry/vector2.cpp | 75 --
src/modm/math/geometry/vector2.hpp | 384 ---------
src/modm/math/geometry/vector2_impl.hpp | 579 -------------
src/modm/math/geometry/vector3.hpp | 218 -----
src/modm/math/geometry/vector3_impl.hpp | 538 ------------
src/modm/math/geometry/vector4.hpp | 262 ------
src/modm/math/geometry/vector4_impl.hpp | 788 ------------------
src/modm/math/geometry/vector_impl.hpp | 333 --------
src/modm/math/lu_decomposition.hpp | 71 +-
src/modm/math/lu_decomposition_impl.hpp | 168 ++--
src/modm/math/matrix.hpp | 153 ++--
src/modm/math/matrix_impl.hpp | 441 ++++------
src/modm/math/utils/integer_traits.hpp | 22 +-
test/modm/math/geometry/circle_2d_test.cpp | 12 +-
test/modm/math/geometry/line_2d_test.cpp | 20 +-
.../math/geometry/line_segment_2d_test.cpp | 36 +-
test/modm/math/geometry/location_2d_test.cpp | 22 +-
test/modm/math/geometry/polygon_2d_test.cpp | 44 +-
test/modm/math/geometry/quaternion_test.cpp | 3 +-
test/modm/math/geometry/vector1_test.cpp | 54 +-
test/modm/math/geometry/vector2_test.cpp | 246 +++---
test/modm/math/geometry/vector3_test.cpp | 238 +++---
test/modm/math/geometry/vector4_test.cpp | 433 +++++-----
test/modm/math/geometry/vector_test.cpp | 70 +-
test/modm/math/geometry/vector_test.hpp | 3 +
test/modm/math/matrix_test.cpp | 13 +-
test/modm/math/matrix_vector_test.cpp | 14 +-
43 files changed, 1719 insertions(+), 5449 deletions(-)
delete mode 100644 src/modm/math/geometry/location_2d_impl.hpp
delete mode 100644 src/modm/math/geometry/vector1.hpp
delete mode 100644 src/modm/math/geometry/vector1_impl.hpp
delete mode 100644 src/modm/math/geometry/vector2.cpp
delete mode 100644 src/modm/math/geometry/vector2.hpp
delete mode 100644 src/modm/math/geometry/vector2_impl.hpp
delete mode 100644 src/modm/math/geometry/vector3.hpp
delete mode 100644 src/modm/math/geometry/vector3_impl.hpp
delete mode 100644 src/modm/math/geometry/vector4.hpp
delete mode 100644 src/modm/math/geometry/vector4_impl.hpp
delete mode 100644 src/modm/math/geometry/vector_impl.hpp
diff --git a/src/modm/math/geometry/geometric_traits.hpp b/src/modm/math/geometry/geometric_traits.hpp
index fd5528c94c..b61af32602 100644
--- a/src/modm/math/geometry/geometric_traits.hpp
+++ b/src/modm/math/geometry/geometric_traits.hpp
@@ -1,6 +1,7 @@
/*
* Copyright (c) 2009-2011, Fabian Greif
* Copyright (c) 2012, Niklas Hauser
+ * Copyright (c) 2022, Thomas Sommer
*
* This file is part of the modm project.
*
@@ -10,12 +11,13 @@
*/
// ----------------------------------------------------------------------------
-#ifndef MODM_GEOMETRIC_TRAITS_HPP
-#define MODM_GEOMETRIC_TRAITS_HPP
+#pragma once
+#include <concepts>
#include <cmath>
-#include <stdint.h>
+#include <limits>
#include <modm/architecture/utils.hpp>
+#include <modm/math/utils/arithmetic_traits.hpp>
namespace modm
{
@@ -24,120 +26,42 @@ namespace modm
*
* \ingroup modm_math_geometry
* \author Fabian Greif
+ * \author Thomas Sommer
*/
template <typename T>
- struct GeometricTraits
- {
- static const bool isValidType = false;
+ struct GeometricTraits;
- /**
- * \brief Round if converting from a floating point base to
- * a integer base.
- *
- * For T = \c float and \c double this method is specialized to return
- * the result directly without any rounding.
- */
- static inline T
- round(float value)
- {
- return ::round(value);
- }
- };
-
- template <>
- struct GeometricTraits<int8_t>
+ template <std::integral T>
+ struct GeometricTraits<T>
{
- static const bool isValidType = true;
-
- typedef float FloatType;
- typedef int16_t WideType;
-
- static inline int8_t
- round(float value)
- {
- return ::round(value);
- }
- };
-
- // TODO is this useful?
- template <>
- struct GeometricTraits<uint8_t>
- {
- static const bool isValidType = true;
-
- typedef float FloatType;
- typedef int16_t WideType;
+ [[deprecated("Use an appropriate C++ concept instead!")]]
+ static const bool isValidType = false;
- static inline uint8_t
- round(float value)
- {
- return ::round(value);
- }
+ using FloatType = float;
+ using WideType = modm::WideType<T>;
};
- template <>
- struct GeometricTraits<int16_t>
+ template <std::floating_point T>
+ struct GeometricTraits<T>
{
+ [[deprecated("Use an appropriate C++ concept instead!")]]
static const bool isValidType = true;
- typedef float FloatType;
- typedef int32_t WideType;
-
- static inline int16_t
- round(float value)
- {
- return ::round(value);
- }
+ using FloatType = T;
+ using WideType = T;
};
+ #ifdef __AVR__
template <>
struct GeometricTraits<int32_t>
{
+ [[deprecated("Use an appropriate C++ concept instead!")]]
static const bool isValidType = true;
- typedef float FloatType;
-
- // Usually the range of a int32_t is big enough so that no
+ using FloatType = float;
// 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;
-
- static inline int32_t
- round(float value)
- {
- return ::round(value);
- }
- };
-
- template <>
- struct GeometricTraits<float>
- {
- static const bool isValidType = true;
-
- typedef float FloatType;
- typedef float WideType;
-
- static inline float
- round(float value)
- {
- return value;
- }
+ using WideType = int32_t;
};
-
- template <>
- struct GeometricTraits<double>
- {
- static const bool isValidType = true;
-
- typedef double FloatType;
- typedef double WideType;
-
- static inline double
- round(double value)
- {
- return value;
- }
- };
-}
-
-#endif // MODM_GEOMETRIC_TRAITS_HPP
+ #endif
+}
\ No newline at end of file
diff --git a/src/modm/math/geometry/line_2d.hpp b/src/modm/math/geometry/line_2d.hpp
index 6e8528cf58..05d9e8bcc9 100644
--- a/src/modm/math/geometry/line_2d.hpp
+++ b/src/modm/math/geometry/line_2d.hpp
@@ -38,10 +38,7 @@ namespace modm
typedef typename GeometricTraits<T>::FloatType FloatType;
public:
- /**
- * \brief Default-Constructor
- */
- Line2D();
+ constexpr Line2D() = default;
/**
* \brief Construct a line
@@ -49,7 +46,9 @@ namespace modm
* \param point a point on the line
* \param directionVector direction vector, the length doesn't matter
*/
- Line2D(const Vector<T, 2>& point, const Vector<T, 2>& directionVector);
+ constexpr Line2D(const Vector<T, 2>& point, const Vector<T, 2>& directionVector)
+ : point(point), directionVector(directionVector)
+ {}
inline void
diff --git a/src/modm/math/geometry/line_2d_impl.hpp b/src/modm/math/geometry/line_2d_impl.hpp
index f436fa83a7..29f556c939 100644
--- a/src/modm/math/geometry/line_2d_impl.hpp
+++ b/src/modm/math/geometry/line_2d_impl.hpp
@@ -15,19 +15,6 @@
#error "Don't include this file directly, use 'line_2d.hpp' instead!"
#endif
-// ----------------------------------------------------------------------------
-template <typename T>
-modm::Line2D<T>::Line2D() :
- point(), directionVector()
-{
-}
-
-template <typename T>
-modm::Line2D<T>::Line2D(const Vector<T, 2>& point, const Vector<T, 2>& direction) :
- point(point), directionVector(direction)
-{
-}
-
// ----------------------------------------------------------------------------
template <typename T>
inline void
@@ -79,7 +66,7 @@ modm::Line2D<T>::getDistanceTo(const Vector<T, 2>& point) const
FloatType d = c1 / c2;
// calculate the closest point
- Vector<T, 2> closestPoint = this->point + d * this->directionVector;
+ const Vector<T, 2> closestPoint = this->point + this->directionVector * d;
// return the length of the vector from the closest point on the line
// to the given point
diff --git a/src/modm/math/geometry/line_segment_2d.hpp b/src/modm/math/geometry/line_segment_2d.hpp
index eb57e020d3..4f2d7f22c6 100644
--- a/src/modm/math/geometry/line_segment_2d.hpp
+++ b/src/modm/math/geometry/line_segment_2d.hpp
@@ -2,6 +2,7 @@
* Copyright (c) 2009-2011, Fabian Greif
* Copyright (c) 2012, Martin Rosekeit
* Copyright (c) 2012, Niklas Hauser
+ * Copyright (c) 2022, Thomas Sommer
*
* This file is part of the modm project.
*
@@ -10,127 +11,137 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
// ----------------------------------------------------------------------------
-
-#ifndef MODM_LINE_SEGMENT_2D_HPP
-#define MODM_LINE_SEGMENT_2D_HPP
+#pragma once
#include "geometric_traits.hpp"
-
-#include "vector.hpp"
#include "point_set_2d.hpp"
+#include "vector.hpp"
namespace modm
{
- // forward declaration
- template <typename T>
- class Circle2D;
+// forward declaration
+template<typename T>
+class Circle2D;
- template <typename T>
- class Polygon2D;
+template<typename T>
+class Polygon2D;
- /**
- * \brief Line segment
- *
- * \author Fabian Greif
- * \ingroup modm_math_geometry
- */
- template <typename T = int16_t>
- class LineSegment2D
- {
- public:
- typedef typename GeometricTraits<T>::WideType WideType;
- typedef typename GeometricTraits<T>::FloatType FloatType;
+/**
+ * \brief Line segment
+ *
+ * \author Fabian Greif
+ * \ingroup modm_math_geometry
+ */
+template<typename T = int16_t>
+class LineSegment2D
+{
+public:
+ using WideType = GeometricTraits<T>::WideType;
+ using FloatType = GeometricTraits<T>::FloatType;
- public:
- LineSegment2D();
+public:
+ modm::Vector<T, 2> startPoint, endPoint;
- LineSegment2D(const Vector<T, 2>& start, const Vector<T, 2>& end);
+ constexpr LineSegment2D() = default;
+ constexpr LineSegment2D(const Vector<T, 2>& start, const Vector<T, 2>& end)
+ : startPoint(start), endPoint(end)
+ {}
- /// Set the starting point of the line segment
- inline void
- setStartPoint(const Vector<T, 2>& point);
+ constexpr bool operator==(const LineSegment2D& other) const = default;
- inline const Vector<T, 2>&
- getStartPoint() const;
+ constexpr LineSegment2D& operator+=(const Vector<T, 2>& vector)
+ {
+ startPoint += vector;
+ endPoint += vector;
+ return *this;
+ }
- /// Set the end point of the line segment
- inline void
- setEndPoint(const Vector<T, 2>& point);
+ constexpr LineSegment2D& operator-=(const Vector<T, 2>& vector)
+ {
+ startPoint -= vector;
+ endPoint -= vector;
+ return *this;
+ }
- inline const Vector<T, 2>&
- getEndPoint() const;
+ constexpr Vector<T, 2>
+ getDirectionVector() const
+ { return endPoint - startPoint; }
- inline void
- set(const Vector<T, 2>& start, const Vector<T, 2>& end);
+ constexpr T
+ getLength() const
+ {
+ Vector<T, 2> directionVector = this->endPoint - this->startPoint;
+ return directionVector.getLength();
+ }
- void
- translate(const Vector<T, 2>& vector);
+ /// Shortest distance to a point
+ constexpr T
+ getDistanceTo(const Vector<T, 2>& point) const;
- /**
- * \brief Length of the line segment
- */
- T
- getLength() const;
+ /// Calculate the point on the line segment closes to the given point
+ constexpr Vector<T, 2>
+ getClosestPointTo(const Vector<T, 2>& point) const;
- Vector<T, 2>
- getDirectionVector() const;
+ /**
+ * \brief Check if two line segments intersect
+ *
+ * Uses Vector2D::ccw() to check if any intersection exists.
+ */
+ constexpr bool
+ intersects(const LineSegment2D& other) const;
- /// Shortest distance to a point
- const T
- getDistanceTo(const Vector<T, 2>& point) const;
+ constexpr bool
+ intersects(const Polygon2D<T>& polygon) const
+ { return polygon.intersects(*this); }
- /// Calculate the point on the line segment closes to the given point
- const Vector<T, 2>
- getClosestPointTo(const Vector<T, 2>& point) const;
+ /// Calculate the intersection point
+ constexpr bool
+ getIntersections(const LineSegment2D& other, PointSet2D<T>& intersectionPoints) const;
- /**
- * \brief Check if two line segments intersect
- *
- * Uses Vector2D::ccw() to check if any intersection exists.
- */
- bool
- intersects(const LineSegment2D& other) const;
+ /**
+ * \brief Calculate the intersection point(s)
+ * \see http://local.wasp.uwa.edu.au/~pbourke/geometry/sphereline/
+ */
+ constexpr bool
+ getIntersections(const Circle2D<T>& circle, PointSet2D<T>& intersectionPoints) const;
- /// Check if a intersection exists
- bool
- intersects(const Polygon2D<T>& polygon) const;
+ constexpr bool
+ getIntersections(const Polygon2D<T>& polygon, PointSet2D<T>& intersectionPoints) const
+ { return polygon.getIntersections(*this, intersectionPoints); }
- /**
- * \brief Calculate the intersection point
- */
- bool
- getIntersections(const LineSegment2D& other,
- PointSet2D<T>& intersectionPoints) const;
+ // deprecated setters and getters
+ [[deprecated("Assign public member directly!")]]
+ void setStartPoint(const Vector<T, 2>& point)
+ { this->startPoint = point; }
- /**
- * \brief Calculate the intersection point(s)
- *
- * \see http://local.wasp.uwa.edu.au/~pbourke/geometry/sphereline/
- */
- bool
- getIntersections(const Circle2D<T>& circle,
- PointSet2D<T>& intersectionPoints) const;
+ [[deprecated("Assign public member directly!")]]
+ const Vector<T, 2>& getStartPoint() const
+ { return this->startPoint; }
- bool
- getIntersections(const Polygon2D<T>& polygon,
- PointSet2D<T>& intersectionPoints) const;
+ [[deprecated("Assign public member directly!")]]
+ void setEndPoint(const Vector<T, 2>& point)
+ { this->endPoint = point; }
- bool
- operator == (const LineSegment2D &other) const;
+ [[deprecated("Assign public member directly!")]]
+ const Vector<T, 2>& getEndPoint() const
+ { return this->endPoint; }
- bool
- operator != (const LineSegment2D &other) const;
+ [[deprecated("Assign public member directly!")]]
+ void set(const Vector<T, 2>& start, const Vector<T, 2>& end)
+ {
+ this->startPoint = start;
+ this->endPoint = end;
+ }
- protected:
- modm::Vector<T, 2> startPoint;
- modm::Vector<T, 2> endPoint;
- };
-}
+ // deprecated translate
+ [[deprecated("Use LineSegment2D<T>::operator+= instead!")]]
+ void translate(const Vector<T, 2>& vector)
+ { operator+=(vector); }
-#include "circle_2d.hpp"
-#include "polygon_2d.hpp"
+};
+} // namespace modm
+#include "circle_2d.hpp"
#include "line_segment_2d_impl.hpp"
-
-#endif // MODM_LINE_SEGMENT_2D_HPP
+#include "polygon_2d.hpp"
\ No newline at end of file
diff --git a/src/modm/math/geometry/line_segment_2d_impl.hpp b/src/modm/math/geometry/line_segment_2d_impl.hpp
index 784148e648..3171c12b2a 100644
--- a/src/modm/math/geometry/line_segment_2d_impl.hpp
+++ b/src/modm/math/geometry/line_segment_2d_impl.hpp
@@ -2,6 +2,7 @@
* Copyright (c) 2009-2011, Fabian Greif
* Copyright (c) 2009, 2012, Martin Rosekeit
* Copyright (c) 2012, Niklas Hauser
+ * Copyright (c) 2022, Thomas Sommer
*
* This file is part of the modm project.
*
@@ -10,91 +11,11 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
// ----------------------------------------------------------------------------
+#pragma once
+#include "line_segment_2d.hpp"
-#ifndef MODM_LINE_SEGMENT_2D_HPP
- #error "Don't include this file directly, use 'line_segment_2d.hpp' instead!"
-#endif
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::LineSegment2D<T>::LineSegment2D() :
- startPoint(), endPoint()
-{
-}
-
-template<typename T>
-modm::LineSegment2D<T>::LineSegment2D(const Vector<T, 2>& start, const Vector<T, 2>& end) :
- startPoint(start), endPoint(end)
-{
-}
-
-// ----------------------------------------------------------------------------
-template <typename T>
-inline void
-modm::LineSegment2D<T>::setStartPoint(const Vector<T, 2>& point)
-{
- this->startPoint = point;
-}
-
-template <typename T>
-inline const modm::Vector<T, 2>&
-modm::LineSegment2D<T>::getStartPoint() const
-{
- return this->startPoint;
-}
-
-template <typename T>
-inline void
-modm::LineSegment2D<T>::setEndPoint(const Vector<T, 2>& point)
-{
- this->endPoint = point;
-}
-
-template <typename T>
-inline const modm::Vector<T, 2>&
-modm::LineSegment2D<T>::getEndPoint() const
-{
- return this->endPoint;
-}
-
-template <typename T>
-inline void
-modm::LineSegment2D<T>::set(const Vector<T, 2>& start, const Vector<T, 2>& end)
-{
- this->startPoint = start;
- this->endPoint = end;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::LineSegment2D<T>::translate(const Vector<T, 2>& vector)
-{
- this->startPoint.translate(vector);
- this->endPoint.translate(vector);
-}
-
-// ----------------------------------------------------------------------------
template<typename T>
-T
-modm::LineSegment2D<T>::getLength() const
-{
- Vector<T, 2> directionVector = this->endPoint - this->startPoint;
-
- return directionVector.getLength();
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::LineSegment2D<T>::getDirectionVector() const
-{
- return endPoint - startPoint;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T
+constexpr T
modm::LineSegment2D<T>::getDistanceTo(const Vector<T, 2>& point) const
{
// vector from the base point of the line to the new point
@@ -127,9 +48,8 @@ modm::LineSegment2D<T>::getDistanceTo(const Vector<T, 2>& point) const
return closestPointToPoint.getLength();
}
-// ----------------------------------------------------------------------------
template<typename T>
-const modm::Vector<T, 2>
+constexpr modm::Vector<T, 2>
modm::LineSegment2D<T>::getClosestPointTo(const Vector<T, 2>& point) const
{
// vector from the base point of the line to the new point
@@ -156,28 +76,18 @@ modm::LineSegment2D<T>::getClosestPointTo(const Vector<T, 2>& point) const
return (this->startPoint + d * directionVector);
}
-// ----------------------------------------------------------------------------
template<typename T>
-bool
+constexpr bool
modm::LineSegment2D<T>::intersects(const LineSegment2D<T>& other) const
{
- return (((Vector<T, 2>::ccw(this->startPoint, this->endPoint, other.startPoint) *
- Vector<T, 2>::ccw(this->startPoint, this->endPoint, other.endPoint)) <= 0) &&
- ((Vector<T, 2>::ccw(other.startPoint, other.endPoint, this->startPoint) *
- Vector<T, 2>::ccw(other.startPoint, other.endPoint, this->endPoint)) <= 0));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::LineSegment2D<T>::intersects(const Polygon2D<T>& polygon) const
-{
- return polygon.intersects(*this);
+ return (((modm::ccw(this->startPoint, this->endPoint, other.startPoint) *
+ modm::ccw(this->startPoint, this->endPoint, other.endPoint)) <= 0) &&
+ ((modm::ccw(other.startPoint, other.endPoint, this->startPoint) *
+ modm::ccw(other.startPoint, other.endPoint, this->endPoint)) <= 0));
}
-// ----------------------------------------------------------------------------
template <typename T>
-bool
+constexpr bool
modm::LineSegment2D<T>::getIntersections(const LineSegment2D& other,
PointSet2D<T>& intersectionPoints) const
{
@@ -206,9 +116,8 @@ modm::LineSegment2D<T>::getIntersections(const LineSegment2D& other,
return false;
}
-// ----------------------------------------------------------------------------
template <typename T>
-bool
+constexpr bool
modm::LineSegment2D<T>::getIntersections(const Circle2D<T>& circle,
PointSet2D<T>& intersectionPoints) const
{
@@ -255,31 +164,4 @@ modm::LineSegment2D<T>::getIntersections(const Circle2D<T>& circle,
}
return result;
}
-}
-
-// ----------------------------------------------------------------------------
-template <typename T>
-bool
-modm::LineSegment2D<T>::getIntersections(const Polygon2D<T>& polygon,
- PointSet2D<T>& intersectionPoints) const
-{
- // invoke intersection method of the polygon
- return polygon.getIntersections(*this, intersectionPoints);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::LineSegment2D<T>::operator == (const LineSegment2D &other) const
-{
- return ((this->startPoint == other.startPoint) &&
- (this->endPoint == other.endPoint));
-}
-
-template<typename T>
-bool
-modm::LineSegment2D<T>::operator != (const LineSegment2D &other) const
-{
- return ((this->startPoint != other.startPoint) ||
- (this->endPoint != other.endPoint));
-}
+}
\ No newline at end of file
diff --git a/src/modm/math/geometry/location_2d.hpp b/src/modm/math/geometry/location_2d.hpp
index c0a350e019..ffa257f70d 100644
--- a/src/modm/math/geometry/location_2d.hpp
+++ b/src/modm/math/geometry/location_2d.hpp
@@ -3,6 +3,8 @@
* Copyright (c) 2009-2011, Fabian Greif
* Copyright (c) 2012, Niklas Hauser
* Copyright (c) 2012, Sascha Schade
+ * Copyright (c) 2013, Kevin Läufer
+ * Copyright (c) 2022, Thomas Sommer
*
* This file is part of the modm project.
*
@@ -11,136 +13,146 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
// ----------------------------------------------------------------------------
-
-#ifndef MODM_LOCATION_2D_HPP
-#define MODM_LOCATION_2D_HPP
-
-#include <cmath>
-
-#include <modm/io/iostream.hpp>
+#pragma once
#include "angle.hpp"
#include "vector.hpp"
+#include <modm/io/iostream.hpp>
+
namespace modm
{
+/**
+ * \brief Location in a 2D coordinate system
+ *
+ * This class is primarily used to describe the location of a robot
+ * on the field. The robot has a position (x- and y-coordinate) and a
+ * orientation (absolute angle in the range (-pi, pi)).
+ *
+ * \ingroup modm_math_geometry
+ */
+template <typename T = int16_t>
+class Location2D
+{
+public:
+ Vector<T, 2> position;
+ float orientation = 0;
+
+ constexpr Location2D() = default;
+
+ constexpr Location2D(const Vector<T, 2>& position, const float& orientation)
+ : position(position), orientation(orientation) {}
+
+ template<typename U>
+ constexpr explicit Location2D(const Location2D<U> &l) : position(l.position), orientation(l.orientation) {}
+
+ constexpr bool operator== (const Location2D &other) const {
+ return (
+ position == other.position and
+ // orientation == other.orientation
+ std::abs(orientation - other.orientation) < __FLT_EPSILON__
+ );
+ }
+
+ /// Add a position increment
+ void move(const Location2D& delta) {
+ Vector<T, 2> movement = delta.position;
+ movement.rotate(orientation);
+
+ position += movement;
+ orientation = Angle::normalize(orientation + delta.orientation);
+ }
+
+ void move(const Vector<T, 2>& delta) {
+ Vector<T, 2> movement(delta);
+
+ movement.rotate(orientation);
+ position += movement;
+ }
+
/**
- * \brief Location in a 2D coordinate system
+ * \brief Add a increment only in x-direction
*
- * This class is primarily used to describe the location of a robot
- * on the field. The robot has a position (x- and y-coordinate) and a
- * orientation (absolute angle in the range (-pi, pi)).
+ * Our robots mostly use a differential drive with two driven wheels
+ * side by side, allowing the robot to move only in the drive direction
+ * (x-direction in the local coordinate system of the robot) and
+ * rotate. A movement perpendicular to the drive direction is
+ * impossible without an external force.
*
- * \ingroup modm_math_geometry
- */
- template <typename T = int16_t>
- class Location2D
- {
- public:
- Location2D();
-
- Location2D(const Vector<T, 2>& position, const float& orientation);
-
- Location2D(const T& x, const T& y, const float& orientation);
-
- inline const Vector<T, 2>&
- getPosition() const;
-
- inline const T&
- getX() const;
-
- inline const T&
- getY() const;
-
- void
- setPosition(const Vector<T, 2>& point);
-
- void
- setPosition(const T& x, const T& y);
-
- inline float
- getOrientation() const;
-
- void
- setOrientation(const float& phi);
-
- /// Add a position increment
- void
- move(const Location2D& diff);
-
- void
- move(const Vector<T, 2>& diff);
-
- /**
- * \brief Add a increment only in x-direction
- *
- * Our robots mostly use a differential drive with two driven wheels
- * side by side, allowing the robot to move only in the drive direction
- * (x-direction in the local coordinate system of the robot) and
- * rotate. A movement perpendicular to the drive direction is
- * impossible without an external force.
- *
- * To estimate the position of the robot over time, we use odometry.
- * Therefore it is necessary to add a lot small increments of
- * movement over time.
- * Because the y-component will always be zero, we created this
- * method, which avoids unnecessary computations for the y-component
- * and is therefore faster the the universal move-method.
- *
- * \param x movement in x-direction
- * \param phi rotation
- */
- void
- move(T x, float phi);
-
- /// TODO
- Vector<T, 2>
- translated(const Vector<T, 2>& vector) const;
-
- /// Convert between Location-objects with different base-types
- template <typename U>
- Location2D<U>
- convert() const;
-
- bool
- operator == (const Location2D &other) const;
-
- bool
- operator != (const Location2D &other) const;
-
- private:
- template <typename U>
- friend IOStream&
- operator <<( IOStream&, const Location2D<U>&);
-
- Vector<T, 2> position;
- float orientation;
- };
-
- // ------------------------------------------------------------------------
- // Global functions
- // ------------------------------------------------------------------------
- /**
- * \brief Stream operator to \b modm::Location<T>
+ * To estimate the position of the robot over time, we use odometry.
+ * Therefore it is necessary to add a lot small increments of
+ * movement over time.
+ * Because the y-component will always be zero, we created this
+ * method, which avoids unnecessary computations for the y-component
+ * and is therefore faster than the universal move-method.
*
- * \ingroup modm_math_geometry
+ * \param x movement in x-direction
+ * \param phi rotation
*/
- template<typename T>
- IOStream&
- operator << (IOStream& os, const Location2D<T>& l);
-
- // ------------------------------------------------------------------------
- // Declaration of specialized methods
- // ------------------------------------------------------------------------
- /*template<>
- bool
- Location2D<float>::operator == (const Location2D &other) const;
-
- template<>
- bool
- Location2D<double>::operator == (const Location2D &other) const;*/
-}
+ void
+ move(T x, float phi) {
+ Vector<T, 2> vector(Vector<float, 2>(x * std::cos(orientation), x * std::sin(orientation)));
+ position += vector;
+ orientation = Angle::normalize(orientation + phi);
+ }
+
+ constexpr Vector<T, 2> operator+=(const Vector<T, 2>& vector) const {
+ Vector<T, 2> result(vector);
+ result.rotate(orientation);
+ result += position;
+
+ return result;
+ }
+
+ constexpr Vector<T, 2> operator-=(const Vector<T, 2>& vector) const {
+ Vector<T, 2> result(vector);
+ result.rotate(orientation);
+ result -= position;
+
+ return result;
+ }
+
+ // deprecated constructor
+ [[deprecated("Use 'setPosition({x, y}, orientation)' instead!")]]
+ constexpr Location2D(const T& x, const T& y, float orientation)
+ : position(x, y), orientation(orientation) {}
+
+ // deprecated getters and setters
+ [[deprecated("Assign public member directly!")]]
+ void setPosition(const Vector<T, 2>& position) { this->position = position; }
-#include "location_2d_impl.hpp"
+ [[deprecated("Assign public member directly!")]]
+ void setPosition(T x, T y) { this->position.x() = x; this->position.y() = y; }
+
+ [[deprecated("Assign public member directly!")]]
+ void setOrientation(float orientation) { this->orientation = orientation; }
+
+ [[deprecated("Assign public member directly!")]]
+ Vector<T, 2> getPosition() const { return position; }
+
+ [[deprecated("Assign public member directly!")]]
+ inline float getOrientation() const { return orientation; }
+
+ [[deprecated("Assign public member directly!")]]
+ T getX() const { return position.x(); }
+
+ [[deprecated("Assign public member directly!")]]
+ T getY() const { return position.y(); }
+
+private:
+ template <typename U>
+ friend IOStream&
+ operator<<( IOStream&, const Location2D<U>&);
+};
+
+
+#if __has_include(<modm/io/iostream.hpp>)
+template<typename T>
+IOStream&
+operator<< (IOStream& os, const Location2D<T>& location) {
+ os << location.position << ", phi=" << location.orientation;
+ return os;
+}
+#endif
-#endif // MODM_LOCATION_2D_HPP
+} // namespace modm
\ No newline at end of file
diff --git a/src/modm/math/geometry/location_2d_impl.hpp b/src/modm/math/geometry/location_2d_impl.hpp
deleted file mode 100644
index 913449fcd7..0000000000
--- a/src/modm/math/geometry/location_2d_impl.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright (c) 2009-2010, Martin Rosekeit
- * Copyright (c) 2009-2011, Fabian Greif
- * Copyright (c) 2013, Kevin Läufer
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_LOCATION_2D_HPP
- #error "Don't include this file directly use 'location.hpp' instead!"
-#endif
-
-#include <cmath>
-#include <cstdlib>
-
-// -----------------------------------------------------------------------------
-template <typename T>
-modm::Location2D<T>::Location2D() :
- position(), orientation()
-{
-}
-
-template <typename T>
-modm::Location2D<T>::Location2D(const Vector<T, 2>& position,
- const float& orientation) :
- position(position),
- orientation(orientation)
-{
-}
-
-template <typename T>
-modm::Location2D<T>::Location2D(const T& x, const T& y, const float& orientation) :
- position(x, y),
- orientation(orientation)
-{
-}
-
-// ----------------------------------------------------------------------------
-template <typename T>
-const modm::Vector<T, 2>&
-modm::Location2D<T>::getPosition() const
-{
- return this->position;
-}
-
-template <typename T>
-inline const T&
-modm::Location2D<T>::getX() const
-{
- return this->position.x;
-}
-
-template <typename T>
-inline const T&
-modm::Location2D<T>::getY() const
-{
- return this->position.y;
-}
-
-template <typename T>
-void
-modm::Location2D<T>::setPosition(const Vector<T, 2>& point)
-{
- this->position = point;
-}
-
-template <typename T>
-void
-modm::Location2D<T>::setPosition(const T& x, const T& y)
-{
- this->position.set(x, y);
-}
-
-template <typename T>
-float
-modm::Location2D<T>::getOrientation() const
-{
- return this->orientation;
-}
-
-template <typename T>
-void
-modm::Location2D<T>::setOrientation(const float& orientation)
-{
- this->orientation = orientation;
-}
-
-// -----------------------------------------------------------------------------
-template <typename T>
-void
-modm::Location2D<T>::move(const Location2D<T>& diff)
-{
- Vector<T, 2> movement = diff.position;
- movement.rotate(this->orientation);
-
- this->position.translate(movement);
- this->orientation = Angle::normalize(this->orientation + diff.orientation);
-}
-
-template <typename T>
-void
-modm::Location2D<T>::move(const Vector<T, 2>& diff)
-{
- Vector<T, 2> movement(diff);
- movement.rotate(this->orientation);
-
- this->position.translate(movement);
-}
-
-template <typename T>
-void
-modm::Location2D<T>::move(T x, float phi)
-{
- Vector<T, 2> vector(GeometricTraits<T>::round(x * std::cos(this->orientation)),
- GeometricTraits<T>::round(x * std::sin(this->orientation)));
- position.translate(vector);
-
- this->orientation = Angle::normalize(this->orientation + phi);
-}
-
-// ----------------------------------------------------------------------------
-template <typename T>
-modm::Vector<T, 2>
-modm::Location2D<T>::translated(const Vector<T, 2>& vector) const
-{
- Vector<T, 2> result(vector);
- result.rotate(this->orientation);
- result.translate(this->position);
-
- return result;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T> template<typename U>
-modm::Location2D<U>
-modm::Location2D<T>::convert() const
-{
- return Location2D<U>(this->position.template convert<U>(), this->orientation);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Location2D<T>::operator == (const Location2D &other) const
-{
- return ((this->position == other.position) &&
- (std::abs(this->orientation - other.orientation) < __FLT_EPSILON__));
-}
-
-template<typename T>
-bool
-modm::Location2D<T>::operator != (const Location2D &other) const
-{
- return ((this->position != other.position) ||
- (std::abs(this->orientation - other.orientation) > __FLT_EPSILON__));
-}
-
-// ----------------------------------------------------------------------------
-template<class T>
-modm::IOStream&
-modm::operator << (modm::IOStream& os, const modm::Location2D<T>& location)
-{
- os << location.position << ", phi=" << location.orientation;
- return os;
-}
diff --git a/src/modm/math/geometry/polygon_2d.hpp b/src/modm/math/geometry/polygon_2d.hpp
index d9b6f103e6..0290c855c8 100644
--- a/src/modm/math/geometry/polygon_2d.hpp
+++ b/src/modm/math/geometry/polygon_2d.hpp
@@ -15,7 +15,7 @@
#define MODM_POLYGON_2D_HPP
#include "point_set_2d.hpp"
-#include "vector2.hpp"
+#include "vector.hpp"
namespace modm
{
diff --git a/src/modm/math/geometry/polygon_2d_impl.hpp b/src/modm/math/geometry/polygon_2d_impl.hpp
index cda21e1949..d4da591ac7 100644
--- a/src/modm/math/geometry/polygon_2d_impl.hpp
+++ b/src/modm/math/geometry/polygon_2d_impl.hpp
@@ -161,7 +161,7 @@ modm::Polygon2D<T>::isInside(const modm::Polygon2D<T>::PointType& point)
SizeType n = this->points.getSize();
for (SizeType i = 0; i < n; ++i) {
- int_fast8_t r = Vector<T, 2>::ccw(this->points[i], this->points[(i + 1) % n], point);
+ int_fast8_t r = modm::ccw(this->points[i], this->points[(i + 1) % n], point);
switch (r) {
case 0:
diff --git a/src/modm/math/geometry/quaternion.hpp b/src/modm/math/geometry/quaternion.hpp
index d3cbcdb761..922f40b0dc 100644
--- a/src/modm/math/geometry/quaternion.hpp
+++ b/src/modm/math/geometry/quaternion.hpp
@@ -11,8 +11,7 @@
*/
// ----------------------------------------------------------------------------
-#ifndef MODM_QUATERNION_HPP
-#define MODM_QUATERNION_HPP
+#pragma once
#include <cmath>
#include <stdint.h>
@@ -20,10 +19,11 @@
namespace modm
{
// forward declaration
- template<class T, uint8_t N>
+ template<typename T, std::size_t N>
+ requires (N > 0)
class Vector;
- template<class T, uint8_t ROWS, uint8_t COLUMNS>
+ template<typename T, std::size_t ROWS, std::size_t COLUMNS>
class Matrix;
/**
@@ -99,10 +99,7 @@ namespace modm
void to3x3Matrix(Matrix<T, 3, 3> *outMatrix);
public:
- T w;
- T x;
- T y;
- T z;
+ T w, x, y, z;
};
template<class T>
@@ -111,5 +108,3 @@ namespace modm
}
#include "quaternion_impl.hpp"
-
-#endif // MODM_QUATERNION_HPP
diff --git a/src/modm/math/geometry/quaternion_impl.hpp b/src/modm/math/geometry/quaternion_impl.hpp
index 0fa1b4e24e..2cac396087 100644
--- a/src/modm/math/geometry/quaternion_impl.hpp
+++ b/src/modm/math/geometry/quaternion_impl.hpp
@@ -9,15 +9,10 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_QUATERNION_HPP
-# error "Don't include this file directly, use 'quaternion.hpp' instead!"
-#endif
+#pragma once
#include "quaternion.hpp"
-// ----------------------------------------------------------------------------
template<class T>
modm::Quaternion<T>::Quaternion()
:
diff --git a/src/modm/math/geometry/ray_2d.hpp b/src/modm/math/geometry/ray_2d.hpp
index b566b1c8ef..6aadf3116e 100644
--- a/src/modm/math/geometry/ray_2d.hpp
+++ b/src/modm/math/geometry/ray_2d.hpp
@@ -47,9 +47,11 @@ namespace modm
typedef typename GeometricTraits<T>::FloatType FloatType;
public:
- Ray2D();
+ constexpr Ray2D() = default;
- Ray2D(const Vector<T, 2>& start, const Vector<T, 2>& direction);
+ constexpr Ray2D(const Vector<T, 2>& start, const Vector<T, 2>& direction)
+ : basePoint(start), direction(direction)
+ {}
/// Set the starting point of the ray
inline void
diff --git a/src/modm/math/geometry/ray_2d_impl.hpp b/src/modm/math/geometry/ray_2d_impl.hpp
index f148c7eafd..ddbc1e6c83 100644
--- a/src/modm/math/geometry/ray_2d_impl.hpp
+++ b/src/modm/math/geometry/ray_2d_impl.hpp
@@ -13,19 +13,6 @@
#error "Don't include this file directly, use 'ray_2d.hpp' instead!"
#endif
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Ray2D<T>::Ray2D() :
- basePoint(), direction()
-{
-}
-
-template<typename T>
-modm::Ray2D<T>::Ray2D(const Vector<T, 2>& start, const Vector<T, 2>& direction) :
- basePoint(start), direction(direction)
-{
-}
-
// ----------------------------------------------------------------------------
template <typename T>
inline void
@@ -145,15 +132,15 @@ bool
modm::Ray2D<T>::intersects(const LineSegment2D<T>& line) const
{
// vector from the base point of the line to the new point
- Vector<T, 2> startToPoint = line.getStartPoint() - this->basePoint;
- Vector<T, 2> endToPoint = line.getEndPoint() - this->basePoint;
+ Vector<T, 2> startToPoint = line.startPoint - this->basePoint;
+ Vector<T, 2> endToPoint = line.endPoint - this->basePoint;
Vector<T, 2> dt = this->direction.toOrthogonalVector();
if ((startToPoint.dot(dt) * endToPoint.dot(dt)) < 0) {
// Points are on different sides of the ray (interpreted as
// continuous line)
- Vector<T, 2> pointToStart = this->basePoint - line.getStartPoint();
+ Vector<T, 2> pointToStart = this->basePoint - line.startPoint;
Vector<T, 2> lt = line.getDirectionVector().toOrthogonalVector();
if ((pointToStart.dot(lt) * this->direction.dot(lt)) < 0) {
// Point and
diff --git a/src/modm/math/geometry/vector.hpp b/src/modm/math/geometry/vector.hpp
index 20f918e37c..8cac37e237 100644
--- a/src/modm/math/geometry/vector.hpp
+++ b/src/modm/math/geometry/vector.hpp
@@ -3,6 +3,7 @@
* Copyright (c) 2012, Georgi Grinshpun
* Copyright (c) 2012, Martin Rosekeit
* Copyright (c) 2012, Niklas Hauser
+ * Copyright (c) 2022, Thomas Sommer
*
* This file is part of the modm project.
*
@@ -11,141 +12,514 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
// ----------------------------------------------------------------------------
+#pragma once
-#ifndef MODM_VECTOR_HPP
-#define MODM_VECTOR_HPP
-
+#include <array>
#include <cmath>
-#include <stdint.h>
+#include <concepts>
+#include <functional>
-#include <modm/math/matrix.hpp>
#include <modm/math/utils/arithmetic_traits.hpp>
+#include <modm/math/utils/integer_traits.hpp>
+#include <modm/io/iostream.hpp>
+
+#include "../matrix.hpp"
+#include "angle.hpp"
namespace modm
{
- // forward declaration
- template<typename T, uint8_t W, uint8_t H> class Matrix;
+
+/**
+ * \brief Class for handling common vector operations
+ *
+ * Arithmetic Operations:
+ * \code
+ * + : plus translation
+* - : minus translation
+* * : scalar multiplication / dot product
+* / : scalar division
+* ^ : cross product / determinant
+* ~ : perpendicular / orthogonal
+* \endcode
+*
+* \author Fabian Greif
+* \author Niklas Hauser
+* \author Thomas Sommer
+* \ingroup modm_math_geometry
+*/
+template<class T, std::size_t N>
+requires (N > 0)
+class Vector : public std::array<T, N>
+{
+ using WideType = std::conditional<std::is_floating_point_v<T>, T, modm::WideType<T>>::type;
+ using FloatType = std::conditional<std::is_floating_point_v<T>, T, float>::type;
+
+ template<std::size_t K>
+ constexpr void assign()
+ {
+ static_assert(K == N, "Number of components passed to constructor must be N!");
+ };
+
+ template<std::size_t K, typename U, class... Args>
+ requires std::convertible_to<U, T>
+ constexpr void assign(U v, Args... args)
+ {
+ *(this->begin() + K) = modm::round_smart<T, U>(v);
+ assign<K + 1>(args...);
+ }
+
+ template<std::size_t K, typename U, std::size_t M, class... Args>
+ constexpr void assign(const std::array<U, M> &arr, Args... args)
+ {
+ std::transform(arr.begin(), arr.end(), this->begin() + K, [](U v) { return modm::round_smart<T, U>(v); });
+ assign<K + M>(args...);
+ }
+
+public:
+ constexpr Vector()
+ {
+ this->fill(0);
+ }
+
+ template <typename U>
+ requires std::convertible_to<U, T>
+ constexpr explicit Vector(U v)
+ {
+ this->fill(modm::round_smart<T, U>(v));
+ }
+
+ template <typename U>
+ constexpr Vector(const U (&arr)[N])
+ {
+ std::transform(std::begin(arr), std::end(arr), this->begin(), [] (U v) { return modm::round_smart<T, U>(v); });
+ }
/**
- * \brief Class for handling common point operations
+ * @brief Multi purpose constructor.
*
- * Basic data type of all geometric operations. Used to represent vectors
- * as well as particular points in the coordinate system.
- *
- * \section point_vector Point vs. vector
+ * @param args Scalar type(s), modm::Vector(s) or std::array(s) in any order
+ */
+ template <class... Args>
+ constexpr Vector(Args... args)
+ {
+ assign<0>(args...);
+ }
+
+ template<typename U>
+ [[deprecated("Use constructor instead!")]]
+ Vector<U, N> convert() const
+ {
+ return {*this};
+ }
+
+ [[deprecated("Use Vector<T, N>::data() instead!")]]
+ T* ptr() {
+ return this->data();
+ }
+
+ [[deprecated("Use Vector<T, N>::data() instead!")]]
+ const T* ptr() const {
+ return this->data();
+ }
+
+ // TODO matrix constructor
+ /* constexpr Vector(const Matrix<T, N, 1> &rhs)
+ {
+ std::copy(std::begin(rhs.element), std::end(rhs.element), this->begin());
+ } */
+
+ // matrix assignment
+ /* constexpr Vector& operator= (const Matrix<T, N, 1> &rhs)
+ {
+ std::copy(std::begin(rhs.element), std::end(rhs.element), this->begin());
+ return *this;
+ } */
+
+ // accessors for x, y, z, w, v, u
+ constexpr T x() const { return this->operator[](0); }
+ constexpr T& x() { return this->operator[](0); }
+
+ constexpr T y() const requires (N > 1) { return this->operator[](1); }
+ constexpr T& y() requires (N > 1) { return this->operator[](1); }
+
+ constexpr T z() const requires (N > 2) { return this->operator[](2); }
+ constexpr T& z() requires (N > 2) { return this->operator[](2); }
+
+ constexpr T w() const requires (N > 3) { return this->operator[](3); }
+ constexpr T& w() requires (N > 3) { return this->operator[](3); }
+
+ constexpr T v() const requires (N > 4) { return this->operator[](4); }
+ constexpr T& v() requires (N > 4) { return this->operator[](4); }
+
+ constexpr T u() const requires (N > 5) { return this->operator[](5); }
+ constexpr T& u() requires (N > 5) { return this->operator[](5); }
+
+private:
+ /**
+ * @brief Creates a new Vector by applying a binary function between each
+ * item of this and each item of other
*
- * In geometry, it is often convenient to use vector arithmetic to
- * represent points.
+ * @tparam Func Binary function
+ */
+ template <class BinFunc, typename U = T>
+ constexpr Vector<U, N>
+ calcNewVector(const Vector &other) const
+ {
+ Vector<U, N> res;
+
+ // no clue why, but RVO / Loop unrolling does not apply here ...
+ // std::transform(this->begin(), this->end(), other.begin(), res.begin(), Func{});
+
+ // ... but this optimizes perfectly.
+ res.x() = BinFunc{}(this->x(), other.x());
+ if constexpr(N > 1) res.y() = BinFunc{}(this->y(), other.y());
+ if constexpr(N > 2) res.z() = BinFunc{}(this->z(), other.z());
+ if constexpr(N > 3) res.w() = BinFunc{}(this->w(), other.w());
+ if constexpr(N > 4) res.v() = BinFunc{}(this->v(), other.v());
+ if constexpr(N > 5) res.u() = BinFunc{}(this->u(), other.u());
+
+ return res;
+ }
+
+ /**
+ * @brief Creates a new Vector by applying a binary function on each
+ * item of this and a scalar
*
- * A vector, by its definition, has no fixed starting point, but if we
- * imagine the starting point of a vector to be the origin, then the
- * endpoint of the vector represents a particular point.
+ * @tparam BinFunc Binary function
+ */
+ template <class BinFunc, typename U = T>
+ constexpr Vector<U, N>
+ calcNewVector(const U scalar) const
+ {
+ Vector<U, N> res;
+
+ // no clue why, but RVO / Loop unrolling does not apply here ...
+ // std::transform(this->begin(), this->end(), res.begin(), Func{});
+
+ // ... but this optimizes perfectly.
+ res.x() = BinFunc{}(this->x(), scalar);
+ if constexpr(N > 1) res.y() = BinFunc{}(this->y(), scalar);
+ if constexpr(N > 2) res.z() = BinFunc{}(this->z(), scalar);
+ if constexpr(N > 3) res.w() = BinFunc{}(this->w(), scalar);
+ if constexpr(N > 4) res.v() = BinFunc{}(this->v(), scalar);
+ if constexpr(N > 5) res.u() = BinFunc{}(this->u(), scalar);
+
+ return res;
+ }
+
+ /**
+ * @brief Creates a new Vector by applying a unary function on each
+ * item of this
*
- * In this manner, every vector can be said to identify a unique point,
- * which is the endpoint of the vector when its starting point is the
- * origin.
+ * @tparam UnFunc Unary function
+ */
+ template <class UnFunc, typename U = T>
+ constexpr Vector<U, N>
+ calcNewVector() const
+ {
+ Vector<U, N> res;
+
+ // no clue why, but RVO / Loop unrolling does not apply here ...
+ // std::transform(this->begin(), this->end(), res.begin(), Func{});
+
+ // ... but this optimizes perfectly.
+ res.x() = UnFunc{}(this->x());
+ if constexpr(N > 1) res.y() = UnFunc{}(this->y());
+ if constexpr(N > 2) res.z() = UnFunc{}(this->z());
+ if constexpr(N > 3) res.w() = UnFunc{}(this->w());
+ if constexpr(N > 4) res.v() = UnFunc{}(this->v());
+ if constexpr(N > 5) res.u() = UnFunc{}(this->u());
+
+ return res;
+ }
+
+public:
+
+ // arithmetic operators
+ constexpr Vector
+ operator+(const Vector &other) const
+ { return calcNewVector< std::plus<T> >(other); }
+
+ constexpr Vector
+ operator-(const Vector &other) const
+ { return calcNewVector< std::minus<T> >(other); }
+
+ template<typename U>
+ constexpr Vector
+ operator* (U scale) const
+ { return calcNewVector< std::multiplies<U> >(scale); }
+
+ template<typename U>
+ constexpr Vector
+ operator/ (U scale) const
+ { return calcNewVector< std::divides<U> >(scale); }
+
+ constexpr Vector
+ operator-() const
+ requires std::is_signed_v<T>
+ { return calcNewVector< std::negate<T> >(); }
+
+ // TODO treat optimal return type
+ constexpr WideType
+ operator*(const Vector &other) const
+ {
+ auto tmp = calcNewVector<std::multiplies<WideType>, WideType>(other);
+ return std::accumulate(tmp.begin(), tmp.end(), WideType(0));
+ }
+
+ [[deprecated("Use Vector<T, N>::operator*() instead!")]]
+ constexpr WideType
+ dot(const Vector &other) const
+ { return operator*(other); }
+
+ Vector& operator+= (const Vector &other)
+ {
+ std::transform(this->begin(), this->end(), other.begin(), this->begin(), std::plus<T>());
+ return *this;
+ }
+
+ [[deprecated("Use Vector<T, N>::operator+= instead!")]]
+ Vector& translate(Vector v)
+ { operator+=(v); return *this; }
+
+ Vector& operator-= (const Vector &other) {
+ std::transform(this->begin(), this->end(), other.begin(), this->begin(), std::minus<T>());
+ return *this;
+ }
+
+ template<typename U>
+ Vector& operator*= (U scale) {
+ std::transform(this->begin(), this->end(), this->begin(), [=] (T v) { return v * scale; });
+ return *this;
+ }
+
+ template<typename U>
+ Vector& operator/= (U scale) {
+ std::transform(this->begin(), this->end(), this->begin(), [=] (T v) { return v / scale; });
+ return *this;
+ }
+
+private:
+
+ // TODO treat optimal return type
+ constexpr WideType sum() const
+ { return std::accumulate(this->begin(), this->end(), WideType(0)); }
+
+public:
+ /**
+ * \brief Calculate the cross-product
*
- * Therefore there isn't a Point-class, but only a Vector class.
+ * In 2D there is no clear definition of this operation.
*
- * Adapted from the implementation of Gaspard Petit (gaspardpetit@gmail.com).
+ * This implementation is the most common one and will return the
+ * magnitude of the vector that would result from a regular
+ * 3D cross product of the input vectors, taking their Z values
+ * implicitly as 0 (i.e. treating the 2D space as a plane in the 3D space).
+ * The 3D cross product will be perpendicular to that plane, and thus
+ * have 0 X & Y components (thus the scalar returned is the Z value of
+ * the 3D cross product vector).
*
- * \see <a href"http://www-etud.iro.umontreal.ca/~petitg/cpp/point.html">Homepage</a>
+ * \code
+ * this.x * other.y - this.y * other.x
+ * \endcode
*
- * \ingroup modm_math_geometry
- * \author Niklas Hauser
+ * Other implementations take no arguments and returns a vector
+ * perpendicular to the input vector. This can be reached with the
+ * toOrthogonalVector() method, which returns a perpendicular copy
+ * of the vector.
*/
- template<typename T, uint8_t N>
- class Vector
+ WideType operator^ (const Vector &other) const requires (N == 2)
{
- public:
- Vector();
- Vector(const T *ptData);
+ return WideType(x()) * WideType(other.y()) - WideType(y()) * WideType(other.x());
+ }
- Vector(const Matrix<T, N, 1> &rhs);
- Vector& operator = (const Matrix<T, N, 1> &rhs);
+ Vector operator^ (const Vector &other) const requires (N == 3)
+ {
+ return Vector(
+ y() * other.z() - z() * other.y(),
+ z() * other.x() - x() * other.z(),
+ x() * other.y() - y() * other.x()
+ );
+ }
- bool operator == (const Vector &rhs) const;
- bool operator != (const Vector &rhs) const;
- bool operator < (const Vector &rhs) const;
- bool operator <= (const Vector &rhs) const;
- bool operator > (const Vector &rhs) const;
- bool operator >= (const Vector &rhs) const;
+ [[deprecated("Use Vector<T, N>::operator^() instead!")]]
+ constexpr WideType cross(const Vector& other) const
+ { return operator^(other); }
+ // auto cross = operator^; // Why is this 'function alias' not accepted?
- const T& operator [] (uint8_t index) const;
- T& operator [] (uint8_t index);
+ // various methods for the lengh of the vector
- T* ptr();
- const T* ptr() const;
+ constexpr auto getLengthSquared() const {
+ // TODO treat the right CalcType
+ // - is always unsigned
+ // - Must fit std::pow(std::numeric_limits<T>::max(), 2) * N
+ using CalcType = WideType;
- Vector operator + (const Vector &rhs) const;
- Vector operator - (const Vector &rhs) const;
- T operator * (const Vector &rhs) const;
- Vector operator * (const T &rhs) const;
- Vector operator / (const T &rhs) const;
- Vector& operator += (const Vector &rhs);
- Vector& operator -= (const Vector &rhs);
- Vector& operator *= (const T &rhs);
- Vector& operator /= (const T &rhs);
- Vector& operator - (); // FIXME
+ CalcType sum{0};
- T getLength() const;
- T getLengthSquared() const;
+ for(auto &v: *this)
+ sum += WideType(v) * WideType(v);
+ return sum;
+ }
- Matrix<T, N, 1>&
- asMatrix();
+ template<typename TR = T>
+ constexpr TR getLength() const
+ { return modm::round_smart<TR>(std::sqrt(getLengthSquared())); }
- const Matrix<T, N, 1>&
- asMatrix() const;
+ constexpr WideType getDistanceTo(const Vector& other) const
+ { return (other - *this).getLength(); }
- Matrix<T, 1, N>&
- asTransposedMatrix();
+ constexpr Vector& scale(float length)
+ {
+ operator*=( length / getLength() );
+ return *this;
+ }
- const Matrix<T, 1, N>&
- asTransposedMatrix() const;
+ constexpr Vector scaled(float length) const
+ { return *this * (length / getLength()); }
- public:
- static inline uint8_t
- getSize();
+ // methods for float Vectors only
- T coords[N];
- };
+ // Normalize length to 1
+ constexpr Vector& normalize()
+ requires std::floating_point<T>
+ {
+ operator/=( getLength() );
+ return *this;
+ }
- template< typename T, uint8_t N >
- struct detail::MakeSigned< Vector<T, N> >
- { using type = Vector< SignedType<T>, N >; };
+ constexpr Vector normalized() const
+ requires std::floating_point<T>
+ { return *this / getLength(); }
- template< typename T, uint8_t N >
- struct detail::MakeUnsigned< Vector<T, N> >
- { using type = Vector< UnsignedType<T>, N >; };
+ constexpr bool hasNan() const
+ requires std::floating_point<T>
+ { return std::any_of(this->begin(), this->end(), [](T c){return std::isnan(c);}); }
- template< typename T, uint8_t N >
- struct detail::WideType< Vector<T, N> >
- { using type = Vector< WideType<T>, N >; };
-}
+ constexpr bool hasInf() const
+ requires std::floating_point<T>
+ { return std::any_of(this->begin(), this->end(), [](T c){return std::isinf(c);}); }
+
+ constexpr bool hasNan() const
+ { return false; }
-#define IMPLEMENT_VECTOR_ACCESSOR2(a,b) \
- Vector<T, 2> a##b() const \
- { \
- return Vector<T, 2>(a, b); \
- }
+ constexpr bool hasInf() const
+ { return false; }
-#define IMPLEMENT_VECTOR_ACCESSOR3(a, b, c) \
- Vector<T, 3> a##b##c() const \
- { \
- return Vector<T, 3>(a, b, c); \
- }
+ // methods for 2D only
-#define IMPLEMENT_VECTOR_ACCESSOR4(a, b, c, d) \
- Vector<T, 4> a##b##c##d() const \
- { \
- return Vector<T, 4>(a, b, c, d); \
- }
+ constexpr Vector operator~ () const
+ requires std::is_signed_v<T> && (N == 2)
+ { return Vector(y(), -x()); }
-#include "vector_impl.hpp"
+ [[deprecated("Use Vector<T, N>::operator~() instead!")]]
+ Vector perpendicular() const requires std::is_signed_v<T> && (N == 2)
+ { return operator~(); }
-#include "vector1.hpp"
-#include "vector2.hpp"
-#include "vector3.hpp"
-#include "vector4.hpp"
+ [[deprecated("Use Vector<T, N>::operator~() instead!")]]
+ Vector toOrthogonalVector() const requires std::is_signed_v<T> && (N == 2)
+ { return operator~(); }
+
+ constexpr float getAngle() const requires (N == 2)
+ { return std::atan2(y(), x()); }
+
+ constexpr float getAngleTo(const Vector& other) const requires (N == 2)
+ { return (other - *this).getAngle(); }
+
+ // TODO implement as operator+=(Angle phi), operator-=(Angle phi) ??
+ constexpr Vector& rotate(float phi) requires (N == 2)
+ {
+ const float c = std::cos(phi);
+ const float s = std::sin(phi);
+ const Vector<float, 2> tmp(c * x() - s * y(), s * x() + c * y());
+ *this = tmp;
+
+ return *this;
+ }
+
+private:
+ template<typename U, std::size_t M>
+ friend IOStream &
+ operator<<(IOStream &os, const Vector<U, M> &c);
+};
+
+template<typename U, std::size_t N>
+Vector<U, N>
+operator* (float scale, const Vector<U, N> &vector)
+{ return vector * scale; }
+
+template<typename U, std::size_t N>
+Vector<U, N>
+operator/ (float scale, const Vector<U, N> &vector)
+{ return vector / scale; }
+
+using Vector1f = Vector<float, 1>;
+using Vector1i = Vector<int16_t, 1>;
+using Vector1u = Vector<uint16_t, 1>;
+
+using Vector2f = Vector<float, 2>;
+using Vector2i = Vector<int16_t, 2>;
+using Vector2u = Vector<uint16_t, 2>;
+
+using Vector3f = Vector<float, 3>;
+using Vector3i = Vector<int16_t, 3>;
+using Vector3u = Vector<uint16_t, 3>;
+
+using Vector4f = Vector<float, 4>;
+using Vector4i = Vector<int16_t, 4>;
+using Vector4u = Vector<uint16_t, 4>;
+
+#if __has_include(<modm/io/iostream.hpp>)
+template<typename U, std::size_t M>
+IOStream &
+operator<<(IOStream &os, const Vector<U, M> &v)
+{
+ // Whitout index
+ // for (auto &i : v) {
+ // os << i << "\t";
+
+ // With letter index
+ for (std::size_t i = 0; i < M; ++i)
+ os << char(i < 3 ? i + 120 : 122 - i) << ":" << v[i] << "\t";
+
+ return os;
+}
+#endif
+
+/**
+ * \brief Check if three points are in a counter-clock wise direction
+ *
+ * Check if we move counter-clock wise if we move from the first point
+ * to the second and the third.
+ *
+ * If all three points are in a line there are three possibilities:
+ * 1) strait line: third point behind the second (returns 1)
+ * 2) last point between the other two (returns 0)
+ * 3) third point before the first one (returns -1)
+ *
+ * This definition is useful for inclusion or intersection testing.
+ */
+template<typename T>
+constexpr int8_t
+ccw(Vector<T, 2> a, Vector<T, 2> b, Vector<T, 2> c) {
+ using WideType = modm::WideType<T>;
+
+ const Vector<WideType, 2> v1 = b - a;
+ const Vector<WideType, 2> v2 = c - a;
+ const WideType d1 = v1.x() * v2.y();
+ const WideType d2 = v1.y() * v2.x();
+
+ if (d1 > d2)
+ return 1;
+ else if (d1 < d2)
+ return -1;
+ else
+ {
+ if ((v1.x() * v2.x() < 0) || (v1.y() * v2.y() < 0))
+ return -1;
+ else
+ return (v1.getLengthSquared()) < (v2.getLengthSquared()) ? 1 : 0;
+ }
+}
-#endif // MODM_VECTOR_HPP
+} // namespace modm
\ No newline at end of file
diff --git a/src/modm/math/geometry/vector1.hpp b/src/modm/math/geometry/vector1.hpp
deleted file mode 100644
index 923879e033..0000000000
--- a/src/modm/math/geometry/vector1.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) 2009-2010, Martin Rosekeit
- * Copyright (c) 2009-2012, Fabian Greif
- * Copyright (c) 2011-2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR1_HPP
-#define MODM_VECTOR1_HPP
-
-#include <cmath>
-#include <cstdlib>
-#include <stdint.h>
-
-#include "vector.hpp"
-
-namespace modm
-{
- /**
- * \brief Class for handling common vector operations (1D)
- *
- * Adapted from the implementation of Gaspard Petit (gaspardpetit@gmail.com).
- *
- * \see <a href"http://www-etud.iro.umontreal.ca/~petitg/cpp/point.html">Homepage</a>
- *
- * \ingroup modm_math_geometry
- * \author Niklas Hauser
- */
- template<typename T>
- class Vector<T, 1>
- {
- public:
- Vector();
- Vector(T inX);
- Vector(const Matrix<T, 1, 1> &rhs);
-
- inline void
- set(const T& x);
-
- inline void
- setX(const T& value);
-
- inline const T&
- getX() const;
-
- Vector& operator = (const Matrix<T, 1, 1> &rhs);
-
- bool operator == (const Vector &rhs) const;
- bool operator != (const Vector &rhs) const;
- bool operator < (const Vector &rhs) const;
- bool operator <= (const Vector &rhs) const;
- bool operator > (const Vector &rhs) const;
- bool operator >= (const Vector &rhs) const;
-
- const T& operator [] (uint8_t index) const;
- T& operator [] (uint8_t index);
- T* ptr();
- const T* ptr() const;
-
- Vector operator - () const;
- Vector operator + (const Vector &rhs) const;
- Vector operator - (const Vector &rhs) const;
- T operator * (const Vector &rhs) const;
- Vector operator * (const T &rhs) const;
- Vector operator / (const T &rhs) const;
-
- Vector& operator += (const Vector &rhs);
- Vector& operator -= (const Vector &rhs);
- Vector& operator *= (const T &rhs);
- Vector& operator /= (const T &rhs);
-
- T getLength() const;
- T getLengthSquared() const;
-
- Matrix<T, 1, 1>&
- asMatrix();
-
- const Matrix<T, 1, 1>&
- asMatrix() const;
-
- bool hasNan() const;
- bool hasInf() const;
-
- public:
- T x;
-
- public:
- #ifndef __DOXYGEN__
- IMPLEMENT_VECTOR_ACCESSOR2(x,x)
- IMPLEMENT_VECTOR_ACCESSOR3(x,x,x)
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,x)
- #endif
- };
-
- template<typename U, typename T>
- static inline Vector<T, 1> operator * (const U &lhs, const Vector<T, 1> &rhs)
- {
- return rhs * lhs;
- }
-
- typedef Vector<float, 1> Vector1f;
- typedef Vector<int16_t, 1> Vector1i;
-}
-
-#include "vector1_impl.hpp"
-
-#endif // MODM_VECTOR1_HPP
diff --git a/src/modm/math/geometry/vector1_impl.hpp b/src/modm/math/geometry/vector1_impl.hpp
deleted file mode 100644
index 3a9045d78a..0000000000
--- a/src/modm/math/geometry/vector1_impl.hpp
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- * Copyright (c) 2011, Fabian Greif
- * Copyright (c) 2012, Georgi Grinshpun
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR1_HPP
- #error "Don't include this file directly, use 'vector1.hpp' instead!"
-#endif
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>::Vector() :
- x()
-{
-}
-
-template<typename T>
-modm::Vector<T, 1>::Vector(T inX) :
- x(inX)
-{
-}
-
-template<typename T>
-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>&
-modm::Vector<T, 1>::operator = (const modm::Matrix<T, 1, 1> &rhs)
-{
- x = *reinterpret_cast<const T*>(&rhs);
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::operator == (const modm::Vector<T, 1> &rhs) const
-{
- return (rhs.x == x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::operator != (const modm::Vector<T, 1> &rhs) const
-{
- return (rhs.x != x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::operator < (const modm::Vector<T, 1> &rhs) const
-{
- return (x < rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::operator <= (const modm::Vector<T, 1> &rhs) const
-{
- return (x <= rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::operator > (const modm::Vector<T, 1> &rhs) const
-{
- return (x > rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::operator >= (const modm::Vector<T, 1> &rhs) const
-{
- return (x >= rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 1>::operator [] (uint8_t index) const
-{
- return reinterpret_cast<const T*>(this)[index];
-}
-
-template<typename T>
-T&
-modm::Vector<T, 1>::operator [] (uint8_t index)
-{
- return reinterpret_cast<T*>(this)[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T*
-modm::Vector<T, 1>::ptr()
-{
- return reinterpret_cast<T*>(this);
-}
-
-template<typename T>
-const T*
-modm::Vector<T, 1>::ptr() const
-{
- return reinterpret_cast<const T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>
-modm::Vector<T, 1>::operator + (const modm::Vector<T, 1> &rhs) const
-{
- return modm::Vector<T, 1>(x+rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>
-modm::Vector<T, 1>::operator - (const modm::Vector<T, 1> &rhs) const
-{
- return modm::Vector<T, 1>(x-rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 1>::operator * (const modm::Vector<T, 1> &rhs) const
-{
- return x*rhs.x;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>
-modm::Vector<T, 1>::operator * (const T &rhs) const
-{
- return modm::Vector<T, 1>(x*rhs);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>
-modm::Vector<T, 1>::operator / (const T &rhs) const
-{
- return modm::Vector<T, 1>(x/rhs);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>&
-modm::Vector<T, 1>::operator += (const modm::Vector<T, 1> &rhs)
-{
- x += rhs.x;
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>&
-modm::Vector<T, 1>::operator -= (const modm::Vector<T, 1> &rhs)
-{
- x -= rhs.x;
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>&
-modm::Vector<T, 1>::operator *= (const T &rhs)
-{
- x *= rhs;
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>&
-modm::Vector<T, 1>::operator /= (const T &rhs)
-{
- x /= rhs;
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 1>
-modm::Vector<T, 1>::operator - () const
-{
- return Vector<T, 1>(-x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 1>::getLength() const
-{
- return std::abs(x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 1>::getLengthSquared() const
-{
- return x * x;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 1, 1>&
-modm::Vector<T, 1>::asMatrix()
-{
- return *(modm::Matrix<T, 1, 1>*) this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const modm::Matrix<T, 1, 1>&
-modm::Vector<T, 1>::asMatrix() const
-{
- return *(modm::Matrix<T, 1, 1>*) this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::hasNan() const
-{
- return std::isnan(x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 1>::hasInf() const
-{
- return std::isinf(x);
-}
-
-// ----------------------------------------------------------------------------
-//template<typename U, typename T>
-//static modm::Vector<T, 1> operator * (const U &lhs, const modm::Vector<T, 1> &rhs)
-//{
-// return rhs * lhs;
-//}
diff --git a/src/modm/math/geometry/vector2.cpp b/src/modm/math/geometry/vector2.cpp
deleted file mode 100644
index 64bd297920..0000000000
--- a/src/modm/math/geometry/vector2.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2010-2012, Fabian Greif
- * Copyright (c) 2010, 2012, Martin Rosekeit
- * Copyright (c) 2012, Georgi Grinshpun
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#include <modm/math/utils/operator.hpp>
-
-#include "vector2.hpp"
-
-// this explicit namespace is needed here, otherwise we get an error about
-// "specialization of ... in different namespace"
-namespace modm
-{
- template<>
- int16_t
- Vector<int16_t, 2>::getLength() const
- {
- int32_t t;
-
- t = math::mul(this->x, this->x);
- t = math::mac(t, this-> y, this->y);
-
- return math::sqrt(t);
- }
-
- template<>
- int32_t
- Vector<int16_t, 2>::getLengthSquared() const
- {
- int32_t t;
-
- t = math::mul(this->x, this->x);
- t = math::mac(t,this-> y, this->y);
-
- return t;
- }
-
- template<>
- int32_t
- Vector<int16_t, 2>::dot(const modm::Vector<int16_t, 2>& other) const
- {
- int32_t t;
-
- t = math::mul(this->x, other.x);
- t = math::mac(t,this->y, other.y);
-
- return t;
- }
-
- // ------------------------------------------------------------------------
- template<>
- template<>
- Vector<double, 2>
- Vector<float, 2>::convert() const
- {
- return Vector<double, 2>(this->x, this->y);
- }
-
- template<>
- template<>
- Vector<float, 2>
- Vector<double, 2>::convert() const
- {
- return Vector<float, 2>(this->x, this->y);
- }
-}
diff --git a/src/modm/math/geometry/vector2.hpp b/src/modm/math/geometry/vector2.hpp
deleted file mode 100644
index 7cb06624e9..0000000000
--- a/src/modm/math/geometry/vector2.hpp
+++ /dev/null
@@ -1,384 +0,0 @@
-/*
- * Copyright (c) 2009-2012, Fabian Greif
- * Copyright (c) 2010, Martin Rosekeit
- * Copyright (c) 2012, Georgi Grinshpun
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR2_HPP
-#define MODM_VECTOR2_HPP
-
-#include <cmath>
-#include <stdint.h>
-#include <modm/io/iostream.hpp>
-
-#include "geometric_traits.hpp"
-#include "angle.hpp"
-#include "vector.hpp"
-
-namespace modm
-{
- // forward declaration
- template <typename T>
- class Location2D;
-
- /**
- * \brief Class for handling common vector operations (2D)
- *
- * Operations:
- * \code
- * + : addition of points
- * - : different of points
- * * : dot product or scalar multiplication
- * / : scalar division
- * ^ : cross product (determinant)
- * ~ : perpendicular
- * \endcode
- *
- * Adapted from the implementation of Gaspard Petit (gaspardpetit@gmail.com)
- * and heavily modified.
- *
- * \see <a href"http://www-etud.iro.umontreal.ca/~petitg/cpp/point.html">Homepage</a>
- *
- * \author Fabian Greif
- * \author Niklas Hauser
- *
- * \ingroup modm_math_geometry
- */
- template<typename T>
- class Vector<T, 2>
- {
- friend class Location2D<T>;
-
- public:
- typedef typename GeometricTraits<T>::WideType WideType;
- typedef typename GeometricTraits<T>::FloatType FloatType;
-
- public:
- /**
- * \brief Default-Constructor
- *
- * Creates a Vector with coordinates (0, 0).
- */
- Vector();
-
- Vector(const T& inX, const T& inY);
-
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY);
- Vector(const T &inX, const Vector<T, 1> &inY);
- Vector(const Vector<T, 1> &inX, const T &inY);
- explicit Vector(T inVal);
- Vector(const Matrix<T, 2, 1> &rhs);
-
- inline void
- setX(const T& value);
-
- inline void
- setY(const T& value);
-
- inline void
- set(const T& x, const T& y);
-
-
- inline const T&
- getX() const;
-
- inline const T&
- getY() const;
-
- /**
- * \brief Calculate length of the vector
- */
- T
- getLength() 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;
-
- /**
- * \brief Normalize length to 1
- *
- * \warning This method is only useful if T is a floating point type.
- * For integer types the result might be wrong!
- */
- Vector&
- normalize();
-
- Vector
- normalized() const;
-
- /**
- * \brief Scale the vector to \p length
- */
- Vector&
- scale(float length);
-
- Vector
- scaled(float length) const;
-
-
- Vector&
- rotate(float phi);
-
- /**
- * \brief Move the point in x and y direction
- */
- Vector&
- translate(const Vector& vector);
-
-
- WideType
- getDistanceTo(const Vector& other) const;
-
- float
- getAngleTo(const Vector& other) const;
-
- /**
- * \brief Calculate the dot-product
- *
- * Also known as the scalar product.
- *
- * \code
- * this.x * other.x + this.y * other.y
- * \endcode
- */
- WideType
- dot(const Vector& other) const;
-
- /**
- * \brief Calculate the cross-product
- *
- * In 2D there is no clear definition of this operation.
- *
- * This implementation is the most common one and will return the
- * magnitude of the vector that would result from a regular
- * 3D cross product of the input vectors, taking their Z values
- * implicitly as 0 (i.e. treating the 2D space as a plane in the 3D space).
- * The 3D cross product will be perpendicular to that plane, and thus
- * have 0 X & Y components (thus the scalar returned is the Z value of
- * the 3D cross product vector).
- *
- * \code
- * this.x * other.y - this.y * other.x
- * \endcode
- *
- * Other implementations take no arguments and returns a vector
- * perpendicular to the input vector. This can be reached with the
- * toOrthogonalVector() method, which returns a perpendicular copy
- * of the vector.
- */
- WideType
- cross(const Vector& other) const;
-
- /**
- * \brief Convert between Point-objects with different base-types
- */
- template<typename U>
- Vector<U, 2>
- convert() const;
-
- /**
- * \brief Returns a perpendicular copy of the vector
- *
- * \return (y, -x)
- */
- Vector
- toOrthogonalVector() const;
-
- // TODO
- Vector
- perpendicular() const;
-
- /**
- * \brief Check if three points are in a counter-clock wise direction
- *
- * Check if we move counter-clock wise if we move from the first point
- * to the second and the third.
- *
- * If all three points are in a line there are three possibilities:
- * 1) strait line: third point behind the second (returns 1)
- * 2) last point between the other two (returns 0)
- * 3) third point before the first one (returns -1)
- *
- * This definition is useful for inclusion or intersection testing.
- */
- static int_fast8_t
- ccw(const Vector& a, const Vector& b, const Vector& c);
-
- Vector& operator = (const Matrix<T, 2, 1> &rhs);
-
- bool operator == (const Vector &rhs) const;
- bool operator != (const Vector &rhs) const;
- bool operator < (const Vector &rhs) const;
- bool operator <= (const Vector &rhs) const;
- bool operator > (const Vector &rhs) const;
- bool operator >= (const Vector &rhs) const;
-
- const T& operator [] (uint8_t index) const;
- T& operator [] (uint8_t index);
-
- T* ptr();
- const T* ptr() const;
-
- Vector operator - () const;
- Vector operator - (const Vector &rhs) const;
- Vector operator + (const Vector &rhs) const;
- T operator * (const Vector &rhs) const;
- T operator ^ (const Vector &rhs) const;
- Vector operator * (float rhs) const;
- Vector operator / (float rhs) const;
-
- Vector& operator += (const Vector &rhs);
- Vector& operator -= (const Vector &rhs);
- Vector& operator *= (const T &rhs);
- Vector& operator /= (const T &rhs);
- Vector& operator ~ ();
-
- Matrix<T, 2, 1>&
- asMatrix();
-
- const Matrix<T, 2, 1>&
- asMatrix() const;
-
- Matrix<T, 1, 2>&
- asTransposedMatrix();
-
- const Matrix<T, 1, 2>&
- asTransposedMatrix() const;
-
- bool hasNan() const;
- bool hasInf() const;
-
- #ifndef __DOXYGEN__
- IMPLEMENT_VECTOR_ACCESSOR2(x,x); IMPLEMENT_VECTOR_ACCESSOR2(x,y);
- IMPLEMENT_VECTOR_ACCESSOR2(y,x); IMPLEMENT_VECTOR_ACCESSOR2(y,y);
-
- IMPLEMENT_VECTOR_ACCESSOR3(x,x,x); IMPLEMENT_VECTOR_ACCESSOR3(x,x,y);
- IMPLEMENT_VECTOR_ACCESSOR3(x,y,x); IMPLEMENT_VECTOR_ACCESSOR3(x,y,y);
- IMPLEMENT_VECTOR_ACCESSOR3(y,x,x); IMPLEMENT_VECTOR_ACCESSOR3(y,x,y);
- IMPLEMENT_VECTOR_ACCESSOR3(y,y,x); IMPLEMENT_VECTOR_ACCESSOR3(y,y,y);
-
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,x); IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,y);
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,x); IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,y);
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,x); IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,y);
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,x); IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,y);
-
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,x); IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,y);
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,x); IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,y);
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,x); IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,y);
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,x); IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,y);
- #endif
-
- public:
- T x;
- T y;
-
- protected:
- template<typename U>
- friend IOStream&
- operator <<(IOStream& os, const Vector<U, 2>& c);
-
- template<typename U>
- friend Vector<U, 2>
- 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;
-
- // ------------------------------------------------------------------------
- // Global functions
- // ------------------------------------------------------------------------
- /**
- * \brief Stream operator for \b modm::Vector<U, 2>
- * \ingroup modm_math_geometry
- */
- template<typename U>
- IOStream&
- operator << (IOStream& os, const Vector<U, 2>& c);
-
- /**
- * \brief Scalar multiplication
- * \ingroup modm_math_geometry
- */
- template<typename U>
- Vector<U, 2>
- operator * (float scale, const Vector<U, 2> &vector);
-
- /**
- * \brief Scalar division
- * \ingroup modm_math_geometry
- */
- template<typename U>
- Vector<U, 2>
- operator / (float scale, const Vector<U, 2> &vector);
-
- // ------------------------------------------------------------------------
- // Declaration of specialized methods
- // ------------------------------------------------------------------------
- template<>
- int16_t
- Vector<int16_t, 2>::getLength() const;
-
- template<>
- int32_t
- Vector<int16_t, 2>::getLengthSquared() const;
-
- template<>
- int32_t
- Vector<int16_t, 2>::dot(const modm::Vector<int16_t, 2>& other) const;
-
-
- template<> template<>
- Vector<double, 2>
- Vector<float, 2>::convert() const;
-
- template<> template<>
- Vector<float, 2>
- Vector<double, 2>::convert() const;
-
- // round for everything that's not float => double or double => float
- template<> template<typename U>
- Vector<U, 2>
- Vector<float, 2>::convert() const
- {
- return Vector<U, 2>(round(this->x), round(this->y));
- }
-
- template<> template<typename U>
- Vector<U, 2>
- Vector<double, 2>::convert() const
- {
- return Vector<U, 2>(round(this->x), round(this->y));
- }
-}
-
-#include "vector2_impl.hpp"
-
-#endif // MODM_VECTOR2_HPP
diff --git a/src/modm/math/geometry/vector2_impl.hpp b/src/modm/math/geometry/vector2_impl.hpp
deleted file mode 100644
index b30f16be8e..0000000000
--- a/src/modm/math/geometry/vector2_impl.hpp
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
- * Copyright (c) 2011, Fabian Greif
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR2_HPP
- #error "Don't include this file directly, use 'vector2.hpp' instead!"
-#endif
-
-#include <cmath>
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector() :
- x(),
- y()
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector(const T& inX, const T& inY) :
- x(inX),
- y(inY)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector(
- const modm::Vector<T, 1> &inX,
- const modm::Vector<T, 1> &inY) :
- x(inX.x),
- y(inY.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector(const T &inX, const modm::Vector<T, 1> &inY) :
- x(inX),
- y(inY.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector(const modm::Vector<T, 1> &inX, const T &inY) :
- x(inX.x),
- y(inY)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector(T inVal) :
- x(inVal),
- y(inVal)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>::Vector(const modm::Matrix<T, 2, 1> &rhs) :
- x(reinterpret_cast<const T*>(&rhs)[0]),
- y(reinterpret_cast<const T*>(&rhs)[1])
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 2>::set(const T& newX, const T& newY)
-{
- this->x = newX;
- this->y = newY;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 2>::setX(const T& value)
-{
- this->x = value;
-}
-
-template<typename T>
-void
-modm::Vector<T, 2>::setY(const T& value)
-{
- this->y = value;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 2>::getX() const
-{
- return this->x;
-}
-
-template<typename T>
-const T&
-modm::Vector<T, 2>::getY() const
-{
- return this->y;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 2>::getLength() const
-{
- float tx = this->x;
- float ty = this->y;
-
- return GeometricTraits<T>::round(std::sqrt(tx*tx + ty*ty));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-typename modm::Vector<T, 2>::WideType
-modm::Vector<T, 2>::getLengthSquared() const
-{
- WideType tx = static_cast<WideType>(this->x);
- WideType ty = static_cast<WideType>(this->y);
-
- return tx * tx + ty * ty;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-float
-modm::Vector<T, 2>::getAngle() const
-{
- return std::atan2(this->y, this->x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::normalize()
-{
- T length = this->getLength();
-
- this->x = this->x / length;
- this->y = this->y / length;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::normalized() const
-{
- Vector a(*this);
- a.normalize();
- return a;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::scale(float length)
-{
- float factor = length / getLength();
-
- this->x = this->x * factor;
- this->y = this->y * factor;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::scaled(float length) const
-{
- Vector a(*this);
- a.scale(length);
- return a;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::rotate(float phi)
-{
- float c = std::cos(phi);
- float s = std::sin(phi);
-
- // without rounding the result might be false for T = integer
- T tx = GeometricTraits<T>::round(c * this->x - s * this->y);
- this->y = GeometricTraits<T>::round(s * this->x + c * this->y);
- this->x = tx;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::translate(const Vector<T, 2>& vector)
-{
- this->x += vector.x;
- this->y += vector.y;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-typename modm::Vector<T, 2>::WideType
-modm::Vector<T, 2>::getDistanceTo(const Vector<T, 2>& other) const
-{
- return (other - *this).getLength();
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-float
-modm::Vector<T, 2>::getAngleTo(const Vector<T, 2>& other) const
-{
- return (other - *this).getAngle();
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-typename modm::Vector<T, 2>::WideType
-modm::Vector<T, 2>::dot(const modm::Vector<T, 2>& other) const
-{
- return (static_cast<WideType>(this->x) * static_cast<WideType>(other.x) +
- static_cast<WideType>(this->y) * static_cast<WideType>(other.y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-typename modm::Vector<T, 2>::WideType
-modm::Vector<T, 2>::cross(const modm::Vector<T, 2>& other) const
-{
- return (static_cast<WideType>(this->x) * static_cast<WideType>(other.y) -
- static_cast<WideType>(this->y) * static_cast<WideType>(other.x));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T> template<typename U>
-modm::Vector<U, 2>
-modm::Vector<T, 2>::convert() const
-{
- return Vector<U, 2>(static_cast<U>(this->x), static_cast<U>(this->y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::toOrthogonalVector() const
-{
- return modm::Vector<T, 2>(y, -x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::perpendicular() const
-{
- return modm::Vector<T, 2>(y, -x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-int_fast8_t
-modm::Vector<T, 2>::ccw(const Vector& a, const Vector& b,
- const Vector& c)
-{
- WideType dx1 = b.x - a.x;
- WideType dy1 = b.y - a.y;
- WideType dx2 = c.x - a.x;
- WideType dy2 = c.y - a.y;
-
- WideType d1 = dx1 * dy2;
- WideType d2 = dy1 * dx2;
-
- if (d1 > d2) {
- return 1;
- }
- else if (d1 < d2) {
- return -1;
- }
- else
- {
- if ((dx1 * dx2 < 0) || (dy1 * dy2 < 0)) {
- return -1;
- }
- else
- {
- if ((dx1 * dx1 + dy1 * dy1) >= (dx2 * dx2 + dy2 * dy2)) {
- return 0;
- }
- else {
- return 1;
- }
- }
- }
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>& modm::Vector<T, 2>::operator = (const modm::Matrix<T, 2, 1> &rhs)
-{
- x = reinterpret_cast<const T*>(&rhs)[0];
- y = reinterpret_cast<const T*>(&rhs)[1];
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool modm::Vector<T, 2>::operator == (const modm::Vector<T, 2> &rhs) const
-{
- return ((rhs.x == x) && (rhs.y == y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool modm::Vector<T, 2>::operator != (const modm::Vector<T, 2> &rhs) const
-{
- return ((rhs.x != x) || (rhs.y != y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool modm::Vector<T, 2>::operator < (const modm::Vector<T, 2> &rhs) const
-{
- return (x < rhs.x) || ((x == rhs.x) && (y < rhs.y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool modm::Vector<T, 2>::operator <= (const modm::Vector<T, 2> &rhs) const
-{
- return (x < rhs.x) || ((x == rhs.x) && (y <= rhs.y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 2>::operator > (const modm::Vector<T, 2> &rhs) const
-{
- return (x > rhs.x) || ((x == rhs.x) && (y > rhs.y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 2>::operator >= (const modm::Vector<T, 2> &rhs) const
-{
- return (x > rhs.x) || ((x == rhs.x) && (y >= rhs.y));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 2>::operator [] (uint8_t index) const
-{
- return reinterpret_cast<const T*>(this)[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T&
-modm::Vector<T, 2>::operator [] (uint8_t index)
-{
- return reinterpret_cast<T*>(this)[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T*
-modm::Vector<T, 2>::ptr()
-{
- return reinterpret_cast<T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T*
-modm::Vector<T, 2>::ptr() const
-{
- return reinterpret_cast<const T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::operator - () const
-{
- return Vector<T, 2>(-x, -y);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::operator - (const modm::Vector<T, 2> &rhs) const
-{
- return modm::Vector<T, 2>(x - rhs.x, y - rhs.y);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::operator + (const modm::Vector<T, 2> &rhs) const
-{
- return modm::Vector<T, 2>(x + rhs.x, y + rhs.y);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 2>::operator * (const modm::Vector<T, 2> &rhs) const
-{
- return (x * rhs.x + y * rhs.y);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 2>::operator ^ (const modm::Vector<T, 2> &rhs) const
-{
- return (x * rhs.y - y * rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::operator * (float scale) const
-{
- return Vector<T, 2>(GeometricTraits<T>::round(this->x * scale),
- GeometricTraits<T>::round(this->y * scale));
-}
-
-template<typename T>
-modm::Vector<T, 2>
-modm::Vector<T, 2>::operator / (float scale) const
-{
- return Vector<T, 2>(GeometricTraits<T>::round(this->x / scale),
- GeometricTraits<T>::round(this->y / scale));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::operator += (const modm::Vector<T, 2> &rhs)
-{
- x += rhs.x;
- y += rhs.y;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::operator -= (const modm::Vector<T, 2> &rhs)
-{
- x -= rhs.x;
- y -= rhs.y;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::operator *= (const T &rhs)
-{
- x *= rhs;
- y *= rhs;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::operator /= (const T &rhs)
-{
- x /= rhs;
- y /= rhs;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 2>&
-modm::Vector<T, 2>::operator ~ ()
-{
- *this = perpendicular();
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 2, 1>&
-modm::Vector<T, 2>::asMatrix()
-{
- return *((modm::Matrix<T, 2, 1> *) this);
-}
-
-template<typename T>
-const modm::Matrix<T, 2, 1>&
-modm::Vector<T, 2>::asMatrix() const
-{
- return *((modm::Matrix<T, 2, 1> *) this);
-}
-//-----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 1, 2>&
-modm::Vector<T, 2>::asTransposedMatrix()
-{
- return *((modm::Matrix<T, 1, 2> *) this);
-}
-
-template<typename T>
-const modm::Matrix<T, 1, 2>&
-modm::Vector<T, 2>::asTransposedMatrix() const
-{
- return *((modm::Matrix<T, 1, 2> *) this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool modm::Vector<T, 2>::hasNan() const
-{
- return std::isnan(x) || std::isnan(y);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool modm::Vector<T, 2>::hasInf() const
-{
- return std::isinf(x) || std::isinf(y);
-}
-
-// ----------------------------------------------------------------------------
-// Global functions
-// ----------------------------------------------------------------------------
-template <typename U>
-modm::IOStream&
-modm::operator << (modm::IOStream& s, const modm::Vector<U, 2>& c)
-{
- s << "x=" << c.x << ", y=" << c.y;
- return s;
-}
-
-// ----------------------------------------------------------------------------
-template<typename U>
-modm::Vector<U, 2>
-modm::operator * (float scale, const Vector<U, 2> &vector)
-{
- // invoke member function
- return vector * scale;
-}
-
-template<typename U>
-modm::Vector<U, 2>
-modm::operator / (float scale, const Vector<U, 2> &vector)
-{
- // invoke member function
- return vector / scale;
-}
-
diff --git a/src/modm/math/geometry/vector3.hpp b/src/modm/math/geometry/vector3.hpp
deleted file mode 100644
index 6287ee671b..0000000000
--- a/src/modm/math/geometry/vector3.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (c) 2011-2012, Fabian Greif
- * Copyright (c) 2012, Georgi Grinshpun
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR3_HPP
-#define MODM_VECTOR3_HPP
-
-#include <stdint.h>
-#include "vector.hpp"
-
-namespace modm
-{
- /**
- * \brief Class for handling common vector operations (3D)
- *
- * + : addition of points
- * - : different of points
- * * : dot product or scalar multiplication
- * / : scalar division
- * ^ : cross product (determinant)
- *
- * Adapted from the implementation of Gaspard Petit (gaspardpetit@gmail.com).
- *
- * \see <a href"http://www-etud.iro.umontreal.ca/~petitg/cpp/point.html">Homepage</a>
- *
- * \ingroup modm_math_geometry
- * \author Niklas Hauser
- */
- template<typename T>
- class Vector<T, 3>
- {
- public:
- Vector();
-
- template<typename U>
- explicit Vector(const U *array);
-
- explicit Vector(T inVal);
- Vector(T inX, T inY, T inZ);
-
- Vector(const Vector<T, 1> &inX, const T &inY, const T &inZ);
- Vector(const T &inX, const Vector<T, 1> &inY, const T &inZ);
- Vector(const T &inX, const T &inY, const Vector<T, 1> &inZ);
-
- Vector(const Vector<T, 1> &inX, const T &inY, const Vector<T, 1> &inZ);
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const T &inZ);
- Vector(const T &inX, const Vector<T, 1> &inY, const Vector<T, 1> &inZ);
-
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const Vector<T, 1> &inZ);
-
- Vector(const Vector<T,2> &inXY, const T &inZ);
- Vector(const T &inX, const Vector<T, 2> &inYZ);
-
- Vector(const Vector<T, 2> &inXY, const Vector<T, 1> &inZ);
- Vector(const Vector<T, 1> &inX, const Vector<T, 2> &inYZ);
-
- template<typename U>
- Vector(const Vector<U, 3> &rhs);
- Vector(const Matrix<T, 3, 1> &rhs);
-
-
- inline void
- set(const T& x, const T& y, const T& z);
-
-
- inline void
- setX(const T& value);
-
- inline void
- setY(const T& value);
-
- inline void
- setZ(const T& value);
-
-
- inline const T&
- getX() const;
-
- inline const T&
- getY() const;
-
- inline const T&
- getZ() const;
-
-
- Vector& operator = (const Matrix<T, 3, 1> &rhs);
-
- bool operator == (const Vector &rhs) const;
- bool operator != (const Vector &rhs) const;
- bool operator < (const Vector &rhs) const;
- bool operator <= (const Vector &rhs) const;
- bool operator > (const Vector &rhs) const;
- bool operator >= (const Vector &rhs) const;
-
- const T& operator [] (uint8_t index) const;
- T& operator [] (uint8_t index);
- T* ptr();
- const T* ptr() const;
-
- Vector operator - () const;
- Vector operator + (const Vector &rhs) const;
- Vector operator - (const Vector &rhs) const;
- T operator * (const Vector &rhs) const;
- Vector operator ^ (const Vector &rhs) const;
- Vector operator * (const T &rhs) const;
- Vector operator / (const T &rhs) const;
-
- Vector& operator += (const Vector &rhs);
- Vector& operator -= (const Vector &rhs);
- Vector& operator *= (const T &rhs);
- Vector& operator /= (const T &rhs);
-
- float getLength() const;
- float getLengthSquared() const;
-
- Vector scaled(float newLength) const;
- void scale(float newLength);
-
- Vector normalized() const;
- void normalize();
-
- Matrix<T, 3, 1>&
- asMatrix();
-
- const Matrix<T, 3, 1>&
- asMatrix() const;
-
- Matrix<T, 1, 3>&
- asTransposedMatrix();
-
- const Matrix<T, 1, 3>&
- asTransposedMatrix() const;
-
- bool hasNan() const;
- bool hasInf() const;
-
- #ifndef __DOXYGEN__
- IMPLEMENT_VECTOR_ACCESSOR2(x,x); IMPLEMENT_VECTOR_ACCESSOR2(x,y); IMPLEMENT_VECTOR_ACCESSOR2(x,z);
- IMPLEMENT_VECTOR_ACCESSOR2(y,x); IMPLEMENT_VECTOR_ACCESSOR2(y,y); IMPLEMENT_VECTOR_ACCESSOR2(y,z);
- IMPLEMENT_VECTOR_ACCESSOR2(z,x); IMPLEMENT_VECTOR_ACCESSOR2(z,y); IMPLEMENT_VECTOR_ACCESSOR2(z,z);
-
- IMPLEMENT_VECTOR_ACCESSOR3(x,x,x); IMPLEMENT_VECTOR_ACCESSOR3(x,x,y); IMPLEMENT_VECTOR_ACCESSOR3(x,x,z);
- IMPLEMENT_VECTOR_ACCESSOR3(x,y,x); IMPLEMENT_VECTOR_ACCESSOR3(x,y,y); IMPLEMENT_VECTOR_ACCESSOR3(x,y,z);
- IMPLEMENT_VECTOR_ACCESSOR3(x,z,x); IMPLEMENT_VECTOR_ACCESSOR3(x,z,y); IMPLEMENT_VECTOR_ACCESSOR3(x,z,z);
- IMPLEMENT_VECTOR_ACCESSOR3(y,x,x); IMPLEMENT_VECTOR_ACCESSOR3(y,x,y); IMPLEMENT_VECTOR_ACCESSOR3(y,x,z);
- IMPLEMENT_VECTOR_ACCESSOR3(y,y,x); IMPLEMENT_VECTOR_ACCESSOR3(y,y,y); IMPLEMENT_VECTOR_ACCESSOR3(y,y,z);
- IMPLEMENT_VECTOR_ACCESSOR3(y,z,x); IMPLEMENT_VECTOR_ACCESSOR3(y,z,y); IMPLEMENT_VECTOR_ACCESSOR3(y,z,z);
- IMPLEMENT_VECTOR_ACCESSOR3(z,x,x); IMPLEMENT_VECTOR_ACCESSOR3(z,x,y); IMPLEMENT_VECTOR_ACCESSOR3(z,x,z);
- IMPLEMENT_VECTOR_ACCESSOR3(z,y,x); IMPLEMENT_VECTOR_ACCESSOR3(z,y,y); IMPLEMENT_VECTOR_ACCESSOR3(z,y,z);
- IMPLEMENT_VECTOR_ACCESSOR3(z,z,x); IMPLEMENT_VECTOR_ACCESSOR3(z,z,y); IMPLEMENT_VECTOR_ACCESSOR3(z,z,z);
-
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,x); IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,y); IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,x); IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,y); IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,x); IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,y); IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,x); IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,y); IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,x); IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,y); IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,x); IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,y); IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,x); IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,y); IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,x); IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,y); IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,x); IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,y); IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,z);
-
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,x); IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,y); IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,x); IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,y); IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,x); IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,y); IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,x); IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,y); IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,x); IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,y); IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,x); IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,y); IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,x); IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,y); IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,x); IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,y); IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,x); IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,y); IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,z);
-
- IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,x); IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,y); IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,x); IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,y); IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,x); IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,y); IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,x); IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,y); IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,x); IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,y); IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,x); IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,y); IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,x); IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,y); IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,x); IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,y); IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,z);
- IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,x); IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,y); IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,z);
- #endif
-
- public:
- T x;
- T y;
- T z;
- };
-
- template<typename U, typename T>
- static inline Vector<T, 3> operator * (const U &lhs, const Vector<T, 3> &rhs)
- {
- return rhs * lhs;
- }
-
- template<typename T, typename U>
- static inline Vector<U, 3> operator * (const Matrix<T, 3, 3> &lhs, const Vector<U, 3> &rhs)
- {
- return lhs * rhs.asMatrix();
- }
-
-
- typedef Vector<float, 3> Vector3f;
- typedef Vector<int16_t, 3> Vector3i;
- typedef Vector<uint16_t, 3> Vector3u;
-}
-
-#include "vector3_impl.hpp"
-
-#endif // MODM_VECTOR3_HPP
diff --git a/src/modm/math/geometry/vector3_impl.hpp b/src/modm/math/geometry/vector3_impl.hpp
deleted file mode 100644
index 70b37af96d..0000000000
--- a/src/modm/math/geometry/vector3_impl.hpp
+++ /dev/null
@@ -1,538 +0,0 @@
-/*
- * Copyright (c) 2011-2012, Fabian Greif
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR3_HPP
- #error "Don't include this file directly, use 'vector3.hpp' instead!"
-#endif
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector() :
- x(),
- y(),
- z()
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-template<typename U>
-modm::Vector<T, 3>::Vector(const U *array) :
- x(array[0]),
- y(array[1]),
- z(array[2])
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(T inX, T inY, T inZ) :
- x(inX),
- y(inY),
- z(inZ)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 1> &inX,
- const modm::Vector<T, 1> &inY,
- const modm::Vector<T, 1> &inZ) :
- x(inX.x),
- y(inY.x),
- z(inZ.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const T &inX,
- const modm::Vector<T, 1> &inY,
- const modm::Vector<T, 1> &inZ) :
- x(inX),
- y(inY.x),
- z(inZ.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const modm::Vector<T, 1> &inZ) :
- x(inX.x),
- y(inY),
- z(inZ.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 1> &inY, const T &inZ)
-:
- x(inX.x),
- y(inY.x),
- z(inZ)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const T &inZ) :
- x(inX.x),
- y(inY),
- z(inZ)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const T &inX, const modm::Vector<T, 1> &inY, const T &inZ) :
- x(inX),
- y(inY.x),
- z(inZ)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const T &inX, const T &inY, const modm::Vector<T, 1> &inZ) :
- x(inX),
- y(inY),
- z(inZ.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 2> &inXY, const T &inZ) :
- x(inXY.x),
- y(inXY.y),
- z(inZ)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 2> &inXY, const modm::Vector<T, 1> &inZ) :
- x(inXY.x),
- y(inXY.y),
- z(inZ.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const T &inX, const modm::Vector<T, 2> &inYZ) :
- x(inX),
- y(inYZ.x),
- z(inYZ.y)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 2> &inYZ) :
- x(inX.x),
- y(inYZ.x),
- z(inYZ.y)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(T inVal) :
- x(inVal),
- y(inVal),
- z(inVal)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>::Vector(const modm::Matrix<T, 3, 1> &rhs) :
- x(reinterpret_cast<const T*>(&rhs)[0]),
- y(reinterpret_cast<const T*>(&rhs)[1]),
- z(reinterpret_cast<const T*>(&rhs)[2])
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-template<typename U>
-modm::Vector<T, 3>::Vector(const modm::Vector<U, 3> &rhs) :
- x(rhs.x),
- y(rhs.y),
- z(rhs.z)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 3>::set(const T& x, const T& y, const T& z)
-{
- this->x = x;
- this->y = y;
- this->z = z;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 3>::setX(const T& value)
-{
- this->x = value;
-}
-
-template<typename T>
-void
-modm::Vector<T, 3>::setY(const T& value)
-{
- this->y = value;
-}
-
-template<typename T>
-void
-modm::Vector<T, 3>::setZ(const T& value)
-{
- this->z = value;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 3>::getX() const
-{
- return this->x;
-}
-
-template<typename T>
-const T&
-modm::Vector<T, 3>::getY() const
-{
- return this->y;
-}
-
-template<typename T>
-const T&
-modm::Vector<T, 3>::getZ() const
-{
- return this->z;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>&
-modm::Vector<T, 3>::operator = (const modm::Matrix<T, 3, 1> &rhs)
-{
- x = reinterpret_cast<const T*>(&rhs)[0];
- y = reinterpret_cast<const T*>(&rhs)[1];
- z = reinterpret_cast<const T*>(&rhs)[2];
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::operator == (const Vector &rhs) const
-{
- return (rhs.x == x) && (rhs.y == y) && (rhs.z == z);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::operator != (const Vector &rhs) const
-{
- return (rhs.x != x) || (rhs.y != y) || (rhs.z != z);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::operator < (const Vector &rhs) const
-{
- return (x < rhs.x) || ((x == rhs.x) && ((y < rhs.y) || ((y == rhs.y) && (z < rhs.z))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::operator <= (const Vector &rhs) const
-{
- return (x < rhs.x) || ((x == rhs.x) && ((y < rhs.y) || ((y == rhs.y) && (z <= rhs.z))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::operator > (const Vector &rhs) const
-{
- return (x > rhs.x) || ((x == rhs.x) && ((y > rhs.y) || ((y == rhs.y) && (z > rhs.z))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::operator >= (const Vector &rhs) const
-{
- return (x > rhs.x) || ((x == rhs.x) && ((y > rhs.y) || ((y == rhs.y) && (z >= rhs.z))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 3>::operator [] (uint8_t index) const
-{
- return reinterpret_cast<const T*>(this)[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T&
-modm::Vector<T, 3>::operator [] (uint8_t index)
-{
- return reinterpret_cast<T*>(this)[index];
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T*
-modm::Vector<T, 3>::ptr()
-{
- return reinterpret_cast<T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T*
-modm::Vector<T, 3>::ptr() const
-{
- return reinterpret_cast<const T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::operator + (const modm::Vector<T, 3> &rhs) const
-{
- return modm::Vector<T, 3>(x+rhs.x, y+rhs.y, z+rhs.z);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::operator - (const modm::Vector<T, 3> &rhs) const
-{
- return modm::Vector<T, 3>(x-rhs.x, y-rhs.y, z-rhs.z);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 3>::operator * (const modm::Vector<T, 3> &rhs) const
-{
- return x*rhs.x + y*rhs.y + z*rhs.z;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::operator ^ (const modm::Vector<T, 3> &rhs) const
-{
- return modm::Vector<T, 3>(y*rhs.z-z*rhs.y, z*rhs.x-x*rhs.z, x*rhs.y-y*rhs.x);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::operator * (const T &rhs) const
-{
- return modm::Vector<T, 3>(x*rhs, y*rhs, z*rhs);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::operator / (const T &rhs) const
-{
- return modm::Vector<T, 3>(x/rhs, y/rhs, z/rhs);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>&
-modm::Vector<T, 3>::operator += (const modm::Vector<T, 3> &rhs)
-{
- x += rhs.x;
- y += rhs.y;
- z += rhs.z;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>&
-modm::Vector<T, 3>::operator -= (const modm::Vector<T, 3> &rhs)
-{
- x -= rhs.x;
- y -= rhs.y;
- z -= rhs.z;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>&
-modm::Vector<T, 3>::operator *= (const T &rhs)
-{
- x *= rhs;
- y *= rhs;
- z *= rhs;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>&
-modm::Vector<T, 3>::operator /= (const T &rhs)
-{
- x /= rhs;
- y /= rhs;
- z /= rhs;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::operator - () const
-{
- return modm::Vector<T, 3>(-x, -y, -z);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-float
-modm::Vector<T, 3>::getLength() const
-{
- return std::sqrt(getLengthSquared());
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-float
-modm::Vector<T, 3>::getLengthSquared() const
-{
- return x*x+y*y+z*z;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 3>::scale(float newLength)
-{
- *this = scaled(newLength);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::scaled(float newLength) const
-{
- float scale = newLength/getLength();
- return *this * scale;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 3>::normalize()
-{
- scale(1.0);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 3>
-modm::Vector<T, 3>::normalized() const
-{
- return scaled(1.0f);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 3, 1>&
-modm::Vector<T, 3>::asMatrix()
-{
- return *(modm::Matrix<T, 3, 1>*)this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const modm::Matrix<T, 3, 1>&
-modm::Vector<T, 3>::asMatrix() const
-{
- return *(modm::Matrix<T, 3, 1>*)this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 1, 3>&
-modm::Vector<T, 3>::asTransposedMatrix()
-{
- return *(modm::Matrix<T, 1, 3>*)this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const modm::Matrix<T, 1, 3>&
-modm::Vector<T, 3>::asTransposedMatrix() const
-{
- return *(modm::Matrix<T, 1, 3>*)this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::hasNan() const
-{
- return std::isnan(x) || std::isnan(y) || std::isnan(z);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 3>::hasInf() const
-{
- return std::isinf(x) || std::isinf(y) || std::isinf(z);
-}
-
-// ----------------------------------------------------------------------------
-//template<typename T>
-//static inline modm::Vector<T,3> operator * (const T &lhs, const modm::Vector<T,3> &rhs)
-//{
-// return rhs * lhs;
-//}
-//
-//
-//// ----------------------------------------------------------------------------
-//template<typename T>
-//static inline modm::Vector<T,3> operator * (const modm::Matrix<T, 3, 3> &lhs, const modm::Vector<T,3> &rhs)
-//{
-// return lhs * rhs.asTMatrix();
-//}
diff --git a/src/modm/math/geometry/vector4.hpp b/src/modm/math/geometry/vector4.hpp
deleted file mode 100644
index c91bcbed9d..0000000000
--- a/src/modm/math/geometry/vector4.hpp
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * Copyright (c) 2011-2012, Fabian Greif
- * Copyright (c) 2012, Georgi Grinshpun
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR4_HPP
-#define MODM_VECTOR4_HPP
-
-#include <stdint.h>
-#include "vector.hpp"
-
-namespace modm
-{
- /**
- * \brief Class for handling common vector operations (4D)
- *
- * + : addition of points
- * - : different of points
- * * : dot product or scalar multiplication
- * / : scalar division
- *
- * Adapted from the implementation of Gaspard Petit (gaspardpetit@gmail.com).
- *
- * \see <a href"http://www-etud.iro.umontreal.ca/~petitg/cpp/point.html">Homepage</a>
- *
- * \ingroup modm_math_geometry
- * \author Niklas Hauser
- */
- template<typename T>
- class Vector<T, 4>
- {
- public:
- Vector();
-
- explicit Vector(T inVal);
- Vector(T inX, T inY, T inZ, T inW);
-
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const Vector<T, 1> &inZ, const Vector<T, 1> &inW);
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const Vector<T, 1> &inZ, const T &inW);
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const T &inZ, const T &inW);
- Vector(const Vector<T, 1> &inX, const T &inY, const Vector<T, 1> &inZ, const T &inW);
- Vector(const T &inX, const Vector<T, 1> &inY, const Vector<T, 1> &inZ, const T &inW);
- Vector(const Vector<T, 1> &inX, const T &inY, const T &inZ, const T &inW);
- Vector(const T &inX, const Vector<T, 1> &inY, const T &inZ, const T &inW);
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const T &inZ, const Vector<T, 1> &inW);
- Vector(const Vector<T, 1> &inX, const T &inY, const T &inZ, const Vector<T, 1> &inW);
- Vector(const T &inX, const Vector<T, 1> &inY, const T &inZ, const Vector<T, 1> &inW);
- Vector(const T &inX, const T &inY, const T &inZ, const Vector<T, 1> &inW);
- Vector(const Vector<T, 1> &inX, const T &inY, const Vector<T, 1> &inZ, const Vector<T, 1> &inW);
- Vector(const T &inX, const T &inY, const Vector<T, 1> &inZ, const Vector<T, 1> &inW);
- Vector(const T &inX, const Vector<T, 1> &inY, const Vector<T, 1> &inZ, const Vector<T, 1> &inW);
-
- Vector(const Vector<T, 2> &inXY, const Vector<T, 1> &inZ, const Vector<T, 1> &inW);
- Vector(const Vector<T, 2> &inXY, const Vector<T, 1> &inZ, const T &inW);
- Vector(const Vector<T, 2> &inXY, const T &inZ, const T &inW);
- Vector(const Vector<T, 2> &inXY, const T &inZ, const Vector<T, 1> &inW);
-
- Vector(const Vector<T, 1> &inX, const Vector<T, 2> &inYZ, const Vector<T, 1> &inW);
- Vector(const Vector<T, 1> &inX, const Vector<T, 2> &inYZ, const T &inW);
- Vector(const T &inX, const Vector<T, 2> &inYZ, const T &inW);
- Vector(const T &inX, const Vector<T, 2> &inYZ, const Vector<T, 1> &inW);
-
- Vector(const Vector<T, 1> &inX, const Vector<T, 1> &inY, const Vector<T, 2> &inZW);
- Vector(const Vector<T, 1> &inX, const T &inY, const Vector<T, 2> &inZW);
- Vector(const T &inX, const T &inY, const Vector<T, 2> &inZW);
- Vector(const T &inX, const Vector<T, 1> &inY, const Vector<T, 2> &inZW);
-
- Vector(const Vector<T, 2> &inXY, const Vector<T, 2> &inZW);
-
- Vector(const Vector<T, 3> &inXYZ, const Vector<T, 1> &inW);
- Vector(const Vector<T, 3> &inXYZ, const T &inW);
-
- Vector(const Vector<T, 1> &inX, const Vector<T, 3> &inYZW);
- Vector(const T &inX, const Vector<T, 3> &inYZW);
-
- Vector(const Matrix<T, 4, 1> &rhs);
-
-
- inline void
- set(const T& x, const T& y, const T& z, const T& w);
-
-
- inline void
- setX(const T& value);
-
- inline void
- setY(const T& value);
-
- inline void
- setZ(const T& value);
-
- inline void
- setW(const T& value);
-
-
- inline const T&
- getX() const;
-
- inline const T&
- getY() const;
-
- inline const T&
- getZ() const;
-
- inline const T&
- getW() const;
-
-
- Vector& operator = (const Matrix<T, 4, 1> &rhs);
-
- bool operator == (const Vector &rhs) const;
- bool operator != (const Vector &rhs) const;
- bool operator < (const Vector &rhs) const;
- bool operator <= (const Vector &rhs) const;
- bool operator > (const Vector &rhs) const;
- bool operator >= (const Vector &rhs) const;
-
- const T& operator [] (uint8_t index) const;
- T& operator [] (uint8_t index);
- T* ptr();
- const T* ptr() const;
-
- Vector operator - () const;
- Vector operator + (const Vector &rhs) const;
- Vector operator - (const Vector &rhs) const;
- T operator * (const Vector &rhs) const;
- Vector operator * (const T &rhs) const;
- Vector operator / (const T &rhs) const;
-
- Vector& operator += (const Vector &rhs);
- Vector& operator -= (const Vector &rhs);
- Vector& operator *= (const T &rhs);
- Vector& operator /= (const T &rhs);
-
- float getLength() const;
- float getLengthSquared() const;
-
- void scale(float newLength);
- Vector scaled(float newLength) const;
-
- void normalize();
- Vector normalized() const;
-
- Matrix<T, 4, 1>&
- asMatrix();
-
- const Matrix<T, 4, 1>&
- asMatrix() const;
-
- Matrix<T, 1, 4>&
- asTransposedMatrix();
-
- const Matrix<T, 1, 4>&
- asTransposedMatrix() const;
-
- #ifndef __DOXYGEN__
- IMPLEMENT_VECTOR_ACCESSOR2(x,x) IMPLEMENT_VECTOR_ACCESSOR2(x,y) IMPLEMENT_VECTOR_ACCESSOR2(x,z) IMPLEMENT_VECTOR_ACCESSOR2(x,w)
- IMPLEMENT_VECTOR_ACCESSOR2(y,x) IMPLEMENT_VECTOR_ACCESSOR2(y,y) IMPLEMENT_VECTOR_ACCESSOR2(y,z) IMPLEMENT_VECTOR_ACCESSOR2(y,w)
- IMPLEMENT_VECTOR_ACCESSOR2(z,x) IMPLEMENT_VECTOR_ACCESSOR2(z,y) IMPLEMENT_VECTOR_ACCESSOR2(z,z) IMPLEMENT_VECTOR_ACCESSOR2(z,w)
- IMPLEMENT_VECTOR_ACCESSOR2(w,x) IMPLEMENT_VECTOR_ACCESSOR2(w,y) IMPLEMENT_VECTOR_ACCESSOR2(w,z) IMPLEMENT_VECTOR_ACCESSOR2(w,w)
-
- IMPLEMENT_VECTOR_ACCESSOR3(x,x,x) IMPLEMENT_VECTOR_ACCESSOR3(x,x,y) IMPLEMENT_VECTOR_ACCESSOR3(x,x,z) IMPLEMENT_VECTOR_ACCESSOR3(x,x,w)
- IMPLEMENT_VECTOR_ACCESSOR3(x,y,x) IMPLEMENT_VECTOR_ACCESSOR3(x,y,y) IMPLEMENT_VECTOR_ACCESSOR3(x,y,z) IMPLEMENT_VECTOR_ACCESSOR3(x,y,w)
- IMPLEMENT_VECTOR_ACCESSOR3(x,z,x) IMPLEMENT_VECTOR_ACCESSOR3(x,z,y) IMPLEMENT_VECTOR_ACCESSOR3(x,z,z) IMPLEMENT_VECTOR_ACCESSOR3(x,z,w)
- IMPLEMENT_VECTOR_ACCESSOR3(y,x,x) IMPLEMENT_VECTOR_ACCESSOR3(y,x,y) IMPLEMENT_VECTOR_ACCESSOR3(y,x,z) IMPLEMENT_VECTOR_ACCESSOR3(y,x,w)
- IMPLEMENT_VECTOR_ACCESSOR3(y,y,x) IMPLEMENT_VECTOR_ACCESSOR3(y,y,y) IMPLEMENT_VECTOR_ACCESSOR3(y,y,z) IMPLEMENT_VECTOR_ACCESSOR3(y,y,w)
- IMPLEMENT_VECTOR_ACCESSOR3(y,z,x) IMPLEMENT_VECTOR_ACCESSOR3(y,z,y) IMPLEMENT_VECTOR_ACCESSOR3(y,z,z) IMPLEMENT_VECTOR_ACCESSOR3(y,z,w)
- IMPLEMENT_VECTOR_ACCESSOR3(z,x,x) IMPLEMENT_VECTOR_ACCESSOR3(z,x,y) IMPLEMENT_VECTOR_ACCESSOR3(z,x,z) IMPLEMENT_VECTOR_ACCESSOR3(z,x,w)
- IMPLEMENT_VECTOR_ACCESSOR3(z,y,x) IMPLEMENT_VECTOR_ACCESSOR3(z,y,y) IMPLEMENT_VECTOR_ACCESSOR3(z,y,z) IMPLEMENT_VECTOR_ACCESSOR3(z,y,w)
- IMPLEMENT_VECTOR_ACCESSOR3(z,z,x) IMPLEMENT_VECTOR_ACCESSOR3(z,z,y) IMPLEMENT_VECTOR_ACCESSOR3(z,z,z) IMPLEMENT_VECTOR_ACCESSOR3(z,z,w)
- IMPLEMENT_VECTOR_ACCESSOR3(w,x,x) IMPLEMENT_VECTOR_ACCESSOR3(w,x,y) IMPLEMENT_VECTOR_ACCESSOR3(w,x,z) IMPLEMENT_VECTOR_ACCESSOR3(w,x,w)
- IMPLEMENT_VECTOR_ACCESSOR3(w,y,x) IMPLEMENT_VECTOR_ACCESSOR3(w,y,y) IMPLEMENT_VECTOR_ACCESSOR3(w,y,z) IMPLEMENT_VECTOR_ACCESSOR3(w,y,w)
- IMPLEMENT_VECTOR_ACCESSOR3(w,z,x) IMPLEMENT_VECTOR_ACCESSOR3(w,z,y) IMPLEMENT_VECTOR_ACCESSOR3(w,z,z) IMPLEMENT_VECTOR_ACCESSOR3(w,z,w)
-
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,x) IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,y) IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,z) IMPLEMENT_VECTOR_ACCESSOR4(x,x,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,x) IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,y) IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,z) IMPLEMENT_VECTOR_ACCESSOR4(x,x,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,x) IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,y) IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,z) IMPLEMENT_VECTOR_ACCESSOR4(x,x,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,x) IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,y) IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,z) IMPLEMENT_VECTOR_ACCESSOR4(x,y,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,x) IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,y) IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,z) IMPLEMENT_VECTOR_ACCESSOR4(x,y,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,x) IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,y) IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,z) IMPLEMENT_VECTOR_ACCESSOR4(x,y,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,x) IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,y) IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,z) IMPLEMENT_VECTOR_ACCESSOR4(x,z,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,x) IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,y) IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,z) IMPLEMENT_VECTOR_ACCESSOR4(x,z,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,x) IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,y) IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,z) IMPLEMENT_VECTOR_ACCESSOR4(x,z,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,w,x,x) IMPLEMENT_VECTOR_ACCESSOR4(x,w,x,y) IMPLEMENT_VECTOR_ACCESSOR4(x,w,x,z) IMPLEMENT_VECTOR_ACCESSOR4(x,w,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,w,y,x) IMPLEMENT_VECTOR_ACCESSOR4(x,w,y,y) IMPLEMENT_VECTOR_ACCESSOR4(x,w,y,z) IMPLEMENT_VECTOR_ACCESSOR4(x,w,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(x,w,z,x) IMPLEMENT_VECTOR_ACCESSOR4(x,w,z,y) IMPLEMENT_VECTOR_ACCESSOR4(x,w,z,z) IMPLEMENT_VECTOR_ACCESSOR4(x,w,z,w)
-
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,x) IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,y) IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,z) IMPLEMENT_VECTOR_ACCESSOR4(y,x,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,x) IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,y) IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,z) IMPLEMENT_VECTOR_ACCESSOR4(y,x,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,x) IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,y) IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,z) IMPLEMENT_VECTOR_ACCESSOR4(y,x,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,x) IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,y) IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,z) IMPLEMENT_VECTOR_ACCESSOR4(y,y,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,x) IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,y) IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,z) IMPLEMENT_VECTOR_ACCESSOR4(y,y,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,x) IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,y) IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,z) IMPLEMENT_VECTOR_ACCESSOR4(y,y,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,x) IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,y) IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,z) IMPLEMENT_VECTOR_ACCESSOR4(y,z,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,x) IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,y) IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,z) IMPLEMENT_VECTOR_ACCESSOR4(y,z,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,x) IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,y) IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,z) IMPLEMENT_VECTOR_ACCESSOR4(y,z,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,w,x,x) IMPLEMENT_VECTOR_ACCESSOR4(y,w,x,y) IMPLEMENT_VECTOR_ACCESSOR4(y,w,x,z) IMPLEMENT_VECTOR_ACCESSOR4(y,w,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,w,y,x) IMPLEMENT_VECTOR_ACCESSOR4(y,w,y,y) IMPLEMENT_VECTOR_ACCESSOR4(y,w,y,z) IMPLEMENT_VECTOR_ACCESSOR4(y,w,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(y,w,z,x) IMPLEMENT_VECTOR_ACCESSOR4(y,w,z,y) IMPLEMENT_VECTOR_ACCESSOR4(y,w,z,z) IMPLEMENT_VECTOR_ACCESSOR4(y,w,z,w)
-
- IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,x) IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,y) IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,z) IMPLEMENT_VECTOR_ACCESSOR4(z,x,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,x) IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,y) IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,z) IMPLEMENT_VECTOR_ACCESSOR4(z,x,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,x) IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,y) IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,z) IMPLEMENT_VECTOR_ACCESSOR4(z,x,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,x) IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,y) IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,z) IMPLEMENT_VECTOR_ACCESSOR4(z,y,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,x) IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,y) IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,z) IMPLEMENT_VECTOR_ACCESSOR4(z,y,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,x) IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,y) IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,z) IMPLEMENT_VECTOR_ACCESSOR4(z,y,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,x) IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,y) IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,z) IMPLEMENT_VECTOR_ACCESSOR4(z,z,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,x) IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,y) IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,z) IMPLEMENT_VECTOR_ACCESSOR4(z,z,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,x) IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,y) IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,z) IMPLEMENT_VECTOR_ACCESSOR4(z,z,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,w,x,x) IMPLEMENT_VECTOR_ACCESSOR4(z,w,x,y) IMPLEMENT_VECTOR_ACCESSOR4(z,w,x,z) IMPLEMENT_VECTOR_ACCESSOR4(z,w,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,w,y,x) IMPLEMENT_VECTOR_ACCESSOR4(z,w,y,y) IMPLEMENT_VECTOR_ACCESSOR4(z,w,y,z) IMPLEMENT_VECTOR_ACCESSOR4(z,w,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(z,w,z,x) IMPLEMENT_VECTOR_ACCESSOR4(z,w,z,y) IMPLEMENT_VECTOR_ACCESSOR4(z,w,z,z) IMPLEMENT_VECTOR_ACCESSOR4(z,w,z,w)
-
- IMPLEMENT_VECTOR_ACCESSOR4(w,x,x,x) IMPLEMENT_VECTOR_ACCESSOR4(w,x,x,y) IMPLEMENT_VECTOR_ACCESSOR4(w,x,x,z) IMPLEMENT_VECTOR_ACCESSOR4(w,x,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,x,y,x) IMPLEMENT_VECTOR_ACCESSOR4(w,x,y,y) IMPLEMENT_VECTOR_ACCESSOR4(w,x,y,z) IMPLEMENT_VECTOR_ACCESSOR4(w,x,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,x,z,x) IMPLEMENT_VECTOR_ACCESSOR4(w,x,z,y) IMPLEMENT_VECTOR_ACCESSOR4(w,x,z,z) IMPLEMENT_VECTOR_ACCESSOR4(w,x,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,y,x,x) IMPLEMENT_VECTOR_ACCESSOR4(w,y,x,y) IMPLEMENT_VECTOR_ACCESSOR4(w,y,x,z) IMPLEMENT_VECTOR_ACCESSOR4(w,y,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,y,y,x) IMPLEMENT_VECTOR_ACCESSOR4(w,y,y,y) IMPLEMENT_VECTOR_ACCESSOR4(w,y,y,z) IMPLEMENT_VECTOR_ACCESSOR4(w,y,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,y,z,x) IMPLEMENT_VECTOR_ACCESSOR4(w,y,z,y) IMPLEMENT_VECTOR_ACCESSOR4(w,y,z,z) IMPLEMENT_VECTOR_ACCESSOR4(w,y,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,z,x,x) IMPLEMENT_VECTOR_ACCESSOR4(w,z,x,y) IMPLEMENT_VECTOR_ACCESSOR4(w,z,x,z) IMPLEMENT_VECTOR_ACCESSOR4(w,z,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,z,y,x) IMPLEMENT_VECTOR_ACCESSOR4(w,z,y,y) IMPLEMENT_VECTOR_ACCESSOR4(w,z,y,z) IMPLEMENT_VECTOR_ACCESSOR4(w,z,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,z,z,x) IMPLEMENT_VECTOR_ACCESSOR4(w,z,z,y) IMPLEMENT_VECTOR_ACCESSOR4(w,z,z,z) IMPLEMENT_VECTOR_ACCESSOR4(w,z,z,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,w,x,x) IMPLEMENT_VECTOR_ACCESSOR4(w,w,x,y) IMPLEMENT_VECTOR_ACCESSOR4(w,w,x,z) IMPLEMENT_VECTOR_ACCESSOR4(w,w,x,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,w,y,x) IMPLEMENT_VECTOR_ACCESSOR4(w,w,y,y) IMPLEMENT_VECTOR_ACCESSOR4(w,w,y,z) IMPLEMENT_VECTOR_ACCESSOR4(w,w,y,w)
- IMPLEMENT_VECTOR_ACCESSOR4(w,w,z,x) IMPLEMENT_VECTOR_ACCESSOR4(w,w,z,y) IMPLEMENT_VECTOR_ACCESSOR4(w,w,z,z) IMPLEMENT_VECTOR_ACCESSOR4(w,w,z,w)
- #endif
-
- public:
- T x;
- T y;
- T z;
- T w;
- };
-
- template<typename U, typename T>
- static inline Vector<T,4> operator * (const U &lhs, const Vector<T,4> &rhs)
- {
- return rhs * lhs;
- }
-
- template<typename T, typename U>
- static inline Vector<U,4> operator * (const Matrix<T, 4, 4> &lhs, const Vector<U,4> &rhs)
- {
- return lhs * rhs.asTMatrix();
- }
-
- typedef Vector<float, 4> Vector4f;
- typedef Vector<int16_t, 4> Vector4i;
- typedef Vector<uint16_t, 4> Vector4u;
-}
-
-#include "vector4_impl.hpp"
-
-#endif // MODM_VECTOR4_HPP
diff --git a/src/modm/math/geometry/vector4_impl.hpp b/src/modm/math/geometry/vector4_impl.hpp
deleted file mode 100644
index 36e8d2c664..0000000000
--- a/src/modm/math/geometry/vector4_impl.hpp
+++ /dev/null
@@ -1,788 +0,0 @@
-/*
- * Copyright (c) 2011-2012, Fabian Greif
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR4_HPP
- #error "Don't include this file directly, use 'vector4.hpp' instead!"
-#endif
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector()
-:
- x(),
- y(),
- z(),
- w()
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(T inX, T inY, T inZ, T inW)
-:
- x(inX),
- y(inY),
- z(inZ),
- w(inW)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 1> &inY, const modm::Vector<T, 1> &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX.x),
- y(inY.x),
- z(inZ.x),
- w(inW.x)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 1> &inY, const modm::Vector<T, 1> &inZ, const T &inW)
-:
- x(inX.x),
- y(inY.x),
- z(inZ.x),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 1> &inY, const T &inZ, const T &inW)
-:
- x(inX.x),
- y(inY.x),
- z(inZ),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const modm::Vector<T, 1> &inZ, const T &inW)
-:
- x(inX.x),
- y(inY),
- z(inZ.x),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 1> &inY, const modm::Vector<T, 1> &inZ, const T &inW)
-:
- x(inX),
- y(inY.x),
- z(inZ.x),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const T &inZ, const T &inW)
-:
- x(inX.x),
- y(inY),
- z(inZ),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 1> &inY, const T &inZ, const T &inW)
-:
- x(inX),
- y(inY.x),
- z(inZ),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 1> &inY, const T &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX.x),
- y(inY.x),
- z(inZ),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const T &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX.x),
- y(inY),
- z(inZ),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 1> &inY, const T &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX),
- y(inY.x),
- z(inZ),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const T &inY, const T &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX),
- y(inY),
- z(inZ),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const modm::Vector<T, 1> &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX.x),
- y(inY),
- z(inZ.x),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const T &inY, const modm::Vector<T, 1> &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX),
- y(inY),
- z(inZ.x),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 1> &inY, const modm::Vector<T, 1> &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inX),
- y(inY.x),
- z(inZ.x),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 2> &inXY, const modm::Vector<T, 1> &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inXY.x),
- y(inXY.y),
- z(inZ.x),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 2> &inXY, const modm::Vector<T, 1> &inZ, const T &inW)
-:
- x(inXY.x),
- y(inXY.y),
- z(inZ.x),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 2> &inXY, const T &inZ, const T &inW)
-:
- x(inXY.x),
- y(inXY.y),
- z(inZ),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 2> &inXY, const T &inZ, const modm::Vector<T, 1> &inW)
-:
- x(inXY.x),
- y(inXY.y),
- z(inZ),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 2> &inYZ, const modm::Vector<T, 1> &inW)
-:
- x(inX.x),
- y(inYZ.x),
- z(inYZ.y),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 2> &inYZ, const T &inW)
-:
- x(inX.x),
- y(inYZ.x),
- z(inYZ.y),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 2> &inYZ, const T &inW)
-:
- x(inX),
- y(inYZ.x),
- z(inYZ.y),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 2> &inYZ, const modm::Vector<T, 1> &inW)
-:
- x(inX),
- y(inYZ.x),
- z(inYZ.y),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 1> &inY, const modm::Vector<T, 2> &inZW)
-:
- x(inX.x),
- y(inY.x),
- z(inZW.x),
- w(inZW.y)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const T &inY, const modm::Vector<T, 2> &inZW)
-:
- x(inX.x),
- y(inY),
- z(inZW.x),
- w(inZW.y)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const T &inY, const modm::Vector<T, 2> &inZW)
-:
- x(inX),
- y(inY),
- z(inZW.x),
- w(inZW.y)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 1> &inY, const modm::Vector<T, 2> &inZW)
-:
- x(inX),
- y(inY.x),
- z(inZW.x),
- w(inZW.y)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 2> &inXY, const modm::Vector<T, 2> &inZW)
-:
- x(inXY.x),
- y(inXY.y),
- z(inZW.x),
- w(inZW.y)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 3> &inXYZ, const modm::Vector<T, 1> &inW)
-:
- x(inXYZ.x),
- y(inXYZ.y),
- z(inXYZ.z),
- w(inW.x)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 3> &inXYZ, const T &inW)
-:
- x(inXYZ.x),
- y(inXYZ.y),
- z(inXYZ.z),
- w(inW)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Vector<T, 1> &inX, const modm::Vector<T, 3> &inYZW)
-:
- x(inX.x),
- y(inYZW.x),
- z(inYZW.y),
- w(inYZW.z)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const T &inX, const modm::Vector<T, 3> &inYZW)
-:
- x(inX),
- y(inYZW.x),
- z(inYZW.y),
- w(inYZW.z)
-{
-}
-
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(const modm::Matrix<T, 4, 1> &rhs)
-:
- x(reinterpret_cast<const T*>(&rhs)[0]),
- y(reinterpret_cast<const T*>(&rhs)[1]),
- z(reinterpret_cast<const T*>(&rhs)[2]),
- w(reinterpret_cast<const T*>(&rhs)[3])
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>::Vector(T inVal)
-:
- x(inVal),
- y(inVal),
- z(inVal),
- w(inVal)
-{
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 4>::set(const T& x_, const T& y_, const T& z_, const T& w_)
-{
- this->x = x_;
- this->y = y_;
- this->z = z_;
- this->w = w_;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 4>::setX(const T& value)
-{
- this->x = value;
-}
-
-template<typename T>
-void
-modm::Vector<T, 4>::setY(const T& value)
-{
- this->y = value;
-}
-
-template<typename T>
-void
-modm::Vector<T, 4>::setZ(const T& value)
-{
- this->z = value;
-}
-
-template<typename T>
-void
-modm::Vector<T, 4>::setW(const T& value)
-{
- this->w = value;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 4>::getX() const
-{
- return this->x;
-}
-
-template<typename T>
-const T&
-modm::Vector<T, 4>::getY() const
-{
- return this->y;
-}
-
-template<typename T>
-const T&
-modm::Vector<T, 4>::getZ() const
-{
- return this->z;
-}
-
-template<typename T>
-const T&
-modm::Vector<T, 4>::getW() const
-{
- return this->w;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>&
-modm::Vector<T, 4>::operator = (const modm::Matrix<T, 4, 1> &rhs)
-{
- x = reinterpret_cast<const T*>(&rhs)[0];
- y = reinterpret_cast<const T*>(&rhs)[1];
- z = reinterpret_cast<const T*>(&rhs)[2];
- w = reinterpret_cast<const T*>(&rhs)[3];
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 4>::operator == (const modm::Vector<T, 4> &rhs) const
-{
- return (rhs.x == x) && (rhs.y == y) && (rhs.z == z) && (rhs.w == w);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 4>::operator != (const modm::Vector<T, 4> &rhs) const
-{
- return (rhs.x != x) || (rhs.y != y) || (rhs.z != z) || (rhs.w != w);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 4>::operator < (const modm::Vector<T, 4> &rhs) const
-{
- return (x < rhs.x) || ((x == rhs.x) && ((y < rhs.y) || ((y == rhs.y) && ((z < rhs.z) || ((z == rhs.z) && (w < rhs.w))))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 4>::operator <= (const modm::Vector<T, 4> &rhs) const
-{
- return (x < rhs.x) || ((x == rhs.x) && ((y < rhs.y) || ((y == rhs.y) && ((z < rhs.z) || ((z == rhs.z) && (w <= rhs.w))))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 4>::operator > (const modm::Vector<T, 4> &rhs) const
-{
- return (x > rhs.x) || ((x == rhs.x) && ((y > rhs.y) || ((y == rhs.y) && ((z > rhs.z) || ((z == rhs.z) && (w > rhs.w))))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-bool
-modm::Vector<T, 4>::operator >= (const modm::Vector<T, 4> &rhs) const
-{
- return (x > rhs.x) || ((x == rhs.x) && ((y > rhs.y) || ((y == rhs.y) && ((z > rhs.z) || ((z == rhs.z) && (w >= rhs.w))))));
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T&
-modm::Vector<T, 4>::operator [] (uint8_t index) const
-{
- return reinterpret_cast<const T*>(this)[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T&
-modm::Vector<T, 4>::operator [] (uint8_t index)
-{
- return reinterpret_cast<T*>(this)[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T*
-modm::Vector<T, 4>::ptr()
-{
- return reinterpret_cast<T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-const T*
-modm::Vector<T, 4>::ptr() const
-{
- return reinterpret_cast<const T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::operator + (const modm::Vector<T, 4> &rhs) const
-{
- return modm::Vector<T, 4>(x+rhs.x, y+rhs.y, z+rhs.z, w+rhs.w);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::operator - (const modm::Vector<T, 4> &rhs) const
-{
- return modm::Vector<T, 4>(x-rhs.x, y-rhs.y, z-rhs.z, w-rhs.w);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-T
-modm::Vector<T, 4>::operator * (const modm::Vector<T, 4> &rhs) const
-{
- return x*rhs.x + y*rhs.y + z*rhs.z + w*rhs.w;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::operator * (const T &rhs) const
-{
- return modm::Vector<T, 4>(x*rhs, y*rhs, z*rhs, w*rhs);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::operator / (const T &rhs) const
-{
- return modm::Vector<T, 4>(x/rhs, y/rhs, z/rhs, w/rhs);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>&
-modm::Vector<T, 4>::operator += (const modm::Vector<T, 4> &rhs)
-{
- x += rhs.x;
- y += rhs.y;
- z += rhs.z;
- w += rhs.w;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>&
-modm::Vector<T, 4>::operator -= (const modm::Vector<T, 4> &rhs)
-{
- x -= rhs.x;
- y -= rhs.y;
- z -= rhs.z;
- w -= rhs.w;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>&
-modm::Vector<T, 4>::operator *= (const T &rhs)
-{
- x *= rhs;
- y *= rhs;
- z *= rhs;
- w *= rhs;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>&
-modm::Vector<T, 4>::operator /= (const T &rhs)
-{
- x /= rhs;
- y /= rhs;
- z /= rhs;
- w /= rhs;
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::operator - () const
-{
- return modm::Vector<T, 4>(-x, -y, -z, -w);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-float
-modm::Vector<T, 4>::getLength() const
-{
- return std::sqrt(getLengthSquared());
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-float
-modm::Vector<T, 4>::getLengthSquared() const
-{
- return x*x + y*y + z*z + w*w;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 4>::scale(float newLength)
-{
- *this = scaled(newLength);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::scaled(float newLength) const
-{
- float scale = newLength / getLength();
- return *this * scale;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-void
-modm::Vector<T, 4>::normalize()
-{
- scale(1.0f);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Vector<T, 4>
-modm::Vector<T, 4>::normalized() const
-{
- return scaled(1.0);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 4, 1>&
-modm::Vector<T, 4>::asMatrix()
-{
- return *(modm::Matrix<T, 4, 1>*)this;
-}
-
-template<typename T>
-const modm::Matrix<T, 4, 1>&
-modm::Vector<T, 4>::asMatrix() const
-{
- return *(modm::Matrix<T, 4, 1>*)this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-modm::Matrix<T, 1, 4>&
-modm::Vector<T, 4>::asTransposedMatrix()
-{
- return *(modm::Matrix<T, 1, 4>*)this;
-}
-
-
-template<typename T>
-const modm::Matrix<T, 1, 4>&
-modm::Vector<T, 4>::asTransposedMatrix() const
-{
- return *(modm::Matrix<T, 1, 4>*)this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T>
-static inline modm::Vector<T,4>
-operator * (const T &lhs, const modm::Vector<T,4> &rhs)
-{
- return rhs * lhs;
-}
-
-template<class T, class U>
-static inline modm::Vector<U,4>
-operator * (const modm::Matrix<T, 4, 4> &lhs, const modm::Vector<U,4> &rhs)
-{
- return lhs * rhs.asTMatrix();
-}
-
diff --git a/src/modm/math/geometry/vector_impl.hpp b/src/modm/math/geometry/vector_impl.hpp
deleted file mode 100644
index ccb4d78451..0000000000
--- a/src/modm/math/geometry/vector_impl.hpp
+++ /dev/null
@@ -1,333 +0,0 @@
-/*
- * Copyright (c) 2011-2012, Fabian Greif
- * Copyright (c) 2012, Niklas Hauser
- *
- * This file is part of the modm project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_VECTOR_HPP
- #error "Don't include this file directly, use 'vector.hpp' instead!"
-#endif
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>::Vector()
-{
-}
-
-template<typename T, uint8_t N>
-modm::Vector<T, N>::Vector(const T *ptData)
-{
- memcpy(coords, ptData, sizeof(T) * N);
-}
-
-template<typename T, uint8_t N>
-modm::Vector<T, N>::Vector(const modm::Matrix<T, N, 1> &rhs)
-{
- memcpy(coords, &rhs, sizeof(T) * N);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-uint8_t
-modm::Vector<T, N>::getSize()
-{
- return N;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>&
-modm::Vector<T, N>::operator = (const modm::Matrix<T, N, 1> &rhs)
-{
- memcpy(coords, &rhs, sizeof(T) * N);
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-bool
-modm::Vector<T, N>::operator == (const modm::Vector<T, N> &rhs) const
-{
- return memcmp(coords, rhs.coords, sizeof(T)*N) == 0;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-bool
-modm::Vector<T, N>::operator != (const modm::Vector<T, N> &rhs) const
-{
- return memcmp(coords, rhs.coords, sizeof(T)*N) != 0;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-bool
-modm::Vector<T, N>::operator < (const modm::Vector<T, N> &rhs) const
-{
- for (uint_fast8_t i = 0; i < N; ++i)
- {
- if ((*this)[i] < rhs[i]) {
- return true;
- }
- else if ((*this)[i] > rhs[i]) {
- return false;
- }
- }
- return false;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-bool
-modm::Vector<T, N>::operator <= (const modm::Vector<T, N> &rhs) const
-{
- for (uint_fast8_t i = 0; i < N; ++i)
- {
- if ((*this)[i] < rhs[i]) {
- return true;
- }
- else if ((*this)[i] > rhs[i]) {
- return false;
- }
- }
- return true;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-bool
-modm::Vector<T, N>::operator > (const modm::Vector<T, N> &rhs) const
-{
- for (uint_fast8_t i = 0; i < N; ++i)
- {
- if ((*this)[i] > rhs[i]) {
- return true;
- }
- else if ((*this)[i] < rhs[i]) {
- return false;
- }
- }
- return false;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-bool
-modm::Vector<T, N>::operator >= (const modm::Vector<T, N> &rhs) const
-{
- for (uint_fast8_t i = 0; i < N; ++i)
- {
- if ((*this)[i] > rhs[i]) {
- return true;
- }
- else if ((*this)[i] < rhs[i]) {
- return false;
- }
- }
- return true;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-const T&
-modm::Vector<T, N>::operator [] (uint8_t index) const
-{
- return coords[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-T&
-modm::Vector<T, N>::operator [] (uint8_t index)
-{
- return coords[index];
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-T*
-modm::Vector<T, N>::ptr()
-{
- return reinterpret_cast<T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-const T*
-modm::Vector<T, N>::ptr() const
-{
- return reinterpret_cast<const T*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>
-modm::Vector<T, N>::operator + (const modm::Vector<T, N> &rhs) const
-{
- modm::Vector<T, N> pt;
- for (uint_fast8_t i = 0; i < N; ++i) {
- pt[i] = coords[i] + rhs.coords[i];
- }
- return pt;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>
-modm::Vector<T, N>::operator - (const modm::Vector<T, N> &rhs) const
-{
- modm::Vector<T, N> pt;
- for (uint_fast8_t i = 0; i < N; ++i) {
- pt[i] = coords[i] - rhs.coords[i];
- }
- return pt;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Matrix<T, N, 1>&
-modm::Vector<T, N>::asMatrix()
-{
- return *reinterpret_cast<modm::Matrix<T, N, 1>*>(this);
-}
-
-template<typename T, uint8_t N>
-const modm::Matrix<T, N, 1>&
-modm::Vector<T, N>::asMatrix() const
-{
- return *reinterpret_cast<const modm::Matrix<T, N, 1>*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-const modm::Matrix<T, 1, N>&
-modm::Vector<T, N>::asTransposedMatrix() const
-{
- return *reinterpret_cast<const modm::Matrix<T, 1, N>*>(this);
-}
-
-template<typename T, uint8_t N>
-modm::Matrix<T, 1, N>&
-modm::Vector<T, N>::asTransposedMatrix()
-{
- return *reinterpret_cast<modm::Matrix<T, 1, N>*>(this);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-T
-modm::Vector<T, N>::operator * (const Vector &rhs) const
-{
- T v = 0;
- for (uint_fast8_t i = 0; i < N; ++i) {
- v += (*this)[i]*rhs[i];
- }
-
- return v;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>
-modm::Vector<T, N>::operator * (const T &rhs) const
-{
- modm::Vector<T, N> pt;
- for (uint_fast8_t i = 0; i < N; ++i) {
- pt[i] = coords[i] * rhs;
- }
- return pt;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>
-modm::Vector<T, N>::operator / (const T &rhs) const
-{
- modm::Vector<T, N> pt;
- for (uint_fast8_t i = 0; i < N; ++i) {
- pt[i] = coords[i] / rhs;
- }
- return pt;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>&
-modm::Vector<T, N>::operator += (const Vector &rhs)
-{
- for (uint_fast8_t i = 0; i < N; ++i) {
- coords[i] += rhs.coords[i];
- }
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>&
-modm::Vector<T, N>::operator -= (const Vector &rhs)
-{
- for (uint_fast8_t i = 0; i < N; ++i) {
- coords[i] -= rhs.coords[i];
- }
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>&
-modm::Vector<T, N>::operator *= (const T &rhs)
-{
- for (uint_fast8_t i = 0; i < N; ++i) {
- coords[i] -= rhs;
- }
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>&
-modm::Vector<T, N>::operator /= (const T &rhs)
-{
- for (uint_fast8_t i = 0; i < N; ++i) {
- coords[i] /= rhs;
- }
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-modm::Vector<T, N>&
-modm::Vector<T, N>::operator - ()
-{
- for (uint_fast8_t i = 0; i < N; ++i) {
- coords[i] = -coords[i];
- }
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-T
-modm::Vector<T, N>::getLength() const
-{
- return std::sqrt(getLengthSquared());
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
-T
-modm::Vector<T, N>::getLengthSquared() const
-{
- T len2 = 0;
- for (uint_fast8_t i = 0; i < N; ++i) {
- len2 += (*this)[i]*(*this)[i];
- }
-
- return len2;
-}
diff --git a/src/modm/math/lu_decomposition.hpp b/src/modm/math/lu_decomposition.hpp
index eb1c18a29a..ffdb1d65c9 100644
--- a/src/modm/math/lu_decomposition.hpp
+++ b/src/modm/math/lu_decomposition.hpp
@@ -11,8 +11,7 @@
*/
// ----------------------------------------------------------------------------
-#ifndef MODM_LU_DECOMPOSITION_HPP
-#define MODM_LU_DECOMPOSITION_HPP
+#pragma once
#include "matrix.hpp"
#include "geometry/vector.hpp"
@@ -20,8 +19,12 @@
namespace modm
{
// forward declaration
- template <class T, uint8_t ROWS, uint8_t COLUMNS> class Matrix;
- template <class T, uint8_t N> class Vector;
+ template <typename T, std::size_t ROWS, std::size_t COLUMNS>
+ class Matrix;
+
+ template <typename T, std::size_t N>
+ requires (N > 0)
+ class Vector;
/**
* \brief Class for decomposing matrices
@@ -39,41 +42,41 @@ namespace modm
class LUDecomposition
{
public:
- template <typename T, uint8_t N>
+ template <typename T, std::size_t SIZE>
static bool
- decompose(const Matrix<T, N, N> &matrix,
- Matrix<T, N, N> *l,
- Matrix<T, N, N> *u);
+ decompose(const Matrix<T, SIZE, SIZE> &matrix,
+ Matrix<T, SIZE, SIZE> *l,
+ Matrix<T, SIZE, SIZE> *u);
- template <typename T, uint8_t N>
+ template <typename T, std::size_t SIZE>
static bool
- decompose(const Matrix<T, N, N> &matrix,
- Matrix<T, N, N> *l,
- Matrix<T, N, N> *u,
- Matrix<T, N, N> *p);
+ decompose(const Matrix<T, SIZE, SIZE> &matrix,
+ Matrix<T, SIZE, SIZE> *l,
+ Matrix<T, SIZE, SIZE> *u,
+ Matrix<T, SIZE, SIZE> *p);
- template <typename T, uint8_t N>
+ template <typename T, std::size_t SIZE>
static bool
- decompose(const Matrix<T, N, N> &matrix,
- Matrix<T, N, N> *l,
- Matrix<T, N, N> *u,
- Vector<int8_t, N> *p);
+ decompose(const Matrix<T, SIZE, SIZE> &matrix,
+ Matrix<T, SIZE, SIZE> *l,
+ Matrix<T, SIZE, SIZE> *u,
+ Vector<int8_t, SIZE> *p);
- template <typename T, uint8_t N, uint8_t BXWIDTH>
+ template <typename T, std::size_t SIZE, std::size_t BXWIDTH>
static bool
- solve(const Matrix<T, N, N> &l,
- const Matrix<T, N, N> &u,
- Matrix<T, N, BXWIDTH> *xb);
+ solve(const Matrix<T, SIZE, SIZE> &l,
+ const Matrix<T, SIZE, SIZE> &u,
+ Matrix<T, SIZE, BXWIDTH> *xb);
- template <typename T, uint8_t N, uint8_t BXWIDTH>
+ template <typename T, std::size_t SIZE, std::size_t BXWIDTH>
static bool
- solve(const Matrix<T, N, N> &A,
- Matrix<T, N, BXWIDTH> *xb);
+ solve(const Matrix<T, SIZE, SIZE> &A,
+ Matrix<T, SIZE, BXWIDTH> *xb);
private:
- template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH>
+ template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH>
class LUSubDecomposition
{
public:
@@ -89,19 +92,19 @@ namespace modm
static bool
decompose(T *u, T *l, int8_t *p);
- template<uint8_t BXWIDTH>
+ template<std::size_t BXWIDTH>
static bool
solveLyEqualsB(
Matrix<T, HEIGHT, WIDTH> *l,
Matrix<T, HEIGHT, BXWIDTH> *bx);
- template<uint8_t BXWIDTH>
+ template<std::size_t BXWIDTH>
static bool
solveUxEqualsY(
Matrix<T, HEIGHT, WIDTH> *u,
Matrix<T, HEIGHT, BXWIDTH> *bx);
- template<uint8_t BXWIDTH>
+ template<std::size_t BXWIDTH>
static bool
solve(
const Matrix<T, HEIGHT, WIDTH> &l,
@@ -109,7 +112,7 @@ namespace modm
Matrix<T, HEIGHT, BXWIDTH> *bx);
};
- template<typename T, uint8_t HEIGHT>
+ template<typename T, std::size_t HEIGHT>
class RowOperation
{
public:
@@ -145,7 +148,7 @@ namespace modm
swap(T *row1, T *row2);
};
- template<typename T, uint8_t OFFSET, uint8_t WIDTH>
+ template<typename T, std::size_t OFFSET, std::size_t WIDTH>
class LUSubDecomposition<T, OFFSET, WIDTH, OFFSET>
{
public:
@@ -155,13 +158,13 @@ namespace modm
static bool
decomposeRecur(T *u, T *l);
- template<uint8_t BXWIDTH>
+ template<std::size_t BXWIDTH>
static bool
solveUxEqualsY(
Matrix<T, WIDTH, OFFSET> *u,
Matrix<T, OFFSET, BXWIDTH> *bx);
- template<uint8_t BXWIDTH>
+ template<std::size_t BXWIDTH>
static bool
solveLyEqualsB(
Matrix<T, WIDTH, OFFSET> *l,
@@ -170,5 +173,3 @@ namespace modm
};
}
#include "lu_decomposition_impl.hpp"
-
-#endif // MODM_LU_DECOMPOSITION_HPP
diff --git a/src/modm/math/lu_decomposition_impl.hpp b/src/modm/math/lu_decomposition_impl.hpp
index f79a9228ee..ecc9874657 100644
--- a/src/modm/math/lu_decomposition_impl.hpp
+++ b/src/modm/math/lu_decomposition_impl.hpp
@@ -9,14 +9,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
-// ----------------------------------------------------------------------------
+#pragma once
+#include "lu_decomposition.hpp"
-#ifndef MODM_LU_DECOMPOSITION_HPP
- #error "Don't include this file directly, use 'lu_decomposition.hpp' instead!"
-#endif
+#include <algorithm>
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE>
+template<typename T, std::size_t SIZE>
bool
modm::LUDecomposition::decompose(
const modm::Matrix<T, SIZE, SIZE> &matrix,
@@ -29,8 +27,7 @@ modm::LUDecomposition::decompose(
return LUSubDecomposition<T, 0, SIZE, SIZE>::decomposeRecur(u->ptr(), l->ptr());
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE>
+template<typename T, std::size_t SIZE>
bool
modm::LUDecomposition::decompose(
const modm::Matrix<T, SIZE, SIZE> &matrix,
@@ -38,16 +35,15 @@ modm::LUDecomposition::decompose(
modm::Matrix<T, SIZE, SIZE> *u,
modm::Vector<int8_t, SIZE> *p)
{
- for (uint_fast8_t i = 0; i < SIZE; ++i) {
+ for (uint_fast8_t i = 0; i < SIZE; ++i)
(*p)[i] = i;
- }
*u = matrix;
*l = modm::Matrix<T, SIZE, SIZE>::identityMatrix();
- return LUSubDecomposition<T, 0, SIZE, SIZE>::decomposeRecur(u->ptr(), l->ptr(), p->ptr());
+ return LUSubDecomposition<T, 0, SIZE, SIZE>::decomposeRecur(u->ptr(), l->ptr(), p->data());
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE>
+
+template<typename T, std::size_t SIZE>
bool
modm::LUDecomposition::decompose(
const modm::Matrix<T, SIZE, SIZE> &matrix,
@@ -56,16 +52,18 @@ modm::LUDecomposition::decompose(
modm::Matrix<T, SIZE, SIZE> *p)
{
modm::Vector<int8_t, SIZE> pv;
- if (not(decompose(matrix, l, u, &pv))){
- return false;}
+
+ if (not(decompose(matrix, l, u, &pv)))
+ return false;
+
*p = modm::Matrix<T, SIZE, SIZE>::zeroMatrix();
- for (int i=0; i<SIZE; i++){
- (*p)[i][pv[i]] = 1;}
+ for (std::size_t i=0; i<SIZE; i++)
+ (*p)[i][pv[i]] = 1;
+
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE, uint8_t BXWIDTH>
+template<typename T, std::size_t SIZE, std::size_t BXWIDTH>
bool
modm::LUDecomposition::solve(
const modm::Matrix<T, SIZE, SIZE> &l,
@@ -75,8 +73,7 @@ modm::LUDecomposition::solve(
return LUSubDecomposition<T, 0, SIZE, SIZE>::solve(l, u, xb);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE, uint8_t BXWIDTH>
+template<typename T, std::size_t SIZE, std::size_t BXWIDTH>
bool
modm::LUDecomposition::solve(
const modm::Matrix<T, SIZE, SIZE> &A,
@@ -85,12 +82,14 @@ modm::LUDecomposition::solve(
modm::Matrix<T, SIZE, SIZE> l;
modm::Matrix<T, SIZE, SIZE> u;
modm::Matrix<T, SIZE, SIZE> p;
- if(not(decompose(A, &l, &u, &p))){
+
+ if(not(decompose(A, &l, &u, &p)))
return false;
- }
+
*xb = (p * (*xb));
- if(not(solve(l, u, xb))){
- return false;}
+ if(not(solve(l, u, xb)))
+ return false;
+
return true;
}
@@ -98,71 +97,60 @@ modm::LUDecomposition::solve(
// PRIVATE CLASS modm::LUDecomposition::RowOperation
//=============================================================================
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE>
+template<typename T, std::size_t SIZE>
void
modm::LUDecomposition::RowOperation<T, SIZE>::multiply(T *intoRow, const T *row, const T &factor)
{
- for (uint_fast8_t i = 0; i < SIZE; ++i) {
+ for (uint_fast8_t i = 0; i < SIZE; ++i)
intoRow[i] = row[i] * factor;
- }
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE>
+template<typename T, std::size_t SIZE>
void
modm::LUDecomposition::RowOperation<T, SIZE>::addRowTimesFactor(T *intoRow, const T *srcRow, const T *addRow, const T ×Factor)
{
- for (uint_fast8_t i = 0; i < SIZE; ++i) {
+ for (uint_fast8_t i = 0; i < SIZE; ++i)
intoRow[i] = srcRow[i] + addRow[i] * timesFactor;
- }
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t SIZE>
+template<typename T, std::size_t SIZE>
void
modm::LUDecomposition::RowOperation<T, SIZE>::swap(T *row1, T *row2)
{
- T tmp[SIZE];
+ // TODO prefer std::swap
- memcpy(tmp, row1, SIZE*sizeof(T));
- memcpy(row1, row2, SIZE*sizeof(T));
- memcpy(row2, tmp, SIZE*sizeof(T));
+ T tmp[SIZE];
+ std::copy(row1, row1 + SIZE, tmp);
+ std::copy(row2, row2 + SIZE, row1);
+ std::copy(tmp, tmp + SIZE, row2);
}
//=============================================================================
// PRIVATE CLASS modm::LUDecomposition::RowOperation<T, 0>
//=============================================================================
-// ----------------------------------------------------------------------------
template<typename T>
void
modm::LUDecomposition::RowOperation<T, 0>::multiply(
T * /* intoRow */, const T * /* row */, const T & /* factor */)
-{
-}
+{}
-// ----------------------------------------------------------------------------
template<typename T>
void
modm::LUDecomposition::RowOperation<T, 0>::addRowTimesFactor(
T * /* intoRow */, const T * /* srcRow */, const T * /* addRow */, const T & /* timesFactor */)
-{
-}
+{}
-// ----------------------------------------------------------------------------
template<typename T>
void
modm::LUDecomposition::RowOperation<T, 0>::swap(T * /* row1 */, T * /* row2 */)
-{
-}
+{}
//=============================================================================
// PRIVATE CLASS modm::LUDecomposition::LUSubDecomposition
//=============================================================================
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decomposeRecur(T * u, T * l)
{
@@ -172,34 +160,29 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decomposeRe
return LUSubDecomposition<T, OFFSET+1, HEIGHT, WIDTH>::decomposeRecur(u, l);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decompose(T * u, T * l)
{
- const uint8_t width = WIDTH;
- const uint8_t height = HEIGHT;
-
// normalize the row
- T factor = u[OFFSET*width + OFFSET];
- l[OFFSET*width + OFFSET] = factor;
+ T factor = u[OFFSET*WIDTH + OFFSET];
+ l[OFFSET*WIDTH + OFFSET] = factor;
- u[OFFSET*width + OFFSET] = 1;
- RowOperation<T, WIDTH-OFFSET-1>::multiply(&u[OFFSET*width + OFFSET+1], &u[OFFSET*width + OFFSET+1], T(1.0)/factor);
+ u[OFFSET*WIDTH + OFFSET] = 1;
+ RowOperation<T, WIDTH-OFFSET-1>::multiply(&u[OFFSET*WIDTH + OFFSET+1], &u[OFFSET*WIDTH + OFFSET+1], T(1.0)/factor);
- for (uint_fast8_t j = OFFSET+1; j < height; ++j)
+ for (uint_fast8_t j = OFFSET+1; j < HEIGHT; ++j)
{
- factor = u[j*width + OFFSET];
- l[j*width + OFFSET] = factor;
- u[j*width + OFFSET] = 0;
- RowOperation<T, WIDTH-OFFSET-1>::addRowTimesFactor(&u[j*width + OFFSET+1], &u[j*width + OFFSET+1], &u[OFFSET*width + OFFSET+1], -factor);
+ factor = u[j*WIDTH + OFFSET];
+ l[j*WIDTH + OFFSET] = factor;
+ u[j*WIDTH + OFFSET] = 0;
+ RowOperation<T, WIDTH-OFFSET-1>::addRowTimesFactor(&u[j*WIDTH + OFFSET+1], &u[j*WIDTH + OFFSET+1], &u[OFFSET*WIDTH + OFFSET+1], -factor);
}
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decomposeRecur(T *u, T *l, int8_t *p)
{
@@ -209,21 +192,17 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decomposeRe
return LUSubDecomposition<T, OFFSET+1, HEIGHT, WIDTH>::decomposeRecur(u, l, p);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decompose(T *u, T *l, int8_t *p)
{
- const uint8_t width = WIDTH;
- const uint8_t height = HEIGHT;
-
// swap with a lower row so that we have the highest value factor
// FIXME: we need to use something other than fabs here
- T max = fabs(u[OFFSET*width + OFFSET]);
- uint8_t maxRow = OFFSET;
- for (uint_fast8_t j = OFFSET+1; j < height; ++j)
+ T max = fabs(u[OFFSET*WIDTH + OFFSET]);
+ std::size_t maxRow = OFFSET;
+ for (uint_fast8_t j = OFFSET+1; j < HEIGHT; ++j)
{
- T v = fabs(u[j*width + OFFSET]);
+ T v = fabs(u[j*WIDTH + OFFSET]);
if (v > max)
{
max = v;
@@ -236,16 +215,15 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::decompose(T
uint16_t temp = p[OFFSET];
p[OFFSET] = p[maxRow];
p[maxRow] = temp;
- RowOperation<T, WIDTH-OFFSET>::swap(&u[maxRow*width+OFFSET], &u[OFFSET*width+OFFSET]);
- RowOperation<T, OFFSET>::swap(&l[maxRow*width], &l[OFFSET*width]);
+ RowOperation<T, WIDTH-OFFSET>::swap(&u[maxRow*WIDTH+OFFSET], &u[OFFSET*WIDTH+OFFSET]);
+ RowOperation<T, OFFSET>::swap(&l[maxRow*WIDTH], &l[OFFSET*WIDTH]);
}
return decompose(u, l);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH> template<uint8_t BXWIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH> template<std::size_t BXWIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solveLyEqualsB(
modm::Matrix<T, HEIGHT, WIDTH> *l,
@@ -255,9 +233,8 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solveLyEqua
RowOperation<T, BXWIDTH>::multiply((*bx)[OFFSET], (*bx)[OFFSET], 1.0/factor);
// make sure there is a row under us
- if (OFFSET >= HEIGHT-1) {
+ if (OFFSET >= HEIGHT-1)
return true;
- }
// substract the row so that all lower rows have a 0 at OFFSET
for (uint_fast8_t j = OFFSET+1; j < HEIGHT; ++j)
@@ -272,23 +249,21 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solveLyEqua
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH> template<uint8_t BXWIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH> template<std::size_t BXWIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solveUxEqualsY(
modm::Matrix<T, HEIGHT, WIDTH> *u,
modm::Matrix<T, HEIGHT, BXWIDTH> *bx)
{
// make sure there is a row under us
- if (OFFSET >= HEIGHT-1) {
+ if (OFFSET >= HEIGHT-1)
return true;
- }
// solve the problem for SIZE-1
LUSubDecomposition<T, OFFSET+1, HEIGHT, WIDTH>::solveUxEqualsY(u, bx);
// substract the row so that all upper rows have a 0 at OFFSET
- for (uint8_t j = 0; j < OFFSET+1; ++j)
+ for (std::size_t j = 0; j < OFFSET+1; ++j)
{
T factor = (*u)[j][OFFSET+1];
RowOperation<T, BXWIDTH>::addRowTimesFactor((*bx)[j], (*bx)[j], (*bx)[OFFSET+1], -factor);
@@ -298,8 +273,7 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solveUxEqua
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t HEIGHT, uint8_t WIDTH> template<uint8_t BXWIDTH>
+template<typename T, std::size_t OFFSET, std::size_t HEIGHT, std::size_t WIDTH> template<std::size_t BXWIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solve(
const modm::Matrix<T, HEIGHT, WIDTH> &l,
@@ -316,36 +290,31 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, HEIGHT, WIDTH>::solve(
// start solving Ly = b
modm::Matrix<T, HEIGHT, WIDTH> lCopy(l);
- if (!solveLyEqualsB(&lCopy, bx)) {
+ if (!solveLyEqualsB(&lCopy, bx))
return false;
- }
modm::Matrix<T, HEIGHT, WIDTH> uCopy(u);
- if (!solveUxEqualsY(&uCopy, bx)) {
+ if (!solveUxEqualsY(&uCopy, bx))
return false;
- }
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t WIDTH>
+template<typename T, std::size_t OFFSET, std::size_t WIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, WIDTH, OFFSET>::decomposeRecur(T * /* u */, T * /* l */, int8_t * /* p */)
{
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t WIDTH>
+template<typename T, std::size_t OFFSET, std::size_t WIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, WIDTH, OFFSET>::decomposeRecur(T * /* u */, T * /* l */)
{
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t WIDTH> template<uint8_t BXWIDTH>
+template<typename T, std::size_t OFFSET, std::size_t WIDTH> template<std::size_t BXWIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, WIDTH, OFFSET>::solveUxEqualsY(
modm::Matrix<T, WIDTH, OFFSET> * /* u */,
@@ -354,8 +323,7 @@ modm::LUDecomposition::LUSubDecomposition<T, OFFSET, WIDTH, OFFSET>::solveUxEqua
return true;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t OFFSET, uint8_t WIDTH> template<uint8_t BXWIDTH>
+template<typename T, std::size_t OFFSET, std::size_t WIDTH> template<std::size_t BXWIDTH>
bool
modm::LUDecomposition::LUSubDecomposition<T, OFFSET, WIDTH, OFFSET>::solveLyEqualsB(
modm::Matrix<T, WIDTH, OFFSET> * /* l */,
diff --git a/src/modm/math/matrix.hpp b/src/modm/math/matrix.hpp
index 18686840b8..bc922bc482 100644
--- a/src/modm/math/matrix.hpp
+++ b/src/modm/math/matrix.hpp
@@ -11,11 +11,11 @@
*/
// ----------------------------------------------------------------------------
-#ifndef MODM_MATRIX_HPP
-#define MODM_MATRIX_HPP
+#pragma once
#include <cmath>
-#include <string.h> // for memset() and memcmp()
+#include <span>
+#include <algorithm>
#include <stdint.h>
#include <modm/io/iostream.hpp>
@@ -31,7 +31,7 @@ namespace modm
* Having the width and height as template parameters has several
* advantages over the tradition dynamic matrix class:
*
- * - The compiler knows how many elements you have in your matrix and can
+ * - The compiler knows how many ElementCount you have in your matrix and can
* unroll and optimize loops
* - You can ensure that you are not doing operations on matrices with
* incompatible sizes (multiplication for example). The compiler will
@@ -50,33 +50,40 @@ namespace modm
* \author Niklas Hauser
* \author Fabian Greif
*/
- template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+ template<typename T, std::size_t ROWS, std::size_t COLUMNS>
class Matrix
{
public:
+ static constexpr std::size_t RowCount = ROWS;
+ static constexpr std::size_t ColumnCount = COLUMNS;
+ static constexpr std::size_t ElementCount = RowCount * ColumnCount;
+
+ T element[ElementCount]{};
+
/**
* \brief Default Constructor
*
- * Creates a Matrix with uninitialized elements. Use zeroMatrix() to
- * create a matrix with all elements set to zero.
+ * Creates a Matrix with uninitialized ElementCount. Use zeroMatrix() to
+ * create a matrix with all ElementCount set to zero.
*/
- Matrix();
+ constexpr Matrix() = default;
/**
* \brief Create a matrix from an array
*
* Example:
* \code
- * const int16_t m[6] = {
+ *
+ * modm::Matrix<int16_t, 3, 2> a({
* 1, 2,
* 3, 4,
* 5, 6,
- * };
- *
- * modm::Matrix<int16_t, 3, 2> a(m);
+ * });
* \endcode
*/
- Matrix(const T *data);
+ constexpr Matrix(std::span<const T, ElementCount> data) {
+ std::ranges::copy(data, element);
+ }
/**
* \brief Get a zero matrix
@@ -100,52 +107,51 @@ namespace modm
* \brief Create a new sub matrix
*
*/
- template <uint8_t MR, uint8_t MC>
+ template <std::size_t MR, std::size_t MC>
Matrix<T, MR, MC>
- subMatrix(uint8_t row, uint8_t column) const;
-
- bool operator == (const Matrix &m) const;
- bool operator != (const Matrix &m) const;
-
- const T*
- operator [] (uint8_t row) const;
+ subMatrix(std::size_t row, std::size_t column) const;
- T*
- operator [] (uint8_t row);
+ T* operator [] (std::size_t row);
+ const T* operator [] (std::size_t row) const;
- inline uint8_t
- getNumberOfRows() const;
+ std::size_t getNumberOfRows() const
+ { return RowCount; }
- inline uint8_t
- getNumberOfColumns() const;
+ std::size_t getNumberOfColumns() const
+ { return ColumnCount; }
Matrix<T, 1, COLUMNS>
- getRow(uint8_t index) const;
+ getRow(std::size_t index) const;
Matrix<T, ROWS, 1>
- getColumn(uint8_t index) const;
+ getColumn(std::size_t index) const;
- // TODO remove these?
- const T* ptr() const;
- T* ptr();
+ [[deprecated("Access public member directly")]]
+ T* ptr() { return element; }
- Matrix operator - ();
- Matrix operator + (const Matrix &rhs) const;
- Matrix operator - (const Matrix &rhs) const;
- Matrix operator * (const T &rhs) const; ///< Scalar multiplication
- Matrix operator / (const T &rhs) const; ///< Scalar division
+ [[deprecated("Access public member directly")]]
+ const T* ptr() const { return element;}
- Matrix& operator += (const Matrix &rhs);
- Matrix& operator -= (const Matrix &rhs);
- Matrix& operator *= (const T &rhs); ///< Scalar multiplication
- Matrix& operator /= (const T &rhs); ///< Scalar division
+ bool operator== (const Matrix &m) const
+ { return std::equal(element, element + ElementCount, m.element); };
+
+ constexpr Matrix operator- ();
+ constexpr Matrix operator+ (const Matrix &rhs) const;
+ constexpr Matrix operator- (const Matrix &rhs) const;
+ constexpr Matrix operator* (T rhs) const; ///< Scalar multiplication
+ constexpr Matrix operator/ (T rhs) const; ///< Scalar division
+
+ Matrix& operator+= (const Matrix &rhs);
+ Matrix& operator-= (const Matrix &rhs);
+ Matrix& operator*= (T rhs); ///< Scalar multiplication
+ Matrix& operator/= (T rhs); ///< Scalar division
/// Matrix multiplication with matrices with the same size
- Matrix operator *= (const Matrix &rhs);
+ Matrix operator*= (const Matrix &rhs);
/// Matrix multiplication with different size matrices
- template<uint8_t RHSCOL>
- Matrix<T, ROWS, RHSCOL>
+ template<std::size_t RHSCOL>
+ constexpr Matrix<T, ROWS, RHSCOL>
operator * (const Matrix<T, COLUMNS, RHSCOL> &rhs) const;
Matrix<T, COLUMNS, ROWS>
@@ -156,7 +162,7 @@ namespace modm
*
* \warning Will only work if the matrix is square!
*/
- inline void
+ void
transpose();
/**
@@ -164,7 +170,7 @@ namespace modm
*
* Uses modm::determinant(*this);
*/
- inline T
+ T
determinant() const;
// TODO Implement these
@@ -183,62 +189,51 @@ namespace modm
replace(const U *data);
///
- template<uint8_t MW, uint8_t MH>
+ template<std::size_t MW, std::size_t MH>
Matrix&
- replace(uint8_t row, uint8_t column, const Matrix<T, MW, MH> &m);
+ replace(std::size_t row, std::size_t column, const Matrix<T, MW, MH> &m);
Matrix&
- replaceRow(uint8_t index, const Matrix<T, 1, COLUMNS> &m);
+ replaceRow(std::size_t index, const Matrix<T, 1, COLUMNS> &m);
Matrix&
- replaceColumn(uint8_t index, const Matrix<T, ROWS, 1> &m);
+ replaceColumn(std::size_t index, const Matrix<T, ROWS, 1> &m);
Matrix<T, ROWS, COLUMNS+1>
- addColumn(uint8_t index, const Matrix<T, ROWS, 1> &c) const;
+ addColumn(std::size_t index, const Matrix<T, ROWS, 1> &c) const;
Matrix<T, ROWS+1, COLUMNS>
- addRow(uint8_t index, const Matrix<T, 1, COLUMNS> &r) const;
+ addRow(std::size_t index, const Matrix<T, 1, COLUMNS> &r) const;
Matrix<T, ROWS, COLUMNS-1>
- removeColumn(uint8_t index) const;
+ removeColumn(std::size_t index) const;
Matrix<T, ROWS-1, COLUMNS>
- removeRow(uint8_t index) const;
-
- public:
- T element[ROWS * COLUMNS];
+ removeRow(std::size_t index) const;
private:
- /// Size of the Matrix in Bytes
- inline size_t
- getSize() const;
-
- /// Number of elements in the Matrix (rows * columns)
- inline uint8_t
- getNumberOfElements() const;
+ std::size_t getSize() const
+ { return ElementCount * sizeof(T); }
};
- template<typename T, uint8_t WIDTH, uint8_t HEIGHT>
+ template<typename T, std::size_t WIDTH, std::size_t HEIGHT>
IOStream&
operator << (IOStream&, const Matrix<T, WIDTH, HEIGHT>&);
- typedef Matrix<float, 1, 1> Matrix1f;
- typedef Matrix<float, 2, 2> Matrix2f;
- typedef Matrix<float, 3, 3> Matrix3f;
- typedef Matrix<float, 4, 4> Matrix4f;
+ using Matrix1f = Matrix<float, 1, 1>;
+ using Matrix2f = Matrix<float, 2, 2>;
+ using Matrix3f = Matrix<float, 3, 3>;
+ using Matrix4f = Matrix<float, 4, 4>;
// ------------------------------------------------------------------------
/// @cond
template<typename T>
- T
- determinant(const modm::Matrix<T, 1, 1> &m);
+ T determinant(const modm::Matrix<T, 1, 1> &m);
template<typename T>
- T
- determinant(const modm::Matrix<T, 2, 2> &m);
- /// @endcond
+ T determinant(const modm::Matrix<T, 2, 2> &m);
/**
* \brief Calculate the determinant
@@ -246,12 +241,8 @@ namespace modm
* \param m Matrix
* \ingroup modm_math_matrix
*/
- template<typename T, uint8_t N>
- T
- determinant(const modm::Matrix<T, N, N> &m);
- /// @}
+ template<typename T, std::size_t N>
+ T determinant(const modm::Matrix<T, N, N> &m);
}
-#include "matrix_impl.hpp"
-
-#endif // MODM_MATRIX_HPP
+#include "matrix_impl.hpp"
\ No newline at end of file
diff --git a/src/modm/math/matrix_impl.hpp b/src/modm/math/matrix_impl.hpp
index ebb25d4af3..d707a955fa 100644
--- a/src/modm/math/matrix_impl.hpp
+++ b/src/modm/math/matrix_impl.hpp
@@ -9,29 +9,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
-// ----------------------------------------------------------------------------
-
-#ifndef MODM_MATRIX_HPP
-# error "Don't include this file directly, use 'matrix.hpp' instead!"
-#endif
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::Matrix()
-{
-}
+#pragma once
+#include "matrix.hpp"
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::Matrix(const T *data)
-{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- element[i] = data[i];
- }
-}
+#include <algorithm>
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
const modm::Matrix<T, ROWS, COLUMNS>&
modm::Matrix<T, ROWS, COLUMNS>::identityMatrix()
{
@@ -41,17 +24,11 @@ modm::Matrix<T, ROWS, COLUMNS>::identityMatrix()
if (!hasIdentityMatrix)
{
if (ROWS < COLUMNS)
- {
- for (uint_fast8_t i = 0; i < ROWS; ++i) {
+ for (std::size_t i = 0; i < ROWS; ++i)
matrix[i][i] = 1;
- }
- }
else
- {
- for (uint_fast8_t i = 0; i < COLUMNS; ++i) {
+ for (std::size_t i = 0; i < COLUMNS; ++i)
matrix[i][i] = 1;
- }
- }
hasIdentityMatrix = true;
}
@@ -60,7 +37,7 @@ modm::Matrix<T, ROWS, COLUMNS>::identityMatrix()
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
const modm::Matrix<T, ROWS, COLUMNS>&
modm::Matrix<T, ROWS, COLUMNS>::zeroMatrix()
{
@@ -69,7 +46,7 @@ modm::Matrix<T, ROWS, COLUMNS>::zeroMatrix()
if (!hasZeroMatrix)
{
- memset(matrix.ptr(), 0, matrix.getSize());
+ std::fill(matrix.element, matrix.element + ElementCount, 0);
hasZeroMatrix = true;
}
@@ -77,252 +54,181 @@ modm::Matrix<T, ROWS, COLUMNS>::zeroMatrix()
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-bool
-modm::Matrix<T, ROWS, COLUMNS>::operator == (const modm::Matrix<T, ROWS, COLUMNS> &m) const
-{
- return memcmp(element, m.element, getSize()) == 0;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-bool
-modm::Matrix<T, ROWS, COLUMNS>::operator != (const modm::Matrix<T, ROWS, COLUMNS> &m) const
-{
- return memcmp(element, m.element, getSize()) != 0;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, 1, COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::getRow(uint8_t index) const
+modm::Matrix<T, ROWS, COLUMNS>::getRow(std::size_t index) const
{
return subMatrix<1, COLUMNS>(index, 0);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, 1>
-modm::Matrix<T, ROWS, COLUMNS>::getColumn(uint8_t index) const
+modm::Matrix<T, ROWS, COLUMNS>::getColumn(std::size_t index) const
{
return subMatrix<ROWS, 1>(0, index);
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
T*
-modm::Matrix<T, ROWS, COLUMNS>::operator [] (uint8_t row)
+modm::Matrix<T, ROWS, COLUMNS>::operator [] (std::size_t row)
{
return &element[row * COLUMNS];
}
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
const T*
-modm::Matrix<T, ROWS, COLUMNS>::operator [] (uint8_t row) const
+modm::Matrix<T, ROWS, COLUMNS>::operator [] (std::size_t row) const
{
return &element[row * COLUMNS];
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-uint8_t
-modm::Matrix<T, ROWS, COLUMNS>::getNumberOfRows() const
-{
- return ROWS;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-uint8_t
-modm::Matrix<T, ROWS, COLUMNS>::getNumberOfColumns() const
-{
- return COLUMNS;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-const T*
-modm::Matrix<T, ROWS, COLUMNS>::ptr() const
-{
- return element;
-}
-
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-T*
-modm::Matrix<T, ROWS, COLUMNS>::ptr()
-{
- return element;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+constexpr modm::Matrix<T, ROWS, COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>::operator - ()
{
modm::Matrix<T, ROWS, COLUMNS> m;
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- m.element[i] = -this->element[i];
- }
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ m.element[i] = -element[i];
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+constexpr modm::Matrix<T, ROWS, COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>::operator - (const modm::Matrix<T, ROWS, COLUMNS> &rhs) const
{
modm::Matrix<T, ROWS, COLUMNS> m;
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
+ for (std::size_t i = 0; i < ElementCount; ++i)
m.element[i] = element[i] - rhs.element[i];
- }
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+constexpr modm::Matrix<T, ROWS, COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>::operator + (const modm::Matrix<T, ROWS, COLUMNS> &rhs) const
{
modm::Matrix<T, ROWS, COLUMNS> m;
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
+ for (std::size_t i = 0; i < ElementCount; ++i)
m.element[i] = element[i] + rhs.element[i];
- }
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::operator += (const modm::Matrix<T, ROWS, COLUMNS> &rhs)
-{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- element[i] += rhs.element[i];
- }
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::operator -= (const modm::Matrix<T, ROWS, COLUMNS> &rhs)
-{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- element[i] -= rhs.element[i];
- }
-
- return *this;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-template<uint8_t RHSCOL>
-modm::Matrix<T, ROWS, RHSCOL>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+template<std::size_t RHSCOL>
+constexpr modm::Matrix<T, ROWS, RHSCOL>
modm::Matrix<T, ROWS, COLUMNS>::operator * (const Matrix<T, COLUMNS, RHSCOL> &rhs) const
{
modm::Matrix<T, ROWS, RHSCOL> m;
- for (uint_fast8_t i = 0; i < ROWS; ++i)
+ for (std::size_t i = 0; i < ROWS; ++i)
{
- for (uint_fast8_t j = 0; j < RHSCOL; ++j)
+ for (std::size_t j = 0; j < RHSCOL; ++j)
{
m[i][j] = element[i * COLUMNS] * rhs[0][j];
- for (uint_fast8_t x = 1; x < COLUMNS; ++x)
- {
+ for (std::size_t x = 1; x < COLUMNS; ++x)
m[i][j] += element[i * COLUMNS + x] * rhs[x][j];
- }
}
}
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::operator *= (const modm::Matrix<T, ROWS, COLUMNS> &rhs)
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+constexpr modm::Matrix<T, ROWS, COLUMNS>
+modm::Matrix<T, ROWS, COLUMNS>::operator * (T rhs) const
{
- (*this) = (*this) * rhs;
- return *this;
+ modm::Matrix<T, ROWS, COLUMNS> m;
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ m.element[i] = element[i] * rhs;
+
+ return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::operator * (const T &rhs) const
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+constexpr modm::Matrix<T, ROWS, COLUMNS>
+modm::Matrix<T, ROWS, COLUMNS>::operator / (T rhs) const
{
modm::Matrix<T, ROWS, COLUMNS> m;
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- m.element[i] = element[i] * rhs;
- }
+
+ float oneOverRhs = 1.0f / rhs;
+
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ m.element[i] = element[i] * oneOverRhs;
return m;
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+modm::Matrix<T, ROWS, COLUMNS>&
+modm::Matrix<T, ROWS, COLUMNS>::operator += (const modm::Matrix<T, ROWS, COLUMNS> &rhs)
+{
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ element[i] += rhs.element[i];
+
+ return *this;
+}
+
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::operator *= (const T &rhs)
+modm::Matrix<T, ROWS, COLUMNS>::operator -= (const modm::Matrix<T, ROWS, COLUMNS> &rhs)
{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- element[i] *= rhs;
- }
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ element[i] -= rhs.element[i];
return *this;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::operator / (const T &rhs) const
+modm::Matrix<T, ROWS, COLUMNS>::operator *= (const modm::Matrix<T, ROWS, COLUMNS> &rhs)
{
- modm::Matrix<T, ROWS, COLUMNS> m;
-
- float oneOverRhs = 1.0f / rhs;
+ (*this) = (*this) * rhs;
+ return *this;
+}
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- m.element[i] = element[i] * oneOverRhs;
- }
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+modm::Matrix<T, ROWS, COLUMNS>&
+modm::Matrix<T, ROWS, COLUMNS>::operator *= (T rhs)
+{
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ element[i] *= rhs;
- return m;
+ return *this;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::operator /= (const T &rhs)
+modm::Matrix<T, ROWS, COLUMNS>::operator /= (T rhs)
{
float oneOverRhs = 1.0f / rhs;
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
+ for (std::size_t i = 0; i < ElementCount; ++i)
element[i] *= oneOverRhs;
- }
return *this;
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, COLUMNS, ROWS>
modm::Matrix<T, ROWS, COLUMNS>::asTransposed() const
{
modm::Matrix<T, COLUMNS, ROWS> m;
- for (uint_fast8_t i = 0; i < ROWS; ++i) {
- for (uint_fast8_t j = 0; j < COLUMNS; ++j) {
+ for (std::size_t i = 0; i < ROWS; ++i)
+ for (std::size_t j = 0; j < COLUMNS; ++j)
m.element[j * ROWS + i] = element[i * COLUMNS + j];
- }
- }
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
void
modm::Matrix<T, ROWS, COLUMNS>::transpose()
{
@@ -332,7 +238,7 @@ modm::Matrix<T, ROWS, COLUMNS>::transpose()
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
inline T
modm::Matrix<T, ROWS, COLUMNS>::determinant() const
{
@@ -342,43 +248,37 @@ modm::Matrix<T, ROWS, COLUMNS>::determinant() const
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
bool
modm::Matrix<T, ROWS, COLUMNS>::hasNan() const
{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- if (isnan(element[i])) {
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ if (isnan(element[i]))
return true;
- }
- }
return false;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
bool
modm::Matrix<T, ROWS, COLUMNS>::hasInf() const
{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
- if (isinf(element[i])) {
+ for (std::size_t i = 0; i < ElementCount; ++i)
+ if (isinf(element[i]))
return true;
- }
- }
return false;
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t WIDTH, uint8_t HEIGHT>
+template<typename T, std::size_t WIDTH, std::size_t HEIGHT>
modm::Matrix<T, WIDTH, HEIGHT>
operator * (int8_t lhs, const modm::Matrix<T, WIDTH, HEIGHT> &m)
{
return m * lhs;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t WIDTH, uint8_t HEIGHT>
+template<typename T, std::size_t WIDTH, std::size_t HEIGHT>
modm::Matrix<T, WIDTH, HEIGHT>
operator * (float lhs, const modm::Matrix<T, WIDTH, HEIGHT> &m)
{
@@ -386,15 +286,14 @@ operator * (float lhs, const modm::Matrix<T, WIDTH, HEIGHT> &m)
}
// ----------------------------------------------------------------------------
-/*template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+/*template<typename T, std::size_t ROWS, std::size_t COLUMNS>
void
modm::Matrix<T, ROWS, COLUMNS>::inverse()
{
*this = inversed();
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>::inversed() const
{
@@ -404,210 +303,169 @@ modm::Matrix<T, ROWS, COLUMNS>::inversed() const
}*/
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-size_t
-modm::Matrix<T, ROWS, COLUMNS>::getSize() const
-{
- return getNumberOfElements() * sizeof(T);
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-uint8_t
-modm::Matrix<T, ROWS, COLUMNS>::getNumberOfElements() const
-{
- return ROWS * COLUMNS;
-}
-
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-template <uint8_t MR, uint8_t MC>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+template <std::size_t MR, std::size_t MC>
modm::Matrix<T, MR, MC>
-modm::Matrix<T, ROWS, COLUMNS>::subMatrix(uint8_t row, uint8_t column) const
+modm::Matrix<T, ROWS, COLUMNS>::subMatrix(std::size_t row, std::size_t column) const
{
static_assert(MR <= ROWS, "sub matrix must be smaller than the original");
static_assert(MC <= COLUMNS, "sub matrix must be smaller than the original");
Matrix<T, MR, MC> sub;
- for (uint_fast8_t i = 0; i < MR; ++i) {
- for (uint_fast8_t j = 0; j < MC; ++j) {
+ for (std::size_t i = 0; i < MR; ++i)
+ for (std::size_t j = 0; j < MC; ++j)
sub[i][j] = (*this)[i + row][j + column];
- }
- }
return sub;
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS> template<typename U>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS> template<typename U>
modm::Matrix<T, ROWS, COLUMNS>&
modm::Matrix<T, ROWS, COLUMNS>::replace(const U *data)
{
- for (uint_fast8_t i = 0; i < getNumberOfElements(); ++i) {
+ for (std::size_t i = 0; i < ElementCount; ++i)
element[i] = data[i];
- }
return *this;
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
-template <uint8_t MR, uint8_t MC>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
+template <std::size_t MR, std::size_t MC>
modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::replace(uint8_t row, uint8_t column, const modm::Matrix<T, MR, MC> &m)
+modm::Matrix<T, ROWS, COLUMNS>::replace(std::size_t row, std::size_t column, const modm::Matrix<T, MR, MC> &m)
{
static_assert(MR <= ROWS, "replacement matrix can't be larger than the original");
static_assert(MC <= COLUMNS, "replacement matrix can't be larger than the original");
- for (uint_fast8_t i = 0; i < MR && (i + row) < ROWS; ++i)
- {
- for (uint_fast8_t j = 0; j < MC && (j + column) < COLUMNS; ++j)
- {
+ for (std::size_t i = 0; i < MR && (i + row) < ROWS; ++i)
+ for (std::size_t j = 0; j < MC && (j + column) < COLUMNS; ++j)
element[(i + row) * COLUMNS + (j + column)] = m[i][j];
- }
- }
return *this;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::replaceRow(uint8_t index, const modm::Matrix<T, 1, COLUMNS> &m)
+modm::Matrix<T, ROWS, COLUMNS>::replaceRow(std::size_t index, const modm::Matrix<T, 1, COLUMNS> &m)
{
return replace(index, 0, m);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS>&
-modm::Matrix<T, ROWS, COLUMNS>::replaceColumn(uint8_t index, const modm::Matrix<T, ROWS, 1> &m)
+modm::Matrix<T, ROWS, COLUMNS>::replaceColumn(std::size_t index, const modm::Matrix<T, ROWS, 1> &m)
{
return replace(0, index, m);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS+1, COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::addRow(uint8_t index, const modm::Matrix<T, 1, COLUMNS> &r) const
+modm::Matrix<T, ROWS, COLUMNS>::addRow(std::size_t index, const modm::Matrix<T, 1, COLUMNS> &r) const
{
modm::Matrix<T, ROWS+1, COLUMNS> m;
- uint_fast8_t i = 0, ri = 0;
+ std::size_t i = 0, ri = 0;
- for (; i < index; ++i) {
+ for (; i < index; ++i)
m.replaceRow(ri++, getRow(i));
- }
+
m.replaceRow(ri++, r);
- for (; i < ROWS+1; ++i) {
+
+ for (; i < ROWS+1; ++i)
m.replaceRow(ri++, getRow(i));
- }
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS+1>
-modm::Matrix<T, ROWS, COLUMNS>::addColumn(uint8_t index, const modm::Matrix<T, ROWS, 1> &c) const
+modm::Matrix<T, ROWS, COLUMNS>::addColumn(std::size_t index, const modm::Matrix<T, ROWS, 1> &c) const
{
modm::Matrix<T, ROWS, COLUMNS+1> m;
- uint_fast8_t i = 0, ci = 0;
+ std::size_t i = 0, ci = 0;
- for (; i < index; ++i) {
+ for (; i < index; ++i)
m.replaceColumn(ci++, getColumn(i));
- }
+
m.replaceColumn(ci++, c);
- for (; i < COLUMNS+1; ++i) {
+
+ for (; i < COLUMNS+1; ++i)
m.replaceColumn(ci++, getColumn(i));
- }
return m;
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS-1, COLUMNS>
-modm::Matrix<T, ROWS, COLUMNS>::removeRow(uint8_t index ) const
+modm::Matrix<T, ROWS, COLUMNS>::removeRow(std::size_t index ) const
{
if (index == 0)
- {
return subMatrix<ROWS-1, COLUMNS>(1, 0);
- }
else if (index == (ROWS - 1))
- {
return subMatrix<ROWS-1, COLUMNS>(0, 0);
- }
else
{
Matrix<T, ROWS-1, COLUMNS> m;
- uint_fast8_t i = 0, ri = 0;
+ std::size_t i = 0, ri = 0;
- for (; i < index; ++i) {
+ for (; i < index; ++i)
m.replaceRow(ri++, getRow(i));
- }
+
++i; // skip one row
- for (; i < ROWS; ++i) {
+
+ for (; i < ROWS; ++i)
m.replaceRow(ri++, getRow(i));
- }
return m;
}
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::Matrix<T, ROWS, COLUMNS-1>
-modm::Matrix<T, ROWS, COLUMNS>::removeColumn(uint8_t index) const
+modm::Matrix<T, ROWS, COLUMNS>::removeColumn(std::size_t index) const
{
if (index == 0)
- {
return subMatrix<ROWS, COLUMNS-1>(0, 1);
- }
else if (index == (COLUMNS - 1))
- {
return subMatrix<ROWS, COLUMNS-1>(0, 0);
- }
else
{
Matrix<T, ROWS, COLUMNS-1> m;
- uint_fast8_t i = 0, ci = 0;
+ std::size_t i = 0, ci = 0;
- for (; i < index; ++i) {
+ for (; i < index; ++i)
m.replaceColumn(ci++, getColumn(i));
- }
+
++i; // skip one column
- for (; i < COLUMNS; ++i) {
+
+ for (; i < COLUMNS; ++i)
m.replaceColumn(ci++, getColumn(i));
- }
return m;
}
}
// ----------------------------------------------------------------------------
-template<typename T, uint8_t ROWS, uint8_t COLUMNS>
+template<typename T, std::size_t ROWS, std::size_t COLUMNS>
modm::IOStream&
modm::operator << (modm::IOStream& os, const modm::Matrix<T, ROWS, COLUMNS> &m)
{
os << "{ ";
- for (uint_fast8_t i = 0; i < ROWS; ++i)
+ for (std::size_t i = 0; i < ROWS; ++i)
{
os << "{ ";
- for (uint_fast8_t j = 0; j < COLUMNS; ++j)
+ for (std::size_t j = 0; j < COLUMNS; ++j)
{
os << m.element[i * COLUMNS + j];
if (j < COLUMNS-1)
- {
os << ", ";
- }
}
os << " }";
if (i < ROWS-1)
- {
os << ", \n";
- }
}
os << " }";
return os;
@@ -621,7 +479,6 @@ modm::determinant(const modm::Matrix<T, 1, 1> &m)
return m[0][0];
}
-// ----------------------------------------------------------------------------
template<typename T>
T
modm::determinant(const modm::Matrix<T, 2, 2> &m)
@@ -629,35 +486,29 @@ modm::determinant(const modm::Matrix<T, 2, 2> &m)
return (m[0][0] * m[1][1] - m[0][1] * m[1][0]);
}
-// ----------------------------------------------------------------------------
-template<typename T, uint8_t N>
+template<typename T, std::size_t N>
T
modm::determinant(const modm::Matrix<T, N, N> &m)
{
// not the most efficient way, but should work for now...
T value = 0;
int8_t factor = 1;
- for (uint_fast8_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
T coeff = m[0][i];
modm::Matrix<T, N-1, N-1> subM;
- for (uint_fast8_t x = 0; x < i; ++x) {
- for (uint_fast8_t y = 1; y < N; ++y) {
+ for (std::size_t x = 0; x < i; ++x)
+ for (std::size_t y = 1; y < N; ++y)
subM[y-1][x] = m[y][x];
- }
- }
- for (uint_fast8_t x = i+1; x < N; ++x) {
- for (uint_fast8_t y = 1; y < N; ++y) {
+ for (std::size_t x = i+1; x < N; ++x)
+ for (std::size_t y = 1; y < N; ++y)
subM[y-1][x-1] = m[y][x];
- }
- }
value += coeff * factor * determinant(subM);
factor *= -1;
}
return value;
-}
-
+}
\ No newline at end of file
diff --git a/src/modm/math/utils/integer_traits.hpp b/src/modm/math/utils/integer_traits.hpp
index 4be8caea30..6da134c802 100644
--- a/src/modm/math/utils/integer_traits.hpp
+++ b/src/modm/math/utils/integer_traits.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021, Thomas Sommer
+ * Copyright (c) 2021-2022, Thomas Sommer
*
* This file is part of the modm project.
*
@@ -13,6 +13,8 @@
#include <limits>
#include <type_traits>
+#include <numeric>
+#include <concepts>
#include <cmath>
namespace modm
@@ -66,7 +68,23 @@ struct fits_any {
};
template <typename ... Ts>
-using fits_any_t = typename fits_any<Ts...>::type;
+ using fits_any_t = typename fits_any<Ts...>::type;
+
+/**
+ * @brief Simple function that only applies std::round
+ * when a float/double is assigned to an integral
+ *
+ * @tparam TR Type of return
+ * @tparam TA Type of argument
+
+ */
+template <typename TR, typename TA>
+constexpr TR round_smart(TA v)
+{ return v; }
+
+template <std::integral TR, std::floating_point TA>
+constexpr TR round_smart(TA v)
+{ return std::round(v); }
/// @}
}
diff --git a/test/modm/math/geometry/circle_2d_test.cpp b/test/modm/math/geometry/circle_2d_test.cpp
index 5a85d07c34..71c1552f71 100644
--- a/test/modm/math/geometry/circle_2d_test.cpp
+++ b/test/modm/math/geometry/circle_2d_test.cpp
@@ -59,8 +59,8 @@ Circle2DTest::testIntersectionCircle()
TEST_ASSERT_TRUE(circle1.getIntersections(circle2, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 10);
- TEST_ASSERT_EQUALS(points[0].getY(), 0);
+ TEST_ASSERT_EQUALS(points[0].x(), 10);
+ TEST_ASSERT_EQUALS(points[0].y(), 0);
points.removeAll();
@@ -75,11 +75,11 @@ Circle2DTest::testIntersectionCircle()
TEST_ASSERT_TRUE(circle1.getIntersections(circle2, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 2U);
- TEST_ASSERT_EQUALS(points[0].getX(), 15);
- TEST_ASSERT_EQUALS(points[0].getY(), -26);
+ TEST_ASSERT_EQUALS(points[0].x(), 15);
+ TEST_ASSERT_EQUALS(points[0].y(), -26);
- TEST_ASSERT_EQUALS(points[1].getX(), 15);
- TEST_ASSERT_EQUALS(points[1].getY(), 26);
+ TEST_ASSERT_EQUALS(points[1].x(), 15);
+ TEST_ASSERT_EQUALS(points[1].y(), 26);
points.removeAll();
diff --git a/test/modm/math/geometry/line_2d_test.cpp b/test/modm/math/geometry/line_2d_test.cpp
index 7fa15e81ae..ec3bb4b180 100644
--- a/test/modm/math/geometry/line_2d_test.cpp
+++ b/test/modm/math/geometry/line_2d_test.cpp
@@ -96,8 +96,8 @@ Line2DTest::testIntersectionPointsLine()
TEST_ASSERT_TRUE(line1.getIntersections(line2, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 10);
- TEST_ASSERT_EQUALS(points[0].getY(), 20);
+ TEST_ASSERT_EQUALS(points[0].x(), 10);
+ TEST_ASSERT_EQUALS(points[0].y(), 20);
points.removeAll();
@@ -106,8 +106,8 @@ Line2DTest::testIntersectionPointsLine()
TEST_ASSERT_TRUE(line1.getIntersections(line2, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 10);
- TEST_ASSERT_EQUALS(points[0].getY(), -20);
+ TEST_ASSERT_EQUALS(points[0].x(), 10);
+ TEST_ASSERT_EQUALS(points[0].y(), -20);
}
void
@@ -127,11 +127,11 @@ Line2DTest::testIntersectionPointsCircle()
TEST_ASSERT_TRUE(line.getIntersections(circle, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 2U);
- TEST_ASSERT_EQUALS(points[0].getX(), -14);
- TEST_ASSERT_EQUALS(points[0].getY(), -14);
+ TEST_ASSERT_EQUALS(points[0].x(), -14);
+ TEST_ASSERT_EQUALS(points[0].y(), -14);
- TEST_ASSERT_EQUALS(points[1].getX(), 14);
- TEST_ASSERT_EQUALS(points[1].getY(), 14);
+ TEST_ASSERT_EQUALS(points[1].x(), 14);
+ TEST_ASSERT_EQUALS(points[1].y(), 14);
points.removeAll();
@@ -142,8 +142,8 @@ Line2DTest::testIntersectionPointsCircle()
TEST_ASSERT_TRUE(line.getIntersections(circle, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 20);
- TEST_ASSERT_EQUALS(points[0].getY(), 0);
+ TEST_ASSERT_EQUALS(points[0].x(), 20);
+ TEST_ASSERT_EQUALS(points[0].y(), 0);
points.removeAll();
diff --git a/test/modm/math/geometry/line_segment_2d_test.cpp b/test/modm/math/geometry/line_segment_2d_test.cpp
index 06d8058956..ec5940c8b1 100644
--- a/test/modm/math/geometry/line_segment_2d_test.cpp
+++ b/test/modm/math/geometry/line_segment_2d_test.cpp
@@ -231,8 +231,8 @@ LineSegment2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(line1.getIntersections(line4, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 50);
- TEST_ASSERT_EQUALS(points[0].getY(), 10);
+ TEST_ASSERT_EQUALS(points[0].x(), 50);
+ TEST_ASSERT_EQUALS(points[0].y(), 10);
points.removeAll();
@@ -240,8 +240,8 @@ LineSegment2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(line1.getIntersections(line5, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 40);
- TEST_ASSERT_EQUALS(points[0].getY(), 0);
+ TEST_ASSERT_EQUALS(points[0].x(), 40);
+ TEST_ASSERT_EQUALS(points[0].y(), 0);
points.removeAll();
@@ -253,8 +253,8 @@ LineSegment2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(line2.getIntersections(line4, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 50);
- TEST_ASSERT_EQUALS(points[0].getY(), 17);
+ TEST_ASSERT_EQUALS(points[0].x(), 50);
+ TEST_ASSERT_EQUALS(points[0].y(), 17);
points.removeAll();
@@ -262,8 +262,8 @@ LineSegment2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(line2.getIntersections(line5, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 30);
- TEST_ASSERT_EQUALS(points[0].getY(), 10);
+ TEST_ASSERT_EQUALS(points[0].x(), 30);
+ TEST_ASSERT_EQUALS(points[0].y(), 10);
points.removeAll();
@@ -306,8 +306,8 @@ LineSegment2DTest::testIntersectionPointsCircle()
TEST_ASSERT_TRUE(line.getIntersections(circle, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), -14);
- TEST_ASSERT_EQUALS(points[0].getY(), -14);
+ TEST_ASSERT_EQUALS(points[0].x(), -14);
+ TEST_ASSERT_EQUALS(points[0].y(), -14);
points.removeAll();
@@ -318,8 +318,8 @@ LineSegment2DTest::testIntersectionPointsCircle()
TEST_ASSERT_TRUE(line.getIntersections(circle, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 14);
- TEST_ASSERT_EQUALS(points[0].getY(), 14);
+ TEST_ASSERT_EQUALS(points[0].x(), 14);
+ TEST_ASSERT_EQUALS(points[0].y(), 14);
points.removeAll();
@@ -330,11 +330,11 @@ LineSegment2DTest::testIntersectionPointsCircle()
TEST_ASSERT_TRUE(line.getIntersections(circle, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 2U);
- TEST_ASSERT_EQUALS(points[0].getX(), 14);
- TEST_ASSERT_EQUALS(points[0].getY(), -14);
+ TEST_ASSERT_EQUALS(points[0].x(), 14);
+ TEST_ASSERT_EQUALS(points[0].y(), -14);
- TEST_ASSERT_EQUALS(points[1].getX(), -14);
- TEST_ASSERT_EQUALS(points[1].getY(), 14);
+ TEST_ASSERT_EQUALS(points[1].x(), -14);
+ TEST_ASSERT_EQUALS(points[1].y(), 14);
points.removeAll();
@@ -345,8 +345,8 @@ LineSegment2DTest::testIntersectionPointsCircle()
TEST_ASSERT_TRUE(line.getIntersections(circle, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 20);
- TEST_ASSERT_EQUALS(points[0].getY(), 0);
+ TEST_ASSERT_EQUALS(points[0].x(), 20);
+ TEST_ASSERT_EQUALS(points[0].y(), 0);
points.removeAll();
diff --git a/test/modm/math/geometry/location_2d_test.cpp b/test/modm/math/geometry/location_2d_test.cpp
index b40322855f..5c1dfa1eab 100644
--- a/test/modm/math/geometry/location_2d_test.cpp
+++ b/test/modm/math/geometry/location_2d_test.cpp
@@ -45,7 +45,7 @@ Location2DTest::testAccessors()
TEST_ASSERT_EQUALS(location.getPosition(), modm::Vector2i(30, 40));
- location.setPosition(50, 60);
+ location.setPosition({50, 60});
TEST_ASSERT_EQUALS(location.getPosition(), modm::Vector2i(50, 60));
@@ -61,9 +61,9 @@ Location2DTest::testOperators()
modm::Location2D<int16_t> locationB;
modm::Location2D<int16_t> locationC;
- locationA.setPosition(modm::Vector2i(30, 40));
- locationB.setPosition(modm::Vector2i(30, 40));
- locationC.setPosition(modm::Vector2i(30, 41));
+ locationA.position = modm::Vector2i(30, 40);
+ locationB.position = modm::Vector2i(30, 40);
+ locationC.position = modm::Vector2i(30, 41);
TEST_ASSERT_TRUE(locationA == locationA);
TEST_ASSERT_FALSE(locationA != locationA);
@@ -78,7 +78,13 @@ Location2DTest::testOperators()
TEST_ASSERT_TRUE(locationA != locationC);
TEST_ASSERT_TRUE(locationB != locationC);
- locationA.setOrientation(0.001);
+ locationA.orientation = __FLT_EPSILON__ * 3 / 4;
+ TEST_ASSERT_TRUE(locationA == locationB);
+ TEST_ASSERT_TRUE(locationB == locationA);
+ TEST_ASSERT_FALSE(locationA != locationB);
+ TEST_ASSERT_FALSE(locationB != locationA);
+
+ locationA.orientation = 0.001;
TEST_ASSERT_FALSE(locationA == locationB);
TEST_ASSERT_FALSE(locationB == locationA);
TEST_ASSERT_TRUE(locationA != locationB);
@@ -110,11 +116,9 @@ Location2DTest::testMove()
void
Location2DTest::testConvert()
{
- modm::Location2D<float> a(
- modm::Vector<float, 2>(-10.65, 20.31),
- M_PI);
+ modm::Location2D<float> a({-10.65, 20.31}, M_PI);
- modm::Location2D<int16_t> b = a.convert<int16_t>();
+ modm::Location2D<int16_t> b(a);
TEST_ASSERT_EQUALS(b.getX(), -11);
TEST_ASSERT_EQUALS(b.getY(), 20);
diff --git a/test/modm/math/geometry/polygon_2d_test.cpp b/test/modm/math/geometry/polygon_2d_test.cpp
index a197071247..2675cea9b8 100644
--- a/test/modm/math/geometry/polygon_2d_test.cpp
+++ b/test/modm/math/geometry/polygon_2d_test.cpp
@@ -253,8 +253,8 @@ Polygon2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(polygon.getIntersections(line, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 18);
- TEST_ASSERT_EQUALS(points[0].getY(), -6);
+ TEST_ASSERT_EQUALS(points[0].x(), 18);
+ TEST_ASSERT_EQUALS(points[0].y(), -6);
points.removeAll();
@@ -264,8 +264,8 @@ Polygon2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(polygon.getIntersections(line, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 1U);
- TEST_ASSERT_EQUALS(points[0].getX(), 30);
- TEST_ASSERT_EQUALS(points[0].getY(), -10);
+ TEST_ASSERT_EQUALS(points[0].x(), 30);
+ TEST_ASSERT_EQUALS(points[0].y(), -10);
points.removeAll();
@@ -275,17 +275,17 @@ Polygon2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(polygon.getIntersections(line, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 4U);
- TEST_ASSERT_EQUALS(points[0].getX(), 32);
- TEST_ASSERT_EQUALS(points[0].getY(), 30);
+ TEST_ASSERT_EQUALS(points[0].x(), 32);
+ TEST_ASSERT_EQUALS(points[0].y(), 30);
- TEST_ASSERT_EQUALS(points[1].getX(), 37);
- TEST_ASSERT_EQUALS(points[1].getY(), 11);
+ TEST_ASSERT_EQUALS(points[1].x(), 37);
+ TEST_ASSERT_EQUALS(points[1].y(), 11);
- TEST_ASSERT_EQUALS(points[2].getX(), 42);
- TEST_ASSERT_EQUALS(points[2].getY(), -8);
+ TEST_ASSERT_EQUALS(points[2].x(), 42);
+ TEST_ASSERT_EQUALS(points[2].y(), -8);
- TEST_ASSERT_EQUALS(points[3].getX(), 44);
- TEST_ASSERT_EQUALS(points[3].getY(), -15);
+ TEST_ASSERT_EQUALS(points[3].x(), 44);
+ TEST_ASSERT_EQUALS(points[3].y(), -15);
points.removeAll();
@@ -295,14 +295,14 @@ Polygon2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(polygon.getIntersections(line, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 3U);
- TEST_ASSERT_EQUALS(points[0].getX(), 32);
- TEST_ASSERT_EQUALS(points[0].getY(), 30);
+ TEST_ASSERT_EQUALS(points[0].x(), 32);
+ TEST_ASSERT_EQUALS(points[0].y(), 30);
- TEST_ASSERT_EQUALS(points[1].getX(), 36);
- TEST_ASSERT_EQUALS(points[1].getY(), 9);
+ TEST_ASSERT_EQUALS(points[1].x(), 36);
+ TEST_ASSERT_EQUALS(points[1].y(), 9);
- TEST_ASSERT_EQUALS(points[2].getX(), 39);
- TEST_ASSERT_EQUALS(points[2].getY(), -6);
+ TEST_ASSERT_EQUALS(points[2].x(), 39);
+ TEST_ASSERT_EQUALS(points[2].y(), -6);
points.removeAll();
@@ -312,11 +312,11 @@ Polygon2DTest::testIntersectionPointsLineSegment()
TEST_ASSERT_TRUE(polygon.getIntersections(line, points));
TEST_ASSERT_EQUALS(points.getNumberOfPoints(), 2U);
- TEST_ASSERT_EQUALS(points[0].getX(), 50);
- TEST_ASSERT_EQUALS(points[0].getY(), 30);
+ TEST_ASSERT_EQUALS(points[0].x(), 50);
+ TEST_ASSERT_EQUALS(points[0].y(), 30);
- TEST_ASSERT_EQUALS(points[1].getX(), 50);
- TEST_ASSERT_EQUALS(points[1].getY(), 30);
+ TEST_ASSERT_EQUALS(points[1].x(), 50);
+ TEST_ASSERT_EQUALS(points[1].y(), 30);
points.removeAll();
}
diff --git a/test/modm/math/geometry/quaternion_test.cpp b/test/modm/math/geometry/quaternion_test.cpp
index 3f3b3edc99..083308c225 100644
--- a/test/modm/math/geometry/quaternion_test.cpp
+++ b/test/modm/math/geometry/quaternion_test.cpp
@@ -12,9 +12,10 @@
#include <modm/math/geometry/vector.hpp>
#include <modm/math/geometry/quaternion.hpp>
-#include "quaternion_test.hpp"
#include <modm/math/geometry/angle.hpp>
+#include "quaternion_test.hpp"
+
void
QuaternionTest::testConstructor()
{
diff --git a/test/modm/math/geometry/vector1_test.cpp b/test/modm/math/geometry/vector1_test.cpp
index 1f7af1c463..783dbc22d8 100644
--- a/test/modm/math/geometry/vector1_test.cpp
+++ b/test/modm/math/geometry/vector1_test.cpp
@@ -17,38 +17,38 @@ void
Vector1Test::testConstructor()
{
modm::Vector1i a;
- TEST_ASSERT_EQUALS(a.x, 0);
+ TEST_ASSERT_EQUALS(a.x(), 0);
modm::Vector1i b(20);
- TEST_ASSERT_EQUALS(b.x, 20);
+ TEST_ASSERT_EQUALS(b.x(), 20);
- a.x = 100;
- TEST_ASSERT_EQUALS(a.x, 100);
+ a.x() = 100;
+ TEST_ASSERT_EQUALS(a.x(), 100);
modm::Vector1i c(a);
- TEST_ASSERT_EQUALS(c.x, 100);
+ TEST_ASSERT_EQUALS(c.x(), 100);
- int16_t array[1] = {-4};
+ /* int16_t array[1] = {-4};
modm::Matrix<int16_t, 1, 1> m(array);
- modm::Vector1i d(m);
- TEST_ASSERT_EQUALS(d.x, -4);
+ /* modm::Vector1i d(m);
+ TEST_ASSERT_EQUALS(d.x(), -4); */
}
void
Vector1Test::testAssign()
{
modm::Vector1i a(42);
- int16_t array[1] = {-42};
- modm::Matrix<int16_t, 1, 1> m(array);
+ /* int16_t array[1] = {-42};
+ modm::Matrix<int16_t, 1, 1> m(array); */
modm::Vector1i b;
b = a;
- TEST_ASSERT_EQUALS(b.x, 42);
+ TEST_ASSERT_EQUALS(b.x(), 42);
- b = m;
- TEST_ASSERT_EQUALS(b.x, -42);
+ /* b = m;
+ TEST_ASSERT_EQUALS(b.x(), -42); */
}
void
@@ -85,7 +85,7 @@ void
Vector1Test::testRawDataAccess()
{
modm::Vector1i a(2);
- int16_t *pointer = a.ptr();
+ int16_t *pointer = a.data();
TEST_ASSERT_EQUALS(a[0], 2);
TEST_ASSERT_EQUALS(pointer[0], 2);
@@ -97,31 +97,31 @@ Vector1Test::testOperators()
modm::Vector1i a(7);
modm::Vector1i b(-18);
- TEST_ASSERT_EQUALS((a + b).x, 7-18);
- TEST_ASSERT_EQUALS((a - b).x, 7-(-18));
+ TEST_ASSERT_EQUALS((a + b).x(), 7-18);
+ TEST_ASSERT_EQUALS((a - b).x(), 7-(-18));
TEST_ASSERT_EQUALS((a * b), -7*18);
- TEST_ASSERT_EQUALS((a * 3).x, 7*3);
- TEST_ASSERT_EQUALS((3 * a).x, 3*7);
- TEST_ASSERT_EQUALS((b / 2).x, -18/2);
+ TEST_ASSERT_EQUALS((a * 3).x(), 7*3);
+ TEST_ASSERT_EQUALS((3 * a).x(), 3*7);
+ TEST_ASSERT_EQUALS((b / 2).x(), -18/2);
-b;
- TEST_ASSERT_EQUALS(b.x, -18);
+ TEST_ASSERT_EQUALS(b.x(), -18);
b = -b;
- TEST_ASSERT_EQUALS(b.x, 18);
+ TEST_ASSERT_EQUALS(b.x(), 18);
a += b;
- TEST_ASSERT_EQUALS(a.x, 7+18);
+ TEST_ASSERT_EQUALS(a.x(), 7+18);
a -= b;
- TEST_ASSERT_EQUALS(a.x, 7+18-18);
+ TEST_ASSERT_EQUALS(a.x(), 7+18-18);
a *= 2;
- TEST_ASSERT_EQUALS(a.x, 7*2);
+ TEST_ASSERT_EQUALS(a.x(), 7*2);
b /= 2;
- TEST_ASSERT_EQUALS(b.x, 18/2);
+ TEST_ASSERT_EQUALS(b.x(), 18/2);
// test division of floats
modm::Vector1f c(-18.7f);
- TEST_ASSERT_EQUALS_FLOAT((c / 2.4f).x, -7.7916666667);
+ TEST_ASSERT_EQUALS_FLOAT((c / 2.4f).x(), -7.7916666667);
c /= 7.5f;
- TEST_ASSERT_EQUALS_FLOAT(c.x, -2.4933333333);
+ TEST_ASSERT_EQUALS_FLOAT(c.x(), -2.4933333333);
}
void
diff --git a/test/modm/math/geometry/vector2_test.cpp b/test/modm/math/geometry/vector2_test.cpp
index c788deb84b..d10b28f8d6 100644
--- a/test/modm/math/geometry/vector2_test.cpp
+++ b/test/modm/math/geometry/vector2_test.cpp
@@ -17,43 +17,44 @@ void
Vector2Test::testConstructor()
{
modm::Vector2i a;
- TEST_ASSERT_EQUALS(a.getX(), 0);
- TEST_ASSERT_EQUALS(a.getY(), 0);
+ TEST_ASSERT_EQUALS(a.x(), 0);
+ TEST_ASSERT_EQUALS(a.y(), 0);
- a.setX(100);
- a.setY(9);
- TEST_ASSERT_EQUALS(a.getX(), 100);
- TEST_ASSERT_EQUALS(a.getY(), 9);
+ a = {100, 9};
+ TEST_ASSERT_EQUALS(a.x(), 100);
+ TEST_ASSERT_EQUALS(a.y(), 9);
modm::Vector2i b(20);
- TEST_ASSERT_EQUALS(b.getX(), 20);
- TEST_ASSERT_EQUALS(b.getY(), 20);
+ TEST_ASSERT_EQUALS(b.x(), 20);
+ TEST_ASSERT_EQUALS(b.y(), 20);
modm::Vector2i c(20,30);
- TEST_ASSERT_EQUALS(c.getX(), 20);
- TEST_ASSERT_EQUALS(c.getY(), 30);
+ TEST_ASSERT_EQUALS(c.x(), 20);
+ TEST_ASSERT_EQUALS(c.y(), 30);
- int16_t array[2] = {-4,5};
+ const int16_t array[] = {-4,5};
modm::Matrix<int16_t, 2, 1> m(array);
- modm::Vector2i d(m);
- TEST_ASSERT_EQUALS(d.getX(), -4);
- TEST_ASSERT_EQUALS(d.getY(), 5);
+
+ /* modm::Vector2i d(m);
+ TEST_ASSERT_EQUALS(d.x(), -4);
+ TEST_ASSERT_EQUALS(d.y(), 5); */
modm::Vector2i e(a);
- TEST_ASSERT_EQUALS(e.getX(), 100);
- TEST_ASSERT_EQUALS(e.getY(), 9);
+ TEST_ASSERT_EQUALS(e.x(), 100);
+ TEST_ASSERT_EQUALS(e.y(), 9);
modm::Vector1i f(4);
- modm::Vector2i g(1,f);
- TEST_ASSERT_EQUALS(g.getX(), 1);
- TEST_ASSERT_EQUALS(g.getY(), 4);
- modm::Vector2i h(f,5);
- TEST_ASSERT_EQUALS(h.getX(), 4);
- TEST_ASSERT_EQUALS(h.getY(), 5);
- modm::Vector2i i(f,f);
- TEST_ASSERT_EQUALS(i.getX(), 4);
- TEST_ASSERT_EQUALS(i.getY(), 4);
+ // TODO implement variadic Constructor
+ // modm::Vector2i g(1,f);
+ // TEST_ASSERT_EQUALS(g.x(), 1);
+ // TEST_ASSERT_EQUALS(g.y(), 4);
+ // modm::Vector2i h(f,5);
+ // TEST_ASSERT_EQUALS(h.x(), 4);
+ // TEST_ASSERT_EQUALS(h.y(), 5);
+ // modm::Vector2i i(f,f);
+ // TEST_ASSERT_EQUALS(i.x(), 4);
+ // TEST_ASSERT_EQUALS(i.y(), 4);
}
void
@@ -61,18 +62,18 @@ Vector2Test::testAssign()
{
modm::Vector2i a(42,-4);
- int16_t array[2] = {-26,9};
+ const int16_t array[] = {-26,9};
modm::Matrix<int16_t, 2, 1> m(array);
modm::Vector2i b;
b = a;
- TEST_ASSERT_EQUALS(b.getX(), 42);
- TEST_ASSERT_EQUALS(b.getY(), -4);
+ TEST_ASSERT_EQUALS(b.x(), 42);
+ TEST_ASSERT_EQUALS(b.y(), -4);
- b = m;
- TEST_ASSERT_EQUALS(b.getX(), -26);
- TEST_ASSERT_EQUALS(b.getY(), 9);
+ /* b = m;
+ TEST_ASSERT_EQUALS(b.x(), -26);
+ TEST_ASSERT_EQUALS(b.y(), 9); */
}
void
@@ -109,7 +110,7 @@ void
Vector2Test::testRawDataAccess()
{
modm::Vector2i a(2,5);
- int16_t *pointer = a.ptr();
+ int16_t *pointer = a.data();
TEST_ASSERT_EQUALS(a[0], 2);
TEST_ASSERT_EQUALS(a[1], 5);
@@ -124,65 +125,65 @@ Vector2Test::testOperators()
modm::Vector2i b(-18,7);
modm::Vector2i c;
- TEST_ASSERT_EQUALS((a + b).getX(), 7-18);
- TEST_ASSERT_EQUALS((a + b).getY(), 5+7);
- TEST_ASSERT_EQUALS((a - b).getX(), 7-(-18));
- TEST_ASSERT_EQUALS((a - b).getY(), 5-7);
+ TEST_ASSERT_EQUALS((a + b).x(), 7-18);
+ TEST_ASSERT_EQUALS((a + b).y(), 5+7);
+ TEST_ASSERT_EQUALS((a - b).x(), 7-(-18));
+ TEST_ASSERT_EQUALS((a - b).y(), 5-7);
TEST_ASSERT_EQUALS((a * b), 7*(-18)+5*7);
TEST_ASSERT_EQUALS((a ^ b), 7*7-(-18)*5);
- TEST_ASSERT_EQUALS((a * 3).getX(), 7*3);
- TEST_ASSERT_EQUALS((a * 3).getY(), 5*3);
- TEST_ASSERT_EQUALS((3 * a).getX(), 3*7);
- TEST_ASSERT_EQUALS((3 * a).getY(), 3*5);
- TEST_ASSERT_EQUALS((b / 2).getX(), -18/2);
- TEST_ASSERT_EQUALS((b / 2).getY(), 4); // 3.5 -> rounded 4
+ TEST_ASSERT_EQUALS((a * 3).x(), 7*3);
+ TEST_ASSERT_EQUALS((a * 3).y(), 5*3);
+ TEST_ASSERT_EQUALS((3 * a).x(), 3*7);
+ TEST_ASSERT_EQUALS((3 * a).y(), 3*5);
+ TEST_ASSERT_EQUALS((b / 2.0).x(), -18/2);
+ TEST_ASSERT_EQUALS((b / 2.0).y(), 4); // 3.5 -> rounded 4
-b;
- TEST_ASSERT_EQUALS(b.getX(), -18);
- TEST_ASSERT_EQUALS(b.getY(), 7);
+ TEST_ASSERT_EQUALS(b.x(), -18);
+ TEST_ASSERT_EQUALS(b.y(), 7);
b = -b;
- TEST_ASSERT_EQUALS(b.getX(), 18);
- TEST_ASSERT_EQUALS(b.getY(), -7);
+ TEST_ASSERT_EQUALS(b.x(), 18);
+ TEST_ASSERT_EQUALS(b.y(), -7);
a += b;
- TEST_ASSERT_EQUALS(a.getX(), 7+18);
- TEST_ASSERT_EQUALS(a.getY(), 5-7);
+ TEST_ASSERT_EQUALS(a.x(), 7+18);
+ TEST_ASSERT_EQUALS(a.y(), 5-7);
a -= b;
- TEST_ASSERT_EQUALS(a.getX(), 7+18-18);
- TEST_ASSERT_EQUALS(a.getY(), 5-7-(-7));
+ TEST_ASSERT_EQUALS(a.x(), 7+18-18);
+ TEST_ASSERT_EQUALS(a.y(), 5-7-(-7));
c = a - b;
- TEST_ASSERT_EQUALS(a.getX(), 7);
- TEST_ASSERT_EQUALS(a.getY(), 5);
- TEST_ASSERT_EQUALS(b.getX(), 18);
- TEST_ASSERT_EQUALS(b.getY(), -7);
- TEST_ASSERT_EQUALS(c.getX(), -11);
- TEST_ASSERT_EQUALS(c.getY(), 12);
+ TEST_ASSERT_EQUALS(a.x(), 7);
+ TEST_ASSERT_EQUALS(a.y(), 5);
+ TEST_ASSERT_EQUALS(b.x(), 18);
+ TEST_ASSERT_EQUALS(b.y(), -7);
+ TEST_ASSERT_EQUALS(c.x(), -11);
+ TEST_ASSERT_EQUALS(c.y(), 12);
c = a + b;
- TEST_ASSERT_EQUALS(a.getX(), 7);
- TEST_ASSERT_EQUALS(a.getY(), 5);
- TEST_ASSERT_EQUALS(b.getX(), 18);
- TEST_ASSERT_EQUALS(b.getY(), -7);
- TEST_ASSERT_EQUALS(c.getX(), 25);
- TEST_ASSERT_EQUALS(c.getY(), -2);
+ TEST_ASSERT_EQUALS(a.x(), 7);
+ TEST_ASSERT_EQUALS(a.y(), 5);
+ TEST_ASSERT_EQUALS(b.x(), 18);
+ TEST_ASSERT_EQUALS(b.y(), -7);
+ TEST_ASSERT_EQUALS(c.x(), 25);
+ TEST_ASSERT_EQUALS(c.y(), -2);
a *= 2;
- TEST_ASSERT_EQUALS(a.getX(), 7*2);
- TEST_ASSERT_EQUALS(a.getY(), 5*2);
+ TEST_ASSERT_EQUALS(a.x(), 7*2);
+ TEST_ASSERT_EQUALS(a.y(), 5*2);
b /= 2;
- TEST_ASSERT_EQUALS(b.getX(), 18/2);
- TEST_ASSERT_EQUALS(b.getY(), -7/2);
- ~b;
- TEST_ASSERT_EQUALS(b.getX(), -7/2);
- TEST_ASSERT_EQUALS(b.getY(), -18/2);
+ TEST_ASSERT_EQUALS(b.x(), 18/2);
+ TEST_ASSERT_EQUALS(b.y(), -7/2);
+ b = ~b;
+ TEST_ASSERT_EQUALS(b.x(), -7/2);
+ TEST_ASSERT_EQUALS(b.y(), -18/2);
// test division of floats
modm::Vector2f d(-18.7f,5.5f);
- TEST_ASSERT_EQUALS_FLOAT((d / 2.4f).getX(), -7.7916666667);
- TEST_ASSERT_EQUALS_FLOAT((d / 2.4f).getY(), 2.2916666667);
+ TEST_ASSERT_EQUALS_FLOAT((d / 2.4f).x(), -7.7916666667);
+ TEST_ASSERT_EQUALS_FLOAT((d / 2.4f).y(), 2.2916666667);
d /= 7.5f;
- TEST_ASSERT_EQUALS_FLOAT(d.getX(), -2.4933333333);
- TEST_ASSERT_EQUALS_FLOAT(d.getY(), 0.7333333333);
+ TEST_ASSERT_EQUALS_FLOAT(d.x(), -2.4933333333);
+ TEST_ASSERT_EQUALS_FLOAT(d.y(), 0.7333333333);
}
void
@@ -190,19 +191,19 @@ Vector2Test::testLengthInteger()
{
modm::Vector2i a;
- a.set(100, 100);
+ a = {100, 100};
TEST_ASSERT_EQUALS(a.getLength(), 141);
TEST_ASSERT_EQUALS(a.getLengthSquared(), 20000);
- a.set(-100, -100);
+ a = {-100, -100};
TEST_ASSERT_EQUALS(a.getLength(), 141);
TEST_ASSERT_EQUALS(a.getLengthSquared(), 20000);
- a.set(0, 100);
+ a = {0, 100};
TEST_ASSERT_EQUALS(a.getLength(), 100);
TEST_ASSERT_EQUALS(a.getLengthSquared(), 10000);
- a.set(-20, 300);
+ a = {-20, 300};
TEST_ASSERT_EQUALS(a.getLength(), 301);
TEST_ASSERT_EQUALS(a.getLengthSquared(), 90400);
}
@@ -215,21 +216,23 @@ Vector2Test::testLength()
TEST_ASSERT_EQUALS_FLOAT(a.getLengthSquared(), 3.f*3.f+4.f*4.f);
TEST_ASSERT_EQUALS_FLOAT(a.getLength(), 5.f);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.5f).getX(), 1.5f);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.5f).getY(), 2.f);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.5f).x(), 1.5f);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.5f).y(), 2.f);
+
a.scale(2.f);
- TEST_ASSERT_EQUALS_FLOAT(a.getX(), 1.2f);
- TEST_ASSERT_EQUALS_FLOAT(a.getY(), 1.6f);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 1.2f);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 1.6f);
+
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().x(), 0.6f);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().y(), 0.8f);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().getX(), 0.6f);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().getY(), 0.8f);
a.normalize();
- TEST_ASSERT_EQUALS_FLOAT(a.getX(), 0.6f);
- TEST_ASSERT_EQUALS_FLOAT(a.getY(), 0.8f);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 0.6f);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 0.8f);
modm::Vector2f b(a.perpendicular());
- TEST_ASSERT_EQUALS_FLOAT(b.getX(), 0.8f);
- TEST_ASSERT_EQUALS_FLOAT(b.getY(), -0.6f);
+ TEST_ASSERT_EQUALS_FLOAT(b.x(), 0.8f);
+ TEST_ASSERT_EQUALS_FLOAT(b.y(), -0.6f);
}
void
@@ -252,13 +255,13 @@ Vector2Test::testScale()
a.scale(100);
- TEST_ASSERT_EQUALS(a.getX(), 44);
- TEST_ASSERT_EQUALS(a.getY(), 89);
+ TEST_ASSERT_EQUALS(a.x(), 44);
+ TEST_ASSERT_EQUALS(a.y(), 89);
a.scale(static_cast<int16_t>(30));
- TEST_ASSERT_EQUALS(a.getX(), 13);
- TEST_ASSERT_EQUALS(a.getY(), 26);
+ TEST_ASSERT_EQUALS(a.x(), 13);
+ TEST_ASSERT_EQUALS(a.y(), 26);
}
void
@@ -268,25 +271,25 @@ Vector2Test::testRotate()
a.rotate(M_PI / 2);
- TEST_ASSERT_EQUALS(a.getX(), -200);
- TEST_ASSERT_EQUALS(a.getY(), 100);
+ TEST_ASSERT_EQUALS(a.x(), -200);
+ TEST_ASSERT_EQUALS(a.y(), 100);
a.rotate(-M_PI);
- TEST_ASSERT_EQUALS(a.getX(), 200);
- TEST_ASSERT_EQUALS(a.getY(), -100);
+ TEST_ASSERT_EQUALS(a.x(), 200);
+ TEST_ASSERT_EQUALS(a.y(), -100);
- a.set(100, 100);
+ a = {100, 100};
a.rotate(modm::Angle::toRadian(20));
- TEST_ASSERT_EQUALS(a.getX(), 60);
- TEST_ASSERT_EQUALS(a.getY(), 128);
+ TEST_ASSERT_EQUALS(a.x(), 60);
+ TEST_ASSERT_EQUALS(a.y(), 128);
- a.set(20, 10);
+ a = {20, 10};
a.rotate(-M_PI / 2);
- TEST_ASSERT_EQUALS(a.getX(), 10);
- TEST_ASSERT_EQUALS(a.getY(), -20);
+ TEST_ASSERT_EQUALS(a.x(), 10);
+ TEST_ASSERT_EQUALS(a.y(), -20);
}
void
@@ -296,9 +299,9 @@ Vector2Test::testRotateFloat()
a.rotate(modm::Angle::toRadian(20));
- TEST_ASSERT_EQUALS_FLOAT(a.getX(), 59.767247746f);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 59.767247746f);
#ifndef MODM_OS_WIN32 // FIXME: Windows has some unknown accuracy issue here
- TEST_ASSERT_EQUALS_FLOAT(a.getY(), 128.1712764112f);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 128.1712764112f);
#endif
}
@@ -308,10 +311,11 @@ Vector2Test::testTranslate()
modm::Vector2i a(10, 10);
modm::Vector2i b(20, -20);
- a.translate(b);
+ // a.translate(b);
+ a += b;
- TEST_ASSERT_EQUALS(a.getX(), 30);
- TEST_ASSERT_EQUALS(a.getY(), -10);
+ TEST_ASSERT_EQUALS(a.x(), 30);
+ TEST_ASSERT_EQUALS(a.y(), -10);
}
void
@@ -319,13 +323,13 @@ Vector2Test::testConversion()
{
modm::Vector<float, 2> a(12.763f, -13.3123f);
- TEST_ASSERT_EQUALS(a.getX(), 12.763f);
- TEST_ASSERT_EQUALS(a.getY(), -13.3123f);
+ TEST_ASSERT_EQUALS(a.x(), 12.763f);
+ TEST_ASSERT_EQUALS(a.y(), -13.3123f);
- modm::Vector2i b = a.convert<int16_t>();
+ modm::Vector2i b(a);
- TEST_ASSERT_EQUALS(b.getX(), 13);
- TEST_ASSERT_EQUALS(b.getY(), -13);
+ TEST_ASSERT_EQUALS(b.x(), 13);
+ TEST_ASSERT_EQUALS(b.y(), -13);
}
void
@@ -346,13 +350,13 @@ Vector2Test::testAngle()
{
modm::Vector2i a;
- a.set(100, 100);
+ a = {100, 100};
TEST_ASSERT_EQUALS_FLOAT(a.getAngle(), M_PI / 4);
- a.set(-100, -100);
+ a = {-100, -100};
TEST_ASSERT_EQUALS_FLOAT(a.getAngle(), - 3* M_PI / 4);
- a.set(0, 100);
+ a = {0, 100};
TEST_ASSERT_EQUALS_FLOAT(a.getAngle(), M_PI / 2);
}
@@ -401,18 +405,18 @@ Vector2Test::testCCW()
modm::Vector2i c(40, 40);
modm::Vector2i d(0, 40);
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(a, b, d), 1);
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(b, d, a), 1);
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(b, a, d), -1);
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(a, d, b), -1);
+ TEST_ASSERT_EQUALS(modm::ccw(a, b, d), 1);
+ TEST_ASSERT_EQUALS(modm::ccw(b, d, a), 1);
+ TEST_ASSERT_EQUALS(modm::ccw(b, a, d), -1);
+ TEST_ASSERT_EQUALS(modm::ccw(a, d, b), -1);
// three points in a strait row
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(a, b, c), 1);
+ TEST_ASSERT_EQUALS(modm::ccw(a, b, c), 1);
// last point between the two other
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(a, c, b), 0);
+ TEST_ASSERT_EQUALS(modm::ccw(a, c, b), 0);
// last point before the first
- TEST_ASSERT_EQUALS(modm::Vector2i::ccw(b, c, a), -1);
+ TEST_ASSERT_EQUALS(modm::ccw(b, c, a), -1);
}
diff --git a/test/modm/math/geometry/vector3_test.cpp b/test/modm/math/geometry/vector3_test.cpp
index b2eb9bf2fc..88420359ad 100644
--- a/test/modm/math/geometry/vector3_test.cpp
+++ b/test/modm/math/geometry/vector3_test.cpp
@@ -20,100 +20,98 @@ Vector3Test::testConstructor()
modm::Vector1i p1(3);
modm::Vector2i p2(1, 2);
- int16_t array[3] = {-4, 5, 7};
- modm::Matrix<int16_t, 3, 1> m(array);
+ const int16_t arr[] = {-4, 5, 7};
+ modm::Matrix<int16_t, 3, 1> m(arr);
modm::Vector3i a;
- TEST_ASSERT_EQUALS(a.x, 0);
- TEST_ASSERT_EQUALS(a.y, 0);
- TEST_ASSERT_EQUALS(a.z, 0);
+ TEST_ASSERT_EQUALS(a.x(), 0);
+ TEST_ASSERT_EQUALS(a.y(), 0);
+ TEST_ASSERT_EQUALS(a.z(), 0);
- a.x = 100;
- a.y = 9;
- a.z = 4;
- TEST_ASSERT_EQUALS(a.x, 100);
- TEST_ASSERT_EQUALS(a.y, 9);
- TEST_ASSERT_EQUALS(a.z, 4);
+ a = {100, 9, 4};
+ TEST_ASSERT_EQUALS(a.x(), 100);
+ TEST_ASSERT_EQUALS(a.y(), 9);
+ TEST_ASSERT_EQUALS(a.z(), 4);
modm::Vector3i b(20,1,-4);
- TEST_ASSERT_EQUALS(b.x, 20);
- TEST_ASSERT_EQUALS(b.y, 1);
- TEST_ASSERT_EQUALS(b.z, -4);
+ TEST_ASSERT_EQUALS(b.x(), 20);
+ TEST_ASSERT_EQUALS(b.y(), 1);
+ TEST_ASSERT_EQUALS(b.z(), -4);
- modm::Vector3i c(array);
- TEST_ASSERT_EQUALS(c.x, -4);
- TEST_ASSERT_EQUALS(c.y, 5);
- TEST_ASSERT_EQUALS(c.z, 7);
+ modm::Vector3i c(arr);
+ TEST_ASSERT_EQUALS(c.x(), -4);
+ TEST_ASSERT_EQUALS(c.y(), 5);
+ TEST_ASSERT_EQUALS(c.z(), 7);
modm::Vector3i d(4);
- TEST_ASSERT_EQUALS(d.x, 4);
- TEST_ASSERT_EQUALS(d.y, 4);
- TEST_ASSERT_EQUALS(d.z, 4);
+ TEST_ASSERT_EQUALS(d.x(), 4);
+ TEST_ASSERT_EQUALS(d.y(), 4);
+ TEST_ASSERT_EQUALS(d.z(), 4);
modm::Vector3i e(1,2,p1);
- TEST_ASSERT_EQUALS(e.x, 1);
- TEST_ASSERT_EQUALS(e.y, 2);
- TEST_ASSERT_EQUALS(e.z, 3);
+ TEST_ASSERT_EQUALS(e.x(), 1);
+ TEST_ASSERT_EQUALS(e.y(), 2);
+ TEST_ASSERT_EQUALS(e.z(), 3);
modm::Vector3i f(1,p1,2);
- TEST_ASSERT_EQUALS(f.x, 1);
- TEST_ASSERT_EQUALS(f.y, 3);
- TEST_ASSERT_EQUALS(f.z, 2);
+ TEST_ASSERT_EQUALS(f.x(), 1);
+ TEST_ASSERT_EQUALS(f.y(), 3);
+ TEST_ASSERT_EQUALS(f.z(), 2);
modm::Vector3i g(p1,2,1);
- TEST_ASSERT_EQUALS(g.x, 3);
- TEST_ASSERT_EQUALS(g.y, 2);
- TEST_ASSERT_EQUALS(g.z, 1);
+ TEST_ASSERT_EQUALS(g.x(), 3);
+ TEST_ASSERT_EQUALS(g.y(), 2);
+ TEST_ASSERT_EQUALS(g.z(), 1);
modm::Vector3i h(1,p1,p1);
- TEST_ASSERT_EQUALS(h.x, 1);
- TEST_ASSERT_EQUALS(h.y, 3);
- TEST_ASSERT_EQUALS(h.z, 3);
+ TEST_ASSERT_EQUALS(h.x(), 1);
+ TEST_ASSERT_EQUALS(h.y(), 3);
+ TEST_ASSERT_EQUALS(h.z(), 3);
modm::Vector3i i(p1,1,p1);
- TEST_ASSERT_EQUALS(i.x, 3);
- TEST_ASSERT_EQUALS(i.y, 1);
- TEST_ASSERT_EQUALS(i.z, 3);
+ TEST_ASSERT_EQUALS(i.x(), 3);
+ TEST_ASSERT_EQUALS(i.y(), 1);
+ TEST_ASSERT_EQUALS(i.z(), 3);
modm::Vector3i j(p1,p1,1);
- TEST_ASSERT_EQUALS(j.x, 3);
- TEST_ASSERT_EQUALS(j.y, 3);
- TEST_ASSERT_EQUALS(j.z, 1);
+ TEST_ASSERT_EQUALS(j.x(), 3);
+ TEST_ASSERT_EQUALS(j.y(), 3);
+ TEST_ASSERT_EQUALS(j.z(), 1);
modm::Vector3i k(p1,p1,p1);
- TEST_ASSERT_EQUALS(k.x, 3);
- TEST_ASSERT_EQUALS(k.y, 3);
- TEST_ASSERT_EQUALS(k.z, 3);
+ TEST_ASSERT_EQUALS(k.x(), 3);
+ TEST_ASSERT_EQUALS(k.y(), 3);
+ TEST_ASSERT_EQUALS(k.z(), 3);
modm::Vector3i l(2,p2);
- TEST_ASSERT_EQUALS(l.x, 2);
- TEST_ASSERT_EQUALS(l.y, 1);
- TEST_ASSERT_EQUALS(l.z, 2);
+ TEST_ASSERT_EQUALS(l.x(), 2);
+ TEST_ASSERT_EQUALS(l.y(), 1);
+ TEST_ASSERT_EQUALS(l.z(), 2);
modm::Vector3i r(p2,6);
- TEST_ASSERT_EQUALS(r.x, 1);
- TEST_ASSERT_EQUALS(r.y, 2);
- TEST_ASSERT_EQUALS(r.z, 6);
+ TEST_ASSERT_EQUALS(r.x(), 1);
+ TEST_ASSERT_EQUALS(r.y(), 2);
+ TEST_ASSERT_EQUALS(r.z(), 6);
modm::Vector3i n(p1,p2);
- TEST_ASSERT_EQUALS(n.x, 3);
- TEST_ASSERT_EQUALS(n.y, 1);
- TEST_ASSERT_EQUALS(n.z, 2);
+ TEST_ASSERT_EQUALS(n.x(), 3);
+ TEST_ASSERT_EQUALS(n.y(), 1);
+ TEST_ASSERT_EQUALS(n.z(), 2);
modm::Vector3i o(p2,p1);
- TEST_ASSERT_EQUALS(o.x, 1);
- TEST_ASSERT_EQUALS(o.y, 2);
- TEST_ASSERT_EQUALS(o.z, 3);
+ TEST_ASSERT_EQUALS(o.x(), 1);
+ TEST_ASSERT_EQUALS(o.y(), 2);
+ TEST_ASSERT_EQUALS(o.z(), 3);
modm::Vector3i p(a);
- TEST_ASSERT_EQUALS(p.x, 100);
- TEST_ASSERT_EQUALS(p.y, 9);
- TEST_ASSERT_EQUALS(p.z, 4);
-
- modm::Vector3i q(m);
- TEST_ASSERT_EQUALS(q.x, -4);
- TEST_ASSERT_EQUALS(q.y, 5);
- TEST_ASSERT_EQUALS(q.z, 7);
+ TEST_ASSERT_EQUALS(p.x(), 100);
+ TEST_ASSERT_EQUALS(p.y(), 9);
+ TEST_ASSERT_EQUALS(p.z(), 4);
+
+/* modm::Vector3i q(m);
+ TEST_ASSERT_EQUALS(q.x(), -4);
+ TEST_ASSERT_EQUALS(q.y(), 5);
+ TEST_ASSERT_EQUALS(q.z(), 7); */
}
void
@@ -121,20 +119,20 @@ Vector3Test::testAssign()
{
modm::Vector3i a(42,-4,3);
- int16_t array[3] = {-26,9,2};
+ const int16_t array[] = {-26,9,2};
modm::Matrix<int16_t, 3, 1> m(array);
modm::Vector3i b;
b = a;
- TEST_ASSERT_EQUALS(b.x, 42);
- TEST_ASSERT_EQUALS(b.y, -4);
- TEST_ASSERT_EQUALS(b.z, 3);
-
- b = m;
- TEST_ASSERT_EQUALS(b.x, -26);
- TEST_ASSERT_EQUALS(b.y, 9);
- TEST_ASSERT_EQUALS(b.z, 2);
+ TEST_ASSERT_EQUALS(b.x(), 42);
+ TEST_ASSERT_EQUALS(b.y(), -4);
+ TEST_ASSERT_EQUALS(b.z(), 3);
+
+ /* b = m;
+ TEST_ASSERT_EQUALS(b.x(), -26);
+ TEST_ASSERT_EQUALS(b.y(), 9);
+ TEST_ASSERT_EQUALS(b.z(), 2); */
}
void
@@ -171,7 +169,7 @@ void
Vector3Test::testRawDataAccess()
{
modm::Vector3i a(0, 1, 2);
- int16_t *pointer = a.ptr();
+ int16_t *pointer = a.data();
TEST_ASSERT_EQUALS(a[0], 0);
TEST_ASSERT_EQUALS(a[1], 1);
@@ -187,55 +185,55 @@ Vector3Test::testOperators()
modm::Vector3i a(1, 2, 3);
modm::Vector3i b(4, 5, 6);
- TEST_ASSERT_EQUALS((a + b).x, 1+4);
- TEST_ASSERT_EQUALS((a + b).y, 2+5);
- TEST_ASSERT_EQUALS((a + b).z, 3+6);
+ TEST_ASSERT_EQUALS((a + b).x(), 1+4);
+ TEST_ASSERT_EQUALS((a + b).y(), 2+5);
+ TEST_ASSERT_EQUALS((a + b).z(), 3+6);
- TEST_ASSERT_EQUALS((a - b).x, 1-4);
- TEST_ASSERT_EQUALS((a - b).y, 2-5);
- TEST_ASSERT_EQUALS((a - b).z, 3-6);
+ TEST_ASSERT_EQUALS((a - b).x(), 1-4);
+ TEST_ASSERT_EQUALS((a - b).y(), 2-5);
+ TEST_ASSERT_EQUALS((a - b).z(), 3-6);
TEST_ASSERT_EQUALS((a * b), 1*4+2*5+3*6);
- TEST_ASSERT_EQUALS((a ^ b).x, 2*6-3*5);
- TEST_ASSERT_EQUALS((a ^ b).y, 3*4-1*6);
- TEST_ASSERT_EQUALS((a ^ b).z, 1*5-2*4);
+ TEST_ASSERT_EQUALS((a ^ b).x(), 2*6-3*5);
+ TEST_ASSERT_EQUALS((a ^ b).y(), 3*4-1*6);
+ TEST_ASSERT_EQUALS((a ^ b).z(), 1*5-2*4);
- TEST_ASSERT_EQUALS((a * 3).x, 1*3);
- TEST_ASSERT_EQUALS((a * 3).y, 2*3);
- TEST_ASSERT_EQUALS((a * 3).z, 3*3);
- TEST_ASSERT_EQUALS((3 * a).x, 3*1);
- TEST_ASSERT_EQUALS((3 * a).y, 3*2);
- TEST_ASSERT_EQUALS((3 * a).z, 3*3);
+ TEST_ASSERT_EQUALS((a * 3).x(), 1*3);
+ TEST_ASSERT_EQUALS((a * 3).y(), 2*3);
+ TEST_ASSERT_EQUALS((a * 3).z(), 3*3);
+ TEST_ASSERT_EQUALS((3 * a).x(), 3*1);
+ TEST_ASSERT_EQUALS((3 * a).y(), 3*2);
+ TEST_ASSERT_EQUALS((3 * a).z(), 3*3);
- TEST_ASSERT_EQUALS((b / 2).x, 4/2);
- TEST_ASSERT_EQUALS((b / 2).y, 5/2);
- TEST_ASSERT_EQUALS((b / 2).z, 6/2);
+ TEST_ASSERT_EQUALS((b / 2).x(), 4/2);
+ TEST_ASSERT_EQUALS((b / 2).y(), 5/2);
+ TEST_ASSERT_EQUALS((b / 2).z(), 6/2);
-b;
- TEST_ASSERT_EQUALS(b.x, 4);
- TEST_ASSERT_EQUALS(b.y, 5);
- TEST_ASSERT_EQUALS(b.z, 6);
+ TEST_ASSERT_EQUALS(b.x(), 4);
+ TEST_ASSERT_EQUALS(b.y(), 5);
+ TEST_ASSERT_EQUALS(b.z(), 6);
b = -b;
- TEST_ASSERT_EQUALS(b.x, -4);
- TEST_ASSERT_EQUALS(b.y, -5);
- TEST_ASSERT_EQUALS(b.z, -6);
+ TEST_ASSERT_EQUALS(b.x(), -4);
+ TEST_ASSERT_EQUALS(b.y(), -5);
+ TEST_ASSERT_EQUALS(b.z(), -6);
a += b;
- TEST_ASSERT_EQUALS(a.x, 1-4);
- TEST_ASSERT_EQUALS(a.y, 2-5);
- TEST_ASSERT_EQUALS(a.z, 3-6);
+ TEST_ASSERT_EQUALS(a.x(), 1-4);
+ TEST_ASSERT_EQUALS(a.y(), 2-5);
+ TEST_ASSERT_EQUALS(a.z(), 3-6);
a -= b;
- TEST_ASSERT_EQUALS(a.x, 1);
- TEST_ASSERT_EQUALS(a.y, 2);
- TEST_ASSERT_EQUALS(a.z, 3);
+ TEST_ASSERT_EQUALS(a.x(), 1);
+ TEST_ASSERT_EQUALS(a.y(), 2);
+ TEST_ASSERT_EQUALS(a.z(), 3);
a *= 2;
- TEST_ASSERT_EQUALS(a.x, 1*2);
- TEST_ASSERT_EQUALS(a.y, 2*2);
- TEST_ASSERT_EQUALS(a.z, 3*2);
+ TEST_ASSERT_EQUALS(a.x(), 1*2);
+ TEST_ASSERT_EQUALS(a.y(), 2*2);
+ TEST_ASSERT_EQUALS(a.z(), 3*2);
b /= 2;
- TEST_ASSERT_EQUALS(b.x, -4/2);
- TEST_ASSERT_EQUALS(b.y, -5/2);
- TEST_ASSERT_EQUALS(b.z, -6/2);
+ TEST_ASSERT_EQUALS(b.x(), -4/2);
+ TEST_ASSERT_EQUALS(b.y(), -5/2);
+ TEST_ASSERT_EQUALS(b.z(), -6/2);
}
void
@@ -246,21 +244,21 @@ Vector3Test::testLength()
TEST_ASSERT_EQUALS_FLOAT(a.getLengthSquared(), 1.f*1.f+2.f*2.f+3.f*3.f);
TEST_ASSERT_EQUALS_FLOAT(a.getLength(), 3.741657387);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).x, 0.5345224838);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).y, 1.0690449676);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).z, 1.6035674514);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).x(), 0.5345224838);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).y(), 1.0690449676);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).z(), 1.6035674514);
a.scale(2.f);
- TEST_ASSERT_EQUALS_FLOAT(a.x, 0.5345224838);
- TEST_ASSERT_EQUALS_FLOAT(a.y, 1.0690449676);
- TEST_ASSERT_EQUALS_FLOAT(a.z, 1.6035674514);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 0.5345224838);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 1.0690449676);
+ TEST_ASSERT_EQUALS_FLOAT(a.z(), 1.6035674514);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().x, 0.2672612419);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().y, 0.5345224838);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().z, 0.8017837257);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().x(), 0.2672612419);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().y(), 0.5345224838);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().z(), 0.8017837257);
a.normalize();
- TEST_ASSERT_EQUALS_FLOAT(a.x, 0.2672612419);
- TEST_ASSERT_EQUALS_FLOAT(a.y, 0.5345224838);
- TEST_ASSERT_EQUALS_FLOAT(a.z, 0.8017837257);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 0.2672612419);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 0.5345224838);
+ TEST_ASSERT_EQUALS_FLOAT(a.z(), 0.8017837257);
}
void
diff --git a/test/modm/math/geometry/vector4_test.cpp b/test/modm/math/geometry/vector4_test.cpp
index 05f500256a..15c7357680 100644
--- a/test/modm/math/geometry/vector4_test.cpp
+++ b/test/modm/math/geometry/vector4_test.cpp
@@ -20,222 +20,219 @@ Vector4Test::testConstructor()
modm::Vector2i p2(2, 2);
modm::Vector3i p3(3, 3, 3);
- int16_t array[4] = {1, 2, 3, 4};
+ const int16_t array[] = {1, 2, 3, 4};
modm::Matrix<int16_t, 4, 1> m(array);
modm::Vector4i a;
- TEST_ASSERT_EQUALS(a.x, 0);
- TEST_ASSERT_EQUALS(a.y, 0);
- TEST_ASSERT_EQUALS(a.z, 0);
- TEST_ASSERT_EQUALS(a.w, 0);
-
- a.x = 1;
- a.y = 2;
- a.z = 3;
- a.w = 4;
- TEST_ASSERT_EQUALS(a.x, 1);
- TEST_ASSERT_EQUALS(a.y, 2);
- TEST_ASSERT_EQUALS(a.z, 3);
- TEST_ASSERT_EQUALS(a.w, 4);
+ TEST_ASSERT_EQUALS(a.x(), 0);
+ TEST_ASSERT_EQUALS(a.y(), 0);
+ TEST_ASSERT_EQUALS(a.z(), 0);
+ TEST_ASSERT_EQUALS(a.w(), 0);
+
+ a = {1, 2, 3, 4};
+ TEST_ASSERT_EQUALS(a.x(), 1);
+ TEST_ASSERT_EQUALS(a.y(), 2);
+ TEST_ASSERT_EQUALS(a.z(), 3);
+ TEST_ASSERT_EQUALS(a.w(), 4);
modm::Vector4i b(1,2,3,4);
- TEST_ASSERT_EQUALS(b.x, 1);
- TEST_ASSERT_EQUALS(b.y, 2);
- TEST_ASSERT_EQUALS(b.z, 3);
- TEST_ASSERT_EQUALS(b.w, 4);
+ TEST_ASSERT_EQUALS(b.x(), 1);
+ TEST_ASSERT_EQUALS(b.y(), 2);
+ TEST_ASSERT_EQUALS(b.z(), 3);
+ TEST_ASSERT_EQUALS(b.w(), 4);
modm::Vector4i c(array);
- TEST_ASSERT_EQUALS(c.x, 1);
- TEST_ASSERT_EQUALS(c.y, 2);
- TEST_ASSERT_EQUALS(c.z, 3);
- TEST_ASSERT_EQUALS(c.w, 4);
+ TEST_ASSERT_EQUALS(c.x(), 1);
+ TEST_ASSERT_EQUALS(c.y(), 2);
+ TEST_ASSERT_EQUALS(c.z(), 3);
+ TEST_ASSERT_EQUALS(c.w(), 4);
modm::Vector4i d(4);
- TEST_ASSERT_EQUALS(d.x, 4);
- TEST_ASSERT_EQUALS(d.y, 4);
- TEST_ASSERT_EQUALS(d.z, 4);
- TEST_ASSERT_EQUALS(d.w, 4);
-
+ TEST_ASSERT_EQUALS(d.x(), 4);
+ TEST_ASSERT_EQUALS(d.y(), 4);
+ TEST_ASSERT_EQUALS(d.z(), 4);
+ TEST_ASSERT_EQUALS(d.w(), 4);
+ // TODO implement variadic constructor
modm::Vector4i e(p1,1,2,3);
- TEST_ASSERT_EQUALS(e.x, 1);
- TEST_ASSERT_EQUALS(e.y, 1);
- TEST_ASSERT_EQUALS(e.z, 2);
- TEST_ASSERT_EQUALS(e.w, 3);
+ TEST_ASSERT_EQUALS(e.x(), 1);
+ TEST_ASSERT_EQUALS(e.y(), 1);
+ TEST_ASSERT_EQUALS(e.z(), 2);
+ TEST_ASSERT_EQUALS(e.w(), 3);
modm::Vector4i f(1,p1,2,3);
- TEST_ASSERT_EQUALS(f.x, 1);
- TEST_ASSERT_EQUALS(f.y, 1);
- TEST_ASSERT_EQUALS(f.z, 2);
- TEST_ASSERT_EQUALS(f.w, 3);
+ TEST_ASSERT_EQUALS(f.x(), 1);
+ TEST_ASSERT_EQUALS(f.y(), 1);
+ TEST_ASSERT_EQUALS(f.z(), 2);
+ TEST_ASSERT_EQUALS(f.w(), 3);
- // modm::Vector4i g(1,2,p1,3);
- // TEST_ASSERT_EQUALS(g.x, 1);
- // TEST_ASSERT_EQUALS(g.y, 2);
- // TEST_ASSERT_EQUALS(g.z, 1);
- // TEST_ASSERT_EQUALS(g.w, 3);
+ modm::Vector4i g(1,2,p1,3);
+ TEST_ASSERT_EQUALS(g.x(), 1);
+ TEST_ASSERT_EQUALS(g.y(), 2);
+ TEST_ASSERT_EQUALS(g.z(), 1);
+ TEST_ASSERT_EQUALS(g.w(), 3);
modm::Vector4i h(1,2,3,p1);
- TEST_ASSERT_EQUALS(h.x, 1);
- TEST_ASSERT_EQUALS(h.y, 2);
- TEST_ASSERT_EQUALS(h.z, 3);
- TEST_ASSERT_EQUALS(h.w, 1);
+ TEST_ASSERT_EQUALS(h.x(), 1);
+ TEST_ASSERT_EQUALS(h.y(), 2);
+ TEST_ASSERT_EQUALS(h.z(), 3);
+ TEST_ASSERT_EQUALS(h.w(), 1);
modm::Vector4i i(p1,p1,1,2);
- TEST_ASSERT_EQUALS(i.x, 1);
- TEST_ASSERT_EQUALS(i.y, 1);
- TEST_ASSERT_EQUALS(i.z, 1);
- TEST_ASSERT_EQUALS(i.w, 2);
+ TEST_ASSERT_EQUALS(i.x(), 1);
+ TEST_ASSERT_EQUALS(i.y(), 1);
+ TEST_ASSERT_EQUALS(i.z(), 1);
+ TEST_ASSERT_EQUALS(i.w(), 2);
modm::Vector4i j(p1,1,p1,2);
- TEST_ASSERT_EQUALS(j.x, 1);
- TEST_ASSERT_EQUALS(j.y, 1);
- TEST_ASSERT_EQUALS(j.z, 1);
- TEST_ASSERT_EQUALS(j.w, 2);
+ TEST_ASSERT_EQUALS(j.x(), 1);
+ TEST_ASSERT_EQUALS(j.y(), 1);
+ TEST_ASSERT_EQUALS(j.z(), 1);
+ TEST_ASSERT_EQUALS(j.w(), 2);
modm::Vector4i k(p1,1,2,p1);
- TEST_ASSERT_EQUALS(k.x, 1);
- TEST_ASSERT_EQUALS(k.y, 1);
- TEST_ASSERT_EQUALS(k.z, 2);
- TEST_ASSERT_EQUALS(k.w, 1);
+ TEST_ASSERT_EQUALS(k.x(), 1);
+ TEST_ASSERT_EQUALS(k.y(), 1);
+ TEST_ASSERT_EQUALS(k.z(), 2);
+ TEST_ASSERT_EQUALS(k.w(), 1);
modm::Vector4i l(1,p1,2,p1);
- TEST_ASSERT_EQUALS(l.x, 1);
- TEST_ASSERT_EQUALS(l.y, 1);
- TEST_ASSERT_EQUALS(l.z, 2);
- TEST_ASSERT_EQUALS(l.w, 1);
+ TEST_ASSERT_EQUALS(l.x(), 1);
+ TEST_ASSERT_EQUALS(l.y(), 1);
+ TEST_ASSERT_EQUALS(l.z(), 2);
+ TEST_ASSERT_EQUALS(l.w(), 1);
modm::Vector4i r(1,2,p1,p1);
- TEST_ASSERT_EQUALS(r.x, 1);
- TEST_ASSERT_EQUALS(r.y, 2);
- TEST_ASSERT_EQUALS(r.z, 1);
- TEST_ASSERT_EQUALS(r.w, 1);
+ TEST_ASSERT_EQUALS(r.x(), 1);
+ TEST_ASSERT_EQUALS(r.y(), 2);
+ TEST_ASSERT_EQUALS(r.z(), 1);
+ TEST_ASSERT_EQUALS(r.w(), 1);
modm::Vector4i n(1,p1,p1,2);
- TEST_ASSERT_EQUALS(n.x, 1);
- TEST_ASSERT_EQUALS(n.y, 1);
- TEST_ASSERT_EQUALS(n.z, 1);
- TEST_ASSERT_EQUALS(n.w, 2);
+ TEST_ASSERT_EQUALS(n.x(), 1);
+ TEST_ASSERT_EQUALS(n.y(), 1);
+ TEST_ASSERT_EQUALS(n.z(), 1);
+ TEST_ASSERT_EQUALS(n.w(), 2);
modm::Vector4i o(p2,p1,p1);
- TEST_ASSERT_EQUALS(o.x, 2);
- TEST_ASSERT_EQUALS(o.y, 2);
- TEST_ASSERT_EQUALS(o.z, 1);
- TEST_ASSERT_EQUALS(o.w, 1);
+ TEST_ASSERT_EQUALS(o.x(), 2);
+ TEST_ASSERT_EQUALS(o.y(), 2);
+ TEST_ASSERT_EQUALS(o.z(), 1);
+ TEST_ASSERT_EQUALS(o.w(), 1);
modm::Vector4i s(p2,p1,1);
- TEST_ASSERT_EQUALS(s.x, 2);
- TEST_ASSERT_EQUALS(s.y, 2);
- TEST_ASSERT_EQUALS(s.z, 1);
- TEST_ASSERT_EQUALS(s.w, 1);
+ TEST_ASSERT_EQUALS(s.x(), 2);
+ TEST_ASSERT_EQUALS(s.y(), 2);
+ TEST_ASSERT_EQUALS(s.z(), 1);
+ TEST_ASSERT_EQUALS(s.w(), 1);
modm::Vector4i t(p2,1,p1);
- TEST_ASSERT_EQUALS(t.x, 2);
- TEST_ASSERT_EQUALS(t.y, 2);
- TEST_ASSERT_EQUALS(t.z, 1);
- TEST_ASSERT_EQUALS(t.w, 1);
+ TEST_ASSERT_EQUALS(t.x(), 2);
+ TEST_ASSERT_EQUALS(t.y(), 2);
+ TEST_ASSERT_EQUALS(t.z(), 1);
+ TEST_ASSERT_EQUALS(t.w(), 1);
modm::Vector4i u(p2,1,1);
- TEST_ASSERT_EQUALS(u.x, 2);
- TEST_ASSERT_EQUALS(u.y, 2);
- TEST_ASSERT_EQUALS(u.z, 1);
- TEST_ASSERT_EQUALS(u.w, 1);
+ TEST_ASSERT_EQUALS(u.x(), 2);
+ TEST_ASSERT_EQUALS(u.y(), 2);
+ TEST_ASSERT_EQUALS(u.z(), 1);
+ TEST_ASSERT_EQUALS(u.w(), 1);
modm::Vector4i o2(p1,p2,p1);
- TEST_ASSERT_EQUALS(o2.x, 1);
- TEST_ASSERT_EQUALS(o2.y, 2);
- TEST_ASSERT_EQUALS(o2.z, 2);
- TEST_ASSERT_EQUALS(o2.w, 1);
+ TEST_ASSERT_EQUALS(o2.x(), 1);
+ TEST_ASSERT_EQUALS(o2.y(), 2);
+ TEST_ASSERT_EQUALS(o2.z(), 2);
+ TEST_ASSERT_EQUALS(o2.w(), 1);
modm::Vector4i s2(p1,p2,1);
- TEST_ASSERT_EQUALS(s2.x, 1);
- TEST_ASSERT_EQUALS(s2.y, 2);
- TEST_ASSERT_EQUALS(s2.z, 2);
- TEST_ASSERT_EQUALS(s2.w, 1);
+ TEST_ASSERT_EQUALS(s2.x(), 1);
+ TEST_ASSERT_EQUALS(s2.y(), 2);
+ TEST_ASSERT_EQUALS(s2.z(), 2);
+ TEST_ASSERT_EQUALS(s2.w(), 1);
modm::Vector4i t2(1,p2,p1);
- TEST_ASSERT_EQUALS(t2.x, 1);
- TEST_ASSERT_EQUALS(t2.y, 2);
- TEST_ASSERT_EQUALS(t2.z, 2);
- TEST_ASSERT_EQUALS(t2.w, 1);
+ TEST_ASSERT_EQUALS(t2.x(), 1);
+ TEST_ASSERT_EQUALS(t2.y(), 2);
+ TEST_ASSERT_EQUALS(t2.z(), 2);
+ TEST_ASSERT_EQUALS(t2.w(), 1);
modm::Vector4i u2(1,p2,1);
- TEST_ASSERT_EQUALS(u2.x, 1);
- TEST_ASSERT_EQUALS(u2.y, 2);
- TEST_ASSERT_EQUALS(u2.z, 2);
- TEST_ASSERT_EQUALS(u2.w, 1);
+ TEST_ASSERT_EQUALS(u2.x(), 1);
+ TEST_ASSERT_EQUALS(u2.y(), 2);
+ TEST_ASSERT_EQUALS(u2.z(), 2);
+ TEST_ASSERT_EQUALS(u2.w(), 1);
modm::Vector4i o3(p1,p1,p2);
- TEST_ASSERT_EQUALS(o3.x, 1);
- TEST_ASSERT_EQUALS(o3.y, 1);
- TEST_ASSERT_EQUALS(o3.z, 2);
- TEST_ASSERT_EQUALS(o3.w, 2);
+ TEST_ASSERT_EQUALS(o3.x(), 1);
+ TEST_ASSERT_EQUALS(o3.y(), 1);
+ TEST_ASSERT_EQUALS(o3.z(), 2);
+ TEST_ASSERT_EQUALS(o3.w(), 2);
modm::Vector4i s3(p1,1,p2);
- TEST_ASSERT_EQUALS(s3.x, 1);
- TEST_ASSERT_EQUALS(s3.y, 1);
- TEST_ASSERT_EQUALS(s3.z, 2);
- TEST_ASSERT_EQUALS(s3.w, 2);
+ TEST_ASSERT_EQUALS(s3.x(), 1);
+ TEST_ASSERT_EQUALS(s3.y(), 1);
+ TEST_ASSERT_EQUALS(s3.z(), 2);
+ TEST_ASSERT_EQUALS(s3.w(), 2);
modm::Vector4i t3(1,p1,p2);
- TEST_ASSERT_EQUALS(t3.x, 1);
- TEST_ASSERT_EQUALS(t3.y, 1);
- TEST_ASSERT_EQUALS(t3.z, 2);
- TEST_ASSERT_EQUALS(t3.w, 2);
+ TEST_ASSERT_EQUALS(t3.x(), 1);
+ TEST_ASSERT_EQUALS(t3.y(), 1);
+ TEST_ASSERT_EQUALS(t3.z(), 2);
+ TEST_ASSERT_EQUALS(t3.w(), 2);
modm::Vector4i u3(1,1,p2);
- TEST_ASSERT_EQUALS(u3.x, 1);
- TEST_ASSERT_EQUALS(u3.y, 1);
- TEST_ASSERT_EQUALS(u3.z, 2);
- TEST_ASSERT_EQUALS(u3.w, 2);
+ TEST_ASSERT_EQUALS(u3.x(), 1);
+ TEST_ASSERT_EQUALS(u3.y(), 1);
+ TEST_ASSERT_EQUALS(u3.z(), 2);
+ TEST_ASSERT_EQUALS(u3.w(), 2);
modm::Vector4i u4(p2,p2);
- TEST_ASSERT_EQUALS(u4.x, 2);
- TEST_ASSERT_EQUALS(u4.y, 2);
- TEST_ASSERT_EQUALS(u4.z, 2);
- TEST_ASSERT_EQUALS(u4.w, 2);
+ TEST_ASSERT_EQUALS(u4.x(), 2);
+ TEST_ASSERT_EQUALS(u4.y(), 2);
+ TEST_ASSERT_EQUALS(u4.z(), 2);
+ TEST_ASSERT_EQUALS(u4.w(), 2);
modm::Vector4i u5(p3,p1);
- TEST_ASSERT_EQUALS(u5.x, 3);
- TEST_ASSERT_EQUALS(u5.y, 3);
- TEST_ASSERT_EQUALS(u5.z, 3);
- TEST_ASSERT_EQUALS(u5.w, 1);
+ TEST_ASSERT_EQUALS(u5.x(), 3);
+ TEST_ASSERT_EQUALS(u5.y(), 3);
+ TEST_ASSERT_EQUALS(u5.z(), 3);
+ TEST_ASSERT_EQUALS(u5.w(), 1);
modm::Vector4i u6(p1,p3);
- TEST_ASSERT_EQUALS(u6.x, 1);
- TEST_ASSERT_EQUALS(u6.y, 3);
- TEST_ASSERT_EQUALS(u6.z, 3);
- TEST_ASSERT_EQUALS(u6.w, 3);
+ TEST_ASSERT_EQUALS(u6.x(), 1);
+ TEST_ASSERT_EQUALS(u6.y(), 3);
+ TEST_ASSERT_EQUALS(u6.z(), 3);
+ TEST_ASSERT_EQUALS(u6.w(), 3);
modm::Vector4i u7(p3,1);
- TEST_ASSERT_EQUALS(u7.x, 3);
- TEST_ASSERT_EQUALS(u7.y, 3);
- TEST_ASSERT_EQUALS(u7.z, 3);
- TEST_ASSERT_EQUALS(u7.w, 1);
+ TEST_ASSERT_EQUALS(u7.x(), 3);
+ TEST_ASSERT_EQUALS(u7.y(), 3);
+ TEST_ASSERT_EQUALS(u7.z(), 3);
+ TEST_ASSERT_EQUALS(u7.w(), 1);
modm::Vector4i u8(1,p3);
- TEST_ASSERT_EQUALS(u8.x, 1);
- TEST_ASSERT_EQUALS(u8.y, 3);
- TEST_ASSERT_EQUALS(u8.z, 3);
- TEST_ASSERT_EQUALS(u8.w, 3);
+ TEST_ASSERT_EQUALS(u8.x(), 1);
+ TEST_ASSERT_EQUALS(u8.y(), 3);
+ TEST_ASSERT_EQUALS(u8.z(), 3);
+ TEST_ASSERT_EQUALS(u8.w(), 3);
modm::Vector4i p(a);
- TEST_ASSERT_EQUALS(p.x, 1);
- TEST_ASSERT_EQUALS(p.y, 2);
- TEST_ASSERT_EQUALS(p.z, 3);
- TEST_ASSERT_EQUALS(p.w, 4);
+ TEST_ASSERT_EQUALS(p.x(), 1);
+ TEST_ASSERT_EQUALS(p.y(), 2);
+ TEST_ASSERT_EQUALS(p.z(), 3);
+ TEST_ASSERT_EQUALS(p.w(), 4);
- modm::Vector4i q(m);
- TEST_ASSERT_EQUALS(q.x, 1);
- TEST_ASSERT_EQUALS(q.y, 2);
- TEST_ASSERT_EQUALS(q.z, 3);
- TEST_ASSERT_EQUALS(q.w, 4);
+ /* modm::Vector4i q(m);
+ TEST_ASSERT_EQUALS(q.x(), 1);
+ TEST_ASSERT_EQUALS(q.y(), 2);
+ TEST_ASSERT_EQUALS(q.z(), 3);
+ TEST_ASSERT_EQUALS(q.w(), 4); */
// did I forget anything...
}
@@ -245,22 +242,22 @@ Vector4Test::testAssign()
{
modm::Vector4i a(1,2,3,4);
- int16_t array[4] = {5,6,7,8};
+ const int16_t array[] = {5,6,7,8};
modm::Matrix<int16_t, 4, 1> m(array);
modm::Vector4i b;
b = a;
- TEST_ASSERT_EQUALS(b.x, 1);
- TEST_ASSERT_EQUALS(b.y, 2);
- TEST_ASSERT_EQUALS(b.z, 3);
- TEST_ASSERT_EQUALS(b.w, 4);
-
- b = m;
- TEST_ASSERT_EQUALS(b.x, 5);
- TEST_ASSERT_EQUALS(b.y, 6);
- TEST_ASSERT_EQUALS(b.z, 7);
- TEST_ASSERT_EQUALS(b.w, 8);
+ TEST_ASSERT_EQUALS(b.x(), 1);
+ TEST_ASSERT_EQUALS(b.y(), 2);
+ TEST_ASSERT_EQUALS(b.z(), 3);
+ TEST_ASSERT_EQUALS(b.w(), 4);
+
+ /* b = m;
+ TEST_ASSERT_EQUALS(b.x(), 5);
+ TEST_ASSERT_EQUALS(b.y(), 6);
+ TEST_ASSERT_EQUALS(b.z(), 7);
+ TEST_ASSERT_EQUALS(b.w(), 8); */
}
void
@@ -297,7 +294,7 @@ void
Vector4Test::testRawDataAccess()
{
modm::Vector4i a(0,1,2,3);
- int16_t *pointer = a.ptr();
+ int16_t *pointer = a.data();
TEST_ASSERT_EQUALS(a[0], 0);
TEST_ASSERT_EQUALS(a[1], 1);
@@ -315,63 +312,63 @@ Vector4Test::testOperators()
modm::Vector4i a(1, 2, 3, 4);
modm::Vector4i b(4, 5, 6, 7);
- TEST_ASSERT_EQUALS((a + b).x, 1+4);
- TEST_ASSERT_EQUALS((a + b).y, 2+5);
- TEST_ASSERT_EQUALS((a + b).z, 3+6);
- TEST_ASSERT_EQUALS((a + b).w, 4+7);
+ TEST_ASSERT_EQUALS((a + b).x(), 1+4);
+ TEST_ASSERT_EQUALS((a + b).y(), 2+5);
+ TEST_ASSERT_EQUALS((a + b).z(), 3+6);
+ TEST_ASSERT_EQUALS((a + b).w(), 4+7);
- TEST_ASSERT_EQUALS((a - b).x, 1-4);
- TEST_ASSERT_EQUALS((a - b).y, 2-5);
- TEST_ASSERT_EQUALS((a - b).z, 3-6);
- TEST_ASSERT_EQUALS((a - b).w, 4-7);
+ TEST_ASSERT_EQUALS((a - b).x(), 1-4);
+ TEST_ASSERT_EQUALS((a - b).y(), 2-5);
+ TEST_ASSERT_EQUALS((a - b).z(), 3-6);
+ TEST_ASSERT_EQUALS((a - b).w(), 4-7);
TEST_ASSERT_EQUALS((a * b), 1*4+2*5+3*6+4*7);
- TEST_ASSERT_EQUALS((a * 3).x, 1*3);
- TEST_ASSERT_EQUALS((a * 3).y, 2*3);
- TEST_ASSERT_EQUALS((a * 3).z, 3*3);
- TEST_ASSERT_EQUALS((a * 3).w, 4*3);
+ TEST_ASSERT_EQUALS((a * 3).x(), 1*3);
+ TEST_ASSERT_EQUALS((a * 3).y(), 2*3);
+ TEST_ASSERT_EQUALS((a * 3).z(), 3*3);
+ TEST_ASSERT_EQUALS((a * 3).w(), 4*3);
- TEST_ASSERT_EQUALS((3 * a).x, 3*1);
- TEST_ASSERT_EQUALS((3 * a).y, 3*2);
- TEST_ASSERT_EQUALS((3 * a).z, 3*3);
- TEST_ASSERT_EQUALS((3 * a).w, 3*4);
+ TEST_ASSERT_EQUALS((3 * a).x(), 3*1);
+ TEST_ASSERT_EQUALS((3 * a).y(), 3*2);
+ TEST_ASSERT_EQUALS((3 * a).z(), 3*3);
+ TEST_ASSERT_EQUALS((3 * a).w(), 3*4);
- TEST_ASSERT_EQUALS((b / 2).x, 4/2);
- TEST_ASSERT_EQUALS((b / 2).y, 5/2);
- TEST_ASSERT_EQUALS((b / 2).z, 6/2);
- TEST_ASSERT_EQUALS((b / 2).w, 7/2);
+ TEST_ASSERT_EQUALS((b / 2).x(), 4/2);
+ TEST_ASSERT_EQUALS((b / 2).y(), 5/2);
+ TEST_ASSERT_EQUALS((b / 2).z(), 6/2);
+ TEST_ASSERT_EQUALS((b / 2).w(), 7/2);
-b;
- TEST_ASSERT_EQUALS(b.x, 4);
- TEST_ASSERT_EQUALS(b.y, 5);
- TEST_ASSERT_EQUALS(b.z, 6);
- TEST_ASSERT_EQUALS(b.w, 7);
+ TEST_ASSERT_EQUALS(b.x(), 4);
+ TEST_ASSERT_EQUALS(b.y(), 5);
+ TEST_ASSERT_EQUALS(b.z(), 6);
+ TEST_ASSERT_EQUALS(b.w(), 7);
b = -b;
- TEST_ASSERT_EQUALS(b.x, -4);
- TEST_ASSERT_EQUALS(b.y, -5);
- TEST_ASSERT_EQUALS(b.z, -6);
- TEST_ASSERT_EQUALS(b.w, -7);
+ TEST_ASSERT_EQUALS(b.x(), -4);
+ TEST_ASSERT_EQUALS(b.y(), -5);
+ TEST_ASSERT_EQUALS(b.z(), -6);
+ TEST_ASSERT_EQUALS(b.w(), -7);
a += b;
- TEST_ASSERT_EQUALS(a.x, 1-4);
- TEST_ASSERT_EQUALS(a.y, 2-5);
- TEST_ASSERT_EQUALS(a.z, 3-6);
- TEST_ASSERT_EQUALS(a.w, 4-7);
+ TEST_ASSERT_EQUALS(a.x(), 1-4);
+ TEST_ASSERT_EQUALS(a.y(), 2-5);
+ TEST_ASSERT_EQUALS(a.z(), 3-6);
+ TEST_ASSERT_EQUALS(a.w(), 4-7);
a -= b;
- TEST_ASSERT_EQUALS(a.x, 1);
- TEST_ASSERT_EQUALS(a.y, 2);
- TEST_ASSERT_EQUALS(a.z, 3);
- TEST_ASSERT_EQUALS(a.w, 4);
+ TEST_ASSERT_EQUALS(a.x(), 1);
+ TEST_ASSERT_EQUALS(a.y(), 2);
+ TEST_ASSERT_EQUALS(a.z(), 3);
+ TEST_ASSERT_EQUALS(a.w(), 4);
a *= 2;
- TEST_ASSERT_EQUALS(a.x, 1*2);
- TEST_ASSERT_EQUALS(a.y, 2*2);
- TEST_ASSERT_EQUALS(a.z, 3*2);
- TEST_ASSERT_EQUALS(a.w, 4*2);
+ TEST_ASSERT_EQUALS(a.x(), 1*2);
+ TEST_ASSERT_EQUALS(a.y(), 2*2);
+ TEST_ASSERT_EQUALS(a.z(), 3*2);
+ TEST_ASSERT_EQUALS(a.w(), 4*2);
b /= 2;
- TEST_ASSERT_EQUALS(b.x, -4/2);
- TEST_ASSERT_EQUALS(b.y, -5/2);
- TEST_ASSERT_EQUALS(b.z, -6/2);
- TEST_ASSERT_EQUALS(b.w, -7/2);
+ TEST_ASSERT_EQUALS(b.x(), -4/2);
+ TEST_ASSERT_EQUALS(b.y(), -5/2);
+ TEST_ASSERT_EQUALS(b.z(), -6/2);
+ TEST_ASSERT_EQUALS(b.w(), -7/2);
}
void
@@ -382,23 +379,23 @@ Vector4Test::testLength()
TEST_ASSERT_EQUALS_FLOAT(a.getLengthSquared(), 1.f*1.f+2.f*2.f+3.f*3.f+4.f*4.f);
TEST_ASSERT_EQUALS_FLOAT(a.getLength(), 5.477225575);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).x, 0.3651483717);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).y, 0.7302967433);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).z, 1.095445115);
- TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).w, 1.4605934867);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).x(), 0.3651483717);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).y(), 0.7302967433);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).z(), 1.095445115);
+ TEST_ASSERT_EQUALS_FLOAT(a.scaled(2.f).w(), 1.4605934867);
a.scale(2.f);
- TEST_ASSERT_EQUALS_FLOAT(a.x, 0.3651483717);
- TEST_ASSERT_EQUALS_FLOAT(a.y, 0.7302967433);
- TEST_ASSERT_EQUALS_FLOAT(a.z, 1.095445115);
- TEST_ASSERT_EQUALS_FLOAT(a.w, 1.4605934867);
-
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().x, 0.1825741858);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().y, 0.3651483717);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().z, 0.5477225575);
- TEST_ASSERT_EQUALS_FLOAT(a.normalized().w, 0.7302967433);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 0.3651483717);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 0.7302967433);
+ TEST_ASSERT_EQUALS_FLOAT(a.z(), 1.095445115);
+ TEST_ASSERT_EQUALS_FLOAT(a.w(), 1.4605934867);
+
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().x(), 0.1825741858);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().y(), 0.3651483717);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().z(), 0.5477225575);
+ TEST_ASSERT_EQUALS_FLOAT(a.normalized().w(), 0.7302967433);
a.normalize();
- TEST_ASSERT_EQUALS_FLOAT(a.x, 0.1825741858);
- TEST_ASSERT_EQUALS_FLOAT(a.y, 0.3651483717);
- TEST_ASSERT_EQUALS_FLOAT(a.z, 0.5477225575);
- TEST_ASSERT_EQUALS_FLOAT(a.w, 0.7302967433);
+ TEST_ASSERT_EQUALS_FLOAT(a.x(), 0.1825741858);
+ TEST_ASSERT_EQUALS_FLOAT(a.y(), 0.3651483717);
+ TEST_ASSERT_EQUALS_FLOAT(a.z(), 0.5477225575);
+ TEST_ASSERT_EQUALS_FLOAT(a.w(), 0.7302967433);
}
diff --git a/test/modm/math/geometry/vector_test.cpp b/test/modm/math/geometry/vector_test.cpp
index 9e2ada7597..0dab630ae2 100644
--- a/test/modm/math/geometry/vector_test.cpp
+++ b/test/modm/math/geometry/vector_test.cpp
@@ -17,7 +17,7 @@ void
VectorTest::testConstructor()
{
int16_t array[2] = {1, 2};
- modm::Matrix<int16_t, 2, 1> m(array);
+/* modm::Matrix<int16_t, 2, 1> m(array); */
modm::Vector<int16_t, 2> a;
TEST_ASSERT_EQUALS(a[0], 0);
@@ -36,19 +36,18 @@ VectorTest::testConstructor()
TEST_ASSERT_EQUALS(p[0], 1);
TEST_ASSERT_EQUALS(p[1], 2);
- modm::Vector<int16_t, 2> q(m);
+/* modm::Vector<int16_t, 2> q(m);
TEST_ASSERT_EQUALS(q[0], 1);
- TEST_ASSERT_EQUALS(q[1], 2);
+ TEST_ASSERT_EQUALS(q[1], 2); */
}
void
VectorTest::testAssign()
-{
- int16_t array1[4] = {1, 2, 3, 4};
- modm::Vector<int16_t, 4> a(array1);
+{;
+ modm::Vector<int16_t, 4> a = {1, 2, 3, 4};
- int16_t array2[4] = {5, 6, 7, 8};
- modm::Matrix<int16_t, 4, 1> m(array2);
+ /* int16_t array2[4] = {5, 6, 7, 8};
+ modm::Matrix<int16_t, 4, 1> m(array2); */
modm::Vector<int16_t, 4> b;
@@ -58,11 +57,11 @@ VectorTest::testAssign()
TEST_ASSERT_EQUALS(b[2], 3);
TEST_ASSERT_EQUALS(b[3], 4);
- b = m;
+ /* b = m;
TEST_ASSERT_EQUALS(b[0], 5);
TEST_ASSERT_EQUALS(b[1], 6);
TEST_ASSERT_EQUALS(b[2], 7);
- TEST_ASSERT_EQUALS(b[3], 8);
+ TEST_ASSERT_EQUALS(b[3], 8); */
}
void
@@ -99,12 +98,13 @@ VectorTest::testCompare()
TEST_ASSERT_FALSE(a >= c);
}
+// TODO I think this is no more required
void
VectorTest::testRawDataAccess()
{
int16_t array[4] = {0, 1, 2, 3};
modm::Vector<int16_t,4> a(array);
- int16_t *pointer = a.ptr();
+ int16_t *pointer = a.data();
TEST_ASSERT_EQUALS(a[0], 0);
TEST_ASSERT_EQUALS(a[1], 1);
@@ -119,11 +119,9 @@ VectorTest::testRawDataAccess()
void
VectorTest::testOperators()
{
- int16_t array1[4] = {1, 2, 3, 4};
- modm::Vector<int16_t,4> a(array1);
+ modm::Vector<int16_t,4> a({1, 2, 3, 4});
- int16_t array2[4] = {4, 5, 6, 7};
- modm::Vector<int16_t,4> b(array2);
+ modm::Vector<int16_t,4> b({4, 5, 6, 7});
TEST_ASSERT_EQUALS((a + b)[0], 1+4);
TEST_ASSERT_EQUALS((a + b)[1], 2+5);
@@ -135,7 +133,7 @@ VectorTest::testOperators()
TEST_ASSERT_EQUALS((a - b)[2], 3-6);
TEST_ASSERT_EQUALS((a - b)[3], 4-7);
- TEST_ASSERT_EQUALS((a * b), 1*4 + 2*5 + 3*6 + 4*7);
+ TEST_ASSERT_EQUALS((a.dot(b)), 1*4 + 2*5 + 3*6 + 4*7);
TEST_ASSERT_EQUALS((a * 3)[0], 1*3);
TEST_ASSERT_EQUALS((a * 3)[1], 2*3);
@@ -199,23 +197,33 @@ void VectorTest::testConvert()
modm::Vector<float, 2> f(1.3, 2.7);
modm::Vector<double, 2> d(1.3, 2.7);
+ // convert() is deprecated but we still test for b.c.
+ modm::Vector<double, 2> d2 = f.convert<double>();
+ TEST_ASSERT_EQUALS_FLOAT(d2.x(), 1.3);
+ TEST_ASSERT_EQUALS_FLOAT(d2.y(), 2.7);
+ // convert() is deprecated but we still test for b.c.
+ modm::Vector<float, 2> f2 = d.convert<float>();
+ TEST_ASSERT_EQUALS_FLOAT(f2.x(), 1.3);
+ TEST_ASSERT_EQUALS_FLOAT(f2.y(), 2.7);
+
+ // Conversion constructor replaces convert()
+ modm::Vector<double, 2> d3(f);
+ TEST_ASSERT_EQUALS_FLOAT(d3.x(), 1.3);
+ TEST_ASSERT_EQUALS_FLOAT(d3.y(), 2.7);
+ // Conversion constructor replaces convert()
+ modm::Vector<float, 2> f3(d);
+ TEST_ASSERT_EQUALS_FLOAT(f3.x(), 1.3);
+ TEST_ASSERT_EQUALS_FLOAT(f3.y(), 2.7);
+
modm::Vector<uint8_t, 2> u8(1.3, 2.7);
- TEST_ASSERT_EQUALS(u8.x, 1);
- TEST_ASSERT_EQUALS(u8.y, 3);
+ TEST_ASSERT_EQUALS(u8.x(), 1);
+ TEST_ASSERT_EQUALS(u8.y(), 3);
modm::Vector<int8_t, 2> i8(1.3, 2.7);
- TEST_ASSERT_EQUALS(i8.x, 1);
- TEST_ASSERT_EQUALS(i8.y, 3);
+ TEST_ASSERT_EQUALS(i8.x(), 1);
+ TEST_ASSERT_EQUALS(i8.y(), 3);
- modm::Vector<uint16_t, 2> u16(1.3, 2.7);
- TEST_ASSERT_EQUALS(u16.x, 1);
- TEST_ASSERT_EQUALS(u16.y, 3);
-
- modm::Vector<int16_t, 2> i16(1.3, 2.7);
- TEST_ASSERT_EQUALS(i16.x, 1);
- TEST_ASSERT_EQUALS(i16.y, 3);
-
- modm::Vector<double, 2> d2 = f.convert<double>();
-
- modm::Vector<float, 2> f2 = f.convert<float>();
+ modm::Vector<int8_t, 2> i82(f);
+ TEST_ASSERT_EQUALS(i82.x(), 1);
+ TEST_ASSERT_EQUALS(i82.y(), 3);
}
diff --git a/test/modm/math/geometry/vector_test.hpp b/test/modm/math/geometry/vector_test.hpp
index 4ffb83e8a2..262b416b39 100644
--- a/test/modm/math/geometry/vector_test.hpp
+++ b/test/modm/math/geometry/vector_test.hpp
@@ -34,4 +34,7 @@ class VectorTest : public unittest::TestSuite
void
testLength();
+
+ void
+ testConvert();
};
diff --git a/test/modm/math/matrix_test.cpp b/test/modm/math/matrix_test.cpp
index 77f5ee3737..b16322cca6 100644
--- a/test/modm/math/matrix_test.cpp
+++ b/test/modm/math/matrix_test.cpp
@@ -44,8 +44,8 @@ MatrixTest::testConstruction()
modm::Matrix<int16_t, 3, 2> b(n);
- TEST_ASSERT_EQUALS(b.getNumberOfRows(), 3);
- TEST_ASSERT_EQUALS(b.getNumberOfColumns(), 2);
+ TEST_ASSERT_EQUALS(b.getNumberOfRows(), std::size_t(3));
+ TEST_ASSERT_EQUALS(b.getNumberOfColumns(), std::size_t(2));
TEST_ASSERT_EQUALS(b[0][0], 1);
TEST_ASSERT_EQUALS(b[0][1], 2);
@@ -359,7 +359,10 @@ MatrixTest::testMatrixMultiplication()
6, 7, 8, 9, 10,
11, 12, 13, 14, 15
};
- modm::Matrix<int16_t, 2, 5> l(q);
+ std::span<const int16_t> r(q);
+ std::span<const int16_t, 10> q10{r};
+
+ modm::Matrix<int16_t, 2, 5> l(q10);
modm::Matrix<int16_t, 5, 3> ll(q);
modm::Matrix<int16_t, 2, 3> aa = l * ll;
@@ -447,7 +450,7 @@ MatrixTest::testReplace()
TEST_ASSERT_EQUALS(c[1][0], 7);
TEST_ASSERT_EQUALS(c[1][1], 2);
- const int16_t o[2] = { 10, 12 };
+ const int16_t o[] = { 10, 12 };
modm::Matrix<int16_t, 1, 2> row(o);
c.replaceRow(0, row);
@@ -597,7 +600,7 @@ MatrixTest::testRemoveRowColumn()
void
MatrixTest::testDeterminant()
{
- const int16_t m[9] = {
+ const int16_t m[] = {
1, 2, 3,
4, 5, 6,
7, 8, 9
diff --git a/test/modm/math/matrix_vector_test.cpp b/test/modm/math/matrix_vector_test.cpp
index 179edfa563..f6521b2add 100644
--- a/test/modm/math/matrix_vector_test.cpp
+++ b/test/modm/math/matrix_vector_test.cpp
@@ -39,13 +39,13 @@ MatrixVectorTest::testMatrixVectorMultiplication()
1.
};
- const modm::Matrix<float, 3, 3> a(m);
- const modm::Vector3f b(v);
+ // TODO
+ // const modm::Matrix<float, 3, 3> a(m);
+ // const modm::Vector3f b(v);
- modm::Vector3f c = a * b;
-
- TEST_ASSERT_EQUALS(c[0], -18);
- TEST_ASSERT_EQUALS(c[1], -20);
- TEST_ASSERT_EQUALS(c[2], -15);
+ // modm::Vector3f c = a * b;
+ // TEST_ASSERT_EQUALS(c[0], -18);
+ // TEST_ASSERT_EQUALS(c[1], -20);
+ // TEST_ASSERT_EQUALS(c[2], -15);
}
From 30c76f309e68451c7fbb99b2f82dc5cef471a9ef Mon Sep 17 00:00:00 2001
From: Thomas Sommer <thomas@tomsaw.de>
Date: Tue, 25 Jan 2022 13:53:04 +0100
Subject: [PATCH 3/3] update /src and /examples, primary: x -> x(), y -> y(), z
-> z()
---
.../avr/display/dogm128/benchmark/main.cpp | 4 +-
examples/nucleo_f042k6/lis3mdl/main.cpp | 6 +-
examples/nucleo_f042k6/lsm6ds33/main.cpp | 12 ++--
examples/nucleo_f429zi/pat9125el/main.cpp | 2 +-
examples/stm32_f4ve/gui/main.cpp | 56 +++++++++----------
.../stm32_f4ve/gui/touchscreen_calibrator.hpp | 44 +++++++--------
.../stm32f4_discovery/open407v-d/gui/main.cpp | 48 ++++++++--------
.../open407v-d/gui/touchscreen_calibrator.hpp | 44 +++++++--------
.../open407v-d/touchscreen/main.cpp | 34 +++++------
.../touchscreen/touchscreen_calibrator.hpp | 44 +++++++--------
src/modm/driver/display/ili9341_impl.hpp | 24 ++++----
src/modm/driver/inertial/bno055.hpp | 2 +-
src/modm/driver/inertial/lis3mdl.hpp | 2 +-
src/modm/driver/inertial/lis3mdl_impl.hpp | 9 +--
src/modm/driver/inertial/lsm6ds33.hpp | 2 +-
src/modm/driver/inertial/lsm6ds33_impl.hpp | 25 +++------
src/modm/driver/motion/pat9125el.hpp | 2 +-
src/modm/driver/motion/pat9125el_impl.hpp | 4 +-
src/modm/driver/touch/ads7843_impl.hpp | 2 +-
src/modm/ui/display/graphic_display.cpp | 28 +++++-----
src/modm/ui/display/graphic_display.hpp | 10 ++--
src/modm/ui/display/graphic_display_fill.cpp | 14 ++---
src/modm/ui/display/graphic_display_text.cpp | 7 ++-
...nochrome_graphic_display_vertical_impl.hpp | 26 ++++-----
src/modm/ui/gui/view.cpp | 8 +--
src/modm/ui/gui/widgets/button.cpp | 12 ++--
src/modm/ui/gui/widgets/checkbox.cpp | 4 +-
src/modm/ui/gui/widgets/label.cpp | 2 +-
src/modm/ui/gui/widgets/numberfield.cpp | 4 +-
src/modm/ui/gui/widgets/numberfield_impl.hpp | 4 +-
src/modm/ui/gui/widgets/stringfield.cpp | 4 +-
src/modm/ui/gui/widgets/widget.cpp | 22 ++++----
32 files changed, 251 insertions(+), 260 deletions(-)
diff --git a/examples/avr/display/dogm128/benchmark/main.cpp b/examples/avr/display/dogm128/benchmark/main.cpp
index b8989c1dbe..6489192b54 100644
--- a/examples/avr/display/dogm128/benchmark/main.cpp
+++ b/examples/avr/display/dogm128/benchmark/main.cpp
@@ -129,8 +129,8 @@ introScreen()
void
drawSpinner(Point center, uint8_t pos)
{
- const uint8_t x = center.getX();
- const uint8_t y = center.getY();
+ const uint8_t x = center.x();
+ const uint8_t y = center.y();
switch(pos % 8)
{
diff --git a/examples/nucleo_f042k6/lis3mdl/main.cpp b/examples/nucleo_f042k6/lis3mdl/main.cpp
index 461a11c476..2c1d95e5b6 100644
--- a/examples/nucleo_f042k6/lis3mdl/main.cpp
+++ b/examples/nucleo_f042k6/lis3mdl/main.cpp
@@ -58,9 +58,9 @@ main()
if(success)
{
MODM_LOG_INFO << "Magnetic Vector:" << modm::endl;
- MODM_LOG_INFO << "X: "<< magVector.x << " gauss" << modm::endl;
- MODM_LOG_INFO << "Y: "<< magVector.y << " gauss" << modm::endl;
- MODM_LOG_INFO << "Z: "<< magVector.z << " gauss" << modm::endl;
+ MODM_LOG_INFO << "X: "<< magVector.x() << " gauss" << modm::endl;
+ MODM_LOG_INFO << "Y: "<< magVector.y() << " gauss" << modm::endl;
+ MODM_LOG_INFO << "Z: "<< magVector.z() << " gauss" << modm::endl;
MODM_LOG_INFO << modm::endl;
}
else
diff --git a/examples/nucleo_f042k6/lsm6ds33/main.cpp b/examples/nucleo_f042k6/lsm6ds33/main.cpp
index 0c839f9d24..9c9af231f8 100644
--- a/examples/nucleo_f042k6/lsm6ds33/main.cpp
+++ b/examples/nucleo_f042k6/lsm6ds33/main.cpp
@@ -54,15 +54,15 @@ main()
if(accSuccess && gyroSuccess)
{
MODM_LOG_INFO << "Acceleration Vector:" << modm::endl;
- MODM_LOG_INFO << "X: "<< accVector.x << " g" << modm::endl;
- MODM_LOG_INFO << "Y: "<< accVector.y << " g" << modm::endl;
- MODM_LOG_INFO << "Z: "<< accVector.z << " g" << modm::endl;
+ MODM_LOG_INFO << "X: "<< accVector.x() << " g" << modm::endl;
+ MODM_LOG_INFO << "Y: "<< accVector.y() << " g" << modm::endl;
+ MODM_LOG_INFO << "Z: "<< accVector.z() << " g" << modm::endl;
MODM_LOG_INFO << modm::endl;
MODM_LOG_INFO << "Spin Rates Vector:" << modm::endl;
- MODM_LOG_INFO << "X: "<< gyroVector.x << " deg/s" << modm::endl;
- MODM_LOG_INFO << "Y: "<< gyroVector.y << " deg/s" << modm::endl;
- MODM_LOG_INFO << "Z: "<< gyroVector.z << " deg/s" << modm::endl;
+ MODM_LOG_INFO << "X: "<< gyroVector.x() << " deg/s" << modm::endl;
+ MODM_LOG_INFO << "Y: "<< gyroVector.y() << " deg/s" << modm::endl;
+ MODM_LOG_INFO << "Z: "<< gyroVector.z() << " deg/s" << modm::endl;
MODM_LOG_INFO << modm::endl;
}
diff --git a/examples/nucleo_f429zi/pat9125el/main.cpp b/examples/nucleo_f429zi/pat9125el/main.cpp
index 7a4ea3ea36..9ddb3c845c 100644
--- a/examples/nucleo_f429zi/pat9125el/main.cpp
+++ b/examples/nucleo_f429zi/pat9125el/main.cpp
@@ -57,7 +57,7 @@ class Thread : public modm::pt::Protothread
position += sensor.getData();
Board::Leds::write(0b111);
- MODM_LOG_INFO << "Position: " << position.x << ", " << position.y << modm::endl;
+ MODM_LOG_INFO << "Position: " << position << modm::endl;
sensor.resetMoved();
} else {
Board::Leds::write(0b000);
diff --git a/examples/stm32_f4ve/gui/main.cpp b/examples/stm32_f4ve/gui/main.cpp
index 29c27eecaa..a979e96173 100644
--- a/examples/stm32_f4ve/gui/main.cpp
+++ b/examples/stm32_f4ve/gui/main.cpp
@@ -169,23 +169,23 @@ static void
drawCross(modm::ColorGraphicDisplay& display, modm::glcd::Point center)
{
display.setColor(html::Red);
- display.drawLine(center.x - 15, center.y, center.x - 2, center.y);
- display.drawLine(center.x + 2, center.y, center.x + 15, center.y);
- display.drawLine(center.x, center.y - 15, center.x, center.y - 2);
- display.drawLine(center.x, center.y + 2, center.x, center.y + 15);
+ display.drawLine(center.x() - 15, center.y(), center.x() - 2, center.y());
+ display.drawLine(center.x() + 2, center.y(), center.x() + 15, center.y());
+ display.drawLine(center.x(), center.y() - 15, center.x(), center.y() - 2);
+ display.drawLine(center.x(), center.y() + 2, center.x(), center.y() + 15);
display.setColor(html::White);
- display.drawLine(center.x - 15, center.y + 15, center.x - 7, center.y + 15);
- display.drawLine(center.x - 15, center.y + 7, center.x - 15, center.y + 15);
+ display.drawLine(center.x() - 15, center.y() + 15, center.x() - 7, center.y() + 15);
+ display.drawLine(center.x() - 15, center.y() + 7, center.x() - 15, center.y() + 15);
- display.drawLine(center.x - 15, center.y - 15, center.x - 7, center.y - 15);
- display.drawLine(center.x - 15, center.y - 7, center.x - 15, center.y - 15);
+ display.drawLine(center.x() - 15, center.y() - 15, center.x() - 7, center.y() - 15);
+ display.drawLine(center.x() - 15, center.y() - 7, center.x() - 15, center.y() - 15);
- display.drawLine(center.x + 7, center.y + 15, center.x + 15, center.y + 15);
- display.drawLine(center.x + 15, center.y + 7, center.x + 15, center.y + 15);
+ display.drawLine(center.x() + 7, center.y() + 15, center.x() + 15, center.y() + 15);
+ display.drawLine(center.x() + 15, center.y() + 7, center.x() + 15, center.y() + 15);
- display.drawLine(center.x + 7, center.y - 15, center.x + 15, center.y - 15);
- display.drawLine(center.x + 15, center.y - 15, center.x + 15, center.y - 7);
+ display.drawLine(center.x() + 7, center.y() - 15, center.x() + 15, center.y() - 15);
+ display.drawLine(center.x() + 15, center.y() - 15, center.x() + 15, center.y() - 7);
}
static void
@@ -211,7 +211,7 @@ calibrateTouchscreen(modm::ColorGraphicDisplay& display, modm::glcd::Point *fixe
// wait until a valid sample can be taken
}
- MODM_LOG_DEBUG << "calibration point: (" << sample[i].x << " | " << sample[i].y << ")" << modm::endl;
+ MODM_LOG_DEBUG << "calibration point: (" << sample[i].x() << " | " << sample[i].y() << ")" << modm::endl;
}
touchscreen.calibrate(calibrationPoint, sample);
@@ -227,14 +227,14 @@ void
drawPoint(modm::GraphicDisplay& display, modm::glcd::Point point)
{
MODM_LOG_DEBUG << __PRETTY_FUNCTION__ << modm::endl;
- if (point.x < 0 || point.y < 0) {
+ if (point.x() < 0 || point.y() < 0) {
return;
}
- display.setPixel(point.x, point.y);
- display.setPixel(point.x + 1, point.y);
- display.setPixel(point.x, point.y + 1);
- display.setPixel(point.x + 1, point.y + 1);
+ display.setPixel(point.x(), point.y());
+ display.setPixel(point.x() + 1, point.y());
+ display.setPixel(point.x(), point.y() + 1);
+ display.setPixel(point.x() + 1, point.y() + 1);
}
// ----------------------------------------------------------------------------
@@ -286,8 +286,8 @@ debounceTouch(modm::glcd::Point *out, modm::glcd::Point *old)
// translate point according to calibration
touchscreen.translate(&raw, &point);
- if(abs(point.x - old->x) < TP_TOLERANCE &&
- abs(point.y - old->y) < TP_TOLERANCE
+ if(abs(point.x() - old->x()) < TP_TOLERANCE &&
+ abs(point.y() - old->y()) < TP_TOLERANCE
)
{
// point is within area of last touch
@@ -321,8 +321,8 @@ touchUp(void* data)
modm::gui::InputEvent* ev = static_cast<modm::gui::InputEvent*>(data);
MODM_LOG_DEBUG << "asynchronous UP-event:" << modm::endl;
- MODM_LOG_DEBUG << "x: " << ev->coord.x << modm::endl;
- MODM_LOG_DEBUG << "y: " << ev->coord.y << modm::endl;
+ MODM_LOG_DEBUG << "x: " << ev->coord.x() << modm::endl;
+ MODM_LOG_DEBUG << "y: " << ev->coord.y() << modm::endl;
// queue UP-event as new input event
input_queue.push(ev);
@@ -351,8 +351,8 @@ gatherInput()
auto async_ev = new modm::gui::AsyncEvent(500, &touchUp, (void*)(ev_up));
async_events.append(async_ev);
- MODM_LOG_DEBUG << "touch down x: " << point.x << modm::endl;
- MODM_LOG_DEBUG << "touch down y: " << point.y << modm::endl;
+ MODM_LOG_DEBUG << "touch down x: " << point.x() << modm::endl;
+ MODM_LOG_DEBUG << "touch down y: " << point.y() << modm::endl;
}
}
@@ -492,11 +492,11 @@ main()
/*
* display an arbitrary image
*/
- // if(pixPos.x < 0 || (pixPos.x + pix[0]) > tft.getWidth()){
- // pixDeltaPos.x *= -1;
+ // if(pixPos.x() < 0 || (pixPos.x() + pix[0]) > tft.getWidth()){
+ // pixDeltaPos.x() *= -1;
// }
- // if(pixPos.y < 0 || (pixPos.y + pix[1]) > tft.getHeight()){
- // pixDeltaPos.y *= -1;
+ // if(pixPos.y() < 0 || (pixPos.y() + pix[1]) > tft.getHeight()){
+ // pixDeltaPos.y() *= -1;
// }
// pixPos += pixDeltaPos;
// tft.drawImage(pixPos, pix);
diff --git a/examples/stm32_f4ve/gui/touchscreen_calibrator.hpp b/examples/stm32_f4ve/gui/touchscreen_calibrator.hpp
index 9fe858941a..f8fefd47be 100644
--- a/examples/stm32_f4ve/gui/touchscreen_calibrator.hpp
+++ b/examples/stm32_f4ve/gui/touchscreen_calibrator.hpp
@@ -56,34 +56,34 @@ modm::TouchscreenCalibrator::calibrate(
modm::glcd::Point * display, modm::glcd::Point * sample)
{
// K��(X0��X2) (Y1��Y2)��(X1��X2) (Y0��Y2)
- scale = ((sample[0].x - sample[2].x) * (sample[1].y - sample[2].y)) -
- ((sample[1].x - sample[2].x) * (sample[0].y - sample[2].y));
+ scale = ((sample[0].x() - sample[2].x()) * (sample[1].y() - sample[2].y())) -
+ ((sample[1].x() - sample[2].x()) * (sample[0].y() - sample[2].y()));
if (scale == 0) {
return false;
}
// A��((XD0��XD2) (Y1��Y2)��(XD1��XD2) (Y0��Y2))��K
- An = ((display[0].x - display[2].x) * (sample[1].y - sample[2].y)) -
- ((display[1].x - display[2].x) * (sample[0].y - sample[2].y));
+ An = ((display[0].x() - display[2].x()) * (sample[1].y() - sample[2].y())) -
+ ((display[1].x() - display[2].x()) * (sample[0].y() - sample[2].y()));
// B��((X0��X2) (XD1��XD2)��(XD0��XD2) (X1��X2))��K */
- Bn = ((sample[0].x - sample[2].x) * (display[1].x - display[2].x)) -
- ((display[0].x - display[2].x) * (sample[1].x - sample[2].x));
+ Bn = ((sample[0].x() - sample[2].x()) * (display[1].x() - display[2].x())) -
+ ((display[0].x() - display[2].x()) * (sample[1].x() - sample[2].x()));
// C��(Y0(X2XD1��X1XD2)+Y1(X0XD2��X2XD0)+Y2(X1XD0��X0XD1))��K */
- Cn = (sample[2].x * display[1].x - sample[1].x * display[2].x) * sample[0].y +
- (sample[0].x * display[2].x - sample[2].x * display[0].x) * sample[1].y +
- (sample[1].x * display[0].x - sample[0].x * display[1].x) * sample[2].y;
+ Cn = (sample[2].x() * display[1].x() - sample[1].x() * display[2].x()) * sample[0].y() +
+ (sample[0].x() * display[2].x() - sample[2].x() * display[0].x()) * sample[1].y() +
+ (sample[1].x() * display[0].x() - sample[0].x() * display[1].x()) * sample[2].y();
// D��((YD0��YD2) (Y1��Y2)��(YD1��YD2) (Y0��Y2))��K */
- Dn = ((display[0].y - display[2].y) * (sample[1].y - sample[2].y)) -
- ((display[1].y - display[2].y) * (sample[0].y - sample[2].y));
+ Dn = ((display[0].y() - display[2].y()) * (sample[1].y() - sample[2].y())) -
+ ((display[1].y() - display[2].y()) * (sample[0].y() - sample[2].y()));
// E��((X0��X2) (YD1��YD2)��(YD0��YD2) (X1��X2))��K */
- En = ((sample[0].x - sample[2].x) * (display[1].y - display[2].y)) -
- ((display[0].y - display[2].y) * (sample[1].x - sample[2].x));
+ En = ((sample[0].x() - sample[2].x()) * (display[1].y() - display[2].y())) -
+ ((display[0].y() - display[2].y()) * (sample[1].x() - sample[2].x()));
// F��(Y0(X2YD1��X1YD2)+Y1(X0YD2��X2YD0)+Y2(X1YD0��X0YD1))��K */
- Fn = (sample[2].x * display[1].y - sample[1].x * display[2].y) * sample[0].y +
- (sample[0].x * display[2].y - sample[2].x * display[0].y) * sample[1].y +
- (sample[1].x * display[0].y - sample[0].x * display[1].y) * sample[2].y;
+ Fn = (sample[2].x() * display[1].y() - sample[1].x() * display[2].y()) * sample[0].y() +
+ (sample[0].x() * display[2].y() - sample[2].x() * display[0].y()) * sample[1].y() +
+ (sample[1].x() * display[0].y() - sample[0].x() * display[1].y()) * sample[2].y();
return true;
}
@@ -94,12 +94,12 @@ modm::TouchscreenCalibrator::translate(modm::glcd::Point * raw, modm::glcd::Poin
if (scale != 0)
{
/* XD = AX+BY+C */
- translated->x =
- ((An * raw->x) +
- (Bn * raw->y) + Cn) / scale;
+ translated->x() =
+ ((An * raw->x()) +
+ (Bn * raw->y()) + Cn) / scale;
/* YD = DX+EY+F */
- translated->y =
- ((Dn * raw->x) +
- (En * raw->y) + Fn) / scale;
+ translated->y() =
+ ((Dn * raw->x()) +
+ (En * raw->y()) + Fn) / scale;
}
}
diff --git a/examples/stm32f4_discovery/open407v-d/gui/main.cpp b/examples/stm32f4_discovery/open407v-d/gui/main.cpp
index 994beaf434..f1e97a8d03 100644
--- a/examples/stm32f4_discovery/open407v-d/gui/main.cpp
+++ b/examples/stm32f4_discovery/open407v-d/gui/main.cpp
@@ -178,23 +178,23 @@ static void
drawCross(modm::ColorGraphicDisplay& display, modm::glcd::Point center)
{
display.setColor(Red);
- display.drawLine(center.x - 15, center.y, center.x - 2, center.y);
- display.drawLine(center.x + 2, center.y, center.x + 15, center.y);
- display.drawLine(center.x, center.y - 15, center.x, center.y - 2);
- display.drawLine(center.x, center.y + 2, center.x, center.y + 15);
+ display.drawLine(center.x() - 15, center.y(), center.x() - 2, center.y());
+ display.drawLine(center.x() + 2, center.y(), center.x() + 15, center.y());
+ display.drawLine(center.x(), center.y() - 15, center.x(), center.y() - 2);
+ display.drawLine(center.x(), center.y() + 2, center.x(), center.y() + 15);
display.setColor(White);
- display.drawLine(center.x - 15, center.y + 15, center.x - 7, center.y + 15);
- display.drawLine(center.x - 15, center.y + 7, center.x - 15, center.y + 15);
+ display.drawLine(center.x() - 15, center.y() + 15, center.x() - 7, center.y() + 15);
+ display.drawLine(center.x() - 15, center.y() + 7, center.x() - 15, center.y() + 15);
- display.drawLine(center.x - 15, center.y - 15, center.x - 7, center.y - 15);
- display.drawLine(center.x - 15, center.y - 7, center.x - 15, center.y - 15);
+ display.drawLine(center.x() - 15, center.y() - 15, center.x() - 7, center.y() - 15);
+ display.drawLine(center.x() - 15, center.y() - 7, center.x() - 15, center.y() - 15);
- display.drawLine(center.x + 7, center.y + 15, center.x + 15, center.y + 15);
- display.drawLine(center.x + 15, center.y + 7, center.x + 15, center.y + 15);
+ display.drawLine(center.x() + 7, center.y() + 15, center.x() + 15, center.y() + 15);
+ display.drawLine(center.x() + 15, center.y() + 7, center.x() + 15, center.y() + 15);
- display.drawLine(center.x + 7, center.y - 15, center.x + 15, center.y - 15);
- display.drawLine(center.x + 15, center.y - 15, center.x + 15, center.y - 7);
+ display.drawLine(center.x() + 7, center.y() - 15, center.x() + 15, center.y() - 15);
+ display.drawLine(center.x() + 15, center.y() - 15, center.x() + 15, center.y() - 7);
}
static void
@@ -219,7 +219,7 @@ calibrateTouchscreen(modm::ColorGraphicDisplay& display, modm::glcd::Point *fixe
// wait until a valid sample can be taken
}
- MODM_LOG_DEBUG << "calibration point: (" << sample[i].x << " | " << sample[i].y << ")" << modm::endl;
+ MODM_LOG_DEBUG << "calibration point: (" << sample[i].x() << " | " << sample[i].y() << ")" << modm::endl;
}
touchscreen.calibrate(calibrationPoint, sample);
@@ -234,14 +234,14 @@ calibrateTouchscreen(modm::ColorGraphicDisplay& display, modm::glcd::Point *fixe
void
drawPoint(modm::GraphicDisplay& display, modm::glcd::Point point)
{
- if (point.x < 0 || point.y < 0) {
+ if (point.x() < 0 || point.y() < 0) {
return;
}
- display.setPixel(point.x, point.y);
- display.setPixel(point.x + 1, point.y);
- display.setPixel(point.x, point.y + 1);
- display.setPixel(point.x + 1, point.y + 1);
+ display.setPixel(point.x(), point.y());
+ display.setPixel(point.x() + 1, point.y());
+ display.setPixel(point.x(), point.y() + 1);
+ display.setPixel(point.x() + 1, point.y() + 1);
}
// ----------------------------------------------------------------------------
@@ -293,8 +293,8 @@ debounceTouch(modm::glcd::Point *out, modm::glcd::Point *old)
// translate point according to calibration
touchscreen.translate(&raw, &point);
- if(abs(point.x - old->x) < TP_TOLERANCE &&
- abs(point.y - old->y) < TP_TOLERANCE
+ if(abs(point.x() - old->x()) < TP_TOLERANCE &&
+ abs(point.y() - old->y()) < TP_TOLERANCE
)
{
// point is within area of last touch
@@ -327,8 +327,8 @@ touchUp(void* data)
modm::gui::InputEvent* ev = static_cast<modm::gui::InputEvent*>(data);
MODM_LOG_DEBUG << "asynchronous UP-event:" << modm::endl;
- MODM_LOG_DEBUG << "x: " << ev->coord.x << modm::endl;
- MODM_LOG_DEBUG << "y: " << ev->coord.y << modm::endl;
+ MODM_LOG_DEBUG << "x: " << ev->coord.x() << modm::endl;
+ MODM_LOG_DEBUG << "y: " << ev->coord.y() << modm::endl;
// queue UP-event as new input event
input_queue.push(ev);
@@ -358,8 +358,8 @@ gatherInput()
auto async_ev = new modm::gui::AsyncEvent(500, &touchUp, (void*)(ev_up));
async_events.append(async_ev);
- MODM_LOG_DEBUG << "touch down x: " << point.x << modm::endl;
- MODM_LOG_DEBUG << "touch down y: " << point.y << modm::endl;
+ MODM_LOG_DEBUG << "touch down x: " << point.x() << modm::endl;
+ MODM_LOG_DEBUG << "touch down y: " << point.y() << modm::endl;
}
}
diff --git a/examples/stm32f4_discovery/open407v-d/gui/touchscreen_calibrator.hpp b/examples/stm32f4_discovery/open407v-d/gui/touchscreen_calibrator.hpp
index 27c60664a9..3670852be2 100644
--- a/examples/stm32f4_discovery/open407v-d/gui/touchscreen_calibrator.hpp
+++ b/examples/stm32f4_discovery/open407v-d/gui/touchscreen_calibrator.hpp
@@ -59,34 +59,34 @@ modm::TouchscreenCalibrator::calibrate(
modm::glcd::Point * display, modm::glcd::Point * sample)
{
// K��(X0��X2) (Y1��Y2)��(X1��X2) (Y0��Y2)
- scale = ((sample[0].x - sample[2].x) * (sample[1].y - sample[2].y)) -
- ((sample[1].x - sample[2].x) * (sample[0].y - sample[2].y));
+ scale = ((sample[0].x() - sample[2].x()) * (sample[1].y() - sample[2].y())) -
+ ((sample[1].x() - sample[2].x()) * (sample[0].y() - sample[2].y()));
if (scale == 0) {
return false;
}
// A��((XD0��XD2) (Y1��Y2)��(XD1��XD2) (Y0��Y2))��K
- An = ((display[0].x - display[2].x) * (sample[1].y - sample[2].y)) -
- ((display[1].x - display[2].x) * (sample[0].y - sample[2].y));
+ An = ((display[0].x() - display[2].x()) * (sample[1].y() - sample[2].y())) -
+ ((display[1].x() - display[2].x()) * (sample[0].y() - sample[2].y()));
// B��((X0��X2) (XD1��XD2)��(XD0��XD2) (X1��X2))��K */
- Bn = ((sample[0].x - sample[2].x) * (display[1].x - display[2].x)) -
- ((display[0].x - display[2].x) * (sample[1].x - sample[2].x));
+ Bn = ((sample[0].x() - sample[2].x()) * (display[1].x() - display[2].x())) -
+ ((display[0].x() - display[2].x()) * (sample[1].x() - sample[2].x()));
// C��(Y0(X2XD1��X1XD2)+Y1(X0XD2��X2XD0)+Y2(X1XD0��X0XD1))��K */
- Cn = (sample[2].x * display[1].x - sample[1].x * display[2].x) * sample[0].y +
- (sample[0].x * display[2].x - sample[2].x * display[0].x) * sample[1].y +
- (sample[1].x * display[0].x - sample[0].x * display[1].x) * sample[2].y;
+ Cn = (sample[2].x() * display[1].x() - sample[1].x() * display[2].x()) * sample[0].y() +
+ (sample[0].x() * display[2].x() - sample[2].x() * display[0].x()) * sample[1].y() +
+ (sample[1].x() * display[0].x() - sample[0].x() * display[1].x()) * sample[2].y();
// D��((YD0��YD2) (Y1��Y2)��(YD1��YD2) (Y0��Y2))��K */
- Dn = ((display[0].y - display[2].y) * (sample[1].y - sample[2].y)) -
- ((display[1].y - display[2].y) * (sample[0].y - sample[2].y));
+ Dn = ((display[0].y() - display[2].y()) * (sample[1].y() - sample[2].y())) -
+ ((display[1].y() - display[2].y()) * (sample[0].y() - sample[2].y()));
// E��((X0��X2) (YD1��YD2)��(YD0��YD2) (X1��X2))��K */
- En = ((sample[0].x - sample[2].x) * (display[1].y - display[2].y)) -
- ((display[0].y - display[2].y) * (sample[1].x - sample[2].x));
+ En = ((sample[0].x() - sample[2].x()) * (display[1].y() - display[2].y())) -
+ ((display[0].y() - display[2].y()) * (sample[1].x() - sample[2].x()));
// F��(Y0(X2YD1��X1YD2)+Y1(X0YD2��X2YD0)+Y2(X1YD0��X0YD1))��K */
- Fn = (sample[2].x * display[1].y - sample[1].x * display[2].y) * sample[0].y +
- (sample[0].x * display[2].y - sample[2].x * display[0].y) * sample[1].y +
- (sample[1].x * display[0].y - sample[0].x * display[1].y) * sample[2].y;
+ Fn = (sample[2].x() * display[1].y() - sample[1].x() * display[2].y()) * sample[0].y() +
+ (sample[0].x() * display[2].y() - sample[2].x() * display[0].y()) * sample[1].y() +
+ (sample[1].x() * display[0].y() - sample[0].x() * display[1].y()) * sample[2].y();
return true;
}
@@ -97,12 +97,12 @@ modm::TouchscreenCalibrator::translate(modm::glcd::Point * raw, modm::glcd::Poin
if (scale != 0)
{
/* XD = AX+BY+C */
- translated->x =
- ((An * raw->x) +
- (Bn * raw->y) + Cn) / scale;
+ translated->x() =
+ ((An * raw->x()) +
+ (Bn * raw->y()) + Cn) / scale;
/* YD = DX+EY+F */
- translated->y =
- ((Dn * raw->x) +
- (En * raw->y) + Fn) / scale;
+ translated->y() =
+ ((Dn * raw->x()) +
+ (En * raw->y()) + Fn) / scale;
}
}
diff --git a/examples/stm32f4_discovery/open407v-d/touchscreen/main.cpp b/examples/stm32f4_discovery/open407v-d/touchscreen/main.cpp
index c82fbdc9bb..7495adcb96 100644
--- a/examples/stm32f4_discovery/open407v-d/touchscreen/main.cpp
+++ b/examples/stm32f4_discovery/open407v-d/touchscreen/main.cpp
@@ -135,23 +135,23 @@ static void
drawCross(modm::ColorGraphicDisplay& display, modm::glcd::Point center)
{
display.setColor(Red);
- display.drawLine(center.x - 15, center.y, center.x - 2, center.y);
- display.drawLine(center.x + 2, center.y, center.x + 15, center.y);
- display.drawLine(center.x, center.y - 15, center.x, center.y - 2);
- display.drawLine(center.x, center.y + 2, center.x, center.y + 15);
+ display.drawLine(center.x()- 15, center.y(), center.x()- 2, center.y());
+ display.drawLine(center.x()+ 2, center.y(), center.x()+ 15, center.y());
+ display.drawLine(center.x(), center.y() - 15, center.x(), center.y() - 2);
+ display.drawLine(center.x(), center.y() + 2, center.x(), center.y() + 15);
display.setColor(White);
- display.drawLine(center.x - 15, center.y + 15, center.x - 7, center.y + 15);
- display.drawLine(center.x - 15, center.y + 7, center.x - 15, center.y + 15);
+ display.drawLine(center.x()- 15, center.y() + 15, center.x()- 7, center.y() + 15);
+ display.drawLine(center.x()- 15, center.y() + 7, center.x()- 15, center.y() + 15);
- display.drawLine(center.x - 15, center.y - 15, center.x - 7, center.y - 15);
- display.drawLine(center.x - 15, center.y - 7, center.x - 15, center.y - 15);
+ display.drawLine(center.x()- 15, center.y() - 15, center.x()- 7, center.y() - 15);
+ display.drawLine(center.x()- 15, center.y() - 7, center.x()- 15, center.y() - 15);
- display.drawLine(center.x + 7, center.y + 15, center.x + 15, center.y + 15);
- display.drawLine(center.x + 15, center.y + 7, center.x + 15, center.y + 15);
+ display.drawLine(center.x()+ 7, center.y() + 15, center.x()+ 15, center.y() + 15);
+ display.drawLine(center.x()+ 15, center.y() + 7, center.x()+ 15, center.y() + 15);
- display.drawLine(center.x + 7, center.y - 15, center.x + 15, center.y - 15);
- display.drawLine(center.x + 15, center.y - 15, center.x + 15, center.y - 7);
+ display.drawLine(center.x()+ 7, center.y() - 15, center.x()+ 15, center.y() - 15);
+ display.drawLine(center.x()+ 15, center.y() - 15, center.x()+ 15, center.y() - 7);
}
static void
@@ -184,14 +184,14 @@ calibrateTouchscreen(modm::ColorGraphicDisplay& display)
void
drawPoint(modm::GraphicDisplay& display, modm::glcd::Point point)
{
- if (point.x < 0 || point.y < 0) {
+ if (point.x()< 0 || point.y() < 0) {
return;
}
- display.setPixel(point.x, point.y);
- display.setPixel(point.x + 1, point.y);
- display.setPixel(point.x, point.y + 1);
- display.setPixel(point.x + 1, point.y + 1);
+ display.setPixel(point.x(), point.y());
+ display.setPixel(point.x()+ 1, point.y());
+ display.setPixel(point.x(), point.y() + 1);
+ display.setPixel(point.x()+ 1, point.y() + 1);
}
// ----------------------------------------------------------------------------
diff --git a/examples/stm32f4_discovery/open407v-d/touchscreen/touchscreen_calibrator.hpp b/examples/stm32f4_discovery/open407v-d/touchscreen/touchscreen_calibrator.hpp
index dacb51c44f..35a6ff26a6 100644
--- a/examples/stm32f4_discovery/open407v-d/touchscreen/touchscreen_calibrator.hpp
+++ b/examples/stm32f4_discovery/open407v-d/touchscreen/touchscreen_calibrator.hpp
@@ -58,34 +58,34 @@ modm::TouchscreenCalibrator::calibrate(
modm::glcd::Point * display, modm::glcd::Point * sample)
{
// K��(X0��X2) (Y1��Y2)��(X1��X2) (Y0��Y2)
- scale = ((sample[0].x - sample[2].x) * (sample[1].y - sample[2].y)) -
- ((sample[1].x - sample[2].x) * (sample[0].y - sample[2].y));
+ scale = ((sample[0].x() - sample[2].x()) * (sample[1].y() - sample[2].y())) -
+ ((sample[1].x() - sample[2].x()) * (sample[0].y() - sample[2].y()));
if (scale == 0) {
return false;
}
// A��((XD0��XD2) (Y1��Y2)��(XD1��XD2) (Y0��Y2))��K
- An = ((display[0].x - display[2].x) * (sample[1].y - sample[2].y)) -
- ((display[1].x - display[2].x) * (sample[0].y - sample[2].y));
+ An = ((display[0].x() - display[2].x()) * (sample[1].y() - sample[2].y())) -
+ ((display[1].x() - display[2].x()) * (sample[0].y() - sample[2].y()));
// B��((X0��X2) (XD1��XD2)��(XD0��XD2) (X1��X2))��K */
- Bn = ((sample[0].x - sample[2].x) * (display[1].x - display[2].x)) -
- ((display[0].x - display[2].x) * (sample[1].x - sample[2].x));
+ Bn = ((sample[0].x() - sample[2].x()) * (display[1].x() - display[2].x())) -
+ ((display[0].x() - display[2].x()) * (sample[1].x() - sample[2].x()));
// C��(Y0(X2XD1��X1XD2)+Y1(X0XD2��X2XD0)+Y2(X1XD0��X0XD1))��K */
- Cn = (sample[2].x * display[1].x - sample[1].x * display[2].x) * sample[0].y +
- (sample[0].x * display[2].x - sample[2].x * display[0].x) * sample[1].y +
- (sample[1].x * display[0].x - sample[0].x * display[1].x) * sample[2].y;
+ Cn = (sample[2].x() * display[1].x() - sample[1].x() * display[2].x()) * sample[0].y() +
+ (sample[0].x() * display[2].x() - sample[2].x() * display[0].x()) * sample[1].y() +
+ (sample[1].x() * display[0].x() - sample[0].x() * display[1].x()) * sample[2].y();
// D��((YD0��YD2) (Y1��Y2)��(YD1��YD2) (Y0��Y2))��K */
- Dn = ((display[0].y - display[2].y) * (sample[1].y - sample[2].y)) -
- ((display[1].y - display[2].y) * (sample[0].y - sample[2].y));
+ Dn = ((display[0].y() - display[2].y()) * (sample[1].y() - sample[2].y())) -
+ ((display[1].y() - display[2].y()) * (sample[0].y() - sample[2].y()));
// E��((X0��X2) (YD1��YD2)��(YD0��YD2) (X1��X2))��K */
- En = ((sample[0].x - sample[2].x) * (display[1].y - display[2].y)) -
- ((display[0].y - display[2].y) * (sample[1].x - sample[2].x));
+ En = ((sample[0].x() - sample[2].x()) * (display[1].y() - display[2].y())) -
+ ((display[0].y() - display[2].y()) * (sample[1].x() - sample[2].x()));
// F��(Y0(X2YD1��X1YD2)+Y1(X0YD2��X2YD0)+Y2(X1YD0��X0YD1))��K */
- Fn = (sample[2].x * display[1].y - sample[1].x * display[2].y) * sample[0].y +
- (sample[0].x * display[2].y - sample[2].x * display[0].y) * sample[1].y +
- (sample[1].x * display[0].y - sample[0].x * display[1].y) * sample[2].y;
+ Fn = (sample[2].x() * display[1].y() - sample[1].x() * display[2].y()) * sample[0].y() +
+ (sample[0].x() * display[2].y() - sample[2].x() * display[0].y()) * sample[1].y() +
+ (sample[1].x() * display[0].y() - sample[0].x() * display[1].y()) * sample[2].y();
return true;
}
@@ -96,12 +96,12 @@ modm::TouchscreenCalibrator::translate(modm::glcd::Point * raw, modm::glcd::Poin
if (scale != 0)
{
/* XD = AX+BY+C */
- translated->x =
- ((An * raw->x) +
- (Bn * raw->y) + Cn) / scale;
+ translated->x() =
+ ((An * raw->x()) +
+ (Bn * raw->y()) + Cn) / scale;
/* YD = DX+EY+F */
- translated->y =
- ((Dn * raw->x) +
- (En * raw->y) + Fn) / scale;
+ translated->y() =
+ ((Dn * raw->x()) +
+ (En * raw->y()) + Fn) / scale;
}
}
diff --git a/src/modm/driver/display/ili9341_impl.hpp b/src/modm/driver/display/ili9341_impl.hpp
index d44ce85c69..07756489c5 100644
--- a/src/modm/driver/display/ili9341_impl.hpp
+++ b/src/modm/driver/display/ili9341_impl.hpp
@@ -209,7 +209,7 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::drawHorizontalLine(
BatchHandle h(*this);
- setClipping(start.getX(), start.getY(), length, 1);
+ setClipping(start.x(), start.y(), length, 1);
while (length > BufferSize)
{
this->writeData(buffer, BufferSize * 2);
@@ -230,7 +230,7 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::drawVerticalLine(
BatchHandle h(*this);
- setClipping(start.getX(), start.getY(), 1, length);
+ setClipping(start.x(), start.y(), 1, length);
while (length > BufferSize)
{
this->writeData(buffer, BufferSize * 2);
@@ -244,8 +244,8 @@ void
Ili9341<Interface, Reset, Backlight, BufferSize>::fillRectangle(
glcd::Point upperLeft, uint16_t width, uint16_t height)
{
- auto const x { upperLeft.getX() };
- auto const y { upperLeft.getY() };
+ auto const x { upperLeft.x() };
+ auto const y { upperLeft.y() };
std::size_t pixelCount { std::size_t(width) * std::size_t(height) };
uint16_t const pixelValue { modm::toBigEndian(foregroundColor.color) };
@@ -281,7 +281,7 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::fillCircle(
BatchHandle h(*this);
- setClipping(center.getX() - radius, center.getY(), 2 * radius, 1);
+ setClipping(center.x() - radius, center.y(), 2 * radius, 1);
for (std::size_t i = 0; i < 2 * radius; ++i)
this->writeData(setColor, 2);
@@ -297,16 +297,16 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::fillCircle(
ddF_x += 2;
f += ddF_x + 1;
- setClipping(center.getX() - x, center.getY() - y, 2 * x, 1);
+ setClipping(center.x() - x, center.y() - y, 2 * x, 1);
for (std::size_t i = 0; i < 2 * x; ++i)
this->writeData(setColor, 2);
- setClipping(center.getX() - y, center.getY() - x, 2 * y, 1);
+ setClipping(center.x() - y, center.y() - x, 2 * y, 1);
for (std::size_t i = 0; i < 2 * y; ++i)
this->writeData(setColor, 2);
- setClipping(center.getX() - x, center.getY() + y, 2 * x, 1);
+ setClipping(center.x() - x, center.y() + y, 2 * x, 1);
for (std::size_t i = 0; i < 2 * x; ++i)
this->writeData(setColor, 2);
- setClipping(center.getX() - y, center.getY() + x, 2 * y, 1);
+ setClipping(center.x() - y, center.y() + x, 2 * y, 1);
for (std::size_t i = 0; i < 2 * y; ++i)
this->writeData(setColor, 2);
}
@@ -324,7 +324,7 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::drawImageRaw(glcd::Point upper
BatchHandle h(*this);
- setClipping(upperLeft.getX(), upperLeft.getY(), width, height);
+ setClipping(upperLeft.x(), upperLeft.y(), width, height);
uint8_t bit = 0x01;
for (uint16_t r = 0; r < height; ++r)
@@ -356,7 +356,7 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::drawRaw(glcd::Point upperLeft,
buffer[i] = modm::fromBigEndian(buffer[i]);
}
- setClipping(upperLeft.getX(), upperLeft.getY(), width, height);
+ setClipping(upperLeft.x(), upperLeft.y(), width, height);
this->writeData((uint8_t*)buffer, width * height * 2);
}
@@ -428,7 +428,7 @@ Ili9341<Interface, Reset, Backlight, BufferSize>::drawBitmap(glcd::Point upperLe
{
BatchHandle h(*this);
- setClipping(upperLeft.getX(), upperLeft.getY(), width, height);
+ setClipping(upperLeft.x(), upperLeft.y(), width, height);
for (int i = 0; i < width * height; ++i) {
buffer[0] = data[i*2+1];
buffer[1] = data[i*2];
diff --git a/src/modm/driver/inertial/bno055.hpp b/src/modm/driver/inertial/bno055.hpp
index b4abbd387e..6bff7c18f4 100644
--- a/src/modm/driver/inertial/bno055.hpp
+++ b/src/modm/driver/inertial/bno055.hpp
@@ -14,7 +14,7 @@
#include <modm/architecture/interface/register.hpp>
#include <modm/architecture/interface/i2c_device.hpp>
#include <modm/processing/resumable.hpp>
-#include <modm/math/geometry/vector3.hpp>
+#include <modm/math/geometry/vector.hpp>
#include <modm/math/geometry/quaternion.hpp>
namespace modm
diff --git a/src/modm/driver/inertial/lis3mdl.hpp b/src/modm/driver/inertial/lis3mdl.hpp
index b042f664af..7cbd775b4f 100644
--- a/src/modm/driver/inertial/lis3mdl.hpp
+++ b/src/modm/driver/inertial/lis3mdl.hpp
@@ -15,7 +15,7 @@
#include <modm/architecture/interface/register.hpp>
#include <modm/processing/resumable.hpp>
#include <modm/math/utils/endianness.hpp>
-#include <modm/math/geometry/vector3.hpp>
+#include <modm/math/geometry/vector.hpp>
#include "lis3_transport.hpp"
namespace modm
diff --git a/src/modm/driver/inertial/lis3mdl_impl.hpp b/src/modm/driver/inertial/lis3mdl_impl.hpp
index 6e038c4e22..5694905147 100644
--- a/src/modm/driver/inertial/lis3mdl_impl.hpp
+++ b/src/modm/driver/inertial/lis3mdl_impl.hpp
@@ -81,9 +81,7 @@ modm::Lis3mdl<I2cMaster>::readMagnetometerRaw(Vector3i& data)
success = RF_CALL(this->read(static_cast<uint8_t>(Register::OUT_X_L),reinterpret_cast<uint8_t*>(readBuffer),6));
if(success)
{
- data.x = readBuffer[0];
- data.y = readBuffer[1];
- data.z = readBuffer[2];
+ data = readBuffer;
}
RF_END_RETURN(success);
}
@@ -102,9 +100,8 @@ modm::Lis3mdl<I2cMaster>::readMagnetometer(Vector3f& data)
uint8_t scaleIndex = (static_cast<uint8_t>(getScale()))>>5;
float conversionValue = convTable[scaleIndex];
- data.x = static_cast<float>(readBuffer[0]) * conversionValue;
- data.y = static_cast<float>(readBuffer[1]) * conversionValue;
- data.z = static_cast<float>(readBuffer[2]) * conversionValue;
+ data = readBuffer;
+ data *= conversionValue;
}
RF_END_RETURN(success);
diff --git a/src/modm/driver/inertial/lsm6ds33.hpp b/src/modm/driver/inertial/lsm6ds33.hpp
index 8cff8be54a..6ba6c1c779 100644
--- a/src/modm/driver/inertial/lsm6ds33.hpp
+++ b/src/modm/driver/inertial/lsm6ds33.hpp
@@ -15,7 +15,7 @@
#include <modm/architecture/interface/register.hpp>
#include <modm/processing/resumable.hpp>
#include <modm/math/utils/endianness.hpp>
-#include <modm/math/geometry/vector3.hpp>
+#include <modm/math/geometry/vector.hpp>
#include "lis3_transport.hpp"
namespace modm
diff --git a/src/modm/driver/inertial/lsm6ds33_impl.hpp b/src/modm/driver/inertial/lsm6ds33_impl.hpp
index 5e6e458202..727d873cbf 100644
--- a/src/modm/driver/inertial/lsm6ds33_impl.hpp
+++ b/src/modm/driver/inertial/lsm6ds33_impl.hpp
@@ -51,11 +51,8 @@ modm::Lsm6ds33<I2cMaster>::readAccelerationRaw(Vector3i& acceleration)
{
RF_BEGIN();
success = RF_CALL(this->read(static_cast<uint8_t>(Register::OUT_X_L_XL),reinterpret_cast<uint8_t*>(readBuffer),6));
- if(success)
- {
- acceleration.x = readBuffer[0];
- acceleration.y = readBuffer[1];
- acceleration.z = readBuffer[2];
+ if(success) {
+ acceleration = readBuffer;
}
RF_END_RETURN(success);
}
@@ -66,11 +63,8 @@ modm::Lsm6ds33<I2cMaster>::readGyroscopeRaw(Vector3i& spinRates)
{
RF_BEGIN();
success = RF_CALL(this->read(static_cast<uint8_t>(Register::OUT_X_L_G),reinterpret_cast<uint8_t*>(readBuffer),6));
- if(success)
- {
- spinRates.x = readBuffer[0];
- spinRates.y = readBuffer[1];
- spinRates.z = readBuffer[2];
+ if(success) {
+ spinRates = readBuffer;
}
RF_END_RETURN(success);
}
@@ -102,9 +96,8 @@ modm::Lsm6ds33<I2cMaster>::readAcceleration(Vector3f& acceleration)
uint8_t accScaleIndex = (static_cast<uint8_t>(getAccelerationScale()))>>2;
float conversionValue = accConvTable[accScaleIndex];
- acceleration.x = static_cast<float>(readBuffer[0]) * conversionValue;
- acceleration.y = static_cast<float>(readBuffer[1]) * conversionValue;
- acceleration.z = static_cast<float>(readBuffer[2]) * conversionValue;
+ acceleration = readBuffer;
+ acceleration *= conversionValue;
}
RF_END_RETURN(success);
@@ -133,9 +126,9 @@ modm::Lsm6ds33<I2cMaster>::readGyroscope(Vector3f& acceleration)
conversionValue = gyroConvTable[gyroScaleIndex];
}
- acceleration.x = static_cast<float>(readBuffer[0]) * conversionValue;
- acceleration.y = static_cast<float>(readBuffer[1]) * conversionValue;
- acceleration.z = static_cast<float>(readBuffer[2]) * conversionValue;
+ acceleration.x() = static_cast<float>(readBuffer[0]) * conversionValue;
+ acceleration.y() = static_cast<float>(readBuffer[1]) * conversionValue;
+ acceleration.z() = static_cast<float>(readBuffer[2]) * conversionValue;
}
RF_END_RETURN(success);
diff --git a/src/modm/driver/motion/pat9125el.hpp b/src/modm/driver/motion/pat9125el.hpp
index 24d2fad6df..ada839f20f 100644
--- a/src/modm/driver/motion/pat9125el.hpp
+++ b/src/modm/driver/motion/pat9125el.hpp
@@ -15,7 +15,7 @@
#include <array>
#include <type_traits>
#include <modm/driver/motion/pat9125el_transport.hpp>
-#include <modm/math/geometry/vector2.hpp>
+#include <modm/math/geometry/vector.hpp>
namespace modm
{
diff --git a/src/modm/driver/motion/pat9125el_impl.hpp b/src/modm/driver/motion/pat9125el_impl.hpp
index 35766fe3eb..b76e6dae0b 100644
--- a/src/modm/driver/motion/pat9125el_impl.hpp
+++ b/src/modm/driver/motion/pat9125el_impl.hpp
@@ -111,8 +111,8 @@ Pat9125el<Transport, IntPin>::updateData()
const int16_t y = (readBuffer[1] | ((readBuffer[2] & 0b00001111) << 8));
// convert 12-bit 2's complement data to 16-bit signed int
- data.x = static_cast<int16_t>(x << 4) >> 4;
- data.y = static_cast<int16_t>(y << 4) >> 4;
+ data.x() = static_cast<int16_t>(x << 4) >> 4;
+ data.y() = static_cast<int16_t>(y << 4) >> 4;
moved = true;
}
diff --git a/src/modm/driver/touch/ads7843_impl.hpp b/src/modm/driver/touch/ads7843_impl.hpp
index a8f1ef47fa..dddf5a5c53 100644
--- a/src/modm/driver/touch/ads7843_impl.hpp
+++ b/src/modm/driver/touch/ads7843_impl.hpp
@@ -79,7 +79,7 @@ modm::Ads7843<Spi, Cs, Int>::read(glcd::Point * point)
if (count == 9) {
glcd::Point p;
- if (getAverage(bufferX, p.x) && getAverage(bufferY, p.y)) {
+ if (getAverage(bufferX, p.x()) && getAverage(bufferY, p.y())) {
*point = p;
return true;
}
diff --git a/src/modm/ui/display/graphic_display.cpp b/src/modm/ui/display/graphic_display.cpp
index 1c5727e66e..e5bd3df168 100644
--- a/src/modm/ui/display/graphic_display.cpp
+++ b/src/modm/ui/display/graphic_display.cpp
@@ -91,31 +91,31 @@ modm::GraphicDisplay::drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
void
modm::GraphicDisplay::drawHorizontalLine(glcd::Point start, uint16_t length)
{
- for (int_fast16_t i = start.x; i < static_cast<int16_t>(start.x + length); ++i)
+ for (int_fast16_t i = start.x(); i < static_cast<int16_t>(start.x() + length); ++i)
{
- this->setPixel(i, start.y);
+ this->setPixel(i, start.y());
}
}
void
modm::GraphicDisplay::drawVerticalLine(glcd::Point start, uint16_t length)
{
- for (int_fast16_t i = start.y; i < static_cast<int16_t>(start.y + length); ++i)
+ for (int_fast16_t i = start.y(); i < static_cast<int16_t>(start.y() + length); ++i)
{
- this->setPixel(start.x, i);
+ this->setPixel(start.x(), i);
}
}
void
modm::GraphicDisplay::drawRectangle(glcd::Point start, uint16_t width, uint16_t height)
{
- uint16_t x2 = start.x + width - 1;
- uint16_t y2 = start.y + height - 1;
+ uint16_t x2 = start.x() + width - 1;
+ uint16_t y2 = start.y() + height - 1;
this->drawHorizontalLine(start, width);
- this->drawHorizontalLine(glcd::Point(start.x, y2), width);
+ this->drawHorizontalLine(glcd::Point(start.x(), y2), width);
this->drawVerticalLine(start, height);
- this->drawVerticalLine(glcd::Point(x2, start.y), height);
+ this->drawVerticalLine(glcd::Point(x2, start.y()), height);
}
void
@@ -124,8 +124,8 @@ modm::GraphicDisplay::drawRoundedRectangle(glcd::Point start, uint16_t width, ui
{
if (radius == 0) { this->drawRectangle(start, width, height); }
- const int16_t x = start.x;
- const int16_t y = start.y;
+ const int16_t x = start.x();
+ const int16_t y = start.y();
int16_t x1 = 0;
int16_t y1 = radius;
@@ -191,8 +191,8 @@ modm::GraphicDisplay::drawCircle(glcd::Point center, uint16_t radius)
void
modm::GraphicDisplay::drawCircle4(glcd::Point center, int16_t x, int16_t y)
{
- const int16_t cx = center.x;
- const int16_t cy = center.y;
+ const int16_t cx = center.x();
+ const int16_t cy = center.y();
this->setPixel(cx + x, cy + y);
this->setPixel(cx - x, cy - y);
@@ -281,9 +281,9 @@ modm::GraphicDisplay::drawImageRaw(glcd::Point start, uint16_t width, uint16_t h
for (uint16_t j = 0; j < rowHeight; j++)
{
if (byte & 0x01)
- this->setPixel(start.x + i, start.y + k * 8 + j);
+ this->setPixel(start.x() + i, start.y() + k * 8 + j);
else
- this->clearPixel(start.x + i, start.y + k * 8 + j);
+ this->clearPixel(start.x() + i, start.y() + k * 8 + j);
byte >>= 1;
}
diff --git a/src/modm/ui/display/graphic_display.hpp b/src/modm/ui/display/graphic_display.hpp
index ea67ecfdb5..775b6acbab 100644
--- a/src/modm/ui/display/graphic_display.hpp
+++ b/src/modm/ui/display/graphic_display.hpp
@@ -114,7 +114,7 @@ class GraphicDisplay : public IOStream
inline void
setPixel(glcd::Point p)
{
- this->setPixel(p.x, p.y);
+ this->setPixel(p.x(), p.y());
}
/**
@@ -134,7 +134,7 @@ class GraphicDisplay : public IOStream
inline void
clearPixel(glcd::Point p)
{
- this->setPixel(p.x, p.y);
+ this->setPixel(p.x(), p.y());
}
/**
@@ -171,7 +171,7 @@ class GraphicDisplay : public IOStream
inline void
drawLine(glcd::Point start, glcd::Point end)
{
- this->drawLine(start.x, start.y, end.x, end.y);
+ this->drawLine(start.x(), start.y(), end.x(), end.y());
}
/**
@@ -346,7 +346,7 @@ class GraphicDisplay : public IOStream
inline void
setCursorX(int16_t x)
{
- this->cursor.x = x;
+ this->cursor.x() = x;
}
/**
@@ -357,7 +357,7 @@ class GraphicDisplay : public IOStream
inline void
setCursorY(int16_t y)
{
- this->cursor.y = y;
+ this->cursor.y() = y;
}
inline glcd::Point
diff --git a/src/modm/ui/display/graphic_display_fill.cpp b/src/modm/ui/display/graphic_display_fill.cpp
index 389f8e8564..a7933784ee 100644
--- a/src/modm/ui/display/graphic_display_fill.cpp
+++ b/src/modm/ui/display/graphic_display_fill.cpp
@@ -19,8 +19,8 @@ void
modm::GraphicDisplay::fillRectangle(glcd::Point start,
uint16_t width, uint16_t height)
{
- for (uint16_t i = start.x; (i < start.x + width) && (i < getWidth()); ++i)
- for (uint16_t k = start.y; (k < start.y + height) && (k < getHeight()); ++k)
+ for (uint16_t i = start.x(); (i < start.x() + width) && (i < getWidth()); ++i)
+ for (uint16_t k = start.y(); (k < start.y() + height) && (k < getHeight()); ++k)
this->setPixel(i, k);
}
@@ -33,7 +33,7 @@ modm::GraphicDisplay::fillCircle(glcd::Point center, uint16_t radius)
uint16_t x = 0;
uint16_t y = radius;
- this->drawVerticalLine(glcd::Point(center.x, center.y - radius), 2 * radius);
+ this->drawVerticalLine(glcd::Point(center.x(), center.y() - radius), 2 * radius);
while(x < y)
{
@@ -47,9 +47,9 @@ modm::GraphicDisplay::fillCircle(glcd::Point center, uint16_t radius)
ddF_x += 2;
f += ddF_x + 1;
- this->drawVerticalLine(glcd::Point(center.x + x, center.y - y), 2 * y);
- this->drawVerticalLine(glcd::Point(center.x + y, center.y - x), 2 * x);
- this->drawVerticalLine(glcd::Point(center.x - x, center.y - y), 2 * y);
- this->drawVerticalLine(glcd::Point(center.x - y, center.y - x), 2 * x);
+ this->drawVerticalLine(glcd::Point(center.x() + x, center.y() - y), 2 * y);
+ this->drawVerticalLine(glcd::Point(center.x() + y, center.y() - x), 2 * x);
+ this->drawVerticalLine(glcd::Point(center.x() - x, center.y() - y), 2 * y);
+ this->drawVerticalLine(glcd::Point(center.x() - y, center.y() - x), 2 * x);
}
}
diff --git a/src/modm/ui/display/graphic_display_text.cpp b/src/modm/ui/display/graphic_display_text.cpp
index f1e6d1d68d..06a3c65a09 100644
--- a/src/modm/ui/display/graphic_display_text.cpp
+++ b/src/modm/ui/display/graphic_display_text.cpp
@@ -71,7 +71,8 @@ modm::GraphicDisplay::write(char c)
const uint8_t vspace = font[5];
if (character == '\n') {
- this->cursor.set(0, this->cursor.y + height + hspace);
+ this->cursor.x() = 0;
+ this->cursor.y() += height + hspace;
return;
}
@@ -97,7 +98,7 @@ modm::GraphicDisplay::write(char c)
this->drawImageRaw(cursor, width, height,
accessor::asFlash(font.getPointer() + offset));
- cursor.setX(cursor.x + width);
+ cursor.x() += width;
// all characters below 128 have whitespace afterwards (number given
// by vspace).
@@ -107,7 +108,7 @@ modm::GraphicDisplay::write(char c)
//this->setColor(color::html::White);
for (uint_fast8_t i = 0; i < vspace; ++i) {
//this->drawVerticalLine(cursor, height);
- cursor.setX(cursor.x + 1);
+ cursor.x()++;
}
// restore color
diff --git a/src/modm/ui/display/monochrome_graphic_display_vertical_impl.hpp b/src/modm/ui/display/monochrome_graphic_display_vertical_impl.hpp
index aefaeaec81..c88e6a4dc4 100644
--- a/src/modm/ui/display/monochrome_graphic_display_vertical_impl.hpp
+++ b/src/modm/ui/display/monochrome_graphic_display_vertical_impl.hpp
@@ -21,12 +21,12 @@ void
modm::MonochromeGraphicDisplayVertical<Width, Height>::drawHorizontalLine(glcd::Point start,
uint16_t length)
{
- if (start.y >= 0 and start.y < Height)
+ if (start.y() >= 0 and start.y() < Height)
{
- const int16_t y = start.y / 8;
+ const int16_t y = start.y() / 8;
- const uint8_t byte = 1 << (start.y % 8);
- for (int_fast16_t x = start.x; x < static_cast<int16_t>(start.x + length); ++x)
+ const uint8_t byte = 1 << (start.y() % 8);
+ for (int_fast16_t x = start.x(); x < static_cast<int16_t>(start.x() + length); ++x)
{
if (x < Width) { this->buffer[y][x] |= byte; }
}
@@ -38,19 +38,19 @@ void
modm::MonochromeGraphicDisplayVertical<Width, Height>::drawVerticalLine(glcd::Point start,
uint16_t length)
{
- if (start.x >= 0 and start.x < Width)
+ if (start.x() >= 0 and start.x() < Width)
{
- const int8_t end_y = start.y + length;
+ const int8_t end_y = start.y() + length;
const uint8_t y_last = end_y / 8;
- uint_fast8_t y = start.y / 8;
+ uint_fast8_t y = start.y() / 8;
// Mask out start
- uint_fast8_t byte = 0xFF << start.y % 8;
+ uint_fast8_t byte = 0xFF << start.y() % 8;
while (y != y_last)
{
if (y < Height / 8)
{
- this->buffer[y][start.x] |= byte;
+ this->buffer[y][(start.x())] |= byte;
byte = 0xFF;
}
y++;
@@ -59,7 +59,7 @@ modm::MonochromeGraphicDisplayVertical<Width, Height>::drawVerticalLine(glcd::Po
if (y < Height / 8)
{
byte &= 0xFF >> (8 - end_y % 8);
- this->buffer[y][start.x] |= byte;
+ this->buffer[y][start.x()] |= byte;
}
}
}
@@ -69,9 +69,9 @@ void
modm::MonochromeGraphicDisplayVertical<Width, Height>::drawImageRaw(
glcd::Point start, uint16_t width, uint16_t height, modm::accessor::Flash<uint8_t> data)
{
- if ((start.y % 8) == 0)
+ if ((start.y() % 8) == 0)
{
- uint16_t row = start.y / 8;
+ uint16_t row = start.y() / 8;
uint16_t rowCount = (height + 7) / 8; // always round up
if ((height % 8) == 0)
@@ -80,7 +80,7 @@ modm::MonochromeGraphicDisplayVertical<Width, Height>::drawImageRaw(
{
for (uint_fast16_t k = 0; k < rowCount; k++)
{
- uint16_t x = start.x + i;
+ uint16_t x = start.x() + i;
uint16_t y = k + row;
if (x < Width and y < Height)
diff --git a/src/modm/ui/gui/view.cpp b/src/modm/ui/gui/view.cpp
index 75c5389d8c..7abe67d31a 100644
--- a/src/modm/ui/gui/view.cpp
+++ b/src/modm/ui/gui/view.cpp
@@ -72,10 +72,10 @@ modm::gui::View::update()
bool
modm::gui::View::pack(Widget *w, const modm::glcd::Point &coord)
{
- if(coord.x >= this->dimension.width ||
- coord.y >= this->dimension.height ||
- coord.x < 0 ||
- coord.y < 0)
+ if(coord.x() >= this->dimension.width ||
+ coord.y() >= this->dimension.height ||
+ coord.x() < 0 ||
+ coord.y() < 0)
{
return false;
}
diff --git a/src/modm/ui/gui/widgets/button.cpp b/src/modm/ui/gui/widgets/button.cpp
index e4c2f2996c..1fa32a10e7 100644
--- a/src/modm/ui/gui/widgets/button.cpp
+++ b/src/modm/ui/gui/widgets/button.cpp
@@ -26,8 +26,8 @@ modm::gui::ButtonWidget::render(View* view)
ColorPalette cp = this->color_palette;
// position and dimensions
- const uint16_t x = this->getPosition().x;
- const uint16_t y = this->getPosition().y;
+ const uint16_t x = this->getPosition().x();
+ const uint16_t y = this->getPosition().y();
const uint16_t width = this->getWidth();
const uint16_t height = this->getHeight();
@@ -80,8 +80,8 @@ modm::gui::ArrowButton::render(View* view)
ColorPalette cp = this->color_palette;
// position and dimensions
- const uint16_t x = this->getPosition().x;
- const uint16_t y = this->getPosition().y;
+ const uint16_t x = this->getPosition().x();
+ const uint16_t y = this->getPosition().y();
const uint16_t width = this->getWidth();
const uint16_t height = this->getHeight();
@@ -130,8 +130,8 @@ modm::gui::FilledAreaButton::render(View* view)
modm::ColorGraphicDisplay* out = &view->display();
// position and dimensions
- const uint16_t x = this->getPosition().x;
- const uint16_t y = this->getPosition().y;
+ const uint16_t x = this->getPosition().x();
+ const uint16_t y = this->getPosition().y();
const uint16_t width = this->getWidth();
const uint16_t height = this->getHeight();
diff --git a/src/modm/ui/gui/widgets/checkbox.cpp b/src/modm/ui/gui/widgets/checkbox.cpp
index 53a182ccb8..3985ef48fd 100644
--- a/src/modm/ui/gui/widgets/checkbox.cpp
+++ b/src/modm/ui/gui/widgets/checkbox.cpp
@@ -30,8 +30,8 @@ modm::gui::CheckboxWidget::render(View* view)
const uint16_t box_width = this->dimension.width;
const uint16_t box_height = this->dimension.height;
- const uint16_t box_x = this->getPosition().x;
- const uint16_t box_y = this->getPosition().y;
+ const uint16_t box_x = this->getPosition().x();
+ const uint16_t box_y = this->getPosition().y();
// clear background
out->setColor(cp[Color::BACKGROUND]);
diff --git a/src/modm/ui/gui/widgets/label.cpp b/src/modm/ui/gui/widgets/label.cpp
index 1527f1e965..305a19ac6d 100644
--- a/src/modm/ui/gui/widgets/label.cpp
+++ b/src/modm/ui/gui/widgets/label.cpp
@@ -30,6 +30,6 @@ modm::gui::Label::render(View* view)
out->setFont(&(this->font));
}
- out->setCursor(this->getPosition().x, this->getPosition().y);
+ out->setCursor(this->getPosition().x(), this->getPosition().y());
*out << this->label;
}
diff --git a/src/modm/ui/gui/widgets/numberfield.cpp b/src/modm/ui/gui/widgets/numberfield.cpp
index d8b12fa972..816f2801f2 100644
--- a/src/modm/ui/gui/widgets/numberfield.cpp
+++ b/src/modm/ui/gui/widgets/numberfield.cpp
@@ -34,8 +34,8 @@ modm::gui::FloatField::render(View* view)
const uint16_t box_width = this->dimension.width - 4;
const uint16_t box_height = this->dimension.height;
- const uint16_t box_x = this->getPosition().x + 2;
- const uint16_t box_y = this->getPosition().y;
+ const uint16_t box_x = this->getPosition().x() + 2;
+ const uint16_t box_y = this->getPosition().y();
// clear background
out->setColor(cp[Color::BACKGROUND]);
diff --git a/src/modm/ui/gui/widgets/numberfield_impl.hpp b/src/modm/ui/gui/widgets/numberfield_impl.hpp
index d6d02177a2..79f8e5a085 100644
--- a/src/modm/ui/gui/widgets/numberfield_impl.hpp
+++ b/src/modm/ui/gui/widgets/numberfield_impl.hpp
@@ -30,8 +30,8 @@ modm::gui::NumberField<T>::render(View* view)
const uint16_t box_width = this->dimension.width - 4;
const uint16_t box_height = this->dimension.height;
- const uint16_t box_x = this->getPosition().x + 2;
- const uint16_t box_y = this->getPosition().y;
+ const uint16_t box_x = this->getPosition().x() + 2;
+ const uint16_t box_y = this->getPosition().y();
// clear background
out->setColor(cp[Color::BACKGROUND]);
diff --git a/src/modm/ui/gui/widgets/stringfield.cpp b/src/modm/ui/gui/widgets/stringfield.cpp
index d3928862a7..14dcb22400 100644
--- a/src/modm/ui/gui/widgets/stringfield.cpp
+++ b/src/modm/ui/gui/widgets/stringfield.cpp
@@ -29,8 +29,8 @@ modm::gui::StringField::render(View* view)
const uint16_t box_width = this->dimension.width - 4;
const uint16_t box_height = this->dimension.height;
- const uint16_t box_x = this->getPosition().x + 2;
- const uint16_t box_y = this->getPosition().y;
+ const uint16_t box_x = this->getPosition().x() + 2;
+ const uint16_t box_y = this->getPosition().y();
// clear background
out->setColor(cp[Color::BACKGROUND]);
diff --git a/src/modm/ui/gui/widgets/widget.cpp b/src/modm/ui/gui/widgets/widget.cpp
index 66a0e33b55..674be9ad10 100644
--- a/src/modm/ui/gui/widgets/widget.cpp
+++ b/src/modm/ui/gui/widgets/widget.cpp
@@ -17,7 +17,7 @@
bool
modm::gui::WidgetGroup::pack(Widget* w, const modm::glcd::Point& coord)
{
- if(coord.x > (this->dimension.width - w->dimension.width ) || coord.y > (this->dimension.height - w->dimension.height) || coord.x < 0 || coord.y < 0)
+ if(coord.x() > (this->dimension.width - w->dimension.width ) || coord.y() > (this->dimension.height - w->dimension.height) || coord.x() < 0 || coord.y() < 0)
return false;
/* Widget needs to know its parent to calculate its real, absolute
@@ -107,19 +107,19 @@ modm::gui::Widget::checkIntersection(Widget* w)
/* coordinates of upper left and lower right corner of this widget */
auto upper_left = this->getPosition();
- auto lower_right = modm::glcd::Point(upper_left.x + this->getWidth(), upper_left.y + this->getHeight());
+ auto lower_right = modm::glcd::Point(upper_left.x() + this->getWidth(), upper_left.y() + this->getHeight());
/* coordinates of upper left and lower right corner of the argument Widget* w */
auto upper_left2 = w->getPosition();
- auto lower_right2 = modm::glcd::Point(upper_left2.x + w->getWidth(), upper_left2.y + w->getHeight());
+ auto lower_right2 = modm::glcd::Point(upper_left2.x() + w->getWidth(), upper_left2.y() + w->getHeight());
/* check if rectangles contituted by precedingly defined
* coordinates DON'T overlap
* */
- if(upper_left.x > lower_right2.x ||
- upper_left2.x > lower_right.x ||
- upper_left.y > lower_right2.y ||
- upper_left2.y > lower_right.y
+ if(upper_left.x() > lower_right2.x() ||
+ upper_left2.x() > lower_right.x() ||
+ upper_left.y() > lower_right2.y() ||
+ upper_left2.y() > lower_right.y()
)
{
return false;
@@ -135,10 +135,10 @@ modm::gui::Widget::handleInputEvent(const InputEvent* ev)
auto position = this->getPosition();
/* check if event is within area */
- if((position.x < ev->coord.x) &&
- (position.y < ev->coord.y) &&
- ((position.x + this->getWidth()) > ev->coord.x) &&
- ((position.y + this->getHeight()) > ev->coord.y))
+ if((position.x() < ev->coord.x()) &&
+ (position.y() < ev->coord.y()) &&
+ ((position.x() + this->getWidth()) > ev->coord.x()) &&
+ ((position.y() + this->getHeight()) > ev->coord.y()))
{
/* check if widget has interaction */
if(this->isInteractive())