Initial Commit

Author: lukecampbell

.gitignore

@@ -0,0 +1,2 @@
+*swp
+*pyc

Makefile

@@ -0,0 +1,16 @@
+CC=g++
+CFLAGS=-g -ggdb -Wall -Iinclude
+LDFLAGS= -lm
+OBJECTS=src/test.o
+
+all: src/test
+
+src/test: $(OBJECTS)
+	$(CC) -o $@ $(LDFLAGS) $(OBJECTS)
+
+$(OBJECTS): %.o: %.cpp
+	$(CC) -o $@ $(CFLAGS) -c $<
+
+clean:
+	rm -rf src/*.o
+	rm -rf src/test

cpppython/__init__.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+try:
+    import numpy as np
+    has_np=True
+except ImportError:
+    has_np=False
+    
+def hash_any(value, hv=None):
+    hv = hv or 0
+    if value is None or isinstance(value, (str, unicode, int, long, float, bool)):
+#        log.debug('is primitive:  value=%s  hv=%s', value, hv)
+        hv = hash(value) ^ hv
+    elif  has_np and np.isscalar(value):
+#        log.debug('is numpy.scalar:  value=%s  hv=%s', value, hv)
+        hf = hash(value) ^ hv
+    elif isinstance(value, (list, tuple, set)):
+#        log.debug('is list/tuple/set:  value=%s  hv=%s', value, hv)
+        for x in value:
+            hv = hash_any(x, hv)
+    elif isinstance(value, dict):
+#        log.debug('is dict:  value=%s  hv=%s', value, hv)
+        for k,v in value.iteritems():
+            hv = hash_any(k, hv)
+            hv = hash_any(v, hv)
+    elif isinstance(value, slice):
+        # Hash a tuple of the slice components
+        hv = hash((value.start, value.stop, value.step)) ^ hv
+    elif isinstance(value, object):
+#        log.debug('is object:  value=%s  hv=%s', value, hv)
+        hv = hash_any(value.__dict__, hv)
+
+    return hv
+

cpppython/hash.py

@@ -0,0 +1,54 @@
+from cython.operator cimport dereference as dref
+from libc.stdlib cimport malloc, free
+from cpppython.hash import hash_any
+
+cdef extern from "linked_list.h":
+    cdef cppclass LinkedList[T]:
+        LinkedList()
+        size_t add(T element)
+        size_t length()
+        T pop() except +
+        void remove(size_t i) except +
+        T get(size_t i) except +
+
+        
+
+
+cdef class PyLinkedList:
+    cdef LinkedList[long int] *thisptr
+    store = {}
+    def __cinit__(self):
+        self.thisptr = new LinkedList[long int]()
+    def __dealloc__(self):
+        del self.thisptr
+
+    def add(self, element):
+        cdef long int key = hash_any(element)
+        self.store[<object> key] = element
+        self.thisptr.add(key)
+
+    def length(self):
+        return <object> self.thisptr.length()
+
+    def pop(self):
+        cdef long int key = self.thisptr.pop()
+        retval = self.store[<object> key]
+        del self.store[<object> key]
+        return retval
+
+    def remove(self, i):
+        self.thisptr.remove(<size_t> i)
+
+    def get(self, i):
+        cdef long int key = self.thisptr.get(i)
+        return self.store[<object> key]
+
+    def __len__(self):
+        return <object> self.thisptr.length()
+
+    def __getitem__(self, i):
+        if i<0:
+            return self.get(len(self) + i)
+        return self.get(i)
+
+

cpppython/linked_list.pyx

@@ -0,0 +1,124 @@
+#ifndef __NODE_H__
+#define __NODE_H__
+
+#include <iostream>
+#include <stdexcept>
+
+template <class T>
+struct _LNode {
+    T element;
+    _LNode *next;
+};
+
+
+template <class T>
+class LinkedList {
+    private:
+        struct _LNode<T> *root;
+        size_t elements;
+    public:
+        LinkedList();
+        ~LinkedList();
+
+        size_t add(T element);
+        size_t length();
+        T pop();
+        T get(size_t i);
+        void remove(size_t i);
+};
+
+template <class T>
+LinkedList<T>::LinkedList()
+    : root(NULL), elements(0) 
+{
+}
+
+template <class T>
+LinkedList<T>::~LinkedList() {
+    struct _LNode<T> *p;
+    struct _LNode<T> *tmp;
+    p = root;
+    while(p) {
+        tmp = p;
+        p = p->next;
+        delete tmp;
+    }
+};
+
+
+template <class T>
+size_t LinkedList<T>::add(T element) {
+    struct _LNode<T> *p;
+    if(!root) {
+        root = new struct _LNode<T>;
+        root->element = element;
+        root->next = NULL;
+        return ++elements;
+    }
+    p = root;
+    while(p->next) 
+        p = p->next;
+
+    p->next = new struct _LNode<T>;
+    p = p->next;
+    p->element = element;
+    p->next = NULL;
+    return ++elements;
+}
+    
+template <class T>
+size_t LinkedList<T>::length() {
+    return elements;
+}
+
+template <class T>
+T LinkedList<T>::pop() {
+    struct _LNode<T> *p;
+    struct _LNode<T> *tmp;
+    T retval;
+    if(elements <= 0) {
+        throw std::out_of_range("No elements to pop");
+    }
+    tmp = p = root;
+    while(tmp->next) {
+        p = tmp;
+        tmp = tmp->next;
+    }
+    retval = tmp->element;
+    p->next = NULL;
+    delete tmp;
+    elements--;
+    return retval;
+}
+
+
+template <class T>
+T LinkedList<T>::get(size_t i) {
+    struct _LNode<T> *p;
+    if(i >= elements) {
+        throw std::out_of_range("Index is out of range");
+    }
+    p = root;
+    for(size_t j=0;j<i;j++)
+        p = p->next;
+    return p->element;
+}
+
+template <class T>
+void LinkedList<T>::remove(size_t i) {
+    struct _LNode<T> *p;
+    struct _LNode<T> *tmp;
+    if(i >= elements) {
+        throw std::out_of_range("Index is out of range");
+    }
+    p = root;
+    for(size_t j=0;j<i;j++) {
+        tmp = p;
+        p = p->next;
+    }
+    tmp->next = p->next;
+    delete p;
+    elements--;
+}
+
+#endif /* __NODE_H__ */

