Exemplo n.º 1
0
def test_hasher():
    ht = HashTable()
    a = ht.hash("alice")
    b = ht.hash("elica")
    c = ht.hash("Alice")
    assert a == b
    assert a != c
Exemplo n.º 2
0
def main():
  testHashToIndex()
  print("Starting with empty hash table")
  hash = HashTable()
  hash.put("A key", "a value")
  assert hash.get("A key") == "a value"
  assert hash.get("A key") != "another value"
Exemplo n.º 3
0
def loadHash(lista):
    if not lista is None:
        MyHash = HashTable()
        for item in lista:
            MyHash.insert(item, item)

        return MyHash

    return None
Exemplo n.º 4
0
def insertarTablaHash(arregloLleno: List, tablaHash : HashTable):

    '''
    Para insertar en la tabla hash los usuarios registrados
    :param arregloLleno: arreglo de 2-tuplas compuesto por el nombre de usuario y el 
    arreglo de volumen
    :param tablaHash: tabla hash donde se guardarn todos los nombres de los usuarios y el 
    arreglo de volumen 
    '''

    for i in arregloLleno:
        tablaHash.set(i[0],i[1])
Exemplo n.º 5
0
def console():

    hash_table = HashTable()

    while True:
        op = input(prompts['operations'])

        if op == '1':
            word = input(prompts['word'])
            hash_table.add(word)
            print(hash_table)
        elif op == '4':
            return
Exemplo n.º 6
0
    def _getLocations( self ):
        table = HashTable(10)

        # Add locations to hash table
        with open( 'data/locations.csv' ) as file:
            locationData = csv.reader( file, delimiter=',' )
            # Iterate through locations
            # Time Complexity: O(n)
            for row in locationData:
                location = Location( row[0], row[1], row[2] )
                # Add location to hash table of locations
                table.put( int( location.id ), location )

        return table
Exemplo n.º 7
0
def generation_mode(file_in, num, seed, file_del=None):
    words = synthetic.words(file_in, num, seed)

    size = input("How many lists should be in the hashmap?: ")
    try:
        size = int(size)
    except ValueError as e:
        print("ERROR: Invalid value was passed to the program.\n", e)
        return -1

    hash_table = HashTable(size)
    begin = time.perf_counter()
    hash_table.add_all(words)
    end = time.perf_counter()
    print("Adding time [s]: {:.6f}".format(end - begin))

    begin = time.perf_counter()
    for word in words:
        hash_table.find(word)
    end = time.perf_counter()
    print("Enumerating time [s]: {:.6f}".format(end - begin))

    if file_del is not None:
        words = synthetic.read_file(file_del)
    begin = time.perf_counter()
    for word in words:
        hash_table.delete_all(word)
    end = time.perf_counter()
    print("Deleting time [s]: {:.6f}".format(end - begin))
Exemplo n.º 8
0
class Node(object):
    def __init__(self, location):
        self.edges = HashTable(10)
        self.location = location

    #Time Complexity: O(n) where n is the number of edges
    def addEdge(self, edge):
        self.edges.put(int(edge.id), edge)

    #Time Complexity: O(n) where n is the number of edges
    def findEdge(self, id):
        return self.edges.get(id)

    #Time Complexity: O(n) where n is the number of edges
    def getDistance(self, location):
        return self.edges.get(location.id).weight
Exemplo n.º 9
0
def test_hash_table_constructor_creates_empty_hash_table():
    """Test that HashTable constructor creates an empty hash table."""
    from hash import additive_hash, HashTable
    t = HashTable(10, additive_hash)
    assert len(t.buckets) == 10
    assert t.hash_func is additive_hash
    assert not all(t.buckets)
Exemplo n.º 10
0
	def __init__(self):
		#connect to permanent storage
		self.create_flag = False
		self.delimiter = '|'
		self.storage = "permanent_data.txt"
		self.database = HashTable(5479)
		#call function to read existing data into hash table
		self._import_data()
Exemplo n.º 11
0
 def _getPackages( self ):
     packages = HashTable(10)
     with open('data/packageFile.csv') as file:
         packageData = csv.reader( file, delimiter = ',' )
         for row in packageData:
             package = Package(
                 row[0],
                 row[1],
                 row[2],
                 row[3],
                 row[4],
                 row[5],
                 row[6],
                 row[7]
             )
             package.setLocation( self.getLocationByAddress( row[1] ) )
             packages.put( package.id, package )
     return packages
