uncrustify libraries/AP_Math/vector2.h

libraries/AP_Math/vector2.h

@@ -9,16 +9,16 @@
 
 // Derived closely from:
 /****************************************
- * 2D Vector Classes
+* 2D Vector Classes
- * By Bill Perone (billperone@yahoo.com)
+* By Bill Perone (billperone@yahoo.com)
- * Original: 9-16-2002
+* Original: 9-16-2002
- * Revised: 19-11-2003
+* Revised: 19-11-2003
- *          18-12-2003
+*          18-12-2003
- *          06-06-2004
+*          06-06-2004
- *
+*
- * © 2003, This code is provided "as is" and you can use it freely as long as
+* © 2003, This code is provided "as is" and you can use it freely as long as
- * credit is given to Bill Perone in the application it is used in
+* credit is given to Bill Perone in the application it is used in
- ****************************************/
+****************************************/
 
 #ifndef VECTOR2_H
 #define VECTOR2_H
@@ -31,34 +31,49 @@ struct Vector2
     T x, y;
 
     // trivial ctor
-	Vector2<T>() { x = y = 0; }
+    Vector2<T>() {
+        x = y = 0;
+    }
 
     // setting ctor
-	Vector2<T>(const T x0, const T y0): x(x0), y(y0) {}
+    Vector2<T>(const T x0, const T y0) : x(x0), y(y0) {
+    }
 
     // function call operator
     void operator ()(const T x0, const T y0)
-	{	x= x0; y= y0;	}
+    {
+        x= x0; y= y0;
+    }
 
     // test for equality
     bool operator==(const Vector2<T> &v)
-	{	return (x==v.x && y==v.y);	}
+    {
+        return (x==v.x && y==v.y);
+    }
 
     // test for inequality
     bool operator!=(const Vector2<T> &v)
-	{	return (x!=v.x || y!=v.y);	}
+    {
+        return (x!=v.x || y!=v.y);
+    }
 
     // negation
     Vector2<T> operator -(void) const
-	{	return Vector2<T>(-x, -y);	}
+    {
+        return Vector2<T>(-x, -y);
+    }
 
     // addition
     Vector2<T> operator +(const Vector2<T> &v) const
-	{	return Vector2<T>(x+v.x, y+v.y);	}
+    {
+        return Vector2<T>(x+v.x, y+v.y);
+    }
 
     // subtraction
     Vector2<T> operator -(const Vector2<T> &v) const
-	{   return Vector2<T>(x-v.x, y-v.y);	}
+    {
+        return Vector2<T>(x-v.x, y-v.y);
+    }
 
     // uniform scaling
     Vector2<T> operator *(const T num) const
@@ -104,23 +119,33 @@ struct Vector2
 
     // dot product
     T operator *(const Vector2<T> &v) const
-	{	return x*v.x + y*v.y;	}
+    {
+        return x*v.x + y*v.y;
+    }
 
     // gets the length of this vector squared
     T   length_squared() const
-	{	return (T)(*this * *this);   }
+    {
+        return (T)(*this * *this);
+    }
 
     // gets the length of this vector
     T   length() const
-	{	return (T)sqrt(*this * *this);   }
+    {
+        return (T)sqrt(*this * *this);
+    }
 
     // normalizes this vector
     void    normalize()
-	{	*this/=length();	}
+    {
+        *this/=length();
+    }
 
     // returns the normalized vector
     Vector2<T>  normalized() const
-	{   return  *this/length();  }
+    {
+        return *this/length();
+    }
 
     // reflects this vector about n
     void    reflect(const Vector2<T> &n)
@@ -132,23 +157,33 @@ struct Vector2
 
     // projects this vector onto v
     void    project(const Vector2<T> &v)
-	{	*this= v * (*this * v)/(v*v);	}
+    {
+        *this= v * (*this * v)/(v*v);
+    }
 
     // returns this vector projected onto v
     Vector2<T>  projected(const Vector2<T> &v)
-	{   return v * (*this * v)/(v*v);	}
+    {
+        return v * (*this * v)/(v*v);
+    }
 
     // computes the angle between 2 arbitrary vectors
     T   angle(const Vector2<T> &v1, const Vector2<T> &v2)
-	{   return (T)acos((v1*v2) / (v1.length()*v2.length()));  }
+    {
+        return (T)acos((v1*v2) / (v1.length()*v2.length()));
+    }
 
     // computes the angle between this vector and another vector
     T   angle(const Vector2<T> &v2)
-		{   return (T)acos(((*this)*v2) / (this->length()*v2.length()));  }
+    {
+        return (T)acos(((*this)*v2) / (this->length()*v2.length()));
+    }
 
     // computes the angle between 2 normalized arbitrary vectors
     T   angle_normalized(const Vector2<T> &v1, const Vector2<T> &v2)
-	{   return (T)acos(v1*v2);  }
+    {
+        return (T)acos(v1*v2);
+    }
 
 };