fixes #92 and restructure Vector.py

Author: bzy-nya

cyaron/tests/polygon_test.py

@@ -1,8 +1,10 @@
 import unittest
-from cyaron import Polygon,Vector
+from cyaron import Polygon, Vector
+
+
 class TestPolygon(unittest.TestCase):
     def test_convex_hull(self):
-        hull = Polygon.convex_hull(300, fx=lambda x:int(x*100000), fy=lambda x:int(x*100000))
+        hull = Polygon.convex_hull(300, fx=lambda x: int(x * 100000), fy=lambda x: int(x * 100000))
         points = hull.points
         points = sorted(points)
         # unique
@@ -35,24 +37,26 @@ def test_convex_hull(self):
             st.append(points[i])
         st.pop()
         self.assertEqual(len(st), len(hull.points))
+
     def test_perimeter_area(self):
-        poly = Polygon([[0,0],[0,1],[1,1],[1,0]])
-        self.assertEqual(poly.perimeter(),4)
-        self.assertEqual(poly.area(),1)
+        poly = Polygon([[0, 0], [0, 1], [1, 1], [1, 0]])
+        self.assertEqual(poly.perimeter(), 4)
+        self.assertEqual(poly.area(), 1)
+
     def test_simple_polygon(self):
         poly = Polygon.simple_polygon(Vector.random(300, [1000, 1000], 2))
         points = poly.points
-        for i in range(0,len(points)):
-            for j in range(i+2,len(points)):
-                if j==len(points)-1 and i==0:
+        for i in range(0, len(points)):
+            for j in range(i + 2, len(points)):
+                if j == len(points) - 1 and i == 0:
                     continue
-                a=points[i]
-                b=points[(i+1)%len(points)]
-                c=points[j]
-                d=points[(j+1)%len(points)]
-                prod=lambda x,y: x[0]*y[1]-x[1]*y[0]
-                t1=prod([c[0]-a[0],c[1]-a[1]],[d[0]-a[0],d[1]-a[1]])\
-                  *prod([c[0]-b[0],c[1]-b[1]],[d[0]-b[0],d[1]-b[1]])
-                t2=prod([a[0]-c[0],a[1]-c[1]],[b[0]-c[0],b[1]-c[1]])\
-                  *prod([a[0]-d[0],a[1]-d[1]],[b[0]-d[0],b[1]-d[1]])
-                self.assertFalse(t1<=1e-9 and t2<=1e-9)
+                a = points[i]
+                b = points[(i + 1) % len(points)]
+                c = points[j]
+                d = points[(j + 1) % len(points)]
+                prod = lambda x, y: x[0] * y[1] - x[1] * y[0]
+                t1 = prod([c[0] - a[0], c[1] - a[1]], [d[0] - a[0], d[1] - a[1]]) \
+                     * prod([c[0] - b[0], c[1] - b[1]], [d[0] - b[0], d[1] - b[1]])
+                t2 = prod([a[0] - c[0], a[1] - c[1]], [b[0] - c[0], b[1] - c[1]]) \
+                     * prod([a[0] - d[0], a[1] - d[1]], [b[0] - d[0], b[1] - d[1]])
+                self.assertFalse(t1 <= 1e-9 and t2 <= 1e-9)

cyaron/vector.py

@@ -1,78 +1,91 @@
-#coding=utf8
+# coding=utf8
 
-from .consts import ALPHABET_SMALL
 from .utils import *
 import random
+from enum import Enum
+
+
+class VectorRandomMode(Enum):
+    unique = 0
+    repeatable = 1
+    float = 2
 
 
 class Vector:
+
     @staticmethod
-    def random(num=5, position_range=[10], mode=0, **kwargs):
-        # mode 0=unique 1=repeatable 2=float
-        if(num > 1000000):
+    def random(num: int = 5, position_range: list = None, mode: VectorRandomMode = 0, **kwargs):
+        """
+        brief : generating n random vectors in limited space
+        param :
+            # num            : the number of vectors
+            # position_range : a list of limits for each dimension
+            #                  single number x represents range (0, x)
+            #                  list [x, y] or tuple (x, y) represents range (x, y)
+            # mode           : the mode vectors generate, see Enum Class VectorRandomMode
+        """
+        if position_range is None:
+            position_range = [10]
+
+        if num > 1000000:
             raise Exception("num no more than 1e6")
