Implement Vector2

* docs/Geometry.rst - fix outdated quick start guide
* pygorithm/geometry/vector2.py - implement
* test/test_geometry.py - fix incorrect tests

Author: Tjstretchalot

docs/Geometry.rst

@@ -17,6 +17,7 @@ Quick Start Guide
     poly1 = polygon2.Polygon2.from_regular(5, 5)
     
     # create a polygon from tuple (x, y) - note that the polygon must be convex
+    # and the points must be clockwise
     poly2 = polygon2.Polygon2(points=[ (0, 0), (1, 0), (1, 1), (0, 1) ])
     
     # create a polygon from vector2s. 
@@ -39,9 +40,6 @@ Quick Start Guide
     else:
         print('No intersection')
     
-    # check complete overlap
-    overlap = polygon2.Polygon2.contains_polygon(poly1, poly2, (0, 2), (3, 1))
-    
 Features
 --------
 

pygorithm/geometry/vector2.py

@@ -6,6 +6,8 @@
 Defines a simple two-dimensional, mutable vector.
 """
 
+import math
+
 class Vector2(object):
     """
     Define a simple two-dimensional, mutable vector.
@@ -49,7 +51,21 @@ def __init__(self, *args, **kwargs):
         :param kwargs: named arguments (purpose known by name)
         """
 
-        pass
+        if len(args) == 2:
+            self.x = args[0]
+            self.y = args[1]
+        elif len(args) == 1:
+            if type(args[0]) == tuple:
+                self.x = args[0][0]
+                self.y = args[0][1]
+            else:
+                self.x = args[0].x
+                self.y = args[0].y
+        else:
+            assert(len(args) == 0)
+            
+            self.x = kwargs['x']
+            self.y = kwargs['y']
 
     def __add__(self, other):
         """
@@ -75,7 +91,7 @@ def __add__(self, other):
         :rtype: :class:`pygorithm.geometry.vector2.Vector2`
         """
 
-        pass
+        return Vector2(self.x + other.x, self.y + other.y)
 
     def __sub__(self, other):
         """
@@ -105,7 +121,7 @@ def __sub__(self, other):
         :rtype: :class:`pygorithm.geometry.vector2.Vector2`
         """
 
-        pass
+        return Vector2(self.x - other.x, self.y - other.y)
 
     def __mul__(self, scale_factor):
         """
@@ -136,7 +152,10 @@ def __mul__(self, scale_factor):
         :raises TypeError: if scale_factor is a Vector2
         """
 
-        pass
+        if type(scale_factor) == Vector2:
+            raise TypeError('scale_factor cannot be a Vector2 (use dot!)')
+        
+        return Vector2(self.x * scale_factor, self.y * scale_factor)
 
     def __rmul__(self, scale_factor):
         """
@@ -167,7 +186,10 @@ def __rmul__(self, scale_factor):
         :raises TypeError: if scale_factor is a Vector2
         """
 
-        pass
+        if type(scale_factor) == Vector2:
+            raise TypeError('scale_factor cannot be a Vector2 (use dot!)')
+        
+        return Vector2(self.x * scale_factor, self.y * scale_factor)
 
     def __repr__(self):
         """
@@ -188,11 +210,13 @@ def __repr__(self):
         :rtype: string
         """
 
-        pass
+        return "vector2(x={}, y={})".format(self.x, self.y)
 
     def __str__(self):
         """
-        Create a human-readable representation of this vector
+        Create a human-readable representation of this vector.
+        
+        Rounds to 3 decimal places if there are more.
         
         Example:
         
@@ -212,7 +236,15 @@ def __str__(self):
         :rtype: string
         """
 
-        pass
+        pretty_x = round(self.x * 1000) / 1000
+        if pretty_x == math.floor(pretty_x):
+            pretty_x = math.floor(pretty_x)
+            
+        pretty_y = round(self.y * 1000) / 1000
+        if pretty_y == math.floor(pretty_y):
+            pretty_y = math.floor(pretty_y)
+        
+        return "<{}, {}>".format(pretty_x, pretty_y)
 
     def dot(self, other):
         """
@@ -245,7 +277,7 @@ def dot(self, other):
         :rtype: :class:`numbers.Number`
         """
 
-        pass
+        return self.x * other.x + self.y * other.y
 
     def rotate(self, *args, **kwargs):
         """