Exemplo n.º 12
0
def gen_step_mode(file_in, num, seed, file_del=None):
    size = input("How many lists should be in the hashmap?: ")
    step_val = input(
        "Specify the step value (number of words generated additionally): ")
    try:
        size = int(size)
        step_val = int(step_val)
    except ValueError as e:
        print("ERROR: Invalid value was passed to the program.\n", e)
        return -1

    words_num = 0
    results = []
    while True:
        words_num += step_val
        if words_num > num:
            break
        print(words_num, " words")
        results.append(words_num)
        words = synthetic.words(file_in, words_num, seed)

        hash_table = HashTable(size)
        begin = time.perf_counter()
        hash_table.add_all(words)
        end = time.perf_counter()
        print("Adding time [s]: {:.6f}".format(end - begin))
        results.append(end - begin)

        begin = time.perf_counter()
        for word in words:
            hash_table.find(word)
        end = time.perf_counter()
        print("Enumerating time [s]: {:.6f}".format(end - begin))
        results.append(end - begin)

        if file_del is not None:
            words = synthetic.read_file(file_del)
        begin = time.perf_counter()
        for word in words:
            hash_table.delete_first(word)
        end = time.perf_counter()
        print("Deleting time [s]: {:.6f}".format(end - begin))
        results.append(end - begin)

    analyse_data(results, num, size)
Exemplo n.º 13
0
class Graph(object):
    def __init__(self):
        self.nodes = HashTable(10)

    # Add a vertex to the graph
    # Time Complexity: O(n)
    def addNode(self, location):
        self.nodes.put(int(location.id), Node(location))

    # Add edge between two nodes bidirectionally
    # Time Complexity: O(n)
    def addWeightedEdge(self, origin, terminus, weight):
        originEdge = Edge(origin, weight)
        terminusEdge = Edge(terminus, weight)
        self.nodes.get(origin.id).addEdge(terminusEdge)
        self.nodes.get(terminus.id).addEdge(originEdge)

    # Get id of a vertex at a location
    # Time Complexity: O(n)
    def getNode(self, location):
        return self.nodes.get(location.id)

    # Get first node returned by location name: O(n)
    def getNodeByAddress(self, address):
        for node in self.nodes.getAll():
            if (node.location.address == address):
                return node

    # Get distance between two lcoations
    def getDistanceBetween(self, origin, terminus):
        return self.nodes.get(origin.id).getDistance(terminus)

    # Get nearest neighbor of a location
    # Returns the closest location to the origin
    # Time Complexity: O(n * m)
    def getNearestNeighbor(self, origin, group):
        resultEdges = []
        originNode = self.getNodeByAddress(origin.address)
        originEdges = originNode.edges.getAll()
        for location in group:
            for edge in originEdges:
                if location == edge.location:
                    resultEdges.append(edge)

        nearestNeighbor = min(resultEdges, key=lambda x: x.weight)

        return nearestNeighbor.location
Exemplo n.º 14
0
class test_hash(unittest.TestCase):

	def setUp(self):
		self.hash = HashTable(11)

	def test_put(self):
		self.hash.put("Lindsey Raymond", "9786217554")
		self.assertEqual(self.hash.keys[3], "Lindsey Raymond")
		self.assertEqual(self.hash.data[3], "9786217554")

	def test_get(self):
		self.assertEqual(self.hash.get("Lindsey Raymond"), "9786217554")

	def test_size(self):
		self.assertEqual(self.hash.length, 11)

	def test_get(self):
		self.hash["James Hayward"] = "123456789"
		self.hash.put("Lindsey Raymond", "9786217554")
		self.assertEqual(self.hash["Lindsey Raymond"], self.hash.get("Lindsey Raymond"))
		self.assertEqual(self.hash["James Hayward"], "123456789")
Exemplo n.º 15
0
def words_ready_mode(file_in, file_del=None):
    words = synthetic.read_file(file_in)
    print(words)

    size = input("How many lists should be in the hashmap?: ")
    try:
        size = int(size)
    except ValueError as e:
        print("ERROR: Invalid value was passed to the program.\n", e)
        return -1

    hash_table = HashTable(size)
    hash_table.add_all(words)
    for arr in hash_table.array:
        print(arr)

    if file_del is not None:
        words = synthetic.read_file(file_del)
    for word in words:
        hash_table.delete_all(word)

    for arr in hash_table.array:
        print(arr)