-        if(not list_like(position_range)):
-            raise Exception("the 2nd param must be a list")
+        if not list_like(position_range):
+            raise Exception("the 2nd param must be a list or tuple")
 
         dimension = len(position_range)
+
         offset = []
+        length = []
+
         vector_space = 1
         for i in range(0, dimension):
-            if(list_like(position_range[i])):
-                if(position_range[i][1] < position_range[i][0]):
-                    raise Exception("max should larger than min")
-                offset.insert(i, position_range[i][0])
-                position_range[i] = position_range[i][1] - offset[i]
+            if list_like(position_range[i]):
+                if position_range[i][1] < position_range[i][0]:
+                    raise Exception("upper-bound should larger than lower-bound")
+                offset.append(position_range[i][0])
+                length.append(position_range[i][1] - position_range[i][0])
             else:
-                offset.insert(i, 0)
-            if(position_range[i] <= 0):
-                raise Exception("the difference must more than 0")
-            vector_space *= (position_range[i] + 1)
-        if(mode == 0 and num > vector_space):
-            raise Exception("1st param is too large that CYaRon can not generate unique vectors")
+                offset.append(0)
+                length.append(position_range[i])
+            vector_space *= (length[i] + 1)
+
+        if mode == VectorRandomMode.unique and num > vector_space:
+            raise Exception("1st param is so large that CYaRon can not generate unique vectors")
+
         result = []
-        
-        if(mode == 2 or mode == 1):
-            for i in range(0, num):
-                tmp = []
-                for j in range(0, dimension):
-                    one_num = random.randint(0,position_range[j]) if mode == 1 else random.uniform(0,position_range[j])
-                    tmp.insert(j, one_num + offset[j])
-                result.insert(i, tmp)
-                
-        elif((mode == 0 and vector_space > 5 * num)):
-            num_set = set([])
-            rand = 0;
+        if mode == VectorRandomMode.repeatable:
+            result = [[random.randint(x, y) for x, y in zip(offset, length)] for _ in range(num)]
+        elif mode == VectorRandomMode.float:
+            result = [[random.uniform(x, y) for x, y in zip(offset, length)] for _ in range(num)]
+        elif mode == VectorRandomMode.unique and vector_space > 5 * num:
+            # O(NlogN)
+            num_set = set()
             for i in range(0, num):
                 while True:
-                    rand = random.randint(0, vector_space - 1);
-                    if(not rand in num_set):
+                    rand = random.randint(0, vector_space - 1)
+                    if rand not in num_set:
                         break
-                # Todo: So how to analyse then complexity? I think it is logn
                 num_set.add(rand)
-                tmp = Vector.get_vector(dimension, position_range, rand)
+                tmp = Vector.get_vector(dimension, length, rand)
                 for j in range(0, dimension):
                     tmp[j] += offset[j]
-                result.insert(i, tmp)
-                         
-            
+                result.append(tmp)
         else:
             # generate 0~vector_space and shuffle
-            rand_arr = [i for i in range(0, vector_space)]
+            rand_arr = list(range(0, vector_space))
             random.shuffle(rand_arr)
-            for i in range(0, num):
-                tmp = Vector.get_vector(dimension, position_range, rand_arr[i])
-                for j in range(0, dimension):
-                    tmp[j] += offset[j]
-                result.insert(i, tmp)
+            result = [Vector.get_vector(dimension, length, x) for x in rand_arr[:num]]
+
+            for x in result:
+                for i in range(dimension):
+                    x[i] += offset[i]
+
         return result
 
-    @staticmethod      
-    def get_vector(dimension, position_range, hashnum):
+    @staticmethod
+    def get_vector(dimension: int, position_range: list, hashcode: int):
         tmp = []
         for i in range(0, dimension):
-            tmp.insert(i, hashnum % (position_range[i] + 1))
-            hashnum //= (position_range[i] + 1)
+            tmp.append(hashcode % (position_range[i] + 1))
+            hashcode //= (position_range[i] + 1)
         return tmp
-        
-