@@ -294,7 +326,42 @@ def rotate(self, *args, **kwargs):
         :rtype: :class:`pygorithm.geometry.vector2.Vector2`
         """
 
-        pass
+        args_counter = 0
+        deg_rads = None
+        about = None
+        
+        if 'radians' in kwargs:
+            deg_rads = kwargs['radians']
+        elif 'degrees' in kwargs:
+            deg_rads = kwargs['degrees'] * math.pi / 180
+        else:
+            deg_rads = args[args_counter]
+            args_counter = args_counter + 1
+        
+        if 'about' in kwargs:
+            about = kwargs['about']
+        else:
+            if len(args) > args_counter:
+                about = args[args_counter]
+        
+        fixed_x = self.x
+        fixed_y = self.y
+        
+        if about is not None:
+            fixed_x -= about.x
+            fixed_y -= about.y
+        
+        rotated_x = fixed_x * math.cos(deg_rads) - fixed_y * math.sin(deg_rads)
+        rotated_y = fixed_y * math.cos(deg_rads) + fixed_x * math.sin(deg_rads)
+        
+        final_x = rotated_x
+        final_y = rotated_y
+        
+        if about is not None:
+            final_x += about.x
+            final_y += about.y
+            
+        return Vector2(final_x, final_y)
 
     def normalize(self):
         """
@@ -325,7 +392,7 @@ def normalize(self):
         :rtype: :class:`pygorithm.geometry.vector2.Vector2`
         """
 
-        pass
+        return self * (1 / self.magnitude())
 
     def magnitude_squared(self):
         """
@@ -346,7 +413,8 @@ def magnitude_squared(self):
         :returns: square of the magnitude of this vector
         :rtype: :class:`numbers.Number`
         """
-        pass
+        
+        return self.x * self.x + self.y * self.y
 
     def magnitude(self):
         """
@@ -372,4 +440,5 @@ def magnitude(self):
         :returns: magnitude of this vector
         :rtype: :class:`numbers.Number`
         """
-        pass
+        
+        return math.sqrt(self.magnitude_squared())

tests/test_geometry.py

@@ -113,7 +113,7 @@ def test_repr(self):
 
         vec_repr = repr(vec)
 
-        self.assertEqual('vector2(x=7, y=1)', vec_repr)
+        self.assertEqual('vector2(x=7, y=11)', vec_repr)
 
     def test_str(self):
         vec = vector2.Vector2(7, 11)
@@ -158,20 +158,20 @@ def test_rotate(self):
         self.assertAlmostEqual(0.70710678118, vec3.y)
 
         vec4 = vec1.rotate(math.pi, vector2.Vector2(1, 1))
-        self.assertEqual(1, vec4.x)
-        self.assertEqual(2, vec4.y)
+        self.assertAlmostEqual(1, vec4.x)
+        self.assertAlmostEqual(2, vec4.y)
 
         vec5 = vec1.rotate(radians = math.pi, about = vector2.Vector2(1, 1))
-        self.assertEqual(1, vec5.x)
-        self.assertEqual(2, vec5.y)
+        self.assertAlmostEqual(1, vec5.x)
+        self.assertAlmostEqual(2, vec5.y)
 
         vec6 = vec1.rotate(degrees = 180, about = vector2.Vector2(1, 1))
-        self.assertEqual(1, vec6.x)
-        self.assertEqual(2, vec6.y)
+        self.assertAlmostEqual(1, vec6.x)
+        self.assertAlmostEqual(2, vec6.y)
 
         vec7 = vec1.rotate(vector2.Vector2(1, 1), degrees = 180)
-        self.assertEqual(1, vec7.x)
-        self.assertEqual(2, vec7.y)
+        self.assertAlmostEqual(1, vec7.x)
+        self.assertAlmostEqual(2, vec7.y)
 
     def test_normalize(self):
         vec1 = vector2.Vector2(2, 0)
@@ -567,8 +567,8 @@ def test_constructor_standard(self):
         self.assertEqual(0, poly.lines[3].end.x)
         self.assertEqual(1, poly.lines[3].end.y)
 
-        self.assertIsNotNone(next(vec for vec in poly.normals if vec.horizontal, None))
-        self.assertIsNotNone(next(vec for vec in poly.normals if vec.vertical, None))
+        self.assertIsNotNone(next((vec for vec in poly.normals if vec.horizontal), None))
+        self.assertIsNotNone(next((vec for vec in poly.normals if vec.vertical), None))
 
         self.assertAlmostEqual(0.5, poly.center.x)
         self.assertAlmostEqual(0.5, poly.center.y)