如果我们有：
# -*- coding: utf-8 -*-
import networkx as nx
import random
import matplotlib.pyplot as plt
from operator import itemgetter
NewG=nx.Graph() #this is going to be a connected graph
num_node=5
num_edges=(num_node*(num_node-1))/2
RTrange=10 #release time range
FlowRange=3
nodelist=[]
for i in range(0,num_node):
nodelist.append(i)
NewG.add_nodes_from(nodelist)
for i in range(0,num_node):
for j in range(0,num_node):
if i<>j:
if not NewG.has_edge(i,j) and not NewG.has_edge(j,i):
NewG.add_edge(i,j,weight=1.0)
print (" the new graph have %d number of nodes and %d edges" %
(NewG.number_of_nodes(),NewG.number_of_edges()))
pos=nx.spring_layout(NewG)
colors=range(num_edges)
nx.draw(NewG,pos,node_color='#A0CBE2',edge_color='#A0BF11',width=4,
edge_cmap=plt.cm.Blues,with_labels=True)
plt.savefig("edge_colormap.png") # save as png
plt.show() # display
runs=250
num_pack=10
# ------------begining of mincut function-------
def GraphMincut(G,source,sink,mylist,queue,t,removeEdge):
pointer=queue.head
addEdge=[]
if removeEdge: # any previous unavalable edges need to be
#linked back as long as it hasn't been added to mylist
for x in removeEdge:
a=x[0]
b=x[1]
if (a,b) not in mylist and (b,a) not in mylist:
if not G.has_edge(a,b):
e=(a,b)
addEdge.append(e)
while removeEdge:
removeEdge.pop()
while pointer.time<t and pointer.next<>None:
pointer=pointer.next
if pointer.time==t:
if pointer.data:
for x in pointer.data:
removeEdge.append(x)
if addEdge:
for x in addEdge:
if not G.has_edge(x[0],x[1]):
G.add_edge(x[0],x[1],weight=1.0)
if removeEdge:
G.remove_edges_from(removeEdge)
print "source and sink",source,sink
if nx.edge_connectivity(G,source,sink)==0:
return mylist
else:
MyEdgeList=[]
MyNodeList=[]
MyEdgeList=sorted(nx.minimum_edge_cut(G,source,sink))
MyNodeList=nx.minimum_node_cut(G,source,sink)
print("edge list:",str(MyEdgeList))
print("node list:",str(MyNodeList))
temp=[]
for j in MyEdgeList:
print"j weight:",G[j[0]][j[1]]['weight']
temp.append(G[j[0]][j[1]]['weight'])
v=min(temp)
print "v:",v
new_sink=None
new_source=None
for j in MyEdgeList:
print "J:",j
print"weight:",G[j[0]][j[1]]['weight']
if v==G[j[0]][j[1]]['weight']:
if j[0] in MyNodeList or j[1] in MyNodeList or (source in (j[0],j[1]) and sink in (j[0],j[1])):
print"j in if 1",j
if (source in (j[0],j[1])) or (sink in (j[0],j[1])):
mylist.append((j[0],j[1]))
break
else:
print("j[1]newsourec",j[1])
print("j[0]newsink",j[0])
new_source=j[1]
new_sink=j[0]
mylist.append((j[0],j[1]))
G.remove_edges_from(MyEdgeList)
mylist=GraphMincut(G,new_source,sink,mylist,queue,
t+1,removeEdge)
mylist=GraphMincut(G,source,new_sink,mylist,queue,
t+1,removeEdge)
if source in (j[0],j[1]) and sink in (j[0],j[1]):
return mylist
for i in MyNodeList:
print"i ",i
print"j[0]j[1]",(j[0],j[1])
if i in (j[0],j[1]):
if source in (j[0],j[1]):
new_source=i
new_sink=sink
break
else:
new_sink=i
new_source=source
break
G.remove_edges_from(MyEdgeList)
print"before call --new source and sink:",new_source,new_sink
mylist=GraphMincut(G,new_source,new_sink,mylist,queue,t+1,removeEdge)
return mylist
# ------------------end mincut function------------------
#-------------------packet generator -------------------
def GeneratePacket(source):
Packet={}
Packet['source']=source
sink_choice=nodelist
sink_choice.remove(source)
Packet['sink']= random.choice(sink_choice)
nodelist.append(source)
nodelist.sort()
Packet['weight']=1.0 #random.randrange(2,10)
Packet['computation_time_MC']=0 #initialized Time To Serve variable
Packet['MC_path']=[]
Packet['release_time']=random.randrange(0,RTrange)
Packet['rescheduledTime']=0 # to count the number of times it was
#rescheduled due to unavailable edge at release time
Packet['flow']=random.randrange(1,FlowRange)
return Packet
#-------------------End packet generator -----------------
def Rearrange_Path(path,s):
newpath=[]
length=path.__len__()
for i in range(0,length):
temp=s
for (a,b) in path:
if temp == a:
s=b
newpath.append((a,b))
path.remove((a,b))
else:
if temp==b:
s=a
newpath.append((b,a))
path.remove((a,b))
return newpath
# ------------------ Print packet details -----------------
def ShowPacket(Packet,i):
print "Packet %d has :" %i
print "source :",Packet['source'], "destination :", Packet['sink']
print "release time = :",Packet['release_time']
print "number of flows =",Packet['flow']
print "MC path :",Packet['MC_path']
print "computation time is :",Packet['computation_time_MC']
print "-"*20
# ------------------ End procedure ---------------
# ------------------list classes -----------
class Node(object):
def __init__(self, prev, next):
self.data = []
self.prev = prev
self.next = next
self.time=0
self.packetID=[]
class DoubleList(object):
head = None
tail = None
def __init__(self):
self.head=None
def size(self):
current = self.head
count = 0
while current != None:
count = count + 1
current = current.next
return count
def append_newNode(self, data,position):
new_node = Node( None, None)
if self.head is None:
self.head = self.tail = new_node
new_node.data.append(data)
new_node.time=position
else:
new_node.prev = self.tail
new_node.next = None
self.tail.next = new_node
self.tail = new_node
new_node.time=position
new_node.data.append(data)
def append_packet(self, pID,Rtime):
new_node = Node( None, None)
if self.head is None:
self.head = self.tail = new_node
new_node.packetID.append(pID)
new_node.time=Rtime
else:
new_node.prev = self.tail
new_node.next = None
self.tail.next = new_node
self.tail = new_node
new_node.packetID.append(pID)
new_node.time=Rtime
def append_MiddleNode(self,pID,edge,Rtime,top,bottom):
new_node = Node( None, None)
new_node.prev=top
new_node.next=bottom
top.next=new_node
bottom.prev=new_node
if edge:
new_node.data.append(edge)
new_node.time=Rtime
if pID:
new_node.packetID.append(pID)
def show_all(self):
current_node=self.head
print "Show all scheduled items in event queue :"
while current_node is not None:
print current_node.time , current_node.packetID,
str(current_node.data)
current_node = current_node.next
print "*"*50
# ------------------begin simulation -------------
with open ("resultFile.csv","w") as RF:
RF.write(str(date))
RF.write("\n ")
RF.write("run#,Mean WT MC,Mean WT SPF,Mean SlowD MC, Mean SlowD SPF, Mean THr MC,Mean THr SPF")
RF.write("\n")
with open ("Result.csv","w") as DF: #contains detailed results
DF.write(str(date))
DF.write("\n")
DF.write("run#,original RT, Rescheduled T, current RT, source, sink")
DF.write(",Computation T,#of flows, Start, Finish,Wait \n")
for r in range(0,runs): #simulation run r times
with open ("resultFile.csv","a") as RF:
with open ("Result.csv","a") as DF: #contains detailed results
Packets=[]
for i in range(0,num_pack):#create random packets for the whole
# network
Packets.append({})
packet_Source=random.randrange(0,num_node)
Packets[i]=GeneratePacket(packet_Source)
ShowPacket(Packets[i],i)
# sort packets minimum release time first
Packets.sort(key=itemgetter('release_time'))
print "Packets after sorting by earlist release time -----"
for i in range(0,num_pack):
ShowPacket(Packets[i],i)
# ----- create queue event for (MC)-------
EventQueue = DoubleList()
# initilize statistics parameters
Mean_wait_t_MC=0
Mean_slowdown_MC=0
Mean_Throughput_MC=0
MC_delay_rate=0
MCThroughput=0
MC_slowdown=0
#---inser packets in order in my eventQueue for MC ------------
for i in range(0,num_pack):
R=int(Packets[i]['release_time'])
if EventQueue.size()==0:
EventQueue.append_packet(i,R)
EventQueue.show_all()
else:
current=EventQueue.head
appended= False
for n in range(0,EventQueue.size()):
if current.time==R:
current.packetID.append(i)
EventQueue.show_all()
appended= True
break
else:
current=current.next
if appended==False:
EventQueue.append_packet(i,R)
EventQueue.show_all()
# ---------------------------------
current_Packet=[]
Time_pointer=EventQueue.head
counter=num_pack
while (counter > 0):
if not current_Packet:
while not Time_pointer.packetID and Time_pointer.next<>None:
Time_pointer=Time_pointer.next
current_Packet=Time_pointer.packetID
while current_Packet:
myGraph=nx.Graph()
print"mygraph..initialized"
nx.draw(myGraph)
plt.show(myGraph)
myGraph=NewG.copy()
print"mygraph..after copy"
nx.draw(myGraph)
plt.show(myGraph)
packet_path=[]
x=int(Packets[current_Packet[0]]['source'])
y=int(Packets[current_Packet[0]]['sink'])
ReleaseT=int(Packets[current_Packet[0]]['release_time'])
removeEdge=[]
# here we get the path from Mincut function
GraphMincut(myGraph,x,y,packet_path,EventQueue,ReleaseT,removeEdge)
packet_path=Rearrange_Path(packet_path,x)
p=current_Packet[0]
# incase the packet path was empty list due to unavailable edges at this time
# reschedule the flow by delaying it one time unit
if not packet_path:
print "no available edges at this time release.. delay one time unit"
Packets[p]['release_time']+=1
print "p=",p
R=int(Packets[p]['release_time'])
Packets[p]['rescheduledTime']+=1
current=EventQueue.head
appended= False
for n in range(0,EventQueue.size()):
if current.time==R:
current.packetID.append(p)
current.packetID.sort()
current_Packet.remove(p)
EventQueue.show_all()
appended= True
break
else:
if current.time<R and current.next<> None:
current=current.next
if current.time>R:
EventQueue.append_MiddleNode(p,[],R,current.prev,current)
current_Packet.remove(p)
EventQueue.show_all()
appended= True
break
if appended==False:
EventQueue.append_packet(p,R)
EventQueue.show_all()
current_Packet.remove(p)
break
length= packet_path.__len__()
print"path:",packet_path
print"length: ",length
flow=int(Packets[p]['flow'])
Packets[p]['computation_time_MC']=length+flow-1
Packets[p]['MC_path']=packet_path
original_RT=ReleaseT-int(Packets[p]['rescheduledTime'])
DF.write(" %s," %str(r))
DF.write(" %s," %str(original_RT))
DF.write(" %s," %str(Packets[p]['rescheduledTime']))
DF.write(" %s," %str(Packets[p]['release_time']))
DF.write(" %s," %str(Packets[current_Packet[0]] ['source']))
DF.write(" %s," %str(Packets[current_Packet[0]]['sink']))
DF.write(" %s," %str(length))
DF.write(" %s," %str(flow))
#initilize time variables for MC
Finish_time=0
Start_time=ReleaseT #just to make sure it doesn't start
# b4 it is released
current=EventQueue.head
start= False
counter -=1
end=False
while current.time <Time_pointer.time:
current=current.next
#----begin scheduling events for MC path --------
for i in range(0,flow): # loop to schedule every flow
position=ReleaseT +i
if current.time<>position:
current=EventQueue.head
while current.time <position and current.next<>None:
current=current.next
for j in packet_path:
for k in range(0,EventQueue.size()):
if position==current.time:
a=j[0]
b=j[1]
if (a,b) not in current.data and (b,a)not in current.data:
current.data.append(j)
EventQueue.show_all()
position+=1
if start==False:
start=True
Start_time=current.time
DF.write(" %s,",%str(Start_time))
if current.next <> None:
current=current.next
else:
end=True
break
else:
if current.next==None:
position+=1
EventQueue.append_newNode(j,position)
current=current.next
end=True
break
current=current.next
position+=1
else:
if (position<current.time):
EventQueue.append_MiddleNode([],j,position,current.prev,current)
EventQueue.show_all()
position+=1
if start==False:
start=True
Start_time=current.time
DF.write(" %s,",%str(Start_time))
break
if (position >current.time):
EventQueue.append_newNode(j,position)
EventQueue.show_all()
position+=1
if start==False:
start=True
Start_time=current.time
DF.write(" %s," %str(Start_time))
current=current.next
end=True
break
if end==False:
current=current.prev
Calculate_TT= length + flow -1 # Calculate travel time
#is used to measure travel time between nodes
print "current time is=",current.time
Finish_time=current.time+1
MCThroughput =MCThroughput + (Finish_time - original_RT)
Wait= (Finish_time - original_RT - Calculate_TT)
MC_delay_rate= MC_delay_rate+ Wait
MC_slowdown= MC_slowdown + ((Finish_time -
original_RT)/Calculate_TT)
DF.write(" %s," %str(Finish_time))
DF.write(" %s" %str(Wait))
DF.write("\n ")
print " Start time is ", Start_time
print "Finish time is", Finish_time
print "Computation time is ", Calculate_TT
print " wait time is ",Wait
# now we need to put back the time of release and reschedule to their
#original state to be used again by SPF scheduling (later step)
Packets[p]['rescheduledTime']=0
Packets[p]['release_time']=original_RT
current_Packet.remove(current_Packet[0])
if not Time_pointer.packetID:
for g in range(0,EventQueue.size()):
if not Time_pointer.packetID and
Time_pointer.next<>None:
Time_pointer=Time_pointer.next
else:
break
#------------end scheduling events for MC path
Mean_wait_t_MC= float(MC_delay_rate)/ num_pack
Mean_slowdown_MC= float(MC_slowdown)/num_pack
Mean_Throughput_MC= float(MCThroughput) / num_pack
RF.write(" %s," %str(r))
RF.write(" %s," %str(Mean_wait_t_MC))
RF.write(" %s," %str(Mean_slowdown_MC))
RF.write(" %s," %str(Mean_Throughput_MC) )
RF.write("\n")
del EventQueue
- 如果给定键的数组为空，则应返回0.
- 如果给定键的属性不是数组，则应返回0.
- 如果给定键没有属性，则应返回0.
我正在尝试使用函数getAverageOfElementsAtProperty（obj，'key'）获取属性（键）的元素的平均值。我管理了除上述3点之外的那部分。
我试过了：
var obj = {
key: [1000, 10, 50, 10]
};
但我不确定使用三个还是操作是正确的举动......
答案 0 :(得分：2)
您可以检查多种条件
if (
typeof obj === 'object' && // you have an object
'key' in object && // it contains a "key"
Array.isArray( obj['key'] ) // it is an array
)
答案 1 :(得分：0)
因此，对于您提到的每个条件，可以按照以下方式完成
如果给定键的数组为空，则应返回0
obj.key.length === 0如果给定键的属性不是数组，则应返回0.
!Array.isArray(obj[key])如果给定键上没有属性，则应返回0.
!obj.hasOwnProperty("key")。
您可以直接检查falsy值以检查是否存在。另外，使用Array.isArray函数检查值是否为数组，然后检查数组的长度，使用length属性。
if(!obj.hasOwnProperty("key") || !Array.isArray(obj[key]) || obj.key.length === 0)){
return 0;
}
答案 2 :(得分：0)
if (obj[key].constructor != Array || ...为obj[key]，则 undefined会抛出错误，因为您将访问constructor undefined obj[key]错误。您需要做的是检查值if(obj[key] !== undefined || obj[key].constructor != Array)
return 0;
是否存在，然后它是否是这样的数组：
or 一般情况下： ||（check0 || check1 || ... || checkN）运算符将在第一次有效检查后停止检查（评估）。考虑checki，如果true为checki+1 ... checkN，那么var n = 5;
if(n == 5 || console.log("Here 1"))
;
n = 4;
if(n == 5 || console.log("Here 2"))
;根本不会被评估。因为只有一次有效检查就足够了。这是一个例子：
Here 1
正如您所看到的，console.log("Here 1")永远不会被删除，因为永远无法访问代码export class QuestionBase<T>{
...
modelKey:string;
...
}
。
答案 3 :(得分：0)
我喜欢将if分解为它需要实现的业务逻辑。当我稍后再回到它时，我发现它更容易理解。所以我会这样做
if (!obj.hasOwnProperty(key)) return 0; // If there is no property at the given key
if (!Array.isArray(obj[key])) return 0; // If the property at the given key is not an array
if (obj[key].length === 0) return 0; // If the array at the given key is empty
// add this point we know there is a valid array
答案 4 :(得分：0)
如果密钥存在，您可以首先检查 [1] ，然后检查 [2] （如果是数组），然后 [3] < / strong>如果它不是空的。
顺序重要：由于implementation，如果它在第一个条件下评估为true，它会跳过nexts检查（然后，你可以放心地假设密钥存在，它是一个数组等等......）
(typeof obj[key] === 'undefined')<小时/> 注意此处不需要
Array.isArray(undefined) === false，因为.container[data-direction="reverse"] .pane[style*="display: none"]{
animation:SlideOutToRight 1s ease;
}
.container[data-direction="forward"] .pane[style*="display: none"]{
animation:SlideOutToLeft 1s ease;
}
（检查Realm Documentation），因此，您可以跳过此检查。