548 lines
13 KiB
Python
548 lines
13 KiB
Python
import unittest
|
|
|
|
from LinearAlgebra.Vector import *
|
|
|
|
class Vector2Test(unittest.TestCase):
|
|
def test_Equality(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
|
|
v2: Vector2 = Vector2(1, 2)
|
|
assert(v1 != v2)
|
|
|
|
v2 = Vector2(4, 5)
|
|
assert(v1 == v2)
|
|
|
|
def test_SqrMagnitude(self):
|
|
v: Vector2 = Vector2(1, 2)
|
|
m: float = 0;
|
|
|
|
m = v.SqrMagnitude()
|
|
assert(m == 5)
|
|
|
|
v = Vector2(-1, -2)
|
|
m = v.SqrMagnitude()
|
|
assert(m == 5)
|
|
|
|
v = Vector2(0, 0)
|
|
m = v.SqrMagnitude()
|
|
assert(m == 0)
|
|
|
|
def test_Magnitude(self):
|
|
v: Vector2 = Vector2(1, 2)
|
|
m: float = 0;
|
|
|
|
m = v.Magnitude()
|
|
assert(m == 2.23606797749979)
|
|
|
|
v = Vector2(-1, -2)
|
|
m = v.Magnitude()
|
|
assert(m == 2.23606797749979)
|
|
|
|
v = Vector2(0, 0)
|
|
m = v.Magnitude()
|
|
assert(m == 0)
|
|
|
|
def test_Normalize(self):
|
|
v1: Vector2 = Vector2(0, 2)
|
|
v: Vector2 = Vector2.zero
|
|
|
|
v = v1.Normalized()
|
|
assert(v == Vector2(0, 1))
|
|
|
|
v1 = Vector2(0, -2)
|
|
v = v1.Normalized()
|
|
assert(v == Vector2(0, -1))
|
|
|
|
v1 = Vector2(0, 0)
|
|
v = v1.Normalized()
|
|
assert(v == Vector2(0, 0))
|
|
|
|
def test_Negate(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
r: Vector2 = Vector2.zero
|
|
|
|
r = -v1
|
|
assert(r == Vector2(-4, -5))
|
|
|
|
v1 = Vector2(-4, -5)
|
|
r = -v1
|
|
assert(r == Vector2(4, 5))
|
|
|
|
v1 = Vector2(0, 0)
|
|
r = -v1
|
|
assert(r == Vector2(0, 0))
|
|
|
|
def test_Subtract(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: Vector2 = Vector2.zero
|
|
|
|
|
|
r = v1 - v2
|
|
assert(v1 - v2 == Vector2(3, 3))
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = v1 - v2
|
|
assert(r == Vector2(5, 7))
|
|
|
|
v2 = Vector2(4, 5)
|
|
r = v1 - v2
|
|
assert(r == Vector2(0, 0))
|
|
|
|
v2 = Vector2(0, 0)
|
|
r = v1 - v2
|
|
assert(r == Vector2(4, 5))
|
|
|
|
def test_Addition(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: Vector2 = Vector2.zero
|
|
|
|
r = v1 + v2
|
|
assert(r == Vector2(5, 7))
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = v1 + v2
|
|
assert(r == Vector2(3, 3))
|
|
|
|
v2 = Vector2(0, 0)
|
|
r = v1 + v2
|
|
assert(r == Vector2(4, 5))
|
|
|
|
def test_Scale(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: Vector2 = Vector2.zero
|
|
|
|
r = v1.Scale(v2)
|
|
assert(r == Vector2(4, 10))
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = v1.Scale(v2)
|
|
assert(r == Vector2(-4, -10))
|
|
|
|
v2 = Vector2(0, 0)
|
|
r = v1.Scale(v2)
|
|
assert(r == Vector2(0, 0))
|
|
|
|
def test_Multiply(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
f: float = 3
|
|
r: Vector2 = Vector2.zero
|
|
|
|
r = v1 * f
|
|
assert(r == Vector2(12, 15))
|
|
|
|
f = -3
|
|
r = v1 * f
|
|
assert(r == Vector2(-12, -15))
|
|
|
|
f = 0
|
|
r = v1 * f
|
|
assert(r == Vector2(0, 0))
|
|
|
|
def test_Divide(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
f: float = 2
|
|
v: Vector2 = Vector2.zero
|
|
|
|
v = v1 / f
|
|
assert(v == Vector2(2, 2.5))
|
|
|
|
f = -2
|
|
v = v1 / f
|
|
assert(v == Vector2(-2, -2.5))
|
|
|
|
def test_Distance(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: float = 0
|
|
|
|
r = Vector2.Distance(v1, v2)
|
|
assert(r == 4.242640687119285)
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = Vector2.Distance(v1, v2)
|
|
assert(r == 8.602325267042627)
|
|
|
|
v2 = Vector2(0, 0)
|
|
r = Vector2.Distance(v1, v2)
|
|
assert(r == 6.4031242374328485)
|
|
|
|
def test_Dot(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: float = 0
|
|
|
|
r = Vector2.Dot(v1, v2)
|
|
assert(r == 14)
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = Vector2.Dot(v1, v2)
|
|
assert(r, -14)
|
|
|
|
v2 = Vector2(0, 0)
|
|
r = Vector2.Dot(v1, v2)
|
|
assert(r, 0)
|
|
|
|
def test_Angle(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: Angle = Angle.Degrees(0)
|
|
|
|
r = Vector2.Angle(v1, v2)
|
|
assert(r.InDegrees() == 12.094757077012119)
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = Vector2.Angle(v1, v2)
|
|
assert(r.InDegrees() == 167.9052429229879)
|
|
|
|
v2 = Vector2(0, 0)
|
|
r = Vector2.Angle(v1, v2)
|
|
assert(r.InDegrees() == 0)
|
|
|
|
def test_SignedAngle(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: float = 0
|
|
|
|
r = Vector2.SignedAngle(v1, v2)
|
|
assert(r.InDegrees() == -12.094757077012098)
|
|
|
|
v2 = Vector2(-1, -2)
|
|
r = Vector2.SignedAngle(v1, v2)
|
|
assert(r.InDegrees() == 167.90524292298792)
|
|
|
|
v2 = Vector2(0, 0);
|
|
r = Vector2.SignedAngle(v1, v2)
|
|
assert(r.InDegrees() == 0)
|
|
|
|
v1 = Vector2(0, 1)
|
|
v2 = Vector2(1, 0)
|
|
r = Vector2.SignedAngle(v1, v2)
|
|
assert(r.InDegrees(), 90)
|
|
|
|
v1 = Vector2(0, 1)
|
|
v2 = Vector2(0, -1)
|
|
r = Vector2.SignedAngle(v1, v2)
|
|
assert(r.InDegrees(), 180)
|
|
|
|
def test_Lerp(self):
|
|
v1: Vector2 = Vector2(4, 5)
|
|
v2: Vector2 = Vector2(1, 2)
|
|
r: Vector2 = Vector2.zero
|
|
|
|
r = Vector2.Lerp(v1, v2, 0)
|
|
assert(Vector2.Distance(r, v1), 0)
|
|
|
|
r = Vector2.Lerp(v1, v2, 1)
|
|
assert(Vector2.Distance(r, v2), 0)
|
|
|
|
r = Vector2.Lerp(v1, v2, 0.5)
|
|
assert(Vector2.Distance(r, Vector2(2.5, 3.5)), 0)
|
|
|
|
r = Vector2.Lerp(v1, v2, -1)
|
|
assert(Vector2.Distance(r, Vector2(7.0, 8.0)), 0)
|
|
|
|
r = Vector2.Lerp(v1, v2, 2)
|
|
assert(Vector2.Distance(r, Vector2(-2.0, -1.0)), 0)
|
|
|
|
class Vector3Test(unittest.TestCase):
|
|
def test_Equality(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
r: bool = False
|
|
|
|
r = v1 == v2
|
|
assert(r == False)
|
|
|
|
v2 = Vector3(4, 5, 6);
|
|
r = v1 == v2;
|
|
assert(r == True)
|
|
|
|
def test_SqrMagnitude(self):
|
|
v: Vector3 = Vector3(1, 2, 3)
|
|
m: float = 0;
|
|
|
|
m = v.SqrMagnitude()
|
|
assert(m == 14)
|
|
|
|
v = Vector3(-1, -2, -3)
|
|
m = v.SqrMagnitude()
|
|
assert(m == 14)
|
|
|
|
v = Vector3(0, 0, 0)
|
|
m = v.SqrMagnitude()
|
|
assert(m == 0)
|
|
|
|
def test_Magnitude(self):
|
|
v: Vector3 = Vector3(1, 2, 3)
|
|
m: float = 0;
|
|
|
|
m = v.Magnitude()
|
|
assert(m == 3.7416573867739413)
|
|
|
|
v = Vector3(-1, -2, -3)
|
|
m = v.Magnitude()
|
|
assert(m == 3.7416573867739413)
|
|
|
|
v = Vector3(0, 0, 0)
|
|
m = v.Magnitude()
|
|
assert(m == 0)
|
|
|
|
def test_Normalize(self):
|
|
r: bool = False
|
|
|
|
v1: Vector3 = Vector3(0, 2, 0)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1.Normalized()
|
|
assert(v == Vector3(0, 1, 0))
|
|
|
|
v1 = Vector3(0, -2, 0)
|
|
v = v1.Normalized()
|
|
assert(v == Vector3(0, -1, 0))
|
|
|
|
v1 = Vector3(0, 0, 0)
|
|
v = v1.Normalized()
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
def test_Negate(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = -v1
|
|
assert(v == Vector3(-4, -5, -6))
|
|
|
|
v1 = Vector3(-4, -5, -6)
|
|
v = -v1
|
|
assert(v == Vector3(4, 5, 6))
|
|
|
|
v1 = Vector3(0, 0, 0)
|
|
v = -v1
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
def test_Subtract(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v3: Vector3 = Vector3.zero
|
|
|
|
v = v1 - v2
|
|
assert(v == Vector3(3, 3, 3))
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
v = v1 - v2
|
|
assert(v == Vector3(5, 7, 9))
|
|
|
|
v2 = Vector3(4, 5, 6)
|
|
v = v1 - v2
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
v = v1 - v2
|
|
assert(v == Vector3(4, 5, 6))
|
|
|
|
def test_Addition(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1 + v2
|
|
assert(v == Vector3(5, 7, 9))
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
v = v1 + v2
|
|
assert(v == Vector3(3, 3, 3))
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
v = v1 + v2
|
|
assert(v == Vector3(4, 5, 6))
|
|
|
|
def test_Scale(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1.Scale(v2)
|
|
assert(v == Vector3(4, 10, 18))
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
v = v1.Scale(v2)
|
|
assert(v == Vector3(-4, -10, -18))
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
v = v1.Scale(v2)
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
def test_Multiply(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
f: float = 3
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1 * f
|
|
assert(v == Vector3(12, 15, 18))
|
|
|
|
f = -3
|
|
v = v1 * f
|
|
assert(v == Vector3(-12, -15, -18))
|
|
|
|
f = 0
|
|
v = v1 * f
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
def test_Divide(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
f: float = 2
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1 / f
|
|
assert(v == Vector3(2, 2.5, 3))
|
|
|
|
f = -2
|
|
v = v1 / f
|
|
assert(v == Vector3(-2, -2.5, -3))
|
|
|
|
def test_Distance(self):
|
|
v1: Vector3 = Vector3(4, 5, 6);
|
|
v2: Vector3 = Vector3(1, 2, 3);
|
|
f: float = 0
|
|
|
|
f = Vector3.Distance(v1, v2);
|
|
assert(f == 5.196152422706632)
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
f = Vector3.Distance(v1, v2);
|
|
assert(f == 12.449899597988733)
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
f = Vector3.Distance(v1, v2);
|
|
assert(f == 8.774964387392123)
|
|
|
|
def test_Dot(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
f: float = 0
|
|
|
|
f = Vector3.Dot(v1, v2)
|
|
assert(f == 32)
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
f = Vector3.Dot(v1, v2)
|
|
assert(f, -32)
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
f = Vector3.Dot(v1, v2)
|
|
assert(f, 0)
|
|
|
|
def test_Cross(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = Vector3.Cross(v1, v2)
|
|
assert(v == Vector3(3, -6, 3))
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
v = Vector3.Cross(v1, v2)
|
|
assert(v == Vector3(-3, 6, -3))
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
v = Vector3.Cross(v1, v2)
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
def test_Project(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1.Project(v2)
|
|
assert(v == Vector3(2.2857142857142856, 4.571428571428571, 6.857142857142857))
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
v = v1.Project(v2)
|
|
assert(v == Vector3(2.2857142857142856, 4.571428571428571, 6.857142857142857))
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
v = v1.Project(v2)
|
|
assert(v == Vector3(0, 0, 0))
|
|
|
|
def test_ProjectOnPlane(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v: Vector3 = Vector3.zero
|
|
|
|
v = v1.ProjectOnPlane(v2)
|
|
assert(v == Vector3(1.7142857142857144, 0.4285714285714288, -0.8571428571428568))
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
v = v1.ProjectOnPlane(v2)
|
|
assert(v == Vector3(1.7142857142857144, 0.4285714285714288, -0.8571428571428568))
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
v = v1.ProjectOnPlane(v2)
|
|
assert(v == Vector3(4, 5, 6))
|
|
|
|
def test_Angle(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
f: Angle = Angle.Degrees(0)
|
|
|
|
f = Vector3.Angle(v1, v2)
|
|
assert(f.InDegrees() == 12.933154491899135)
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
f = Vector3.Angle(v1, v2)
|
|
assert(f.InDegrees() == 167.06684550810087)
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
f = Vector3.Angle(v1, v2)
|
|
assert(f.InDegrees() == 0)
|
|
|
|
def test_SignedAngle(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
v3: Vector3 = Vector3(7, 8, -9)
|
|
f: Angle = Angle.Degrees(0);
|
|
r: bool = False
|
|
|
|
f = Vector3.SignedAngle(v1, v2, v3)
|
|
assert(f.InDegrees() == -12.933154491899135)
|
|
|
|
v2 = Vector3(-1, -2, -3)
|
|
f = Vector3.SignedAngle(v1, v2, v3)
|
|
assert(f.InDegrees(), 167.06684550810087)
|
|
|
|
v2 = Vector3(0, 0, 0)
|
|
f = Vector3.SignedAngle(v1, v2, v3)
|
|
assert(f.InDegrees(), 0)
|
|
|
|
v2 = Vector3(1, 2, 3)
|
|
|
|
v3 = Vector3(-7, -8, 9)
|
|
f = Vector3.SignedAngle(v1, v2, v3)
|
|
assert(f.InDegrees(), 12.933154491899135)
|
|
|
|
v3 = Vector3(0, 0, 0)
|
|
f = Vector3.SignedAngle(v1, v2, v3)
|
|
assert(f.InDegrees(), 0)
|
|
|
|
def test_Lerp(self):
|
|
v1: Vector3 = Vector3(4, 5, 6)
|
|
v2: Vector3 = Vector3(1, 2, 3)
|
|
r: Vector3 = Vector3(0, 0, 0)
|
|
|
|
r = Vector3.Lerp(v1, v2, 0)
|
|
assert(Vector3.Distance(r, v1), 0)
|
|
|
|
r = Vector3.Lerp(v1, v2, 1)
|
|
assert(Vector3.Distance(r, v2), 0)
|
|
|
|
r = Vector3.Lerp(v1, v2, 0.5)
|
|
assert(Vector3.Distance(r, Vector3(2.5, 3.5, 4.5)), 0)
|
|
|
|
r = Vector3.Lerp(v1, v2, -1)
|
|
assert(Vector3.Distance(r, Vector3(7.0, 8.0, 9.0)), 0)
|
|
|
|
r = Vector3.Lerp(v1, v2, 2)
|
|
assert(Vector3.Distance(r, Vector3(-2.0, -1.0, 0.0)), 0)
|