def test_or(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req or gnt'
spec.parse();
in_data_1_1 = [[1, 2], [4.1, 1], [5, 2], [6.1, 1]]
in_data_2_1 = [[1.2, 1]]
out_expected_1 = []
out_computed_1 = spec.update(['req', in_data_1_1], ['gnt', in_data_2_1])
self.assertListEqual(out_expected_1, out_computed_1,
"Problem with 6th example:\nExpected output: %s\nComputed output: %s" % (
out_expected_1, out_computed_1))
in_data_1_2 = []
in_data_2_2 = [[3.7, 3], [7.5, 2]]
out_expected_2 = [[1.2, 2], [3.7, 3]]
out_computed_2 = spec.update(['req', in_data_1_2], ['gnt', in_data_2_2])
self.assertListEqual(out_expected_2, out_computed_2,
"Problem with 6th example:\nExpected output: %s\nComputed output: %s" % (
out_expected_2, out_computed_2))
in_data_1_3 = [[6.7, 4], [9.9, 5]]
in_data_2_3 = [[8.1, 6]]
out_expected_3 = [[6.1, 3], [6.7, 4]]
out_computed_3 = spec.update(['req', in_data_1_3], ['gnt', in_data_2_3])
self.assertListEqual(out_expected_3, out_computed_3,
"Problem with 6th example:\nExpected output: %s\nComputed output: %s" % (
out_expected_3, out_computed_3))
def test_eventually_0_1_with_pastify(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = eventually[0,1] req'
spec.parse()
spec.pastify()
in_data_1 = [[5, 3], [5.3, 2], [5.75, 1]]
out_expected_1 = [[5, 3]]
out_computed_1 = spec.update(['req', in_data_1])
self.assertListEqual(out_expected_1, out_computed_1,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_1, out_computed_1))
in_data_2 = [[6.5, 5], [6.75, 6], [9, 5]]
out_expected_2 = [[5.75, 3], [6.3, 2], [6.5, 5], [6.75, 6]]
out_computed_2 = spec.update(['req', in_data_2])
self.assertListEqual(out_expected_2, out_computed_2,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_2, out_computed_2))
in_data_3 = [[9.25, 4], [10, 2]]
out_expected_3 = [[9, 6]]
out_computed_3 = spec.update(['req', in_data_3])
self.assertListEqual(out_expected_3, out_computed_3,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_3, out_computed_3))
def test_since_2(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req since gnt'
spec.parse();
in_data_1 = [[1, 2], [4.1, 1]]
in_data_2 = [[1.2, 1], [3.7, 3], [7.5, 2]]
out_expected = [[1.2, 1], [3.7, 2]]
out_computed = spec.update(['req', in_data_1], ['gnt', in_data_2])
self.assertListEqual(out_expected, out_computed,
"Problem with 3d example:\nExpected output: %s\nComputed output: %s" % (
out_expected, out_computed))
in_data_1 = [[5, 2], [6.1, 1], [6.7, 4]]
in_data_2 = []
out_expected = [[4.1, 1], [5, 2], [6.1, 1]]
out_computed = spec.update(['req', in_data_1], ['gnt', in_data_2])
self.assertListEqual(out_expected, out_computed,
"Problem with 3d example:\nExpected output: %s\nComputed output: %s" % (
out_expected, out_computed))
in_data_1 = [[9.9, 5]]
in_data_2 = [[8.1, 6]]
out_expected = [[6.7, 3], [7.5, 3]]
out_computed = spec.update(['req', in_data_1], ['gnt', in_data_2])
self.assertListEqual(out_expected, out_computed,
"Problem with 3d example:\nExpected output: %s\nComputed output: %s" % (
out_expected, out_computed))
def test_predicate_neq(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req !== 2'
spec.parse();
in_data_1 = [[5, 3], [5.3, 1]]
in_data_2 = [[5.75, 2], [6.5, 5], [6.75, 6], [9, 5], [9.25, 4]]
in_data_3 = [[10, 2]]
out_expected_1 = [[5, 1]]
out_expected_2 = [[5.3, 1], [5.75, 0], [6.5, 3], [6.75, 4], [9, 3]]
out_expected_3 = [[9.25, 2]]
out_computed_1 = spec.update(['req', in_data_1])
out_computed_2 = spec.update(['req', in_data_2])
out_computed_3 = spec.update(['req', in_data_3])
self.assertListEqual(out_expected_1, out_computed_1,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_1, out_computed_1))
self.assertListEqual(out_expected_2, out_computed_2,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_2, out_computed_2))
self.assertListEqual(out_expected_3, out_computed_3,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_3, out_computed_3))
def test_and_1(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req and gnt'
spec.parse();
in_data_1_1 = [[2, 2], [3.3, 3], [5.7, 4]]
in_data_2_1 = [[2.5, 5], [4.7, 6]]
in_data_1_2 = []
in_data_2_2 = [[5.7, 1]]
out_expected_1 = [[2.5, 2], [3.3, 3]]
out_expected_2 = [[4.7, 3]]
out_computed_1 = spec.update(['req', in_data_1_1], ['gnt', in_data_2_1])
out_computed_2 = spec.update(['req', in_data_1_2], ['gnt', in_data_2_2])
self.assertListEqual(out_expected_1, out_computed_1,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_1, out_computed_1))
self.assertListEqual(out_expected_2, out_computed_2,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected_2, out_computed_2))
def monitor():
# Load traces
data = read_csv('example1.csv')
spec = rtamt.STLDenseTimeSpecification()
spec.name = 'Example 1'
spec.declare_const('threshold', 'float', '3')
spec.declare_const('T', 'float', '5')
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('response', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.add_sub_spec('response = eventually[0:T s](gnt >= threshold)')
spec.spec = 'out = ((req >= threshold) implies response)'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data[' req']], ['gnt', data[' gnt']])
print('robustness: ' + str(rob) + ', response: ' +
str(spec.get_value('response')))
def monitor():
a1 = [(0, 3), (3, 2)]
b1 = [(0, 2), (2, 5), (4, 1), (7, -7)]
a2 = [(5, 6), (6, -2), (8, 7), (11, -1)]
b2 = [(10, 4)]
a3 = [(13, -6), (15, 0)]
b3 = [(15, 0)]
# # stl
spec = rtamt.STLDenseTimeSpecification()
spec.name = 'STL dense-time specification'
spec.declare_var('a', 'float')
spec.spec = 'a>=2'
try:
spec.parse()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.update(['a', a1], ['b', b1])
print('rob: ' + str(rob))
rob = spec.update(['a', a2], ['b', b2])
print('rob: ' + str(rob))
rob = spec.update(['a', a3], ['b', b3])
print('rob: ' + str(rob))
def test_once(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = once req'
spec.parse();
in_data = [[5, 3], [5.3, 1], [5.75, 2]]
out_expected = [[5, 3], [5.3, 3], [5.75, 3]]
out_computed = spec.update(['req', in_data])
self.assertListEqual(out_expected, out_computed,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected, out_computed))
in_data = [[6.5, 5], [6.75, 6]]
out_expected = [[6.5, 5], [6.75, 6]]
out_computed = spec.update(['req', in_data])
self.assertListEqual(out_expected, out_computed,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected, out_computed))
in_data = [[9, 5], [9.25, 4], [10, 2]]
out_expected = [[9, 6], [9.25, 6], [10, 6]]
out_computed = spec.update(['req', in_data])
self.assertListEqual(out_expected, out_computed,
"Problem with 1st example:\nExpected output: %s\nComputed output: %s" % (
out_expected, out_computed))
def test_fall(self):
spec = rtamt.STLDenseTimeSpecification()
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = fall(req)'
spec.parse()
self.assertRaises(rtamt.LTLNotImplementedException, spec.update, ['req', [0.0, 3.0]])
def test_always_with_pastify(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = always(req)'
spec.parse()
self.assertRaises(rtamt.LTLPastifyException, spec.pastify)
def test_eventually_0_1_without_pastify(self):
spec = rtamt.STLDenseTimeSpecification()
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = eventually[0,1] req'
spec.parse()
self.assertRaises(rtamt.STLNotImplementedException, spec.update, ['req', [0.0, 3.0]])
def test_until_0_1_with_pastify(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req until gnt'
spec.parse()
self.assertRaises(rtamt.LTLPastifyException, spec.pastify)
def test_until_0_1_without_pastify(self):
spec = rtamt.STLDenseTimeSpecification()
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req until gnt'
spec.parse()
self.assertRaises(rtamt.LTLNotImplementedException, spec.update, [])
def monitor():
# Load traces
data1 = read_csv('example.csv')
spec = rtamt.STLDenseTimeSpecification(semantics=rtamt.Semantics.STANDARD)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req>=3) implies (eventually[0:5.1s](gnt>=3)))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data1[' req']], ['gnt', data1[' gnt']])
print('Example (a) - standard robustness: {}'.format(rob))
spec = rtamt.STLDenseTimeSpecification(semantics=rtamt.Semantics.STANDARD)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req>=3) implies (eventually[0:5100ms](gnt>=3)))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data1[' req']], ['gnt', data1[' gnt']])
# print('Example (a) - standard robustness: {}'.format(rob[len(rob)-1][1]))
print('Example (a) - standard robustness: {}'.format(rob))
def test_once(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = once(req)'
spec.parse()
op = [[0, 2.5], [0.7, 4], [1.3, -1.2], [2.1, 1.7]]
expected = [[0, 2.5], [0.7, 4], [2.1, 4]]
computed = spec.evaluate(['req', op])
self.assertListEqual(expected, computed, "hist")
def test_until_0_1(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req until[0:1] gnt'
spec.parse();
left = [[0, 2], [10, 2]]
right = [[0, 4], [10, 4]]
out = spec.evaluate(['req', left], ['gnt', right])
expected = [[0, 2], [10, 2]]
self.assertListEqual(out, expected, "until[0:1]")
def test_not(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = not(req)'
spec.parse()
op = [[1.3, 4], [3.7, -2.2], [9.4, -33]]
expected = [[1.3, -4], [3.7, 2.2], [9.4, 33]]
computed = spec.evaluate(['req', op])
self.assertListEqual(expected, computed, "not")
def test_pow(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = pow(2,req)'
spec.parse()
op = [[1.3, 4], [3.7, -2.2], [9.4, -33]]
expected = [[1.3, math.pow(2,4)], [3.7, math.pow(2,-2.2)], [9.4, math.pow(2,-33)]]
computed = spec.evaluate(['req', op])
self.assertListEqual(expected, computed, "pow")
def test_division(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req / gnt'
spec.parse();
left = [[0, 1.3], [0.7, 3.], [1.3, 0.1], [2.1, -2.2]]
right = [[0, 2.5], [0.7, 4.], [1.3, -1.2], [2.1, 1.7]]
out = spec.evaluate(['req', left], ['gnt', right])
expected = [[0, 1.3 / 2.5], [0.7, 3. / 4.], [1.3, 0.1 / -1.2], [2.1, -2.2 / 1.7]]
self.assertListEqual(out, expected, "div")
def test_multiplication(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req * gnt'
spec.parse();
left = [[0, 1.3], [0.7, 3], [1.3, 0.1], [2.1, -2.2]]
right = [[0, 2.5], [0.7, 4], [1.3, -1.2], [2.1, 1.7]]
out = spec.evaluate(['req', left], ['gnt', right])
expected = [[0, 1.3 * 2.5], [0.7, 3 * 4], [1.3, 0.1 * -1.2], [2.1, -2.2 * 1.7]]
self.assertListEqual(out, expected, "mult")
def test_eventually_0_1(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = eventually[0:1](req)'
spec.parse()
op = [[0, 4], [5, 2], [10, 5], [15, 3]]
expected = [[0, 4], [5, 2], [9, 5], [15, 5]]
computed = spec.evaluate(['req', op])
self.assertListEqual(expected, computed, "ev[0,1]")
def test_subtraction(self):
spec = rtamt.STLDenseTimeSpecification()
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req - gnt'
spec.parse()
left = [[0, 1.3], [0.7, 3], [1.3, 0.1], [2.1, -2.2]]
right = [[0, 2.5], [0.7, 4], [1.3, -1.2], [2.1, 1.7]]
out = spec.evaluate(['req', left], ['gnt', right])
expected = [[0, 1.3 - 2.5], [0.7, 3 - 4], [1.3, 0.1 - -1.2],
[2.1, -2.2 - 1.7]]
self.assertListEqual(out, expected, "sub")
def test_implies(self):
spec = rtamt.STLDenseTimeSpecification();
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req implies gnt'
spec.parse();
left = [[0, 1.3], [0.7, 3], [1.3, 0.1], [2.1, -2.2]]
right = [[0, 2.5], [0.7, 4], [1.3, -1.2], [2.1, 1.7]]
expected = [[0, 2.5], [0.7, 4], [1.3, -0.1], [2.1, 2.2]]
computed = spec.evaluate(['req', left], ['gnt', right])
self.assertListEqual(expected, computed, "implies")
def test_predicate_neq(self):
spec = rtamt.STLDenseTimeSpecification()
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.spec = 'out = req !== gnt'
spec.parse()
left = [[0, 1.3], [0.7, 3], [1.3, 0.1], [2.1, -2.2]]
right = [[0, 2.5], [0.7, 4], [1.3, -1.2], [2.1, 1.7]]
expected = [[0, 2.5 - 1.3], [0.7, 4 - 3], [1.3, 0.1 + 1.2],
[2.1, 2.2 + 1.7]]
computed = spec.evaluate(['req', left], ['gnt', right])
self.assertListEqual(expected, computed, "neq")
def test_input_vacuity(self):
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.INPUT_VACUITY)
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = (req >= 3) implies (gnt >= 0)'
spec.parse()
left = [[0, 100], [1, -1], [2, -2], [3, 5], [4, -1]]
right = [[0, 20], [1, -2], [2, 10], [3, 4], [4, -1]]
out = spec.update(['req', left], ['gnt', right])
expected = [[0, 0], [1, 4], [2, 5]]
self.assertEqual(out, expected, "input vacuity")
def test_output_robustness(self):
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.OUTPUT_ROBUSTNESS)
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = (req >= 3) implies (gnt >= 0)'
spec.parse()
left = [[0, 100], [1, -1], [2, -2], [3, 5], [4, -1]]
right = [[0, 20], [1, -2], [2, 10], [3, 4], [4, -1]]
out = spec.update(['req', left], ['gnt', right])
expected = [[0, 20], [1, float("inf")]]
self.assertEqual(out, expected, "output robustness")
def monitor():
req = [[0.0, 0.0], [3.0, 6.0], [5.0, 0.0], [11.0, 0.0]]
gnt = [[0.0, 0.0], [7.0, 6.0], [9.0, 0.0], [11.0, 0.0]]
spec = rtamt.STLDenseTimeSpecification()
spec.name = 'STL Dense-time Offline Monitor'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = (req>=3) implies (eventually[0:5](gnt>=3))'
try:
spec.parse()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', req], ['gnt', gnt])
print('Robustness: {}'.format(rob))
def __init__(self):
# STL settings
# Load the spec from STL file
self.spec = rtamt.STLDenseTimeSpecification()
self.spec.name = 'HandMadeMonitor'
self.spec.declare_var('a', 'float')
self.spec.declare_var('b', 'float')
self.spec.declare_var('c', 'float')
self.spec.set_var_io_type('a', 'input')
self.spec.set_var_io_type('b', 'input')
self.spec.set_var_io_type('c', 'output')
self.spec.spec = 'c = always[0,5]( (a<=2) and (b >= 3) )'
try:
self.spec.parse()
self.spec.pastify()
except Exception as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
# For each var from the spec, subscribe to its topic
self.a_subscriber = rospy.Subscriber('rtamt/a',
FloatStamped,
self.a_callback,
queue_size=10)
self.b_subscriber = rospy.Subscriber('rtamt/b',
FloatStamped,
self.b_callback,
queue_size=10)
# Advertise the node as a publisher to the topic defined by the out var of the spec
var_object = self.spec.get_var_object(self.spec.out_var)
self.c_publisher = rospy.Publisher('rtamt/c',
FloatStamped,
queue_size=10)
# queue for rob
self.rob_q = Queue.Queue()
def monitor():
# Load traces
data1 = read_csv('example1.csv')
data2 = read_csv('example2.csv')
data3 = read_csv('example3.csv')
data4 = read_csv('example4.csv')
# # #
#
# Example (a) - standard robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification(semantics=rtamt.Semantics.STANDARD)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req>=3) implies (eventually[0:5](gnt>=3)))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data1[' req']], ['gnt', data1[' gnt']])
# print('Example (a) - standard robustness: {}'.format(rob[len(rob)-1][1]))
print('Example (a) - standard robustness: {}'.format(rob))
# # #
#
# Example (a) - output robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.OUTPUT_ROBUSTNESS)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req>=3) implies (eventually[0:5](gnt>=3)))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data1[' req']], ['gnt', data1[' gnt']])
print('Example (a) - output robustness: {}'.format(rob))
# # #
#
# Example (a) - input vacuity
#
# # # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.INPUT_VACUITY)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data1[' req']], ['gnt', data1[' gnt']])
# print('Example (a) - input vacuity: {}'.format(rob[len(rob)-1][1]))
print('Example (a) - input vacuity: {}'.format(rob))
# # #
#
# Example (b) - standard robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification(semantics=rtamt.Semantics.STANDARD)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data2[' req']], ['gnt', data2[' gnt']])
print('Example (b) - standard robustness: {}'.format(rob))
# # #
#
# Example (b) - output robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.OUTPUT_ROBUSTNESS)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data2[' req']], ['gnt', data2[' gnt']])
print('Example (b) - output robustness: {}'.format(rob))
# # #
#
# Example (b) - input vacuity
#
# # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.INPUT_VACUITY)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data2[' req']], ['gnt', data2[' gnt']])
print('Example (b) - input vacuity: {}'.format(rob))
# # #
#
# Example (c) - standard robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification(semantics=rtamt.Semantics.STANDARD)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data3[' req']], ['gnt', data3[' gnt']])
print('Example (c) - standard robustness: {}'.format(rob))
# # #
#
# Example (c) - output robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.OUTPUT_ROBUSTNESS)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data3[' req']], ['gnt', data3[' gnt']])
print('Example (c) - output robustness: {}'.format(rob))
# # #
#
# Example (c) - input vacuity
#
# # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.INPUT_VACUITY)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data3[' req']], ['gnt', data3[' gnt']])
print('Example (c) - input vacuity: {}'.format(rob))
# # # #
# #
# # Example (d) - standard robustness
# #
# # # #
spec = rtamt.STLDenseTimeSpecification(semantics=rtamt.Semantics.STANDARD)
spec.name = 'Example d'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data4[' req']], ['gnt', data4[' gnt']])
print('Example (d) - standard robustness: {}'.format(rob))
# # # #
# #
# # Example (d) - output robustness
# #
# # # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.OUTPUT_ROBUSTNESS)
spec.name = 'Example d'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data4[' req']], ['gnt', data4[' gnt']])
print('Example (d) - output robustness: {}'.format(rob))
#
# # # #
# #
# # Example (d) - input vacuity
# #
# # # #
spec = rtamt.STLDenseTimeSpecification(
semantics=rtamt.Semantics.INPUT_VACUITY)
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req >= 3) implies eventually[0:5] (gnt >= 3))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', data4[' req']], ['gnt', data4[' gnt']])
print('Example (d) - input vacuity: {}'.format(rob))
def monitor():
# Load traces
req = [[0, 0], [1.5, 2], [2.3, 4.3], [3, 0], [7, 3.1], [8, 1], [9.2, 2.8],
[10, 2.8]]
gnt = [[0, 0], [2.5, 2.9], [5.6, 1], [7.9, 6], [10, 6]]
req_1 = [[0, 0], [1.5, 2], [2.3, 4.3]]
gnt_1 = [[0, 0], [2.5, 2.9]]
req_2 = [[3, 0], [7, 3.1], [8, 1]]
gnt_2 = [[5.6, 1], [7.9, 6]]
req_3 = [[9.2, 2.8], [10, 2.8]]
gnt_3 = [[10, 6]]
# # #
#
# Example - offline robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification()
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req>=3) implies (eventually[1:2](gnt>=3)))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.evaluate(['req', req], ['gnt', gnt])
print('Robustness offline: {}'.format(rob))
# # #
#
# Example - online robustness
#
# # #
spec = rtamt.STLDenseTimeSpecification()
spec.name = 'Example 1'
spec.declare_var('req', 'float')
spec.declare_var('gnt', 'float')
spec.declare_var('out', 'float')
spec.set_var_io_type('req', 'input')
spec.set_var_io_type('gnt', 'output')
spec.spec = 'out = ((req>=3) implies (eventually[1:2](gnt>=3)))'
try:
spec.parse()
spec.pastify()
except rtamt.STLParseException as err:
print('STL Parse Exception: {}'.format(err))
sys.exit()
rob = spec.update(['req', req_1], ['gnt', gnt_1])
print('Robustness online - step 1: {}'.format(rob))
rob = spec.update(['req', req_2], ['gnt', gnt_2])
print('Robustness online - step 2: {}'.format(rob))
rob = spec.update(['req', req_3], ['gnt', gnt_3])
print('Robustness online - step 3: {}'.format(rob))
