def __init__(self, csv_list):
# the node are addresses
self.nodes = []
# edge two addresses in the distance between them
self.edges = []
location1 = 0
location2 = 0
for row in csv_list:
name = row[0]
street = row[1]
city = row[2]
state = row[3]
zip = row[4]
address = Address(street, city, state, zip)
self.nodes.append(address)
location2 = 0
# distances in the csv file begin here
for column in row[5:]:
try:
edge = Distance(column, self.nodes[location1], self.nodes[location2])
self.edges.append(edge)
location2 = location2 + 1
except IndexError:
pass
continue
location1 = location1 + 1
def dist_avg(ptdata,Ci, Cj):
# print('Ci',Ci)
# print('Cj',Cj)
if Ci==Cj:
return 0
n=len(ptdata)
ptsInClusti=[]
ptsInClustj=[]
for i in range(n):
if Ci==ptdata[i].clusterMark:
ptsInClusti.append(ptdata[i])
if Cj==ptdata[i].clusterMark:
ptsInClustj.append(ptdata[i])
# print('ptsInClusti',ptsInClusti)
# print('ptsInClustj',ptsInClustj)
leni=len(ptsInClusti)
lenj=len(ptsInClustj)
maxlen=max(leni,lenj)
sumij=0
for i in range(leni):
for j in range(lenj):
distij=Distance(ptsInClusti[i],ptsInClustj[j]).dis
sumij+=distij
avgdist=sumij/maxlen
# print('Ci,Cj簇间平均距离',avgdist)
return avgdist
def test_meatureDistance(self):
print("detect start")
ne = NobyEyes.NobyEyes()
dis = ne.meatureDistance()
# 腕からの距離計算する
dist = Distance.Distance()
dist.calcDistanceBetween(dis)
self.assertEqual("foo".upper(), "FOO")
def buttonClick(self):
# grab the input
value = float(self.ent_input.get())
lbl = self.inp_unit
# create a distance object
distance = Distance(value, lbl)
# convert it
lbl = self.outp_unit
converted = distance.convert(lbl)
# display to output
self.lbl_results.config(text=str(converted))
def parse_input_file(cities_list, distance_lookup):
f = open('distance.csv')
input_file = csv.reader(f)
for row in input_file:
columns_parsed = 0
city1 = ''
city2 = ''
distance = ''
#print row
if len(row) > 0:
for column in row:
#print column
if columns_parsed == 3:
break
elif len(column) > 0:
if (column.lower()
not in cities_list) and (not num_exist(column)):
cities_list.append(column.lower())
if columns_parsed == 0:
city1 = column.lower()
elif columns_parsed == 1:
city2 = column.lower()
elif columns_parsed == 2:
distance = column
columns_parsed += 1
distance_obj = Distance(city1, city2, distance)
if len(city1) > 0 and len(city2) > 0 and len(distance) > 0:
#print distance_obj
if not city1 in distance_lookup:
distance_lookup[city1] = [distance_obj]
else:
#print 'city1-'+city1
#print distance_lookup[city1]
distance_lookup[city1].append(distance_obj)
#print distance_lookup[city1]
if not city2 in distance_lookup:
distance_lookup[city2] = [distance_obj]
else:
#print 'city2'+city2
#print distance_lookup[city2]
distance_lookup[city2].append(distance_obj)
#print distance_lookup
#print cities_list
#print len(cities_list)
return distance_lookup
def closest_cross_pair(xlist, ylist, delta):
distObj = Distance.Distance()
length = int(len(xlist))
mid = xlist[length // 2][0]
# strip is a list of y sorted points built by finding all x-coords that exist
# within the boundries of the strip, ie mid - delta and mid + delta
strip = [x for x in ylist if mid - delta <= x[0] <= mid + delta]
index = 0
# constant 7*n time
for point in strip:
for i in range(1, 8):
if index + i < len(strip):
distObj.safeAddPoints(point, strip[index + i])
index += 1
return distObj
def main():
filename = sys.argv[1]
distObj = Distance.Distance()
plist = []
# make a list of tuples, where each entry in the list is a (x, y) tuple
with open(filename, 'r') as file:
for point in file:
p1 = int(point.strip().split(' ')[0])
p2 = int(point.strip().split(' ')[1])
plist.append((p1, p2))
# closest-pair returns a distance object, class def. found in Distance.py
final = closest_pair(plist, distObj)
print final.getDistance()
for i in final.getPoints():
print(i)
return
def AIC(X,Y,dtype="default"): YC=set(Y) K=len(YC) S=0 for i in YC: CI=[X[j] for j in range(len(Y)) if Y[j]==i] mui=getAvgEx(CI) for j in CI: if dtype=="default": di=Distance(j,mui) dij=di.euclidean_distance() else: dij=eval(dtype)(j,mui) S+=dij FT=S R=len(X) D=len(X[0]) AC=FT+4*K*D AC=math.log(AC) return AC
def main():
filename = sys.argv[1]
distObj = Distance.Distance()
plist = []
# make a list of tuples, where each entry in the list is a (x, y) tuple
with open(filename, 'r') as file:
for point in file:
p1 = int(point.strip().split(' ')[0])
p2 = int(point.strip().split(' ')[1])
plist.append((p1, p2))
# Do all sorting work up front O(n) complexity
xsorted = sort_rands_on_x(plist)
ysorted = sort_rands_on_y(plist)
# closest-pair returns a distance object, class def found in Distance.py
final = closest_pair(xsorted, ysorted, distObj)
print final.getDistance()
for i in final.getPoints():
print(i)
return
def getD2starWeightSim(self,seqA,seqB,k,r,flag,sequences,kmersetdic,weight,kmer_pro):
dis=Distance.Distance()
sim=dis.getD2StarWeight(seqA,seqB,k,r,flag,sequences,kmersetdic,weight,kmer_pro)
return 1/sim
def getMulD2starWeightSim2(self,feaA,feaB,weight):
dis=Distance.Distance()
sim=dis.getMulD2StarWeight2(feaA,feaB,weight)
return 1/sim
def getMulD2starWeightSim(self,seqA,seqB,kstart,kend,r,flag,sequences,weight,kmer_pro):
dis=Distance.Distance()
sim=dis.getMulD2StarWeight(seqA,seqB,kstart,kend,r,flag,sequences,weight,kmer_pro)
return 1/sim
def getEuSim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.EuD(seqA,seqB,k)
return 1/sim
def getD2sSim(self,seqA,seqB,k,r,flag,kmersetdic,kmer_pro):
dis=Distance.Distance()
sim=dis.getD2S(seqA,seqB,k,r,flag,kmersetdic,kmer_pro)
return 1/sim
def getD2WeightSim(self,seqA,seqB,k,sequences,weight):
dis=Distance.Distance()
sim=dis.getD2Weight(seqA,seqB,k,sequences,weight)
return 1/sim
#Created by Alaa Abdel Latif on 25/08/2016.
#Copyright 2016 Alaa Abdel Latif. All rights reserved.
import sys, time
import gc
from numpy import random
import numpy as np
import linecache
from itertools import izip, imap, islice, product
import operator
from collections import OrderedDict
from scipy import stats
import Aptamers, Distance, utils
from utils import apt_loopFinder
D = Distance.Distance()
Apt = Aptamers.Aptamers()
#append path for ViennaRNA module
sys.path.append(
"/local/data/public/aaaa3/Simulations/ViennaRNA/lib/python2.7/site-packages/"
)
import RNA
from RNA import fold, bp_distance
## NEED TO CHANGE SAMPLING FOR SELECTION TO BE WEIGHTED BY COUNT OF EACH UNIQUE SEQ
class Selection:
#This function takes an empty selected pool, aptamer sequence structure and loop,
#number of target binding sites, the alphabet set of the molecule, length,
#total sequence number and stringency factor and returns full selected pool
#their Lavenshtein distance
def getMulD2WeightSim(self,seqA,seqB,kstart,kend,sequences,weight):
dis=Distance.Distance()
sim=dis.getMulD2Weight(seqA,seqB,kstart,kend,sequences,weight)
return 1/sim
def __init__(self, calibratevalue=405):
self.caldist = calibratevalue
self.pos = 0
self.stepper = Stepper.Stepper()
self.dist = Distance.Distance()
import tkinter as tk
from Distance import *
# Options list for the dropdown menus to select units
OPTIONS = Distance(0, None).getOptions()
class MainWindow(tk.Frame):
def __init__(self, parent):
super(MainWindow, self).__init__(parent)
self.inp_unit = '' # stores current input unit dropdown menu choice
self.outp_unit = '' # stores current output unit dropdown menu choice
# Create a frame to organize all the widgets associated with input values
frm_input = tk.Frame(self, height=100)
master = frm_input
# Create text entry box
self.ent_input = tk.Entry(master, width=10)
self.ent_input.pack()
# Create unit selection drop down menu for input unit
input_variable = tk.StringVar(master)
input_variable.set(' ') # Default option shown in menu
self.unit_input = tk.OptionMenu(master,
input_variable,
*OPTIONS,
command=self.updateInpUnit)
self.unit_input.pack()
def initializeNetwork(self, network):
assert (type(network) == CS4412Graph)
self.network = network
self.distance = Distance()
def getpccSim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.pcc(seqA,seqB,k)
return 1/sim
def getKLDSim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.KLD(seqA,seqB,k)
return 1/sim
def getmanhattanSim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.manhattan(seqA,seqB,k)
return 1/sim
def add_edge(self, n1, n2, e):
distance = Distance(n1, n2, e)
self.edges.append(distance)
def getcosineSim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.cosine(seqA,seqB,k)
return 1/sim
def getMulD2WeightSim3Lis(self,feaA,feaB,weight):
dis=Distance.Distance()
sim=dis.getMulD2Weight3Lis(feaA,feaB,weight)
return 1/sim
lnode.GetNext()) != 0 else 0
return float(num_div_edge) / total_edge
if __name__ == '__main__':
rmer = 10
lmer = 20
# x = SdbConstruction(rmer,lmer)
# x.quick_test(x)
if __name__ == '__main__0':
lmer = 6
rmer = 5
pdb = PDBn(lmer, rmer)
# pdb.__initialize__(lmer, rmer)
distance = Distance.Distance()
read_class = ReadClass.SingleEnd()
# pdb.AddRead(read_class,'SFSAAFFAASSAADDAABAAAAAHFIEJFJWIHAFJWHFIWJFJAKSDNCMOQWIFJ')
# pdb.AddRead(read_class,'BAAAAAHFIEJFJWIHRFJWHFRWJFJAKSDNCMOQWIFJ')
# pdb.AddRead(read_class,'BAAAAAHFIEJFJWIHAFJWHFIWJFJAKSDNCMOQWI')
# pdb.AddRead(read_class,'BAAAAAHFIEJFJMIMAFJWHFIWJFJAKSDNCMOQGKFJ')
# pdb.AddRead(read_class,'DKKSSJJFFLLSSJAHABAAAAAHFIEKFJWIMAFJWHFIWJFJAKSDNCMOQGKFJ')
# pdb.AddRead(read_class,'BAAAAAHFIEKFJWIMAFJWHFIWJFJAKSDNCMOQWIKJ')
pdb.AddRead(read_class, 'PPPQXQPPWWWQQWWAABBAARRGTTATTEEFEAA')
pdb.AddRead(read_class, 'PPPQQQPPWWWQQWWAABBAARRGTTATTXEFEAA')
pdb.AddRead(read_class, 'PPPQQQPPWWWQQWWAABBAXRRGTTATTEEFEAA')
pdb.AddRead(read_class, 'PPPQQQPPWWXQQWWAABBAARRGTTATTEEFEAA')
# pdb.AddRead(read_class,'BBAARRGTQATTEEFEAAendoftheline')
# pdb.AddRead(read_class,'ATTEEFEAAendoftheline')
pdb.AddRead(read_class, 'ATTEEFEAAendoftheline')
pdb.AddRead(read_class, 'OOIIUXUUYYUUJJKAABBAARRGGAATTEEFFAA')
def getchebyshevSim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.chebyshev(seqA,seqB,k)
return 1/sim
best_ind = tools.selBest(pop, 1)[0]
# print("Best individual is %s, %s" % (best_ind, best_ind.fitness.values))
tp=sum(best_ind)
for i in range(len(best_ind)):
best_ind[i]=best_ind[i]/tp
return best_ind
# file= open('test.txt', 'w')
# for w in best_ind:
# file.write(str(w))
# file.write('\n')
# file.close()
if __name__ == "__main__":
dis =Distance.Distance()
print("GA---------------------------")
## 归一化处理
w=main()
su=sum(w)
for i in range(len(w)):
w[i]=w[i]/su
print(w)
print(len(w))
sim=[]
## 计算权重 结合遗传算法
sim=[]
inner2=[]
inner3=[]
inner4=[]
inner5=[]
def getD2Sim(self,seqA,seqB,k):
dis=Distance.Distance()
sim=dis.getD2(seqA,seqB,k)
return 1/sim