include/linked_list.h

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+from setuptools import setup, find_packages
+from distutils.extension import Extension
+
+import sys
+
+if 'setuptools.extension' in sys.modules:
+    m = sys.modules['setuptools.extension']
+    m.Extension.__dict__ = m._Extension.__dict__
+
+packages = find_packages()
+
+linked_list_extension = Extension('cpppython.linked_list', ['cpppython/linked_list.pyx'],include_dirs=['include/'], language='c++')
+
+setup(name='cpptest',
+        version='0.0.1',
+        packages=packages,
+        setup_requires=['setuptools_cython'],
+        ext_modules=[linked_list_extension],
+        )

setup.py

@@ -0,0 +1,36 @@
+#include <iostream>
+#include "linked_list.h"
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+    int a = 20;
+    int tmp;
+    LinkedList<int> list;
+    list.add(a);
+    cout << "Size: " << list.length() << endl;
+    cout << "l[0] = " << list.get(0) << endl;
+    cout << "l.pop() = " << list.pop() << endl;
+    cout << "Size: " << list.length() << endl;
+    try {
+        cout << "Trying to get an element (should fail)"<<endl;
+        tmp = list.get(0);
+        cout << "Shouldn't see this" << endl;
+    } catch(std::out_of_range& e) {
+        cout << "Error: " << e.what() << endl;
+    }
+    for(int i=0;i<20;i++) {
+        list.add(i);
+    }
+
+    list.remove(10);
+
+    while(list.length() > 0)
+        cout << list.pop() << " ";
+    cout << endl;
+
+
+
+    return 0;
+}