def extendR(targetSys, s, inputs, E, mqNum):
newRList = []
for i in range(len(inputs)):
newTrace = s.tws + [TimedWord(inputs[i], 0)]
element, mqNum = fillTableRow(newTrace, E, targetSys, mqNum)
newRList.append(element)
return newRList, mqNum
def getMinCtxList(complementRTA, upperGuard):
# 获得每个状态对应的连接状态 {"0":["0","1","2"]}
stateDict = {}
for s in complementRTA.states:
stateDict[s.stateName] = []
for t in complementRTA.trans:
if t.source == s.stateName:
if t.target not in stateDict[s.stateName]:
stateDict[s.stateName].append(t.target)
# 获得最短反例路径
ctxList = []
shortestPath = findShortestPath(stateDict, complementRTA.initState,
complementRTA.errorState)
if len(shortestPath) == 0:
pass
else:
# 计算最短反例
compareTrace = []
compareTrace += getStateTrace(complementRTA, shortestPath)
firstState = shortestPath[-1]
secondState = shortestPath[-2]
for tran in complementRTA.trans:
if tran.source == secondState and tran.target == firstState:
timeList = getTimeList(tran.guards, upperGuard)
# timeList = [getRandomTime(tran.guards, upperGuard, precision)]
for time in timeList:
tiw = TimedWord(tran.input, time)
tempTrace = compareTrace + [tiw]
ctxList.append(tempTrace)
break
return ctxList
def getTwsConnection(source, target, a, hypothesisRTA):
tw = None
for tran in hypothesisRTA.trans:
if tran.source == source and tran.target == target and tran.isPass(a):
tw = TimedWord(tran.input, tran.evidence)
break
return tw
def stwsTOtws(stws, symbolList):
tws = []
if not stws:
return []
else:
for stw in stws:
tw = TimedWord(symbolList[stw].input,
symbolList[stw].representation)
tws.append(tw)
return tws
def sampleGeneration(hypothesis, upperGuard, stateNum):
sample = []
length = math.ceil(abs(random.normalvariate(0, 2 * stateNum + 1)))
for i in range(length):
input = hypothesis.inputs[random.randint(0,
len(hypothesis.inputs) - 1)]
time = random.randint(0, upperGuard * 2 - 1) / 2
temp = TimedWord(input, time)
sample.append(temp)
return sample
def initSymbol(tws, input, upperGuard, sampleNum, targetSys, mqNum):
guard = timeInterval_upper.Guard("[0," + str(upperGuard) + ")")
evidences = {}
evidencesNum = list(set(np.random.uniform(0, upperGuard, sampleNum)))
for i in range(len(evidencesNum)):
evidencesNum[i] = evidencesNum[i]
evidencesNum.sort()
for i in evidencesNum:
trace = tws + [TimedWord(input, i)]
tempValue = TQs(trace, targetSys)
mqNum += 1
evidences[i] = tempValue
representation = np.random.choice(evidencesNum)
return SymbolTimedWord(input, guard, evidences, representation), mqNum
def getStateTrace(complementRTA, shortestPath):
trace = []
tempPath = shortestPath[:-1]
if len(tempPath) == 1:
return trace
else:
i = 0
while i < len(tempPath) - 1:
for tran in complementRTA.trans:
if tran.source == tempPath[i] and tran.target == tempPath[i +
1]:
time = getRandomTime(tran.guards)
tiw = TimedWord(tran.input, time)
trace.append(tiw)
break
i += 1
return trace
def dealCtx(table, ctx, inputs, targetSys, mqNum):
tws = ctx.tws
# 处理每个状态对应的最小tw序列
stateDict = {} # {elementId:repreList}
for s in table.S:
stateDict[s.elementId] = stwsTOtws(s.stws, table.symbolList)
# 处理table的所有element {elementId: realElement}
tableElement = {}
for s in table.S:
tableElement[s.elementId] = s
for r in table.R:
tableElement[r.elementId] = r
# 处理valueList对应的状态名ElementId
valueList_name_dict = {}
for s in table.S:
stateName = s.elementId
valueList_name_dict[makeStr(s.valueList)] = stateName
# 处理反例tw对应的符号和状态
symbolTups = [] # [(symbolId, elementId)]
elementId = 0
for i in tws:
symbols = tableElement[elementId].symbols
for symbol in symbols:
realSymbol = table.symbolList[symbol]
if realSymbol.input == i.input and realSymbol.guard.isInInterval(
i.time):
symbolId = symbol
# 找到elementId
stws = tableElement[elementId].stws + [symbolId]
for key, value in tableElement.items():
if value.stws == stws:
elementId = key
break
elementId = valueList_name_dict[makeStr(
tableElement[elementId].valueList)]
symbolTups.append((symbolId, elementId))
break
# 获得flag
state = symbolTups[-1][1]
tempTws = stateDict[state]
flag = TQs(tempTws, targetSys)
mqNum += 1
# breakPoint处理，即找到出错处
for i in range(len(tws) - 1, -1, -1):
# u = tws[:i]
a = tws[i]
v = tws[i + 1:]
repA = table.symbolList[symbolTups[i][0]]
twA = TimedWord(repA.input, repA.representation)
if i == 0:
tws1 = [] + [twA] + v
tws2 = [] + [a] + v
else:
tws1 = stateDict[symbolTups[i - 1][1]] + [twA] + v
tws2 = stateDict[symbolTups[i - 1][1]] + [a] + v
if TQs(tws1, targetSys) != flag:
mqNum += 1
table, mqNum = addE(v, table, targetSys, mqNum)
break
elif TQs(tws2, targetSys) != flag:
mqNum += 2
aSymbolId = symbolTups[i][0]
if i == 0:
trace = [] + [a] + v
else:
trace = stateDict[symbolTups[i - 1][1]] + [a] + v
value = TQs(trace, targetSys)
table.symbolList[aSymbolId].evidences[a.time] = value
### 处理兼容
# 获得对应要处理的elementId
if i == 0:
targetId = 0
else:
targetId = symbolTups[i - 1][1]
# 开始处理兼容性
if isEvComp(targetId, table):
table, mqNum = addE(v, table, targetSys, mqNum)
else:
while not isEvComp(targetId, table):
table = makeEvComp(targetId, table, inputs)
table, mqNum = addR(targetId, table, targetSys, mqNum)
break
return table, mqNum