👩‍🌾 Don't use std::pow with integers in Vectors and handle sqrt (#207)

Signed-off-by: Louise Poubel <[email protected]>

include/ignition/math/Vector2.hh

@@ -87,15 +87,16 @@ namespace ignition
       /// \return The length
       public: T Length() const
       {
-        return sqrt(this->SquaredLength());
+        return static_cast<T>(sqrt(this->SquaredLength()));
       }
 
       /// \brief Returns the square of the length (magnitude) of the vector
       /// \return The squared length
       public: T SquaredLength() const
       {
-        return std::pow(this->data[0], 2)
-             + std::pow(this->data[1], 2);
+        return
+          this->data[0] * this->data[0] +
+          this->data[1] * this->data[1];
       }
 
       /// \brief Normalize the vector length

include/ignition/math/Vector3.hh

@@ -97,9 +97,10 @@ namespace ignition
       /// \return the distance
       public: T Distance(const Vector3<T> &_pt) const
       {
-        return sqrt((this->data[0]-_pt[0])*(this->data[0]-_pt[0]) +
+        return static_cast<T>(sqrt(
+                    (this->data[0]-_pt[0])*(this->data[0]-_pt[0]) +
                     (this->data[1]-_pt[1])*(this->data[1]-_pt[1]) +
-                    (this->data[2]-_pt[2])*(this->data[2]-_pt[2]));
+                    (this->data[2]-_pt[2])*(this->data[2]-_pt[2])));
       }
 
       /// \brief Calc distance to the given point
@@ -116,16 +117,17 @@ namespace ignition
       /// \return the length
       public: T Length() const
       {
-        return sqrt(this->SquaredLength());
+        return static_cast<T>(sqrt(this->SquaredLength()));
       }
 
       /// \brief Return the square of the length (magnitude) of the vector
       /// \return the squared length
       public: T SquaredLength() const
       {
-        return std::pow(this->data[0], 2)
-             + std::pow(this->data[1], 2)
-             + std::pow(this->data[2], 2);
+        return
+          this->data[0] * this->data[0] +
+          this->data[1] * this->data[1] +
+          this->data[2] * this->data[2];
       }
 
       /// \brief Normalize the vector length

include/ignition/math/Vector4.hh

@@ -78,10 +78,11 @@ namespace ignition
       /// \return the distance
       public: T Distance(const Vector4<T> &_pt) const
       {
-        return sqrt((this->data[0]-_pt[0])*(this->data[0]-_pt[0]) +
+        return static_cast<T>(sqrt(
+                    (this->data[0]-_pt[0])*(this->data[0]-_pt[0]) +
                     (this->data[1]-_pt[1])*(this->data[1]-_pt[1]) +
                     (this->data[2]-_pt[2])*(this->data[2]-_pt[2]) +
-                    (this->data[3]-_pt[3])*(this->data[3]-_pt[3]));
+                    (this->data[3]-_pt[3])*(this->data[3]-_pt[3])));
       }
 
       /// \brief Calc distance to the given point
@@ -99,17 +100,18 @@ namespace ignition
       /// \return The length
       public: T Length() const
       {
-        return sqrt(this->SquaredLength());
+        return static_cast<T>(sqrt(this->SquaredLength()));
       }
 
       /// \brief Return the square of the length (magnitude) of the vector
       /// \return the length
       public: T SquaredLength() const
       {
-        return std::pow(this->data[0], 2)
-             + std::pow(this->data[1], 2)
-             + std::pow(this->data[2], 2)
-             + std::pow(this->data[3], 2);
+        return
+          this->data[0] * this->data[0] +
+          this->data[1] * this->data[1] +
+          this->data[2] * this->data[2] +
+          this->data[3] * this->data[3];
       }
 
       /// \brief Round to near whole number.

src/Vector2_TEST.cc

@@ -436,5 +436,10 @@ TEST(Vector2Test, Length)
   math::Vector2d v(0.1, -4.2);
   EXPECT_NEAR(v.Length(), 4.20119030752, 1e-10);
   EXPECT_DOUBLE_EQ(v.SquaredLength(), 17.65);
+
+  // Integer vector
+  math::Vector2i vi(3, 4);
+  EXPECT_EQ(vi.Length(), 5);
+  EXPECT_EQ(vi.SquaredLength(), 25);
 }
 

src/Vector3_TEST.cc

@@ -143,6 +143,10 @@ TEST(Vector3dTest, Distance)
 
   double dist2 = vec1.Distance(1, 2, 3);
   EXPECT_DOUBLE_EQ(dist, dist2);
+
+  math::Vector3i vecInt(0, 0, 0);
+  int distInt = vecInt.Distance({2, 2, 1});
+  EXPECT_EQ(distInt, 3);
 }
 
 /////////////////////////////////////////////////
@@ -163,12 +167,15 @@ TEST(Vector3dTest, SquaredLength)
 {
   math::Vector3d vec1(0, 0, 0);
   math::Vector3d vec2(1, 2, 3);
+  math::Vector3i vec3(1, 2, 3);
 
   double sum1 = vec1.SquaredLength();
   double sum2 = vec2.SquaredLength();
+  int sum3 = vec3.SquaredLength();
 
   EXPECT_DOUBLE_EQ(sum1, 0);
   EXPECT_DOUBLE_EQ(sum2, 14);
+  EXPECT_EQ(sum3, 14);
 }
 
 /////////////////////////////////////////////////
@@ -194,6 +201,11 @@ TEST(Vector3dTest, Length)
   math::Vector3d v(0.1, -4.2, 2.5);
   EXPECT_NEAR(v.Length(), 4.88876262463, 1e-10);
   EXPECT_DOUBLE_EQ(v.SquaredLength(), 23.9);
+
+  // Integer vector
+  math::Vector3i vi(1, 2, 2);
+  EXPECT_EQ(vi.Length(), 3);
+  EXPECT_EQ(vi.SquaredLength(), 9);
 }
 
 /////////////////////////////////////////////////

src/Vector4_TEST.cc

@@ -267,6 +267,23 @@ TEST(Vector4dTest, EqualTolerance)
   EXPECT_TRUE(math::Vector4d::Zero.Equal(math::Vector4d::One, 1.1));
 }
 
+/////////////////////////////////////////////////
+TEST(Vector4dTest, Distance)
+{
+  math::Vector4d vec1(0, 0, 0, 0);
+  math::Vector4d vec2(1, 2, 3, 4);
+
+  double dist = vec1.Distance(vec2);
+  EXPECT_NEAR(dist, 5.477225, 1e-6);
+
+  double dist2 = vec1.Distance(1, 2, 3, 4);
+  EXPECT_DOUBLE_EQ(dist, dist2);
+
+  math::Vector4i vecInt(0, 0, 0, 0);
+  int distInt = vecInt.Distance({1, 1, 1, 1});
+  EXPECT_EQ(distInt, 2);
+}
+
 /////////////////////////////////////////////////
 TEST(Vector4dTest, Sum)
 {
@@ -420,5 +437,9 @@ TEST(Vector4dTest, Length)
   math::Vector4d v(0.1, -4.2, 2.5, 1.0);
   EXPECT_NEAR(v.Length(), 4.98998997995, 1e-10);
   EXPECT_DOUBLE_EQ(v.SquaredLength(), 24.9);
+
+  // Integer vector
+  EXPECT_EQ(math::Vector4i::One.Length(), 2);
+  EXPECT_EQ(math::Vector4i::One.SquaredLength(), 4);
 }