Implement Vector2Tests

src/J3ML/LinearAlgebra/AxisAngle.cpp

@@ -0,0 +1,8 @@
+#include <J3ML/LinearAlgebra/AxisAngle.h>
+
+namespace LinearAlgebra {
+
+    AxisAngle::AxisAngle() : axis(Vector3::Zero) {}
+
+    AxisAngle::AxisAngle(const Vector3 &axis, float angle) : axis(axis), angle(angle) {}
+}

src/J3ML/LinearAlgebra/Matrix4x4.cpp

@@ -1 +1,5 @@
-#include <J3ML/LinearAlgebra/Matrix4x4.h>
+#include <J3ML/LinearAlgebra/Matrix4x4.h>
+
+namespace LinearAlgebra {
+
+}

src/J3ML/LinearAlgebra/Vector2.cpp

@@ -5,160 +5,159 @@
 
 namespace LinearAlgebra {
 
+    Vector2::Vector2(): x(0), y(0)
+    {}
 
-Vector2::Vector2(): x(0), y(0)
-{}
+    Vector2::Vector2(float X, float Y): x(X), y(Y)
+    {}
 
-Vector2::Vector2(float X, float Y): x(X), y(Y)
-{}
+    Vector2::Vector2(const Vector2& rhs): x(rhs.x), y(rhs.y)
+    {}
 
-Vector2::Vector2(const Vector2& rhs): x(rhs.x), y(rhs.y)
-{}
+    float Vector2::operator[](std::size_t index)
+    {
+        assert(index < 2);
+        if (index == 0) return x;
+        if (index == 1) return y;
+        return 0;
+    }
 
-float Vector2::operator[](std::size_t index)
-{
-    assert(index < 2);
-    if (index == 0) return x;
-    if (index == 1) return y;
-    return 0;
-}
+    bool Vector2::IsWithinMarginOfError(const Vector2& rhs, float margin) const
+    {
+        return this->Distance(rhs) <= margin;
+    }
 
-bool Vector2::IsWithinMarginOfError(const Vector2& rhs, float margin) const
-{
-    return this->Distance(rhs) <= margin;
-}
+    bool Vector2::operator==(const Vector2& rhs) const
+    {
+        return this->IsWithinMarginOfError(rhs);
+    }
 
-bool Vector2::operator==(const Vector2& rhs) const
-{
-    return this->IsWithinMarginOfError(rhs);
-}
+    bool Vector2::operator!=(const Vector2& rhs) const
+    {
+        return this->IsWithinMarginOfError(rhs) == false;
+    }
 
-bool Vector2::operator!=(const Vector2& rhs) const
-{
-    return this->IsWithinMarginOfError(rhs) == false;
-}
-
-Vector2 Vector2::Min(const Vector2& min) const
-{
-    return {
-            std::min(this->x, min.x),
-            std::min(this->y, min.y)
-    };
-}
-
-Vector2 Vector2::Max(const Vector2& max) const
-{
-    return {
-            std::max(this->x, max.x),
-            std::max(this->y, max.y)
-    };
-}
-
-Vector2 Vector2::Clamp(const Vector2& min, const Vector2& max) const
-{
-    return {
-            std::clamp(this->x, min.x, max.x),
-            std::clamp(this->y, min.y, max.y)
-    };
-}
-
-float Vector2::Distance(const Vector2& to) const
-{
-    return ((*this)-to).Magnitude();
-}
-
-float Vector2::Length() const
-{
-    return std::sqrt(LengthSquared());
-}
-
-float Vector2::LengthSquared() const
-{
-    return (x*x + y*y);
-}
-
-float Vector2::Magnitude() const
-{
-    return std::sqrt(LengthSquared());
-}
-
-float Vector2::Dot(const Vector2& rhs) const
-{
-    auto a = this->Normalize();
-    auto b = rhs.Normalize();
-
-    return a.x * b.x + a.y * b.y;
-}
-
-Vector2 Vector2::Project(const Vector2& rhs) const
-{
-    float scalar = this->Dot(rhs) / (rhs.Magnitude()*rhs.Magnitude());
-    return rhs * scalar;
-}
-
-Vector2 Vector2::Normalize() const
-{
-    if (Length() > 0)
+    Vector2 Vector2::Min(const Vector2& min) const
+    {
         return {
-                x / Length(),
-                y / Length()
+                std::min(this->x, min.x),
+                std::min(this->y, min.y)
         };
-    else
-        return {0,0};
-}
+    }
 
-Vector2 Vector2::Lerp(const Vector2& rhs, float alpha) const
-{
-    return this->operator*(1.0f - alpha) + (rhs * alpha);
-}
+    Vector2 Vector2::Max(const Vector2& max) const
+    {
+        return {
+                std::max(this->x, max.x),
+                std::max(this->y, max.y)
+        };
+    }
 
-float Vector2::AngleBetween(const Vector2& rhs) const
-{
-    auto numer = this->Dot(rhs);
-    auto denom = this->Magnitude() * rhs.Magnitude();
-    return std::acos(numer / denom);
-}
+    Vector2 Vector2::Clamp(const Vector2& min, const Vector2& max) const
+    {
+        return {
+                std::clamp(this->x, min.x, max.x),
+                std::clamp(this->y, min.y, max.y)
+        };
+    }
 
-float Vector2::AngleBetween(const Vector2& lhs, const Vector2& rhs)
-{ return lhs.AngleBetween(rhs); }
+    float Vector2::Distance(const Vector2& to) const
+    {
+        return ((*this)-to).Magnitude();
+    }
 
-Vector2 Vector2::operator+(const Vector2& rhs) const
-{
-    return {this->x + rhs.x, this->y + rhs.y};
-}
+    float Vector2::Length() const
+    {
+        return std::sqrt(LengthSquared());
+    }
 
-Vector2 Vector2::operator-(const Vector2& rhs) const
-{
-    return {this->x - rhs.x, this->y - rhs.y};
-}
+    float Vector2::LengthSquared() const
+    {
+        return (x*x + y*y);
+    }
 
-Vector2 Vector2::operator*(float rhs) const
-{
-    return {
-            this->x * rhs,
-            this->y * rhs
-    };
-}
+    float Vector2::Magnitude() const
+    {
+        return std::sqrt(LengthSquared());
+    }
 
-Vector2 Vector2::operator/(float rhs) const
-{
-    return {
-            this->x / rhs,
-            this->y / rhs
-    };
-}
+    float Vector2::Dot(const Vector2& rhs) const
+    {
+        auto a = this->Normalize();
+        auto b = rhs.Normalize();
 
-Vector2 Vector2::operator-() const
-{
-    return {-x, -y};
-}
+        return a.x * b.x + a.y * b.y;
+    }
 
-const Vector2 Vector2::Zero  = {0, 0};
-const Vector2 Vector2::Up    = {0, -1};
-const Vector2 Vector2::Down  = {0, 1};
-const Vector2 Vector2::Left  = {-1, 0};
-const Vector2 Vector2::Right = {1, 0};
-const Vector2 Vector2::NaN = {NAN, NAN};
+    Vector2 Vector2::Project(const Vector2& rhs) const
+    {
+        float scalar = this->Dot(rhs) / (rhs.Magnitude()*rhs.Magnitude());
+        return rhs * scalar;
+    }
+
+    Vector2 Vector2::Normalize() const
+    {
+        if (Length() > 0)
+            return {
+                    x / Length(),
+                    y / Length()
+            };
+        else
+            return {0,0};
+    }
+
+    Vector2 Vector2::Lerp(const Vector2& rhs, float alpha) const
+    {
+        return this->operator*(1.0f - alpha) + (rhs * alpha);
+    }
+
+    float Vector2::AngleBetween(const Vector2& rhs) const
+    {
+        auto numer = this->Dot(rhs);
+        auto denom = this->Magnitude() * rhs.Magnitude();
+        return std::acos(numer / denom);
+    }
+
+    float Vector2::AngleBetween(const Vector2& lhs, const Vector2& rhs)
+    { return lhs.AngleBetween(rhs); }
+
+    Vector2 Vector2::operator+(const Vector2& rhs) const
+    {
+        return {this->x + rhs.x, this->y + rhs.y};
+    }
+
+    Vector2 Vector2::operator-(const Vector2& rhs) const
+    {
+        return {this->x - rhs.x, this->y - rhs.y};
+    }
+
+    Vector2 Vector2::operator*(float rhs) const
+    {
+        return {
+                this->x * rhs,
+                this->y * rhs
+        };
+    }
+
+    Vector2 Vector2::operator/(float rhs) const
+    {
+        return {
+                this->x / rhs,
+                this->y / rhs
+        };
+    }
+
+    Vector2 Vector2::operator-() const
+    {
+        return {-x, -y};
+    }
+
+    const Vector2 Vector2::Zero  = {0, 0};
+    const Vector2 Vector2::Up    = {0, -1};
+    const Vector2 Vector2::Down  = {0, 1};
+    const Vector2 Vector2::Left  = {-1, 0};
+    const Vector2 Vector2::Right = {1, 0};
+    const Vector2 Vector2::NaN = {NAN, NAN};
 
     float Vector2::GetX() const { return x; }
 
@@ -172,5 +171,22 @@ const Vector2 Vector2::NaN = {NAN, NAN};
 
     float Vector2::Length(const Vector2 &of) { return of.Length(); }
 
+    void Vector2::SetX(float newX) { x = newX;}
+
+    void Vector2::SetY(float newY) { y = newY; }
+
+    bool Vector2::IsNormalized(float epsilonSq) const {
+        return std::abs(LengthSquared() - 1.f) <= epsilonSq;
+    }
+
+    bool Vector2::IsZero(float epsilonSq) const {
+        return LengthSquared() <= epsilonSq;
+    }
+
+    bool Vector2::IsPerpendicular(const Vector2 &other, float epsilonSq) const {
+        float dot = Dot(other);
+        return dot*dot <= epsilonSq * LengthSquared() * other.LengthSquared();
+    }
+
 
 }

