def testGloballyRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('[]_ts:(1, inf) pred1', preds),
MTL.Global), printFail(1)
printPass(1)
assert isinstance(
MTLE.parse_mtl(
'[]_ts:(1, 100) G_ts:(1, 100) globally_ts:(1, 100) (pred1 && pred2)',
preds), MTL.Global), printFail(2)
printPass(2)
assert isinstance(
MTLE.parse_mtl(
'[]_ts:(1, 100) []_ts:(5, 50) G_ts:(25, 35) []_ts:(27, 30) pred1',
preds), MTL.Global), printFail(3)
printPass(3)
assert isinstance(MTLE.parse_mtl('G_ts:(1, 1000) (pred1 && pred2)', preds),
MTL.Global), printFail(4)
printPass(4)
assert isinstance(
MTLE.parse_mtl('[]_ts:(25, 3000) (pred2 | pred3)', preds),
MTL.Global), printFail(5)
printPass(5)
def testFinallyRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('<>_ts:(1, inf) pred1', preds),
MTL.Finally), printFail(1)
printPass(1)
assert isinstance(
MTLE.parse_mtl(
'<>_ts:(1, 100) (finally_ts:(1.0, 200) (pred1 && pred2))', preds),
MTL.Finally), printFail(2)
printPass(2)
assert isinstance(
MTLE.parse_mtl(
'<>_ts:(1, 100) <>_ts:(5, 50) F_ts:(25, 35) <>_ts:(27, 30) pred1',
preds), MTL.Finally), printFail(3)
printPass(3)
assert isinstance(MTLE.parse_mtl('F_ts:(1, 1000) (pred1 && pred2)', preds),
MTL.Finally), printFail(4)
printPass(4)
assert isinstance(
MTLE.parse_mtl('<>_ts:(25, 3000) (pred2 | pred3)', preds),
MTL.Finally), printFail(5)
printPass(5)
def testAndRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('pred1 && pred1', preds), MTL.And), printFail(1)
printPass(1)
assert isinstance(MTLE.parse_mtl('pred1 & pred1 && pred1 /\ pred1 and pred1', preds), MTL.And), printFail(2)
printPass(2)
assert isinstance(MTLE.parse_mtl('pred1 && !pred2 && pred3', preds), MTL.And), printFail(3)
printPass(3)
assert isinstance(MTLE.parse_mtl('pred1 || pred2 && pred3', preds), MTL.And), printFail(4)
printPass(4)
assert isinstance(MTLE.parse_mtl('pred2 | pred3 && pred2 | pred2 && pred1', preds), MTL.And), printFail(5)
printPass(5)
def testNegationRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('!pred1', preds), MTL.Not), printFail(1)
printPass(1)
assert isinstance(MTLE.parse_mtl('!!(pred2)', preds), MTL.Not), printFail(2)
printPass(2)
assert isinstance(MTLE.parse_mtl('!pred3', preds), MTL.Not), printFail(3)
printPass(3)
assert isinstance(MTLE.parse_mtl('!(pred1 and pred2)', preds), MTL.Not), printFail(4)
printPass(4)
assert isinstance(MTLE.parse_mtl('!!!!!(pred1 and pred2 and pred3)', preds), MTL.Not), printFail(5)
printPass(5)
def testNextRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('next pred1', preds),
MTL.Next), printFail(1)
printPass(1)
assert isinstance(MTLE.parse_mtl('next X pred1', preds),
MTL.Next), printFail(2)
printPass(2)
assert isinstance(MTLE.parse_mtl('next (pred1 && pred2)', preds),
MTL.Next), printFail(3)
printPass(3)
assert isinstance(MTLE.parse_mtl('X (pred1 && X X X pred3)', preds),
MTL.Next), printFail(4)
printPass(4)
assert isinstance(MTLE.parse_mtl('X X X X X X X X (pred1 & pred2)', preds),
MTL.Next), printFail(5)
printPass(5)
def testOrRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('pred1 || pred1', preds),
MTL.Or), printFail(1)
printPass(1)
assert isinstance(
MTLE.parse_mtl('pred1 | pred1 || pred1 \/ pred1 or pred1', preds),
MTL.Or), printFail(2)
printPass(2)
assert isinstance(MTLE.parse_mtl('pred1 or !pred2 || pred3', preds),
MTL.Or), printFail(3)
printPass(3)
assert isinstance(MTLE.parse_mtl('pred1 and pred2 or pred3', preds),
MTL.Or), printFail(4)
printPass(4)
assert isinstance(
MTLE.parse_mtl('pred2 and pred3 & pred2 and pred2 or pred1', preds),
MTL.Or), printFail(5)
printPass(5)
def testImpliesRule():
preds = {}
preds['pred1'] = MTL.Predicate('pred1', 1, 2)
preds['pred2'] = MTL.Predicate('pred2', 2, 4)
preds['pred3'] = MTL.Predicate('pred3', 4, 8)
assert isinstance(MTLE.parse_mtl('pred1 -> pred1', preds),
MTL.Or), printFail(1)
printPass(1)
assert isinstance(MTLE.parse_mtl('(pred1 && pred2) -> TRUE', preds),
MTL.Or), printFail(2)
printPass(2)
assert isinstance(MTLE.parse_mtl('pred1 -> pred2 -> pred3', preds),
MTL.Or), printFail(3)
printPass(3)
assert isinstance(
MTLE.parse_mtl('pred1 -> (pred1 && pred2 && pred3)', preds),
MTL.Or), printFail(4)
printPass(4)
assert isinstance(
MTLE.parse_mtl('pred1 -> pred2 -> (pred1 || pred2) -> TRUE', preds),
MTL.Or), printFail(5)
printPass(5)
import tltk_mtl as MTL
import tltk_mtl_ext as MTLE
import numpy as np
na0 = MTL.Predicate('pred0', float(25), float(30))
na1 = MTL.Predicate('pred1', float(1), float(-1.6))
na2 = MTL.Predicate('pred2', float(-1), float(1.4))
na3 = MTL.Predicate('pred3', float(-1), float(2.3))
predicates = {}
predicates['pred0'] = na0
predicates['pred1'] = na1
predicates['pred2'] = na2
predicates['pred3'] = na3
phi = MTLE.parse_mtl(
'G_ts:(0, inf) (pred0) && G_ts:(0, inf)((pred1 && (X pred2)) -> (X (pred3))) && F_ts:(0, 7) (pred1 && X pred2)',
predicates)
traces = {}
traces['pred0'] = np.array([1, 2, 2, 5, 3],
dtype=np.float64) # traces has to be 64
traces['pred1'] = np.array([1, 2, 2, 5, 3],
dtype=np.float64) # traces has to be 64
traces['pred2'] = np.array([1, 2, 2, 5, 3],
dtype=np.float64) # traces has to be 64
traces['pred3'] = np.array([1, 2, 2, 5, 3],
dtype=np.float64) # traces has to be 64
time_data = np.arange(1, 2, 0.2, dtype=np.float32)
import sys
import os
import tltk_mtl as MTL
import tltk_mtl_ext as MTLE
import numpy as np
import time
mode = 'cpu_threaded'
preds = {}
Ar1 = -1
br1 = -160
preds['data1'] = MTL.Predicate('data1', Ar1, br1, mode)
Ar2 = -1
br2 = -4500
preds['data2'] = MTL.Predicate('data2', Ar2, br2, mode)
# root = F(data1 /\ data2)
root = MTLE.parse_mtl('!(F_ts:(0, inf)(data1 && data2))', preds, mode)
traces = {}
traces['data1'] = np.ones(10, dtype=np.float32) * 5
traces['data2'] = np.ones(10, dtype=np.float32) * 10
time_data = np.arange(1, 10 + 1, dtype=np.float32)
t0 = time.time()
root.eval_interval(traces, time_data)
t1 = time.time()
list_range = (2**i for i in range(10,15))
mode = 'cpu_threaded'
x_length = []
y_time = []
for i in list_range:
Ar3 = -1
br3 = -160
Ar4 = 1
br4 = 4500
preds = {}
preds['data1'] = MTL.Predicate('data1',Ar3,br3)
traces = {'data1': np.ones(i,dtype=np.float32)*5}
time_stamps = np.arange(1, i + 1,dtype=np.float32)
root = MTLE.parse_mtl('!(F_ts:(0, inf) data1)', preds, mode)
t0 = time.time()
root.eval_interval(traces, time_stamps)
t1 = time.time()
x_length.append(i)
y_time.append(t1-t0)
print("TLTk" ,"| phi_b1","| Mode:" ,mode,'\t| Samples:', "{:,}".format(i), '\t| Time: ', '%.4f'%(t1 - t0), ' \t| robustness', root.robustness)
del traces
import sys
import tltk_mtl as MTL
import tltk_mtl_ext as MTLE
import numpy as np
Ar3 = -1
br3 = -160
Ar4 = 1
br4 = 4500
preds = {}
preds['speed'] = MTL.Predicate('speed', Ar3, br3)
preds['rpm'] = MTL.Predicate('rpm', Ar4, br4)
root = MTLE.parse_mtl('!(F_ts:(0, 100) (speed && rpm))', preds)
traces = {}
traces['speed'] = np.array([10,20,30,40,50], dtype=np.float64)
traces['rpm'] = np.array([10,20,30,40,50], dtype=np.float64)
time_data = np.arange(1, 10, 2, dtype=np.float32)
root.eval_interval(traces, time_data)
print(root.robustness)
import sys
import tltk_mtl as MTL
import numpy as np
Ar3 = -1
br3 = -160
Ar4 = 1
br4 = 4500
pred3 = MTL.Predicate('speed', Ar3, br3)
pred4 = MTL.Predicate('rpm', Ar4, br4)
root = MTL.Not(MTL.Finally(0, 100, MTL.And(pred3, pred4)))
traces = {}
traces['speed'] = np.array([10, 20, 30, 40, 50], dtype=np.float64)
traces['rpm'] = np.array([10, 20, 30, 40, 50], dtype=np.float64)
time_data = np.arange(1, 10, 2, dtype=np.float32)
root.eval_interval(traces, time_data)
print(root.robustness)
import sys
import os
import tltk_mtl as MTL
import numpy as np
import time
mode = 'cpu_threaded'
Ar1 = -1
br1 = -160
r1 = MTL.Predicate('data1', Ar1, br1, mode)
Ar2 = -1
br2 = -4500
r2 = MTL.Predicate('data2', Ar2, br2, mode)
# root = F(data1 /\ data2)
root = MTL.Not(MTL.Finally(0, float('inf'), MTL.And(r1, r2), mode), mode)
traces = {}
traces['data1'] = np.ones(10, dtype=np.float32) * 5
traces['data2'] = np.ones(10, dtype=np.float32) * 10
time_data = np.arange(1, 10 + 1, dtype=np.float32)
t0 = time.time()
root.eval_interval(traces, time_data)
t1 = time.time()
print("TLTk", "\t | Mode:", mode, '\t| Time: ', '%.4f' % (t1 - t0),
' \t| Robustness:', root.robustness)
