Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

import pickle
def read_from_pickle(pickle_file):
	try:
		with open(pickle_file,"rb") as f:
			print("File loaded from: %s" % pickle_file)
			output = pickle.load(f)
		return output
	except Exception as e:
		print("******Exception: %s" % e)
		return {}
 
def write_dict_to_file(data_dict,output_file):
	tuple_list = [(k,v) for k,v in data_dict.iteritems()]
	write_pairs_to_file(tuple_list,output_file)
 
def write_pairs_to_file(edges_list,edges_list_file):
	f = open(edges_list_file, 'w')
	for e in edges_list:
		u,v = e
		f.write(str(u) + " " + str(v) + " \n")
	f.close()
 
def write_edges_to_file(edges_list,edges_list_file):
	write_pairs_to_file(edges_list,edges_list_file)
 
def write_set_to_txt(output,output_file):
	with open(output_file,"w") as f:
		for k in output:
			f.write(str(k) + "\n")
 
def write_dict_to_txt(output,output_file):
	with open(output_file,"w") as f:
		for k,v in output.iteritems():
			f.write(str(k) + " " + str(v) + " \n")
 
 
def write_to_pickle(output_pickle,output_file):
	with open(output_file,"wb") as f:
		print("File saved to: %s" % output_file)
		pickle.dump(output_pickle,f)
 
def read_pairs_from_file(edges_list_file,first_type = int, second_type = int):
	try:
		edges = []
		f = open(edges_list_file, 'r')
		for line in f:
			elements = line.split()
			s = elements[0]
			t = elements[1]
			s = first_type(s)
			t = second_type(t)
			edges.append((s,t))
		return edges
	except Exception as e:
		return []
 
 
def read_edges_from_file(edges_list_file,first_type = int, second_type = int):
	return read_pairs_from_file(edges_list_file,first_type = int, second_type = int)
 
 
def reverse_edges(edges_list_file,output_file = None,first_type = int, second_type = int):
	edges = read_edges_from_file(edges_list_file,first_type = first_type,second_type = second_type)
	new_edges = [ (v,u) for (u,v) in edges]
	if output_file:
		write_edges_to_file(new_edges,output_file)
	return new_edges
#reverse_edges("data/sx_stackoverflow/sx_stackoverflow_a2q.edges",output_file = "data/sx_stackoverflow/sx_stackoverflow_q2a.edges")
 
 
def read_dict_from_file(file_name,key_type = int, value_type = int):
	input_file = open(file_name,"r")
	d = {}
	for line in input_file.readlines():
		k,v = line.split()
		if (key_type is not None) and (value_type is not None):
			try:
				k=key_type(k)
				v=value_type(v)
				d[k] = v
			except Exception as e:
				print e 
	return d
 
 
def read_dict_from_csv(file_name,key_type = int,value_type = int,key_index = 0, value_index = 1):
	import pandas as pd
	df = pd.read_csv(file_name,sep = ",")
	d = {}
	for k,v in zip(df.iloc[:,key_index],df.iloc[:,value_index]):
		try:
			k = key_type(k)
			v = key_type(v)
			d[k] = v
		except Exception as e:
			pass
	return d
 
def read_dict_list_from_csv(file_name,key_type = int, value_type = int, key_index = 0, value_index = 1):
	import pandas as pd
	df = pd.read_csv(file_name,sep = ",")
	d = {}
	for k,v in zip(df.iloc[:,key_index],df.iloc[:,value_index]):
		k = key_type(k)
		v = key_type(v)
		if k in d:
			d[k] = d[k] + [v]
		else:
			d[k] = [v]
	return d
 
 
 
def switch_key_value_dict_list(d):
	new_d = {}
	for k,v in d.iteritems():
		if v in new_d:
			new_d[v] += [k]
		else:
			new_d[v] = [k]
	return new_d
 
def switch_key_value_dict_value(d):
	new_d = {}
	for k,v in d.iteritems():
		new_d[v] = k
	return new_d
 
 
 
def read_dict_pair_from_csv(file_name,key_type = int, value_type = int):
	import pandas as pd
	df = pd.read_csv(file_name,sep = ",")
	d = {}
	for k,v,days in zip(df.iloc[:,1],df.iloc[:,0],df.iloc[:,2]):
		k = key_type(k)
		v = value_type(v)
		if k in d:
			d[k].append((v,days))
		else:
			d[k] = [(v,days)]
	for k,v in d.iteritems():
		v = sorted(v,key = lambda x: x[1])
		d[k] =v
	return d 
 
def read_dict_pair_from_csv_2(file_name,key_type = int, value_type = int):
	import pandas as pd
	df = pd.read_csv(file_name,delim_whitespace = True)
	d = {}
	for k,v,simi in zip(df.iloc[:,0],df.iloc[:,1],df.iloc[:,2]):
		k = key_type(k)
		v = value_type(v)
		if k in d:
			d[k] = d[k] + [(v,simi)]
		else:
			d[k] = [(v,simi)]
	for k,v in d.iteritems():
		v = sorted(v,key = lambda x: x[1],reverse = True)
		d[k] =v
	return d