src/J3ML/LinearAlgebra/Vector3.cpp

@@ -188,5 +188,48 @@ namespace LinearAlgebra {
 
     float Vector3::GetZ() const { return z;}
 
+    void Vector3::SetX(float newX) { x = newX;}
+
+    void Vector3::SetY(float newY) { y = newY;}
+
+    void Vector3::SetZ(float newZ) { z = newZ;}
+
+    Vector3 Vector3::Min(const Vector3 &lhs, const Vector3 &rhs) {
+        return lhs.Min(rhs);
+    }
+
+    Vector3 Vector3::Max(const Vector3 &lhs, const Vector3 &rhs) {
+        return lhs.Max(rhs);
+    }
+
+    Vector3 Vector3::Clamp(const Vector3 &min, const Vector3 &input, const Vector3 &max) {
+        return input.Clamp(min, max);
+    }
+
+    float Vector3::Distance(const Vector3 &from, const Vector3 &to) {
+        return from.Distance(to);
+    }
+
+    float Vector3::Length(const Vector3 &of) {
+        return of.Length();
+    }
+
+    float Vector3::LengthSquared(const Vector3 &of) {
+        return of.LengthSquared();
+    }
+
+    bool Vector3::IsPerpendicular(const Vector3 &other, float epsilonSq) const {
+        float dot = Dot(other);
+        return dot*dot <= epsilonSq * LengthSquared() * other.LengthSquared();
+    }
+
+    bool Vector3::IsZero(float epsilonSq) const {
+        return LengthSquared() <= epsilonSq;
+    }
+
+    bool Vector3::IsNormalized(float epsilonSq) const {
+        return std::abs(LengthSquared()-1.f) <= epsilonSq;
+    }
+
 #pragma endregion
 }