Exemplo n.º 16
0
class Phonebook:

	def __init__(self):
		#connect to permanent storage
		self.create_flag = False
		self.delimiter = '|'
		self.storage = "permanent_data.txt"
		self.database = HashTable(5479)
		#call function to read existing data into hash table
		self._import_data()
	

	def _read_lines(self):
		with open(self.storage, 'r') as old_data:
			for row in old_data:
				if not row.startswith("#"):
					yield row

	def _import_data(self):
		for row in self._read_lines():
			if row.startswith("~"):
				self.create()
			else:
				name = row.split(self.delimiter)[0]
				number = row.split(self.delimiter)[-1]
				self.database[name] = number

	def add(self, name, number):
		#print(self.database.hashkeys)
		if name not in set(self.database.hashkeys):
			self.database[name] = number
		else:
			raise KeyError("Value already exists")


	def remove(self, name):
		self.database.put(name, None)
		self.database.hashkeys[self.database.hashkeys.index(name)] = None

	def change(self, name, number):
		if name in set(self.database.hashkeys):
			self.database[name] = number
		else:
			raise KeyError("Value does not exist")

	def lookup(self, name):
		try:
			return self.database[name]
		except:
			raise KeyError("Value does not exist")

	def reverse_lookup(self, number):
		#Note that this will be slow
		try:
			location = self.database.data.index(number)
			return self.database.hashkeys[location]
		except:
			raise LookupError("Value does not exist")

	def create(self):
		self.create_flag = True

	def save(self):
		with open(self.storage, 'w') as txt_file:
			txt_file.write("#permanent storage file\n")
			if self.create_flag:
				txt_file.write("~CREATED\n")
			for name in self.database.keys:
				if name != None:
					txt_file.write(name+"|"+self.database[name]+"\n")


	def check_input_errors(self, args):
		if len(args) == 1:
			raise RuntimeError("Need more input")


	def parse_arguments(self, args):
		self.check_input_errors(args)
		if self.create_flag:
			if args[1] == "add":
				self.add(*args[2:4])
			else:
				result = getattr(self, args[1])(args[2])
		else:
			if args[1] == 'create':
				self.create()
			else:
				raise RuntimeError("Phonebook does not exist")
		self.save()
		return result
Exemplo n.º 17
0
	def setUp(self):
		self.hash = HashTable(11)
Exemplo n.º 18
0
def dict_hash():
    dict_hash = HashTable(1024)
    dictionary = open("/usr/share/dict/words", 'r')
    for word in dictionary:
        dict_hash.set(word.rstrip(), 1)
    return dict_hash
Exemplo n.º 19
0
def test_hash_fill_table(read_test_lexicon):
    ht = HashTable()
    for i in read_test_lexicon:
        ht.set(i)
    for i in read_test_lexicon:
        assert ht.get(i) == i
Exemplo n.º 20
0
class TestHashTable(unittest.TestCase):
    def setUp(self):
        self.ht = HashTable()

    def test_hash(self):
        self.assertEqual(self.ht.hash("Maximus"), self.ht.hash("Maximus"))
        self.assertTrue(self.ht.hash("Maximus") < self.ht.capacity)

    def test_insert(self):
        self.ht.insert("key", "value")
        self.assertEqual(self.ht.size, 1)
        self.assertEqual(self.ht.buckets[self.ht.hash("key")].value, "value")

    def test_find(self):
        obj = "Maximus"
        self.ht.insert("Intel", obj)
        self.assertEqual(obj, self.ht.find("Intel"))
        obj = ["Hello", "world"]
        self.ht.insert("hobby", obj)
        self.assertEqual(obj, self.ht.find("hobby"))

    def test_remove(self):
        obj = "19"
        self.ht.insert("age", obj)
        self.assertEqual(1, self.ht.size)
        self.assertEqual(obj, self.ht.remove("age"))
        self.assertEqual(0, self.ht.size)
Exemplo n.º 21
0
def test_get_returns_value_of_key_provided():
    """Test that get function returns the value of key provided."""
    from hash import HashTable, additive_hash
    t = HashTable(10, additive_hash)
    t.set('word', 444)
    assert t.get('word')
Exemplo n.º 22
0
def test_get_raises_error_if_key_not_not_in_table():
    """Test that keyerror raised if key not in table."""
    from hash import HashTable, additive_hash
    t = HashTable(10, additive_hash)
    with pytest.raises(KeyError):
        t.get('key')
Exemplo n.º 23
0
def test_set_raises_error_if_key_not_string():
    """Test that type error raised if key not string in set."""
    from hash import HashTable, additive_hash
    t = HashTable(10, additive_hash)
    with pytest.raises(TypeError):
        t.set(12, 44)
Exemplo n.º 24
0
def test_set_places_key_value_pairs_in_hash_table():
    """Test that set function places key value pairs in hash table correctly."""
    from hash import HashTable, additive_hash
    t = HashTable(10, additive_hash)
    t.set('word', 444)
    assert t.buckets[4][0] == ['word', 444]
