def politicaClock(self, file):
pageFaults = 0
clockHand = 0
location = []
hashTable = HashTable(self.M)
totalLineas = 0
i = 0
while i < self.N:
location.append(PageTableEntry())
i += 1
for line in file:
totalLineas += 1
line = line.rstrip('\n')
if location[clockHand].getValidBit() == 1:
sMH = StringMH(line)
value = hashTable.getValue(sMH)
if value is None:
pageFaults = pageFaults + 1
while location[clockHand].getRefBit() == 1:
location[clockHand].setRefBit(0)
clockHand = clockHand + 1
clockHand = clockHand % self.N
key = location[clockHand].getStringMH()
hashTable.deleteKey(key)
hashTable.putKeyValue(sMH, clockHand)
location[clockHand].setStringMH(sMH)
location[clockHand].setRefBit(0)
clockHand = clockHand + 1
clockHand = clockHand % self.N
else:
if location[value].getRefBit() == 1:
location[value].setRefBit(0)
else:
location[value].setRefBit(1)
else:
sMH = StringMH(line)
value = hashTable.getValue(sMH)
if value is None:
pageFaults = pageFaults + 1
hashTable.putKeyValue(sMH, clockHand)
location[clockHand].setStringMH(sMH)
location[clockHand].setValidBit(1)
location[clockHand].setRefBit(0)
clockHand = clockHand + 1
clockHand = clockHand % self.N
else:
if location[value].getRefBit() == 1:
location[value].setRefBit(0)
else:
location[value].setRefBit(1)
missRate = 100 * (float(pageFaults) / totalLineas)
missWarm = 100 * (float(pageFaults - self.N) / (totalLineas - self.N))
mW = pageFaults - self.N
print "Evaluando una cache CLOCK con " + str(self.N) + " entradas"
print "Resultados:"
print "Miss rate: %0.2f" % missRate + "%% (%d" % pageFaults + " misses out of %d" % totalLineas + " references)"
print "Miss rate (warm cache): %0.2f" % missWarm + "%% (%d" % mW + " misses out of %d" % totalLineas + "-%d" % self.N + " references)"
def main():
hash_table = HashTable()
for x in range(20):
hash_table.insert(x, str(x))
for x in hash_table.getHashTable():
print(len(x))
print(*x)
def politicaClock(self, file):
pageFaults = 0
clockHand = 0
location = []
hashTable = HashTable(self.M)
totalLineas = 0
i = 0
while i < self.N:
location.append(PageTableEntry())
i += 1
for line in file:
totalLineas += 1
line = line.rstrip('\n')
if location[clockHand].getValidBit() == 1:
sMH = StringMH(line)
value = hashTable.getValue(sMH)
if value is None:
pageFaults = pageFaults + 1
while location[clockHand].getRefBit() == 1:
location[clockHand].setRefBit(0)
clockHand = clockHand + 1
clockHand = clockHand % self.N
key = location[clockHand].getStringMH()
hashTable.deleteKey(key)
hashTable.putKeyValue(sMH,clockHand)
location[clockHand].setStringMH(sMH)
location[clockHand].setRefBit(0)
clockHand = clockHand + 1
clockHand = clockHand % self.N
else:
if location[value].getRefBit() == 1:
location[value].setRefBit(0)
else:
location[value].setRefBit(1)
else:
sMH = StringMH(line)
value = hashTable.getValue(sMH)
if value is None:
pageFaults = pageFaults + 1
hashTable.putKeyValue(sMH,clockHand)
location[clockHand].setStringMH(sMH)
location[clockHand].setValidBit(1)
location[clockHand].setRefBit(0)
clockHand = clockHand + 1
clockHand = clockHand % self.N
else:
if location[value].getRefBit() == 1:
location[value].setRefBit(0)
else:
location[value].setRefBit(1)
missRate = 100*(float(pageFaults)/totalLineas)
missWarm = 100*(float(pageFaults - self.N)/(totalLineas-self.N))
mW = pageFaults - self.N
print "Evaluando una cache CLOCK con " + str(self.N) + " entradas"
print "Resultados:"
print "Miss rate: %0.2f" %missRate + "%% (%d" %pageFaults + " misses out of %d" %totalLineas + " references)"
print "Miss rate (warm cache): %0.2f" %missWarm + "%% (%d" %mW + " misses out of %d" %totalLineas + "-%d" %self.N + " references)"
def main():
my_dict = HashTable()
file = open('ispell.dict', 'r')
for word in file:
my_dict.insert((word[:-1], ))
file.close()
word = input('Enter word : ').split()[0]
for i in range(len(word)):
for ch in range(ord('a'), ord('z')):
if chr(ch) == word[i]:
continue
new = word[:i] + chr(ch) + word[i + 1:]
if my_dict.search(new) is not None:
print(new)
def depth_first_search__scan(sm, h):
MAXNODES = 20000000
openSet = [sm]
ht = HashTable.HashTable()
ht.checkAdd(sm)
nodes = 0
while len(openSet) > 0:
currentState = openSet.pop()
#currentState.printMap()
nodes += 1
if currentState.isSolution():
return currentState # SOLUTION FOUND!!!
if nodes % 1000 == 0:
print(nodes, " nodes checked")
sys.stdout.flush()
if nodes == MAXNODES:
print("Limit of nodes reached: exiting without a solution.")
sys.exit(1)
for x in currentState.children():
# check if this has already been generated
if ht.checkAdd(x):
continue
openSet.append(x)
return None
def seeds(dict, i, k, ht):
seedArray = []
for j in range(len(dict[i]) - k):
hash_subseq = HashTable.hash_djb2(dict[i][j:j + k])
if hash_subseq in ht:
if j not in seedArray:
seedArray.append((j, hash_subseq))
dist = []
if len(seedArray) > 3:
for z in range(len(seedArray) - 1):
dist.append(seedArray[z + 1][0] - seedArray[z][0])
re = []
for z in range(len(dist)):
if dist[z] <= 50:
if seedArray[z] in re:
re.append(seedArray[z + 1])
else:
re.append(seedArray[z])
re.append(seedArray[z + 1])
if len(re) >= 3:
return re
else:
return None
else:
return None
def __init__(self, size, init_list=None, skip=1):
"""
Initializes the dictionary.
"""
self.size = size
self.skip = skip
self.n_items = 0
# Init hash table (keys) and data table (values)
self.keys = HashTable(size, collision='rehashing', param=skip)
self.values = [None] * self.size
# Add the initial list of (key, value) to the dictionary
if (init_list is not None):
for key, value in init_list:
self.put(key, value)
def hashJoin(self, tabela1, tabela2):
resultado = []
hashing = HashTable(len(tabela1))
file = open("t/hash.txt", "w")
for s in tabela2:
linha = s.split("\t")
hashing.insereHash(s)
for i in tabela1:
linha = i.split("\t")
resultado = hashing.procuraHash(linha[1])
if resultado is not None:
file.write(resultado + "\t" + "\t".join(linha) + "\n")
def CreateSprite(image):
# send function 2 to the server [2:4][imageID:4]
FTSMain.SEND(struct.pack("ii", 2, image))
reply = FTSMain.RECEIVE("i", 4)
spr = SPRITE(reply[0], image)
HashTable.HTInsert(FTSMain.SPRITETABLE, SPRITEHASHFUNCTION, spr)
return reply[0]
def Sparkseeds(dict, i, k, hashDF, sc):
word = [(i, HashTable.hash_djb2(dict[i][j:j + k]), j)
for j in range(0,
len(dict[i]) - k)]
rddW = sc.parallelize(word)
schemaWordDF = rddW.map(
lambda x: Row(NUM_SEQ=x[0], ID_SEQ=x[1], POS_SEQ=x[2]))
df = sqlContext.createDataFrame(schemaWordDF)
reDF = df.join(hashDF, df.ID_SEQ == hashDF.ID_GEN, how='inner')
reDF = reDF.orderBy(reDF.POS_SEQ).select(reDF.NUM_SEQ, reDF.ID_SEQ,
reDF.POS_SEQ, reDF.POS_GEN)
my_window = Window.partitionBy(reDF.NUM_SEQ).orderBy(reDF.POS_SEQ)
reDF = reDF.withColumn("prev_value", F.lag(reDF.POS_SEQ).over(my_window))
reDF = reDF.withColumn(
"dist",
F.when(F.isnull(reDF.POS_SEQ - reDF.prev_value),
0).otherwise(reDF.POS_SEQ - reDF.prev_value))
reDF = reDF.select(reDF.NUM_SEQ, reDF.ID_SEQ, reDF.POS_SEQ, reDF.dist,
reDF.POS_GEN)
reDF = reDF.withColumn("dist0", F.lead(reDF.dist).over(my_window))
elDF = reDF.filter(((reDF.dist == 0) | (reDF.dist >= 50))
& ((reDF.dist0.isNull()) | (reDF.dist0 >= 50)))
reDF = reDF.subtract(elDF)
reDF = reDF.orderBy(reDF.POS_SEQ).select(reDF.NUM_SEQ, reDF.ID_SEQ,
reDF.POS_SEQ, reDF.POS_GEN)
#pos = function(reDF)
return reDF
def LoadImageSliced(filename, sx, sy):
# a byte array of the filename
ar = bytearray(map((lambda x: ord(x)), list(filename)))
# make it 256 bytes in length (must be fixed size!)
for i in range(0, (256 - len(filename))):
ar += bytearray([0])
# send function 1 to server [1:4][filename:256][sx:4][sy:4]
FTSMain.SEND(struct.pack("i", 1) + ar + struct.pack("ii", sx, sy))
reply = FTSMain.RECEIVE("iii", 12) # get a response [ID,width,height]
img = IMAGE(reply[0], reply[1], reply[2])
HashTable.HTInsert(FTSMain.IMAGETABLE, IMAGEHASHFUNCTION, img)
return reply[0] # return the ID
def __init__(self, name, capacity=0, force_init=False, serializer=marshal):
"""
'name' the path of the file to be 'mmap'ed
use MemCacher(name, ...) to add prefix '/dev/shm' automatically
'capacity' optional, if you want to connect to an existing shmht
'serializer' should contain loads/dumps (marshal, json, pickle, etc.)
"""
self.ht = HashTable.HashTable(name, capacity, force_init, serializer)
self.d = {}
self.loads = serializer.loads
self.dumps = serializer.dumps
def __init__(self, timeout, receiving_port):
# self.udp_ip = udp_ip
# self.udp_port = udp_port
# self.message = message
# self.local_port = local_port
self.udp_obj = udpSendRecieve.UDPNetwork(receiving_port)
self.timeout = timeout
self.cache = HashTable.HashTable("ServerCache")
self.cache.clean()
# self.stack = Stack()
self.list = []
def __init__(self, port, maxnodes, replicate_factor = 0):
self._comm = Comm(port)
self._nodeid = int(hashlib.sha1(self._comm.getIpPort().encode()).hexdigest(), 16) % maxnodes
self._message_creator = Messages(self._comm.ip, port, self._nodeid)
self._finger_table = FingerTable(self._nodeid, maxnodes)
self._hash_table = HashTable()
self._replicate_factor = replicate_factor
self._message_handler = {
"get": self.getKey,
"retrieve": self.retrieveKey,
"put": self.putKey,
"del": self.delKey,
"join": self.join,
"join_response": self.joinResponse,
"table_update": self.updateTable,
"table_response": self.updateTableResponse,
"route": self.routeMessage,
"error": self._infoPrinter,
"response": self._infoPrinter
}
self._hash_table.putNodeInfo(self._nodeid, self._comm.ip, self._comm.port)
def main():
dict = input("Enter the dictionary filename: ") # ex: words.txt
grd = input("Enter the grid filename: ") # ex: 4x7.grid.txt
args = [dict, grd]
global grid
grid, rows, cols = readInGrid(
args[1]) # reads the grid file into the variable 'grid'
global switch
switch = create_switch()
global r, c
r, c = 0, 0
dict1 = open(args[0])
size = 0
for _ in dict1:
size += 1 # size is the number of words in the dictionary
dict1.close()
hashTable = HashTable.HashTable(size, 0.2)
hashTable = readInDict(
args[0], hashTable
) # creates the Hash Table and inserts the words from the dictionary file into it.
count = 0
prevWord = ""
timer = time.time() # 'start' the timer
longestWord = 25
outputFile = open("out.txt", "w")
for r1 in range(rows):
for c1 in range(cols):
for d in range(8):
for l in range(
3, longestWord
): # These loops iterate through each position, then in each direction and length.
word = getWordInGrid(r1, c1, d, l, rows, cols)
if word == prevWord: # Ensures that the same word is not searched multiple times when the end of the grid is reached
continue
prevWord = word
test = hashTable.find(word)
if test: # Writes the found words to the file
outputFile.write(switch[d].__name__ + " (" + str(r1) +
", " + str(c1) + "): " + word +
"\n")
count += 1
timer = time.time() - timer
outputFile.close()
print(str(count) + " words found")
print("Found all words in " + str(timer) + " seconds")
return 0
def test_insert(self):
'''
Test Hash Table class for setting, getting and itteration
:return:
'''
self.my_hash = HashTable(10)
self.my_hash.set('ali', 100)
self.my_hash.set('kadir', 200)
self.my_hash.set('halil', 300)
self.my_hash.set('hayri', 400)
self.my_hash.set('cevdet', 500)
self.my_hash.set('celal', 600)
# Test for values
self.assertEqual(100, self.my_hash.get('ali'))
self.assertEqual(200, self.my_hash.get('kadir'))
self.assertEqual(300, self.my_hash.get('halil'))
self.assertEqual(400, self.my_hash.get('hayri'))
self.assertEqual(500, self.my_hash.get('cevdet'))
self.assertEqual(600, self.my_hash.get('celal'))
# Test for keys
self.assertEqual('ali', self.my_hash.index(100))
self.assertEqual('kadir', self.my_hash.index(200))
self.assertEqual('halil', self.my_hash.index(300))
self.assertEqual('hayri', self.my_hash.index(400))
self.assertEqual('cevdet', self.my_hash.index(500))
self.assertEqual('celal', self.my_hash.index(600))
# Test for iteration
self.new_hash = HashTable(3)
self.new_hash.set('a', 1)
self.new_hash.set('b', 2)
self.new_hash.set('c', 3)
iterable = iter(self.new_hash)
self.assertEqual(next(iterable), 3)
self.assertEqual(next(iterable), 1)
self.assertEqual(next(iterable), 2)
self.assertRaises(StopIteration, next, iterable)
def GetNTsHashTable(gen, nt_list):
hashtable_lst = []
for nt in nt_list:
if isinstance(nt, str):
nt_name = nt
else:
nt_name = nt.name
all_context = gen.DFSNTContext([nt], nt)
if len(all_context) == 0:
continue
if "_BIND" in nt_name or "_EMIT" in nt_name:
nt_name = nt_name[:-5]
hashtable = HashTable.HashTable(nt_name)
hashtable.LoadContext(all_context)
hashtable_lst.append(hashtable)
return hashtable_lst
import csv
import HashTable
from Delivery import Truck, Package, Location, allPackages, loadedPackages
packageTable = HashTable.PackageHashTable()
allLocations = []
allDistances = []
allAddresses = []
totalMilesTraveled = 0.0
# Opens the WGUPS Addresses file, creates a Location for each address
# Runs in O(N)
with open("WGUPS Addresses.csv", "r") as addressFile:
csv_reader = csv.reader(addressFile)
for line in csv_reader:
allAddresses.append(line)
locationID = line[0]
name = line[1]
address = line[2]
location = Location(locationID, name, address)
allLocations.append(location)
# Opens WGUPS Distance Table file, adds the appropriate Distance array to each previously created Location
# Runs in O(N)
with open("WGUPS Distance Table.csv", "r") as distanceFile:
csv_reader = csv.reader(distanceFile)
for line in csv_reader:
allDistances.append(line)
for location in allLocations:
locID = int(location.locationID)
location.updateDistanceArray(allDistances[locID])
def test_insert(self):
hash_table = HashTable()
hash_table.insert(1, str(1))
self.assertEqual(len(hash_table.getHashTable()), 20)
def __init__(self, size):
assert (size > 0)
self.table = HashTable.HashTable(size)
import HashTable as ht
import UnionFindSet as ufs
import sys
accounts = [["David", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["David", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["David", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["David", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["David", "*****@*****.**", "*****@*****.**", "*****@*****.**"]]
#accounts = [["John","*****@*****.**","*****@*****.**"],["John","*****@*****.**","*****@*****.**"],["Mary","*****@*****.**"],["John","*****@*****.**"]]
hashtable_size = len(accounts) * 30
table = ht.HashTable(hashtable_size)
user_dict = []
for i, v in enumerate(accounts):
user_dict.append(v[0])
accounts[i][0] = i
for e_idx in range(1, len(v)):
hash_index = hash(v[e_idx]) % ((sys.maxsize + 1) * 2)
table.put(hash_index, v[e_idx])
accounts[i][e_idx] = hash_index
uts_table = ufs.UnionFindSet(range(len(user_dict)))
for v in accounts:
for idx in range(1, len(v)):
uts_table.union(v[idx - 1], v[idx])
#print(table.hashtable)
print(uts_table.father_dict)
"""map a timenode to the correct node in the OD list of timeNodes"""
"""PersonA took PathB at TimeC from OriginD to DestinationE"""
timeTolerance = 30
"""the variables that PersonA used"""
OriginD = Coordinate.Coordinate(40, -78)
DestinationE = Coordinate.Coordinate(50, -80)
timeCString = "08:00"
timeCDate = datetime.strptime(timeCString, "%H:%M")
TimeC = TimeNode.TimeNode(timeCDate, timeTolerance)
pathB = "66W"
"""process to capture event"""
"""create a hashTable"""
ODNodes = HashTable.HashTable(1)
odNode = ODNode.ODNode(Coordinate.Coordinate(40.5, -78),
Coordinate.Coordinate(50.5, -80), 0)
ODNodes.insert(odNode)
"""create a list of times to be looked at"""
odNode.createTimeIntervals("06:00", "10:00", timeTolerance)
# print("initial Node with Times Added")
# print(odNode.toString())
"""see if PersonA's origin and destination can be mapped"""
tempNode = ODNode.ODNode(OriginD, DestinationE, 0)
if ODNodes.__contains__(tempNode, 100, 100):
"""find and increment the correct node"""
n = ODNodes.find(tempNode, 100, 100)
"""increment the count on this node"""
f.write('%d: %f, %f, %f\n' %
(k, best_test[0][k], best_test[1][k], best_test[2][k]))
print("Tran C done.")
sampler.close()
else:
print tf.train.latest_checkpoint(C_logdir)
saver.restore(sess, tf.train.latest_checkpoint(C_logdir))
best_P, best_Q = sess.run([model.P, model.Q])
sess.close()
tf.reset_default_graph()
# building candidates
[P, Q] = best_P, best_Q
P = (np.sign(P) + 1) / 2
Q = (np.sign(Q) + 1) / 2
H = HashTable(Q, m=args.F_m, r=args.hash_r)
print 'Getting candidates...'
t0 = time.time()
candidates = defaultdict(list)
sampled_users = random.sample(xrange(usernum), 10000)
if args.F_hr > 0.0:
try:
[candidates] = np.load(C_logdir + '/cache.npy')
except:
candidates = [None for _ in range(usernum)]
for u in tqdm(xrange(usernum),
total=usernum,
ncols=70,
leave=False,
unit='users'):
# for u in range(args.usernum):
class MyWin(QMainWindow, Ui_MainWindow):
start_add_time, end_add_time = None, None
start_delete_key_time, end_delete_key_time = None, None
start_delete_value_time, end_delete_value_time = None, None
start_search_key_time, end_search_key_time = None, None
start_search_value_time, end_search_value_time = None, None
def __init__(self):
super().__init__()
self.setupUi(self)
self.hash_table = None
self.initialize_windows()
self.work_with_menu()
def handle_input_add(self, key, val1, val2, val3):
if self.hash_table:
self.start_add_time = time.time()
self.hash_table.add(key, val1, val2, val3)
self.end_add_time = time.time()
def handle_input_change(self, key, val1, val2, val3):
if self.hash_table:
self.hash_table.change(key, val1, val2, val3)
def handle_input_delete_key(self, key):
if self.hash_table:
self.start_delete_key_time = time.time()
self.hash_table.delitem(key)
self.end_delete_key_time = time.time()
def handle_input_delete_value(self, tf1, tf2, tf3, val):
if self.hash_table:
if tf1 and not tf2 and not tf3:
self.start_delete_value_time = time.time()
self.hash_table.delitem_value(val, None, None)
self.end_delete_value_time = time.time()
elif not tf1 and tf2 and not tf3:
self.start_delete_value_time = time.time()
self.hash_table.delitem_value(None, val, None)
self.end_delete_value_time = time.time()
elif not tf1 and not tf2 and tf3:
self.start_delete_value_time = time.time()
self.hash_table.delitem_value(None, None, val)
self.end_delete_value_time = time.time()
else:
pass
def handle_input_search(self):
if self.hash_table:
if self.idEdit.text() and self.serialNameEdit.text() == '' and self.numSeriesEdit.text() == ''\
and self.isWatchedEdit.text() == '':
self.start_search_key_time = time.time()
self.hash_table.getitem(self.idEdit.text())
self.end_search_key_time = time.time()
else:
if self.serialNameEdit.text() and self.numSeriesEdit.text(
) == '' and self.isWatchedEdit.text() == '':
self.start_search_value_time = time.time()
self.hash_table.getitem_value(self.serialNameEdit.text(),
None, None)
self.end_search_value_time = time.time()
elif self.serialNameEdit.text(
) == '' and self.numSeriesEdit.text(
) and self.isWatchedEdit.text() == '':
self.start_search_value_time = time.time()
self.hash_table.getitem_value(None,
self.numSeriesEdit.text(),
None)
self.end_search_value_time = time.time()
elif self.serialNameEdit.text(
) == '' and self.numSeriesEdit.text(
) == '' and self.isWatchedEdit.text():
self.start_search_value_time = time.time()
self.hash_table.getitem_value(None, None,
self.isWatchedEdit.text())
self.end_search_value_time = time.time()
else:
pass
def initialize_windows(self):
self.add_w = AddRecordWin()
self.add_w.adding_data.connect(self.handle_input_add)
self.add_w.okButton.clicked.connect(self.send_data_add_w)
self.add_w.cancelButton.clicked.connect(self.close)
self.change_w = ChangeRecordWin()
self.change_w.changing_data.connect(self.handle_input_change)
self.change_w.okButton.clicked.connect(self.send_data_change_w)
self.change_w.cancelButton.clicked.connect(self.close)
self.delete_k_w = DeleteByKeyWin()
self.delete_k_w.deleting_key_data.connect(self.handle_input_delete_key)
self.delete_k_w.okButton.clicked.connect(self.send_data_delete_k_w)
self.delete_k_w.cancelButton.clicked.connect(self.close)
self.delete_v_w = DeleteByValueWin()
self.delete_v_w.deleting_value_data.connect(
self.handle_input_delete_value)
self.delete_v_w.okButton.clicked.connect(self.send_data_delete_v_w)
self.delete_v_w.cancelButton.clicked.connect(self.close)
self.searchButton.clicked.connect(self.search_data)
self.tableWidget.setHorizontalHeaderLabels(
['id', 'serial_name', 'number_of_series', 'is_watched'])
self.tableWidget.setMouseTracking(True)
self.tableWidget.setFixedSize(545, 271)
self.showButton.clicked.connect(self.show_hash_table)
def work_with_menu(self):
self.actionNew.triggered.connect(self.create_new_hash_table)
self.actionOpen.triggered.connect(self.open_hash_table)
self.actionSave.triggered.connect(self.save_hash_table)
self.actionClean.triggered.connect(self.clean_hash_table)
self.actionDelete.triggered.connect(self.delete_hash_table)
self.actionAddRecord.triggered.connect(self.show_AddRecordWin)
self.actionChangeRecord.triggered.connect(self.show_ChangeRecordWin)
self.actionDelete_by_key.triggered.connect(self.show_DeleteByKeyWin)
self.actionDelete_by_value.triggered.connect(
self.show_DeleteByValueWin)
def create_new_hash_table(self):
self.hash_table = HashTable()
def open_hash_table(self):
self.create_new_hash_table()
filename = QFileDialog.getOpenFileName(self, 'Open file', '/data',
"Image files (*.txt)")[0]
self.hash_table.open_data_base(filename)
#self.hash_table.str()
def save_hash_table(self):
if self.hash_table:
if self.hash_table.current_size:
#self.hash_table.str()
filename = QFileDialog.getSaveFileName(
self, 'Open file', '/data', "Image files (*.txt)")[0]
self.hash_table.save_data_base(filename)
def clean_hash_table(self):
if self.hash_table:
self.hash_table.clean()
def delete_hash_table(self):
del self.hash_table
def show_AddRecordWin(self):
self.add_w.show()
def show_ChangeRecordWin(self):
self.change_w.show()
def show_DeleteByKeyWin(self):
self.delete_k_w.show()
def show_DeleteByValueWin(self):
self.delete_v_w.show()
def show_hash_table(self):
try:
if self.hash_table:
if self.tableWidget:
self.tableWidget.clear()
self.tableWidget.setHorizontalHeaderLabels([
'id', 'serial_name', 'number_of_series', 'is_watched'
])
self.tableWidget.setRowCount(0)
records_list = self.hash_table.repr()
for record in records_list:
row_position = self.tableWidget.rowCount()
self.tableWidget.insertRow(row_position)
for i in range(4):
self.tableWidget.setItem(
row_position, i,
QtWidgets.QTableWidgetItem(str(record[i])))
except AttributeError:
pass
def send_data_add_w(self):
self.add_w.adding_data.emit(self.add_w.idEdit.text(),
self.add_w.serialNameEdit.text(),
self.add_w.numSeriesEdit.text(),
self.add_w.isWatchedEdit.text())
'''print("def send_data(self): ",
self.add_w.idEdit.text(),
self.add_w.serialNameEdit.text(),
self.add_w.numSeriesEdit.text(),
self.add_w.isWatchedEdit.text()) # Пытаюсь посмотреть что лежит в собранных данных, временная мера'''
self.add_w.hide()
def send_data_change_w(self):
self.change_w.changing_data.emit(self.change_w.idEdit.text(),
self.change_w.serialNameEdit.text(),
self.change_w.numSeriesEdit.text(),
self.change_w.isWatchedEdit.text())
self.change_w.hide()
def send_data_delete_k_w(self):
self.delete_k_w.deleting_key_data.emit(self.delete_k_w.idEdit.text())
self.delete_k_w.hide()
def send_data_delete_v_w(self):
self.delete_v_w.deleting_value_data.emit(
self.delete_v_w.serialNameBox.isChecked(),
self.delete_v_w.numSeriesBox.isChecked(),
self.delete_v_w.isWatchedBox.isChecked(),
self.delete_v_w.valueEdit.text())
self.delete_v_w.hide()
def search_data(self):
try:
if self.hash_table:
if self.tableWidget:
self.tableWidget.clear()
self.tableWidget.setHorizontalHeaderLabels([
'id', 'serial_name', 'number_of_series', 'is_watched'
])
self.tableWidget.setRowCount(0)
self.handle_input_search()
records_list = self.hash_table.repr(
path='service_files/result_search.txt')
for record in records_list:
row_position = self.tableWidget.rowCount()
self.tableWidget.insertRow(row_position)
for i in range(4):
self.tableWidget.setItem(
row_position, i,
QtWidgets.QTableWidgetItem(str(record[i])))
except AttributeError:
pass
def time_statistic(self):
print('Adding new record: ', self.end_add_time - self.start_add_time)
print('Deleting by key: ',
self.end_delete_key_time - self.start_delete_key_time)
print('Deleting by one value: ',
self.end_delete_value_time - self.start_delete_value_time)
print('Searching by key: ',
self.end_search_key_time - self.start_search_key_time)
print('Searching by value: ',
self.end_search_value_time - self.start_search_value_time)
def closeEvent(self, event):
reply = QMessageBox.question(self, 'Message', "Are you sure to quit?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
self.time_statistic()
event.accept()
else:
event.ignore()
def IDAstar(sm, h):
MAXNODES = 20000000
openSet = []
closedSet = []
visitSet = []
pathLimit = h(sm) - 1
sucess = False
it = 0
while True:
pathLimit = pathLimit + 1
print("current pathLimit = ", pathLimit)
sm.setG(0)
openSet.insert(0, sm)
ht = HashTable.HashTable()
nodes = 0
while len(openSet) > 0:
currentState = openSet.pop(0)
#currentState.printMap()
nodes = nodes + 1
if currentState.isSolution():
return currentState # SOLUTION FOUND!!!
if nodes % 1000000 == 0:
print((nodes / 1000000), "M nodes checked")
if nodes == MAXNODES:
print("Limit of nodes reached: exiting without a solution.")
sys.exit(1)
if currentState.getF() <= pathLimit:
closedSet.insert(0, currentState)
# get the sucessors of the current state
for x in currentState.children():
# test if node has been "closed"
if isClosed(closedSet, x):
continue
# check if this has already been generated
if ht.checkAdd(x):
continue
# compute G for each
x.setG(currentState.getG() + 1)
x.setF(x.getG() + h(x))
#x.setParent(currentState)
openSet.insert(0, x) # push
else:
visitSet.insert(0, currentState)
#print "Nodes checked = ", nodes
print("iteration = ", it)
it = it + 1
if len(visitSet) == 0:
print("FAIL")
return None
# set a new cut-off value (pathLimit)
low = visitSet[0].getF()
for x in visitSet:
if x.getF() < low:
low = x.getF()
pathLimit = low
# move nodes from VISIT to OPEN and reset closedSet
openSet.extend(visitSet)
visitSet = []
closedSet = []
def main():
ht = HashTable()
ht.put(23, "ella")
ht.put(70, "mars")
ht.put(6, "nocturnal")
ht.put(1, "moo")
ht.put(21, "medee")
ht.put(41, "golden")
print(ht.get(23))
print(ht.get(6))
print(ht.get(1))
print(ht.get(21))
print(ht.hasKey(6))
ht.delete(6)
print(ht.hasKey(6))
def politicaLRU(self, file):
location = DoubleLinkedList()
pageFaults = 0
indice = 0
llena = False
hashTable = HashTable(self.M)
totalLineas = 0
for line in file:
totalLineas += 1
line = line.rstrip('\n')
if llena:
sMH = StringMH(line)
value = hashTable.getValue(sMH)
if value is None:
pageFaults = pageFaults + 1
firstNodeData = location.removeFirstNode()
hashTable.deleteKey(firstNodeData)
refNode = location.append(sMH)
hashTable.putKeyValue(sMH, refNode)
else:
location.remove(value)
refNode = location.append(sMH)
hashTable.updateValue(sMH, refNode)
else:
sMH = StringMH(line)
value = hashTable.getValue(sMH)
if value is None:
pageFaults = pageFaults + 1
refNode = location.append(sMH)
hashTable.putKeyValue(sMH, refNode)
indice = indice + 1
if indice >= self.N:
llena = True
else:
location.remove(value)
refNode = location.append(sMH)
hashTable.updateValue(sMH, refNode)
missRate = 100*(float(pageFaults)/totalLineas)
missWarm = 100*(float(pageFaults - self.N)/(totalLineas-self.N))
mW = pageFaults - self.N
print "Evaluando una cache LRU con " + str(self.N) + " entradas"
print "Resultados:"
print "Miss rate: %0.2f" %missRate + "%% (%d" %pageFaults + " misses out of %d" %totalLineas + " references)"
print "Miss rate (warm cache): %0.2f" %missWarm + "%% (%d" %mW + " misses out of %d" %totalLineas + "-%d" %self.N + " references)"
def IDAstar(sokomap, heuristic) -> [(int, int)]:
MAXNODES = 20000000
openSet: [sokomap] = []
closedSet: [sokomap] = []
visitSet: [sokomap] = []
pathLimit = heuristic(sokomap) - 1
it = 0
sokomap.uniqueBlocksGoals()
sokomap.buildLowerBoundTable()
while True:
pathLimit += 1
print("current pathLimit = ", pathLimit)
sokomap.setG(0)
openSet.insert(0, sokomap)
ht = HashTable.HashTable()
nodes = 0
while len(openSet) > 0:
currentState = openSet.pop(0)
if DEV_DEBUG:
currentState.printMap()
moveList = currentState.getMoveList()
print(
f'"openSet.pop(0)" movelist={getFormattedMoves(moveList)}')
if len(currentState.getUnplacedBlocks()) < 1:
print()
nodes = nodes + 1
if currentState.isSolution():
return currentState # SOLUTION FOUND!!!
if nodes % 1000000 == 0:
print((nodes / 1000000), "M nodes checked")
if nodes == MAXNODES:
print("Limit of nodes reached: exiting without a solution.")
sys.exit(1)
if currentState.getF() <= pathLimit:
closedSet.insert(0, currentState)
# get the sucessors of the current state
children = currentState.getChildren()
for child in children:
# test if node has been "closed"
if isClosed(closedSet, child):
continue
# check if this has already been generated
if ht.checkAdd(child):
if DEV_DEBUG:
print(f'We have already gone this way.')
continue
# compute G for each
child.setG(currentState.getG() + 1)
child.setF(child.getG() + heuristic(child))
#x.setParent(currentState)
if DEV_DEBUG:
print(f'Moving.')
openSet.insert(0, child) # push
else:
visitSet.insert(0, currentState)
#print "Nodes checked = ", nodes
print("iteration = ", it)
it = it + 1
if len(visitSet) == 0:
print("FAIL")
return None
# set a new cut-off value (pathLimit)
low = visitSet[0].getF()
for child in visitSet:
if child.getF() < low:
low = child.getF()
pathLimit = low
# move nodes from VISIT to OPEN and reset closedSet
openSet.extend(visitSet)
visitSet = []
closedSet = []
class Scanner:
__sursa = ""
__string = ""
__list = []
__cod_atom = []
__cod_ts = []
__ts = HashTable.HashTable()
__i = 0
__numbersAF = AF("intregi.txt")
__identifierAF = AF("gucci.txt")
def __init__(self, sursa) -> None:
super().__init__()
self.__sursa = sursa
"""
Citeste fisierul sursa si il salveaza intr-ul string
"""
def read(self):
with open(self.__sursa, 'r') as reader:
self.__string = reader.read()
"""
Ia urmatorul caracter din string
"""
def get(self):
aux = self.__string[self.__i]
self.__i += 1
return aux
"""
Ia caracterul anterior
"""
def back(self):
self.__i -= 1
"""
Creeaza tabelul FIP
"""
def make_fip(self):
self.__cod_atom = [-1] * len(self.__list)
self.__cod_ts = [-1] * len(self.__list)
x = 0
for i in self.__list:
if i in config:
self.__cod_atom[x] = config.index(i)
self.__cod_ts[x] = -1
elif self.__identifierAF.wrapper_verifica(i): # is ID
if len(i) < 8:
self.__cod_atom[x] = 1
val = sum([ord(j) for j in i])
aux = self.__ts.cauta(val)
if not aux:
self.__ts.adauga(val)
self.__cod_ts[x] = self.__ts.index(val) + 1
elif self.__numbersAF.wrapper_verifica(i): # is constant
self.__cod_atom[x] = 2
val = sum([ord(j) for j in i])
aux = self.__ts.cauta(val)
if not aux:
self.__ts.adauga(val)
self.__cod_ts[x] = self.__ts.index(val) + 1
else:
print(i)
raise Exception("SYNTAX IS WRONG")
x += 1
"""
Pune tokenuri in lista
"""
def parser(self):
temporary_string = ""
while True:
try:
aux = self.get()
if aux in string.ascii_letters or aux in string.digits or aux in [
'$', '_', '.'
]:
temporary_string += aux
elif aux in ['+', '-']:
if temporary_string == "":
temporary_string += aux
else:
self.__list.append(temporary_string)
temporary_string = ""
aux2 = self.get()
if aux + aux2 in separators_double:
self.__list.append(aux + aux2)
else:
self.__list.append(aux)
self.back()
elif aux in separators:
if temporary_string != '':
self.__list.append(temporary_string)
temporary_string = ""
aux2 = self.get()
if aux + aux2 in separators_double:
self.__list.append(aux + aux2)
else:
self.__list.append(aux)
self.back()
elif aux in ['&', '|']:
if temporary_string != '':
self.__list.append(temporary_string)
temporary_string = ""
aux2 = self.get()
if aux + aux2 in separators_double:
self.__list.append(aux + aux2)
else:
raise Exception("Syntax wrong bitch")
elif aux in string.whitespace:
if temporary_string != '':
self.__list.append(temporary_string)
temporary_string = ""
else:
temporary_string += aux
except IndexError:
self.back()
aux = self.get()
if aux in separators:
self.__list.append(aux)
return '\0'
"""
Afiseaza lista dupa ce apeleaza celelalte functii
"""
def run(self):
self.read()
self.parser()
self.make_fip()
output_file = "out.txt"
with open(output_file, "w") as file:
# file.write("-" * 25 + "\n")
# file.write(f'{"ATOM":7} {"COD_ATOM":10} {"COD_TS":6}' + "\n")
# file.write("-" * 25 + "\n")
x = 0
for i in self.__list:
# file.write(f'{i:7} '
# f'{str(self.__cod_atom[x]):10} '
# f'{str(self.__cod_ts[x]) if self.__cod_ts[x] != -1 else "-":6}' + "\n")
file.write(f'{i} {self.__cod_atom[x]}\n')
x += 1
x = 0
def GetSprite(sprite):
return HashTable.HTlookUp(FTSMain.SPRITETABLE, SPRITEHASHFUNCTION, sprite)
def SpritesInit():
FTSMain.SPRITETABLE = HashTable.CreateHashTable(FTSMain.TABLESIZE)
def create_new_hash_table(self):
self.hash_table = HashTable()
