Fixed namespace issues

Angle.cpp

@@ -78,7 +78,8 @@ template <> AngleOf<float> AngleOf<float>::pi = 3.1415927410125732421875F;
 template <> AngleOf<float> AngleOf<float>::Rad2Deg = 360.0f / (pi * 2);
 template <> AngleOf<float> AngleOf<float>::Deg2Rad = (pi * 2) / 360.0f;
 
-template <> bool Passer::AngleOf<float>::operator==(AngleOf<float> a) {
+template <>
+bool Passer::LinearAlgebra::AngleOf<float>::operator==(AngleOf<float> a) {
   return (float)*this == (float)a;
 }
 

AngleAxis.h

@@ -9,7 +9,7 @@
 #include "Axis.h"
 
 namespace Passer {
-namespace LinearAlgbra {
+namespace LinearAlgebra {
 
 class AngleAxis {
 public:
@@ -20,8 +20,8 @@ public:
   AngleAxis(Angle angle, Axis axis);
 };
 
-} // namespace LinearAlgbra
+} // namespace LinearAlgebra
 } // namespace Passer
-using namespace Passer::LinearAlgbra;
+using namespace Passer::LinearAlgebra;
 
 #endif

Axis.h

@@ -33,6 +33,6 @@ public:
 
 } // namespace LinearAlgebra
 } // namespace Passer
-using namespace Passer::LinearAlgbra;
+using namespace Passer::LinearAlgebra;
 
 #endif

Polar.cpp

@@ -94,20 +94,20 @@ Polar Polar::operator+=(const Polar &v) {
   return *this;
 }
 
-Polar Passer::operator*(const Polar &v, float f) {
+Polar Passer::LinearAlgebra::operator*(const Polar &v, float f) {
   return Polar(v.distance * f, v.angle);
 }
-Polar Passer::operator*(float f, const Polar &v) {
+Polar Passer::LinearAlgebra::operator*(float f, const Polar &v) {
   return Polar(v.distance * f, v.angle);
 }
 Polar Polar::operator*=(float f) {
   this->distance *= f;
   return *this;
 }
-Polar Passer::operator/(const Polar &v, float f) {
+Polar Passer::LinearAlgebra::operator/(const Polar &v, float f) {
   return Polar(v.distance / f, v.angle);
 }
-Polar Passer::operator/(float f, const Polar &v) {
+Polar Passer::LinearAlgebra::operator/(float f, const Polar &v) {
   return Polar(v.distance / f, v.angle);
 }
 Polar Polar::operator/=(float f) {

Spherical.cpp

@@ -71,20 +71,20 @@ Spherical Spherical::operator-() const {
   return v;
 }
 
-Spherical Passer::operator*(const Spherical &v, float f) {
+Spherical Passer::LinearAlgebra::operator*(const Spherical &v, float f) {
   return Spherical(v.distance * f, v.horizontalAngle, v.verticalAngle);
 }
-Spherical Passer::operator*(float f, const Spherical &v) {
+Spherical Passer::LinearAlgebra::operator*(float f, const Spherical &v) {
   return Spherical(v.distance * f, v.horizontalAngle, v.verticalAngle);
 }
 Spherical Spherical::operator*=(float f) {
   this->distance *= f;
   return *this;
 }
-Spherical Passer::operator/(const Spherical &v, float f) {
+Spherical Passer::LinearAlgebra::operator/(const Spherical &v, float f) {
   return Spherical(v.distance / f, v.horizontalAngle, v.verticalAngle);
 }
-Spherical Passer::operator/(float f, const Spherical &v) {
+Spherical Passer::LinearAlgebra::operator/(float f, const Spherical &v) {
   return Spherical(v.distance / f, v.horizontalAngle, v.verticalAngle);
 }
 Spherical Spherical::operator/=(float f) {

Vector2.cpp

@@ -99,10 +99,10 @@ Vector2 Vector2::operator+=(const Vector2 &v) {
 Vector2 Vector2::Scale(const Vector2 &v1, const Vector2 &v2) {
   return Vector2(v1.x * v2.x, v1.y * v2.y);
 }
-Vector2 Passer::operator*(const Vector2 &v, float f) {
+Vector2 Passer::LinearAlgebra::operator*(const Vector2 &v, float f) {
   return Vector2(v.x * f, v.y * f);
 }
-Vector2 Passer::operator*(float f, const Vector2 &v) {
+Vector2 Passer::LinearAlgebra::operator*(float f, const Vector2 &v) {
   return Vector2(v.x * f, v.y * f);
 }
 Vector2 Vector2::operator*=(float f) {
@@ -110,10 +110,10 @@ Vector2 Vector2::operator*=(float f) {
   this->y *= f;
   return *this;
 }
-Vector2 Passer::operator/(const Vector2 &v, float f) {
+Vector2 Passer::LinearAlgebra::operator/(const Vector2 &v, float f) {
   return Vector2(v.x / f, v.y / f);
 }
-Vector2 Passer::operator/(float f, const Vector2 &v) {
+Vector2 Passer::LinearAlgebra::operator/(float f, const Vector2 &v) {
   return Vector2(v.x / f, v.y / f);
 }
 Vector2 Vector2::operator/=(float f) {
@@ -151,7 +151,7 @@ float Vector2::SignedAngle(const Vector2 &v1, const Vector2 &v2) {
   return -(angleTo - angleFrom) * Angle::Rad2Deg;
 }
 
-Vector2 Vector2::Rotate(const Vector2 &v, Passer::Angle a) {
+Vector2 Vector2::Rotate(const Vector2 &v, Passer::LinearAlgebra::Angle a) {
   float angleRad = a * Angle::Deg2Rad;
 #if defined(AVR)
   float sinValue = sin(angleRad);

Vector3.cpp

@@ -118,10 +118,10 @@ Vector3 Vector3::operator+=(const Vector3 &v) {
 Vector3 Vector3::Scale(const Vector3 &v1, const Vector3 &v2) {
   return Vector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
 }
-Vector3 Passer::operator*(const Vector3 &v, float f) {
+Vector3 Passer::LinearAlgebra::operator*(const Vector3 &v, float f) {
   return Vector3(v.x * f, v.y * f, v.z * f);
 }
-Vector3 Passer::operator*(float f, const Vector3 &v) {
+Vector3 Passer::LinearAlgebra::operator*(float f, const Vector3 &v) {
   return Vector3(v.x * f, v.y * f, v.z * f);
 }
 Vector3 Vector3::operator*=(float f) {
@@ -130,10 +130,10 @@ Vector3 Vector3::operator*=(float f) {
   this->z *= f;
   return *this;
 }
-Vector3 Passer::operator/(const Vector3 &v, float f) {
+Vector3 Passer::LinearAlgebra::operator/(const Vector3 &v, float f) {
   return Vector3(v.x / f, v.y / f, v.z / f);
 }
-Vector3 Passer::operator/(float f, const Vector3 &v) {
+Vector3 Passer::LinearAlgebra::operator/(float f, const Vector3 &v) {
   return Vector3(v.x / f, v.y / f, v.z / f);
 }
 Vector3 Vector3::operator/=(float f) {