Exemplo n.º 25
0
def test_hash_initialized_with_oat():
    """Test if hash table can be initialized using oat hashing function."""
    from hash import HashTable
    cust_hash = HashTable(hash_type='oat')
    cust_hash.hash_type == 'oat'
Exemplo n.º 26
0
def table1key():
    """Table with just 1 key/pair."""
    t = HashTable()
    t.set_key('apple', 'chapel')
    return t
Exemplo n.º 27
0
def table6_add():
    """Initialize table with 6 buckets."""
    t = HashTable()
    return t
Exemplo n.º 28
0
class TestHashTable(unittest.TestCase):
    def setUp(self):
        self.ht = HashTable()

    def test_hash(self):
        self.assertEqual(self.ht.hash("hello"), self.ht.hash("hello"))
        self.assertTrue(self.ht.hash("hello") < self.ht.capacity)

    def test_insert(self):
        self.assertEqual(self.ht.size, 0)
        self.ht.insert("test_key", "test_value")
        self.assertEqual(self.ht.size, 1)
        self.assertEqual(
            self.ht.buckets[self.ht.hash("test_key")].value, "test_value")

        def test_find(self):
            self.assertEqual(self.ht.size, 0)
            obj = "hello"
            self.ht.insert("key1", obj)
            self.assertEqual(obj, self.ht.find("key1"))
            obj = ["this", "is", "a", "list"]
            self.ht.insert("key2", obj)
            self.assertEqual(obj, self.ht.find("key2"))

        def test_remove(self):
            self.assertEqual(self.ht.size, 0)
            obj = "test object"
            self.ht.insert("key1", obj)
            self.assertEqual(1, self.ht.size)
            self.assertEqual(obj, self.ht.remove("key1"))
            self.assertEqual(0, self.ht.size)
            self.assertEqual(None, self.ht.remove("some random key"))

        def test_capacity(self):
            # Test all public methods in one run at a large capacity
            for i in range(0, 1000):
                self.assertEqual(i, self.ht.size)
                self.ht.insert("key" + str(i), "value")
            self.assertEqual(self.ht.size, 1000)
            for i in range(0, 1000):
                self.assertEqual(1000-i, self.ht.size)
                self.assertEqual(self.ht.find("key" + str(i)),
                                 self.ht.remove("key" + str(i)))

        def test_issue2(self):
            self.assertEqual(self.ht.size, 0)
            self.ht.insert('A', 5)
            self.assertEqual(self.ht.size, 1)
            self.ht.insert('B', 10)
            self.assertEqual(self.ht.size, 2)
            self.ht.insert('Ball', 'hello')
            self.assertEqual(self.ht.size, 3)

            self.assertEqual(5, self.ht.remove('A'))
            self.assertEqual(self.ht.size, 2)
            self.assertEqual(None, self.ht.remove('A'))
            self.assertEqual(self.ht.size, 2)
            self.assertEqual(None, self.ht.remove('A'))
            self.assertEqual(self.ht.size, 2)
Exemplo n.º 29
0
def test_get_non_string_key_raises_error():
    """Test taht get with a non string key raises error."""
    from hash import HashTable, additive_hash
    t = HashTable(10, additive_hash)
    with pytest.raises(TypeError):
        t.get(22)
Exemplo n.º 30
0
 def setUp(self):
     self.ht = HashTable()
Exemplo n.º 31
0
def test_bad_hash_type_raises_error():
    """Test if ValueError raised if function other than additive or oat is passed."""
    from hash import HashTable
    with pytest.raises(NameError):
        HashTable(hash_type='something')
Exemplo n.º 32
0
def table6_elf():
    """Initialize table with 6 buckets."""
    t = HashTable(hash_type='elf')
    return t
Exemplo n.º 33
0
def test_hash_table_uses_additive_hash_function():
    """Test that hash table hashes keys with function provided."""
    from hash import additive_hash, HashTable
    t = HashTable(10, additive_hash)
    assert t._hash('one') == additive_hash('one')
Exemplo n.º 34
0
def adt6_no_dups():
    """Full hash table with only one item in each bucket."""
    t = HashTable()
    t.set_key('aaaaaa', 'bettie')
    t.set_key('a', 'bettie')
    t.set_key('apple', 'bob')
    t.set_key('potato', 'fred')
    t.set_key('spinach', 'james')
    t.set_key('sweet potato', 'jenny')
    return t
Exemplo n.º 35
0
def test_hash_table_uses_horner_hash_function():
    """Test that hash table hashes keys with function provided."""
    from hash import horner_hash, HashTable
    t = HashTable(10, horner_hash)
    assert t._hash('two') == horner_hash('two')