abstracted structures fixed

Author: Mari Wahl

src/builtin_structures/numbers/testing_floats.py renamed to src/USEFUL/basic_examples/example_fractions.py

@@ -1,22 +1,22 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
 
 from fractions import Fraction
 
 def rounding_floats(number1, places):
-    ''' some operations with float()'''
     return round(number1, places)
 
 
 def float_to_fractions(number):
     return  Fraction(*number.as_integer_ratio())
-    
+
 
 def get_denominator(number1, number2):
     a = Fraction(number1, number2)
     return a.denominator
-    
+
 
 def get_numerator(number1, number2):
     a = Fraction(number1, number2)
@@ -34,7 +34,7 @@ def test_testing_floats(module_name='this module'):
     assert(float_to_fractions(number1) == number4)
     assert(get_denominator(number2, number6) == number6)
     assert(get_numerator(number2, number6) == number2)
-        
+
     s = 'Tests in {name} have {con}!'
     print(s.format(name=module_name, con='passed'))
 

src/builtin_structures/numbers/testing_numpy.py renamed to src/USEFUL/basic_examples/example_numpy.py

@@ -1,7 +1,9 @@
-#!/usr/bin/python
-# mari von steinkirch @2013
-# steinkirch at gmail
 
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+import time
 import numpy as np
 
 def testing_numpy():
@@ -15,18 +17,44 @@ def testing_numpy():
     print(np.cos(ax))
     print(ax-ay)
     print(np.where(ax<2, ax, 10))
-    
+
     m = np.matrix([ax, ay, ax])
     print(m)
     print(m.T)
-    
+
     grid1 = np.zeros(shape=(10,10), dtype=float)
     grid2 = np.ones(shape=(10,10), dtype=float)
     print(grid1)
     print(grid2)
     print(grid1[1]+10)
     print(grid2[:,2]*2)
 
+
+def trad_version():
+    t1 = time.time()
+    X = range(10000000)
+    Y = range(10000000)
+    Z = []
+    for i in range(len(X)):
+        Z.append(X[i] + Y[i])
+    return time.time() - t1
+
+def numpy_version():
+    t1 = time.time()
+    X = np.arange(10000000)
+    Y = np.arange(10000000)
+    Z = X + Y
+    return time.time() - t1
+
+
+
 if __name__ == '__main__':
     testing_numpy()
+    print(trad_version())
+    print(numpy_version())
+
 
+'''
+3.23564291
+0.0714290142059
+'''

src/builtin_structures/numbers/testing_random.py renamed to src/USEFUL/basic_examples/example_random.py

@@ -1,6 +1,6 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 import random
 
@@ -12,11 +12,11 @@ def testing_random():
     print(random.choice(values))
     print(random.sample(values, 2))
     print(random.sample(values, 3))
-    
+
     ''' shuffle in place '''
     random.shuffle(values)
     print(values)
-    
+
     ''' create random integers '''
     print(random.randint(0,10))
     print(random.randint(0,10))

src/builtin_structures/sets/set_operations_with_lists.py renamed to src/USEFUL/basic_examples/example_sets.py

@@ -1,6 +1,6 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/env python
+
+__author__ = "bt3"
 
 def difference(l1):
     """ return the list with duplicate elements removed """

src/abstract_structures/HashTable.py

@@ -7,28 +7,35 @@ class HashTable(object):
     def __init__(self, slots=10):
         self.slots = slots
         self.table = []
-        self.__create_table()
+        self.create_table()
 
-    def __hash_key(self, value):
+    def hash_key(self, value):
         return hash(value)%self.slots
 
-    def __create_table(self):
+    def create_table(self):
         for i in range(self.slots):
             self.table.append([])
 
     def add_item(self, value):
-        key = self.__hash_key(value)
+        key = self.hash_key(value)
         self.table[key].append(value)
 
     def print_table(self):
         for key in range(len(self.table)):
             print "Key is %s, value is %s." %(key, self.table[key])
 
-
+    def find_item(self, item):
+        pos = self.hash_key(item)
+        if item in self.table[pos]:
+            return True
+        else:
+            return False
 
 if __name__ == '__main__':
     dic = HashTable(5)
     for i in range(1, 40, 2):
         dic.add_item(i)
 
-    dic.print_table()
+    dic.print_table()
+    assert(dic.find_item(20) == False)
+    assert(dic.find_item(21) == True)

src/abstract_structures/queue_with_stack.py renamed to src/abstract_structures/Queue.py

@@ -17,11 +17,24 @@ def dequeue(self):
                 self.deq.append(self.enq.pop())
         return self.deq.pop()
 
+    def isEmpty(self):
+        return not (self.enq + self.deq)
+
+    def size(self):
+        return len(self.enq) + len(self.deq)
+
 if __name__ == '__main__':
     q = Queue()
 
     for i in range(1,10):
         q.enqueue(i)
 
+    assert(q.isEmpty() == False)
+
+    assert(q.size() == 9)
+
     for i in range(1, 10):
-        print q.dequeue()
+        print q.dequeue()
+
+    assert(q.isEmpty() == True)
+

src/abstract_structures/stack_with_minumum.py renamed to src/abstract_structures/Stack.py

@@ -32,6 +32,21 @@ def find_min(self):
         else:
             return 'No min value for empty list.'
 
+    def size(self):
+        return len(self.content)
+
+    def isEmpty(self):
+        return not bool(self.content)
+
+    def peek(self):
+        if self.content:
+            return self.content[-1]
+        else:
+            print('Stack is empty.')
+
+
+    def __repr__(self):
+        return '{}'.format(self.content)
 
 
 if __name__ == '__main__':