initial commit

Author: yyl

.gitignore

@@ -0,0 +1,35 @@
+*.py[cod]
+
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+nosetests.xml
+
+#Translations
+*.mo
+
+#Mr Developer
+.mr.developer.cfg
+
+.DS_Store

misc/iter_survey.py

@@ -0,0 +1,74 @@
+class IterTest(object):
+  def __init__(self, data):
+    self._data = data
+    self._count = 0
+
+  def __iter__(self):
+    return self
+
+  def next(self):
+    if self._count == len(self._data):
+      raise StopIteration
+    else:
+      output = self._data[self._count]
+      self._count += 1
+      return output
+
+class GenTest(object):
+  def __init__(self, data):
+    self._data = data
+
+  def gen(self):
+    count = 0
+    while count < len(self._data):
+      count += 1
+      yield self._data[count - 1]
+
+class IterableTest(object):
+  def __init__(self, data):
+    self._data = data
+
+  def __iter__(self):
+    return self.iterall()
+
+  def iterall(self):
+    count = 0
+    while count < len(self._data):
+      count += 1
+      yield self._data[count - 1]
+
+
+
+if __name__ == '__main__':
+  L = [1,2,3,4,5]
+  i = iter(L)
+  print i
+  D = {'a':1, 'b':2, 'c':3}
+  print D.iteritems()
+  print D.iterkeys()
+  print D.itervalues()
+  for li in i:
+    print li
+  d = GenTest([1,2,3,4,5])
+  g = d.gen()
+  print g
+  print g.next()
+  for dat in g:
+    print dat
+  g2 = d.gen()
+  print g2.next()
+  d2 = IterTest("abcd")
+  I = iter(d2)
+  print I
+  for char in I:
+    print char
+  d3 = IterableTest([4,3,2,1])
+  I2 = iter(d3)
+  print I2
+  for dat in I2:
+    print dat
+  print d3
+  for dat in d3:
+    print dat
+  for dat in d3:
+    print dat

unit1/array.py

@@ -0,0 +1,65 @@
+from exceptions import IndexError
+# fixed-size array
+class Array(object):
+
+  # baseIndex is for the lower bound of the array
+  def __init__(self, length = 0, baseIndex = 0):
+    assert length >= 0
+    self._data = [None for i in xrange(length)]
+    self._baseIndex = baseIndex
+
+  def __copy__(self):
+    tmp = Array(len(self._data))
+    for i, datum in enumerate(self._data):
+      tmp._data[i] = datum
+    tmp._baseIndex = self._baseIndex
+    return tmp
+
+  # get the correct offset from the index input
+  # return IndexError if the index is out of range
+  def getOffset(self, index):
+    offset = index - self._baseIndex
+    if offset >= 0 and offset < len(self._data):
+      return offset
+    else:
+      raise IndexError
+
+  def __getitem__(self, index):
+    return self._data[self.getOffset(index)]
+
+  def __setitem__(self, index, value):
+    self._data[self.getOffset(index)] = value
+
+  def getData(self):
+    return self._data
+
+  data = property(
+      fget = lambda self: self.getData()
+      )
+
+  def getBaseIndex(self):
+    return self._baseIndex
+
+  def setBaseIndex(self, baseIndex):
+    self._baseIndex = baseIndex
+
+  baseIndex = property(
+      fget = lambda self: self.getBaseIndex(),
+      fset = lambda self, value: self.setBaseIndex(value)
+      )
+
+  def __len__(self):
+    return len(self._data)
+
+  def setLength(self, value):
+    if value > len(self._data):
+      for i in xrange(value - len(self._data)):
+        self._data.append(None)
+    else:
+      tmp = [None for i in xrange(value)]
+      self._data = tmp
+        
+  length = property(
+      fget = lambda self: self.__len__(),
+      fset = lambda self, value: self.setLength(value)
+      )

unit1/linkedlist.py

@@ -0,0 +1,126 @@
+from exceptions import RuntimeError
+
+class LinkedList(object):
+
+  class Element(object):
+
+    def __init__(self, list, value, next=None):
+      self._list = list
+      self._value = value
+      self._next = next
+
+    def getValue(self):
+      return self._value
+
+    value = property(
+        fget = lambda self: self.getValue()
+        )
+
+    def getNext(self):
+      return self._next
+
+    next = property(
+        fget = lambda self: self.getNext()
+        )
+
+    def insertAfter(self, item):
+      elt = LinkedList.Element(self._list, item, self._next)
+      self._next = elt
+      if self == self._list._tail:
+        self._list._tail = elt
+
+    def insertBefore(self, item):
+      elt = LinkedList.Element(self._list, item, self)
+      if self._list._head == self:
+        self._list._head = elt
+      else:
+        prev = self._list._head
+        while prev._next != None and prev._next != self:
+          prev = prev._next
+        prev._next = elt
+
+  # Linked list methods
+  def __init__(self):
+    self._head = None
+    self._tail = None 
+
+  def purge(self):
+    self._head = None
+    self._tail = None 
+
+  def getHead(self):
+    return self._head
+
+  head = property(
+      fget = lambda self: self.getHead()
+      )
+
+  def getTail(self):
+    return self._tail
+
+  tail = property(
+      fget = lambda self: self.getTail()
+      )
+
+  def getIsEmpty(self):
+    return self._head == None
+
+  isEmpty = property(
+      fget = lambda self: self.getIsEmpty()
+      )
+
+  # accessors for 1st and last list element
+  def getFirst(self):
+    if self._head == None:
+      raise RuntimeError
+    return self._head._value
+
+  first = property(
+      fget = lambda self: self.getFirst()
+      )
+
+  def getLast(self):
+    if self._tail == None:
+      raise RuntimeError
+    return self._tail._value
+
+  last = property(
+      fget = lambda self: self.getLast()
+      )
+
+  def prepend(self, item):
+    elt = self.Element(self, item, self._head)
+    self._head = elt
+    if self._tail == None:
+      self._tail = elt
+
+  def append(self, item):
+    elt = self.Element(self, item, self._tail)
+    if self._head != None:
+      self._tail._next = elt
+    else:
+      self._head = elt
+    self._tail = elt
+
+  def __copy__(self):
+    tmp = LinkedList()
+    ptr = self._head
+    while ptr != None:
+        tmp.append(ptr._value)
+        ptr = ptr._next
+    return tmp
+
+  def extract(self, value):
+	ptr = self._head
+	prev = None
+	while ptr != None and ptr._value != value:
+		prev = ptr
+		ptr = ptr._next
+	if ptr == None:
+		raise KeyError
+	if ptr == self._head:
+		self._head = None
+	else:
+		prev._next = ptr._next
+	if ptr == self._tail:
+		self._tail = prev