umaudemc 0.16.0__py3-none-any.whl → 0.17.1__py3-none-any.whl

umaudemc/__init__.py

@@ -1 +1 @@
-__version__ = '0.16.0'
+__version__ = '0.17.0'

umaudemc/__main__.py

@@ -318,6 +318,7 @@ def build_parser():
 	)
 	parser_scheck.add_argument(
 		'-D',
+		metavar='name=value',
 		action='append',
 		help='Define a constant to be used in QuaTEx expressions'
 	)

umaudemc/command/scheck.py

@@ -19,16 +19,16 @@ def show_results(program, nsims, qdata):
 	qdata_it = iter(qdata)
 	q = next(qdata_it, None)
 
-	for k, (fname, line, column, params) in enumerate(program.query_locations):
+	for k, query in enumerate(program.queries):
 		# Print the query name and location only if there are many
 		if program.nqueries > 1:
 			# If the number of simulation is lower for this query
 			sim_detail = f' ({q.n} simulations)' if q.n != nsims else ''
 
-			print(f'Query {k + 1} ({fname}:{line}:{column}){sim_detail}')
+			print(f'Query {k + 1} ({query.filename}:{query.line}:{query.column}){sim_detail}')
 
 		# For parametric queries, we show the result for every value
-		var = params[0] if params else None
+		var = query.parameters[0] if query.parameters else None
 
 		while q and q.query == k:
 			if var:
@@ -93,10 +93,10 @@ def plot_results(program, qdata):
 		return
 
 	for k, xs, ys, rs in results:
-		line, column, _ = program.query_locations[k]
+		query = program.queries[k]
 
 		# Plot the mean
-		p = plt.plot(xs, ys, label=f'{line}:{column}')
+		p = plt.plot(xs, ys, label=f'{query.line}:{query.column}')
 		# Plot the confidence interval
 		plt.fill_between(xs, [y - r for y, r in zip(ys, rs)],
 		                 [y + r for y, r in zip(ys, rs)],

umaudemc/command/sworker.py

@@ -96,13 +96,16 @@ class Worker:
 		# (delta, its second argument, does not matter because
 		# convergence is not evaluated by the worker)
 		qdata = [QueryData(k, 1.0, idict)
-		         for k, qinfo in enumerate(program.query_locations)
-		         for idict in make_parameter_dicts(qinfo[3])]
+		         for k, qinfo in enumerate(program.queries)
+		         for idict, _ in make_parameter_dicts(qinfo, 1.0)]
 
+		# Compact arrays are used so that they can be sent through the socket
 		sums = array('d', [0.0] * len(qdata))
 		sum_sq = array('d', [0.0] * len(qdata))
 		counts = array('i', [0] * len(qdata))
 
+		converged = array('i')  # to store indices of converged queries
+
 		while True:
 
 			for _ in range(block):
@@ -120,14 +123,27 @@ class Worker:
 			# Check whether to continue
 			answer = conn.recv(1)
 
+			# Stop command
 			if answer == b's':
 				print('Done')
 				return
 
+			# Partial convergence
+			elif answer == b'p':
+				mcount = int.from_bytes(conn.recv(4), 'big')
+				# Safety check
+				if mcount <= len(qdata):
+					converged.frombytes(conn.recv(4 * mcount))
+					# Set the converged queries to avoid recomputing them
+					for index in converged:
+						qdata[index].converged = True
+					del converged[:]
+
 			elif answer != b'c':
 				usermsgs.print_error(f'Unknown command {answer.decode()}. Stopping.')
 				return
 
+			# Reset the accumulators for the next round
 			for k in range(len(qdata)):
 				sums[k] = 0
 				sum_sq[k] = 0

umaudemc/distributed.py

@@ -225,7 +225,7 @@ def setup_workers(args, initial_data, dspec, constants, seen_files, stack):
 			input_data['block'] = block_size  # if specified
 
 		input_data = json.dumps(input_data).encode()
-		sock.sendall(len(input_data).to_bytes(4) + input_data)
+		sock.sendall(len(input_data).to_bytes(4, 'big') + input_data)
 
 		# Send the relevant files
 		with sock.makefile('wb', buffering=0) as fobj:
@@ -249,6 +249,17 @@ def setup_workers(args, initial_data, dspec, constants, seen_files, stack):
 	return sockets
 
 
+class WorkerData:
+	"""Relevant data for the worker"""
+
+	__attrs__ = ('index', 'block', 'name')
+
+	def __init__(self, index, block, data):
+		self.index = index
+		self.block = data.get('block', block)
+		self.name = data.get('name')
+
+
 def distributed_check(args, initial_data, min_sim, max_sim, program, constants, seen_files):
 	"""Distributed statistical model checking"""
 
@@ -269,20 +280,27 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, constants,
 		# Use a selector to wait for updates from any worker
 		selector = selectors.DefaultSelector()
 
-		for sock, data in zip(sockets, dspec['workers']):
-			selector.register(sock, selectors.EVENT_READ, data={'block': args.block} | data)
-			sock.send(b'c')
+		# Use a selector to be notified of the worker answers
+		for k, (sock, data) in enumerate(zip(sockets, dspec['workers'])):
+			selector.register(sock, selectors.EVENT_READ, data=WorkerData(k, args.block, data))
+			sock.send(b'c')  # continue command
 
 		buffer = array('d')
 		ibuffer = array('i')
 
 		# Query data
-		qdata = [QueryData(k, args.delta, idict)
-		         for k, qinfo in enumerate(program.query_locations)
-		         for idict in make_parameter_dicts(qinfo[3])]
+		qdata = [QueryData(k, delta, idict)
+		         for k, qinfo in enumerate(program.queries)
+		         for idict, delta in make_parameter_dicts(qinfo, args.delta)]
 		nqueries = len(qdata)
 		num_sims = 0
 
+		# In order to tell the workers which queries have converged, we keep
+		# a list of indices of converged queries in cronological order and
+		# a list with the next index to be transmitted to each worker
+		converged_queries = array('i')
+		next_to_tell = [0] * len(sockets)
+
 		quantile = get_quantile_func()
 
 		while sockets:
@@ -294,35 +312,58 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, constants,
 
 				answer = sock.recv(1)
 
+				# Block finished
 				if answer == b'b':
+					# The message is the concatenation of three arrays
+					# (sum, sum_sq, and counts) of nqueries elements each.
+					# sum and sum_sq contain 64-bit floating-point numbers
+					# and counts contains 32-bit integer numbers
 					data = sock.recv(24 * nqueries)
 					buffer.frombytes(data[:16 * nqueries])
 					ibuffer.frombytes(data[16 * nqueries:])
 
+					# Some queries may have not been evaluated because
+					# they converged, but it is easier to sum their zeros
 					for k in range(nqueries):
 						qdata[k].sum += buffer[k]
 						qdata[k].sum_sq += buffer[nqueries + k]
 						qdata[k].n += ibuffer[k]
 
-					num_sims += key.data['block']
+					num_sims += key.data.block
 
 					del buffer[:]
 					del ibuffer[:]
-					finished.append(key.fileobj)
+					finished.append(key)
 
 				else:
-					usermsgs.print_error(f'Server {key.data["name"]} disconnected or misbehaving')
+					usermsgs.print_error(f'Server {key.data.name} disconnected or misbehaving')
 					selector.unregister(key.fileobj)
 					sockets.remove(key.fileobj)
 
 			# Check whether the simulation has converged
-			converged = check_interval(qdata, num_sims, min_sim, args.alpha, quantile, args.verbose)
+			converged, which = check_interval(qdata, num_sims, min_sim, args.alpha, quantile, args.verbose)
+
+			# More converged queries
+			if which:
+				converged_queries.extend(which)
 
 			if converged or max_sim and num_sims >= max_sim:
 				break
 
-			for sock in finished:
-				sock.send(b'c')
+			for key in finished:
+				index = key.data.index
+
+				# Transmit which queries have converged
+				if next_to_tell[index] != len(converged_queries):
+					# We send p followed by the number of indices and then the indices
+					key.fileobj.send(b'p'
+						+ (len(converged_queries) - next_to_tell[index]).to_bytes(4, 'big')
+						+ converged_queries[next_to_tell[index]:].tobytes())
+					next_to_tell[index] = len(converged_queries)
+
+				# Continue without change
+				else:
+					key.fileobj.send(b'c')
 
 			finished.clear()
 

umaudemc/quatex.py

@@ -8,6 +8,19 @@ import os
 from . import usermsgs
 
 
+class QuaTExQuery:
+	"""QuaTeX query information"""
+
+	def __init__(self, fname, line, column, expr, parameters, delta):
+		self.filename = fname  # file cointing the query
+		self.line = line  # query location
+		self.column = column
+		self.parameters = parameters  # parameters as (variable, start, step, end)
+
+		self.expr = expr  # query expression (only needed for compilation)
+		self.delta = delta  # delta value
+
+
 class QuaTExProgram:
 	"""Compiled QuaTEx program"""
 
@@ -23,7 +36,7 @@ class QuaTExProgram:
 		self.nqueries = len(slots) - ndefs
 
 		# Query information (file name, line, column, and parameters)
-		self.query_locations = qinfo
+		self.queries = qinfo
 
 
 class QuaTExLexer:
@@ -171,6 +184,7 @@ class QuaTExLexer:
 			self.ltype = self.LT_STRING
 			self._capture_string()
 
+		# Names cannot start with a number
 		elif c.isalpha() or c == '$':
 			self.ltype = self.LT_NAME
 			self._capture(self._is_name)
@@ -211,9 +225,9 @@ class QuaTExLexer:
 class QuaTExParser:
 	"""Parser for QuaTEx"""
 
-	PS_IFC = 0  # condition
-	PS_IFT = 1  # true branch
-	PS_IFF = 2  # negative branch
+	PS_IF_COND = 0  # condition
+	PS_IF_THEN = 1  # true branch
+	PS_IF_ELSE = 2  # negative branch
 	PS_PAREN = 3  # parenthesis
 	PS_ARITH = 4  # completing an arithmetic expression
 	PS_CALLARGS = 5  # call arguments
@@ -223,6 +237,7 @@ class QuaTExParser:
 	BINOPS_PREC = (4, 4, 3, 3, 3, 11, 12, 7, 7, 6, 6, 6, 6)
 	BINOPS_AST = (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod, ast.And, ast.Or, ast.Eq,
 	              ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE)
+	# Kind of binary operator (0 = BinOp, 1 = BoolOp, 2 = Compare)
 	BINOPS_CMP = (0, ) * 5 + (1, ) * 2 + (2, ) * 6
 	# Unary operator and its precedence (as in C)
 	UNARY_OPS = ('!', )
@@ -238,13 +253,14 @@ class QuaTExParser:
 		self.pending_lexers = []
 		self.seen_files = set() if filename.startswith('<') else {os.path.realpath(filename)}
 
-		# Parameters of the current function
-		self.fvars = []
-		# Whether the variables that may occur
-		# in an expression are known
+		# Whether the variables that may occur in an expression are known
 		self.known_vars = True
+		# Parameters of the current function if self.known_vars
+		# or variables found in the last processed expression otherwise
+		self.fvars = []
 		# Constants defined outside
 		self.constants = {} if constants is None else constants
+		self.pending_constants = []
 
 		# State stack for parsing expressions
 		self.stack = []
@@ -253,7 +269,7 @@ class QuaTExParser:
 		# Whether parsing errors have been encountered
 		self.ok = True
 
-		# Compilation slot indices for each number
+		# Compilation slot indices for each element
 		self.fslots = {}
 		self.calls = []
 		self.observations = []
@@ -284,13 +300,29 @@ class QuaTExParser:
 
 		return True
 
+	def _expect_any(self, *options):
+		"""Check whether any of the given strings is the next token"""
+
+		atoken = self.lexer.get_token()
+		options_str = ', '.join(f'"{opt}"' for opt in options)
+
+		if atoken is None:
+			self._eprint(f'unexpected end of file where any of {options_str} is required.')
+			return None
+
+		if atoken not in options:
+			self._eprint(f'unexpected token "{atoken}" where any of {options_str} is required.')
+			return None
+
+		return atoken
+
 	def _in_state(self, state):
 		"""Check whether the parser is in the given state"""
 
 		return self.stack and self.stack[-1] == state
 
 	def _next_token(self):
-		"""Get the next token without potential file exhaustion"""
+		"""Get the next token dealing with file exhaustion"""
 
 		token = self.lexer.get_token()
 
@@ -332,40 +364,89 @@ class QuaTExParser:
 			self._eprint(f'unexpected token "{var_name}" where a variable name is required.')
 			return (None, ) * 3
 
+		if not self._expect(','):
+			return (None, ) * 3
+
 		# Parameter specification (name, initial value, step, last value)
 		spec = [var_name]
 
-		# Parse the initial value, step, and last value
-		for _ in range(3):
-			if not self._expect(','):
-				return (None, ) * 3
+		# Make a copy of the expression variables, since we continue in
+		# known variables mode with no variables allowed
+		expr_vars = tuple(self.fvars)
+		self.fvars.clear()
 
-			token = self.lexer.get_token()
+		# Parse the initial value, step, and last value
+		for k in range(3):
+			expr = self._parse_constexpr(',' if k < 2 else ')')
 
-			if self.lexer.ltype != self.lexer.LT_NUMBER:
-				self._eprint(f'unexpected token "{token}" where a number is required.')
+			if expr is None:
 				return (None, ) * 3
 
-			spec.append(float(token))
-
-		# Check the closing parenthesis
-		if not self._expect(')'):
-			return (None, ) * 3
+			spec.append(float(expr))
 
 		# Check whether the variables in the expressions are the parameter
-		for var, line, column in self.fvars:
+		for var, line, column in expr_vars:
 			if var != var_name:
 				self._eprint(f'unknown variable "{var}".', line=line, column=column)
 				self.ok = False
 
+		return tuple(spec)
+
+	def _parse_delta(self, parameter):
+		"""Parse the delta annotation"""
+
+		if not self._expect('delta', '='):
+			return None
+
+		# Only the parameter can appear as free variable in the expression
 		self.fvars.clear()
 
-		return tuple(spec)
+		if parameter:
+			self.fvars.append(parameter[0])
+
+		if (delta := self._parse_expr(';', constexpr=True)) is None:
+			return None
 
-	def _parse_expr(self, end_token, inside_def=False):
+		# Prepare delta as a function on the parameter (if any)
+		args = [ast.arg(parameter[0])] if parameter else []
+
+		delta_fn = ast.Expression(ast.Lambda(ast.arguments(args=args), delta))
+		ast.fix_missing_locations(delta_fn)
+
+		return eval(compile(delta_fn, '<delta>', 'eval'), {}, {})
+
+	def _parse_constexpr(self, end_token):
+		"""Parse a constant expression as a number"""
+
+		# Soft errors, like unbound variables, are hard here because
+		# we run the code to obtain a value for the expression
+		old_ok, self.ok = self.ok, True
+
+		if (expr := self._parse_expr(end_token, constexpr=True)) is None:
+			return None
+
+		elif not self.ok:
+			return 0.0  # dummy value to keep running
+
+		self.ok = old_ok
+
+		# Evaluate the expression
+		expr = ast.Expression(expr)
+		ast.fix_missing_locations(expr)
+
+		result = eval(compile(expr, self.lexer.filename, 'eval'), {}, {})
+
+		# Check whether it is a number
+		if not isinstance(result, (int, float)):
+			self._eprint(f'"{result}" obtained while a number is expected.')
+			return None
+
+		return result
+
+	def _parse_expr(self, end_token, constexpr=False):
 		"""Parse an expression"""
 
-		# Current expression
+		# Current expression (as a Python AST node)
 		current = None
 		# Number of nested conditions in the current position
 		inside_cond = 0
@@ -400,13 +481,13 @@ class QuaTExParser:
 					self._eprint('misplaced "if" keyword.')
 					return None
 
-				self.stack.append(self.PS_IFC)
+				self.stack.append(self.PS_IF_COND)
 				arg_stack.append([])
 				inside_cond += 1
 
 			elif token == 'then':
-				if current and self._in_state(self.PS_IFC):
-					self.stack[-1] = self.PS_IFT
+				if current and self._in_state(self.PS_IF_COND):
+					self.stack[-1] = self.PS_IF_THEN
 					arg_stack[-1].append(current)
 					current = None
 					inside_cond -= 1
@@ -415,8 +496,8 @@ class QuaTExParser:
 					return None
 
 			elif token == 'else':
-				if current and self._in_state(self.PS_IFT):
-					self.stack[-1] = self.PS_IFF
+				if current and self._in_state(self.PS_IF_THEN):
+					self.stack[-1] = self.PS_IF_ELSE
 					arg_stack[-1].append(current)
 					current = None
 				else:
@@ -424,7 +505,7 @@ class QuaTExParser:
 					return None
 
 			elif token == 'fi':
-				if current and self._in_state(self.PS_IFF):
+				if current and self._in_state(self.PS_IF_ELSE):
 					arg_stack[-1].append(current)
 					current = ast.IfExp(*arg_stack[-1])
 					arg_stack.pop()
@@ -442,6 +523,10 @@ class QuaTExParser:
 					self._eprint('the next operator # cannot be used in conditions or call arguments.')
 					self.ok = False
 
+				elif constexpr:
+					self._eprint('the next operator # cannot be used in constant contexts.')
+					self.ok = False
+
 				# A function call should follow
 				token = self.lexer.get_token()
 				line, column = self.lexer.sline, self.lexer.scolumn
@@ -455,7 +540,8 @@ class QuaTExParser:
 				inside_next = True
 				call_name, call_line, call_column = token, line, column
 
-			elif token == 'discard' and not (inside_cond or call_name):
+			# discard is a soft keyword
+			elif token == 'discard' and not (inside_cond or call_name or constexpr):
 				if current:
 					self._eprint('misplaced discard keyword.')
 					return None
@@ -491,10 +577,15 @@ class QuaTExParser:
 						self._eprint(f'argument missing after a comma in a call to "{call_name}".')
 						self.ok = False
 
+					# Call are internally represented as tuples that indicate whether
+					# the call is preceded by next (i.e. to be evaluated after a step)
+					# and which code slot contains the callee definition
 					slot = self.fslots.setdefault(call_name, len(self.fslots))
 					current = ast.Tuple([ast.Constant(inside_next), ast.Constant(slot), *args], ast.Load())
-					current.custom_loc = (call_line, call_column)
-					self.calls.append((call_name, call_line, call_column, len(args)))
+					# We keep the source location for error reporting (using the attributes
+					# lineno and col_offset of the AST node only here is not possible)
+					current.custom_loc = dict(fname=self.lexer.filename, line=call_line, column=call_column)
+					self.calls.append((call_name, self.lexer.filename, call_line, call_column, len(args)))
 					inside_next = False
 					call_name = None
 
@@ -549,6 +640,10 @@ class QuaTExParser:
 						self._eprint(f'"{token}" is called in a condition or call argument, but this is not allowed.')
 						return None
 
+					if constexpr:
+						self._eprint(f'"{token}" is called in a constant context, but calls are not allowed.')
+						return None
+
 					self.stack.append(self.PS_CALLARGS)
 					arg_stack.append([])
 					call_name = token
@@ -558,17 +653,16 @@ class QuaTExParser:
 				else:
 					current = ast.Name(token, ast.Load())
 
-					if not self.known_vars:
+					# Constants (from the command line) start with $, but variables can also
+					if token.startswith('$') and (value := self.constants.get(token[1:])) is not None:
+						current = ast.Constant(value)
+
+					elif not self.known_vars:
 						self.fvars.append((token, line, column))
 
 					elif token not in self.fvars:
-						# The variable is an externally-defined constant
-						if token.startswith('$') and (value := self.constants.get(token[1:])) is not None:
-							current = ast.Constant(value)
-
-						else:
-							self._eprint(f'unknown variable "{token}".', line=line, column=column)
-							self.ok = False
+						self._eprint(f'unknown variable "{token}".', line=line, column=column)
+						self.ok = False
 
 
 					# We continue with the peeked token
@@ -694,22 +788,29 @@ class QuaTExParser:
 				if parameter:
 					self.known_vars = False
 
-				expr = self._parse_expr(']')
+				if not (expr := self._parse_expr(']')):
+					return False
 
 				self.known_vars = True
 
 				# Parse parameter specification in parametric queries
 				parameter = self._parse_parameter() if parameter else None
+				delta = None
 
-				if not expr or not self._expect(';'):
+				# Check whether there is a "with delta = <number>" prefix
+				if (token := self._expect_any('with', ';')) is None:
 					return False
 
+				if token == 'with':
+					if (delta := self._parse_delta(parameter)) is None:
+						return False
+
 				# Ignore parameterized expressions with empty range
 				if parameter and parameter[1] > parameter[3]:
 					usermsgs.print_warning_loc(self.lexer.filename, line, column,
 					                           'ignoring parametric query with empty range.')
 				else:
-					self.queries.append((self.lexer.filename, line, column, expr, parameter))
+					self.queries.append(QuaTExQuery(self.lexer.filename, line, column, expr, parameter, delta))
 
 			# Function definition -- <name> ( <args> ) = <expr> ;
 			else:
@@ -744,7 +845,7 @@ class QuaTExParser:
 				if not self._expect('='):
 					return False
 
-				expr = self._parse_expr(';', inside_def=True)
+				expr = self._parse_expr(';')
 
 				if not expr:
 					return False
@@ -763,8 +864,7 @@ class QuaTExParser:
 			expr, tail_pos = pending.pop()
 
 			if isinstance(expr, ast.Tuple) and not tail_pos:
-				self._eprint('non-tail calls are not allowed.',
-				             line=expr.custom_loc[0], column=expr.custom_loc[1])
+				self._eprint('non-tail calls are not allowed.', **expr.custom_loc)
 				return False
 
 			elif isinstance(expr, ast.UnaryOp):
@@ -799,17 +899,17 @@ class QuaTExParser:
 				arities[name] = len(args)
 
 		# Check whether all calls are well-defined
-		for name, line, column, arity in self.calls:
+		for name, fname, line, column, arity in self.calls:
 			def_arity = arities.get(name)
 
 			if def_arity is None:
 				self._eprint(f'call to undefined function "{name}".',
-				             line=line, column=column)
+				             line=line, column=column, fname=fname)
 				ok = False
 
 			elif arity != def_arity:
 				self._eprint(f'wrong number of arguments in a call to "{name}" ({arity} given, but {def_arity} expected).',
-				             line=line, column=column)
+				             line=line, column=column, fname=fname)
 				ok = False
 
 		# Check all calls are tail in expression
@@ -817,8 +917,8 @@ class QuaTExParser:
 			if not self._check_tail(expr):
 				ok = False
 
-		for _, _, _, expr, _ in self.queries:
-			if not self._check_tail(expr):
+		for query in self.queries:
+			if not self._check_tail(query.expr):
 				ok = False
 
 		if not ok:
@@ -848,22 +948,24 @@ class QuaTExParser:
 				             line=line, column=column)
 				ok = False
 
-		for k, (fname, line, column, expr, _) in enumerate(self.queries):
+		for k, query in enumerate(self.queries):
 			try:
-				expr = ast.Expression(expr)
+				expr = ast.Expression(query.expr)
 				ast.fix_missing_locations(expr)
-				slots[used_defs + k] = compile(expr, filename=f'query{fname}:{line}:{column}', mode='eval')
+				slots[used_defs + k] = compile(expr, filename=f'query{query.filename}:{query.line}:{query.column}', mode='eval')
 
 			except TypeError:
 				self._eprint('this query cannot cannot be compiled.',
-				             line=line, column=column, fname=fname)
+				             line=query.line, column=query.column, fname=query.fname)
 				ok = False
 
+			# No longer needed
+			query.expr = None
+
 		if not ok:
 			return None
 
-		return QuaTExProgram(slots, varnames, len(self.fslots),
-		                     tuple((fname, line, column, params) for fname, line, column, _, params in self.queries))
+		return QuaTExProgram(slots, varnames, len(self.fslots), self.queries)
 
 
 def parse_quatex(input_file, filename='<string>', legacy=False, constants=None):

umaudemc/simulators.py

@@ -109,6 +109,42 @@ class StrategyStepSimulator(BaseSimulator):
 			self.step += 1
 
 
+class RuleStepSimulator(BaseSimulator):
+	"""Simulator where rule application (potentially using random) is the step"""
+
+	def __init__(self, initial):
+		super().__init__(initial)
+
+		# See the PMaude simulator to an explanation for why we need that
+		self.random = None
+
+		if nat_kind := self.module.findSort('Nat').kind():
+			if random := self.module.findSymbol('random', (nat_kind,), nat_kind):
+				self.random = random(self.module.parseTerm('1', nat_kind))
+
+	def restart(self):
+		"""Restart simulator"""
+
+		super().restart()
+
+		# PMaude uses Maude's random symbol, which is memoryless
+		# and deterministic for a fixed seed, so we need a new seed
+		if self.random:
+			self.random.copy().reduce()
+		maude.setRandomSeed(random.getrandbits(31))
+
+	def next_step(self):
+		"""Perform a step of the simulation"""
+
+		# Application of any executable rule
+		# (assumming it is deterministic)
+		next_state, *_ = next(self.state.apply(None), (None,))
+
+		if next_state is not None:
+			self.state = next_state
+			self.step += 1
+
+
 def all_children(graph, state):
 	"""All children of a state in a graph"""
 
@@ -128,9 +164,9 @@ class UmaudemcSimulator(BaseSimulator):
 	def __init__(self, initial, graph, assigner):
 		super().__init__(initial)
 
-		self.state_nr = 0
 		self.graph = graph
 		self.assigner = assigner
+		self.state_nr = 0
 		self.time = 0.0
 
 	def restart(self):
@@ -274,13 +310,12 @@ class PMaudeSimulator(BaseSimulator):
 		self.nat_kind = nat_kind
 		self.val = val
 
-		# Prepares the initial term
-		self.state = self.initial.copy()
-		self.state.rewrite()
+		# restart must be called before running
+		self.state = None
 
 		# Try to find Maude's random symbol for calculating random(1). If the
-		# PMaude specification only reduces random(0), even after resetting
-		# the random seed for a new simulation, it will take the same value
+		# PMaude specification only reduces random(0), even after resetting the
+		# random seed for a new simulation, it will take the same cached value
 		self.random = self.module.findSymbol('random', (nat_kind,), nat_kind)
 
 		if self.random:
@@ -473,12 +508,15 @@ def get_simulator(method, data):
 		method = 'step' if data.strategy else 'uniform'
 
 	# Check whether a strategy is provided for methods that require it
-	if not data.strategy and method in ('step', 'strategy-fast', 'strategy'):
+	if not data.strategy and method in ('strategy-fast', 'strategy'):
 		usermsgs.print_error(f'No strategy is provided for the {method} assignment method.')
 		return None
 
 	if method == 'step':
-		return StrategyStepSimulator(data.term, data.strategy)
+		if data.strategy:
+			return StrategyStepSimulator(data.term, data.strategy)
+		else:
+			return RuleStepSimulator(data.term)
 
 	if method == 'strategy-fast':
 		return StrategyPathSimulator(data.module, data.term, data.strategy)

umaudemc/statistical.py

@@ -120,17 +120,17 @@ class QueryData:
 		self.discarded = 0
 
 
-def make_parameter_dicts(qinfo):
+def make_parameter_dicts(qinfo, delta):
 	"""Make the initial variable mapping for the parameters of a query"""
 
-	if qinfo is None:
-		yield {}
+	if qinfo.parameters is None:
+		yield {}, (qinfo.delta() if qinfo.delta else delta)
 
 	else:
-		var, x, step, end = qinfo
+		var, x, step, end = qinfo.parameters
 
 		while x <= end:
-			yield {var: x}
+			yield {var: x}, (qinfo.delta(x) if qinfo.delta else delta)
 			x += step
 
 
@@ -139,8 +139,10 @@ def check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose):
 
 	# Whether the size of the confidence interval for all queries have converged
 	converged = True
+	# Which queries have converged
+	which = []
 
-	for query in qdata:
+	for k, query in enumerate(qdata):
 		# This query has already converged
 		if query.converged:
 			continue
@@ -148,18 +150,23 @@ def check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose):
 		elif query.n == 0:
 			converged = False
 			continue
+		# A single execution
+		elif query.n == 1:
+			query.mu, query.s, query.h = query.sum, 0.0, 0.0
+		# General case
+		else:
+			# The radius encloses the confidence level in the reference
+			# distribution for calculating confidence intervals
+			tinv = quantile(query.n - 1, 1 - alpha / 2) / math.sqrt(query.n)
 
-		# The radius encloses the confidence level in the reference
-		# distribution for calculating confidence intervals
-		tinv = quantile(query.n - 1, 1 - alpha / 2) / math.sqrt(query.n)
-
-		query.mu = query.sum / query.n
-		query.s = math.sqrt(max(query.sum_sq - query.sum * query.mu, 0.0) / (query.n - 1))
-		query.h = query.s * tinv
+			query.mu = query.sum / query.n
+			query.s = math.sqrt(max(query.sum_sq - query.sum * query.mu, 0.0) / (query.n - 1))
+			query.h = query.s * tinv
 
 		if query.h <= query.delta and query.n >= min_sim:
 			query.converged = True
 			query.discarded = num_sims - query.n
+			which.append(k)
 		else:
 			converged = False
 
@@ -170,7 +177,10 @@ def check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose):
 		                    f' σ={" ".join(str(q.s) for q in qdata)}'
 		                    f' r={" ".join(str(q.h) for q in qdata)}')
 
-	return converged
+		for k in which:
+			print(f'  Query {qdata[k].query + 1} has converged')
+
+	return converged, which
 
 
 def run_single(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, block_size,
@@ -200,7 +210,7 @@ def run_single(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, blo
 					query.sum_sq += value * value
 					query.n += 1
 
-		converged = check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose)
+		converged, _ = check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose)
 
 		if converged or max_sim and num_sims >= max_sim:
 			break
@@ -211,7 +221,7 @@ def run_single(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, blo
 	return num_sims, qdata
 
 
-def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, barrier, more, dump=None):
+def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, barrier, more, convergents, dump=None):
 	"""Entry point of a calculating thread"""
 
 	maude.setRandomSeed(seed)
@@ -254,6 +264,12 @@ def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, ba
 		if not more.value:
 			break
 
+		# Disable queries that have converged
+		for k in range(len(qdata)):
+			if convergents[k] == -1:
+				break
+			qdata[convergents[k]].converged = True
+
 		# Continue for a next block
 		block = block_size
 
@@ -280,12 +296,14 @@ def run_parallel(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, b
 	queue = mp.Queue()
 	barrier = mp.Barrier(jobs + 1)
 	more = mp.Value('b', False, lock=False)
+	convergents = mp.Array('i', [-1] * len(qdata), lock=False)
 
 	rest, rest_block = num_sims % jobs, block_size % jobs
 	processes = [mp.Process(target=thread_main,
 	                        args=(program, qdata, simulator, num_sims // jobs + (k < rest),
 	                              block_size // jobs + (k < rest_block),
-	                              seeds[k], queue, barrier, more, dumps[k])) for k in range(jobs)]
+	                              seeds[k], queue, barrier, more, convergents, dumps[k]))
+	             for k in range(jobs)]
 
 	# Start all processes
 	for p in processes:
@@ -301,7 +319,7 @@ def run_parallel(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, b
 				query.sum_sq += sum_sq[k]
 				query.n += counts[k]
 
-		converged = check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose)
+		converged, which = check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose)
 
 		if converged or max_sim and num_sims >= max_sim:
 			break
@@ -309,6 +327,11 @@ def run_parallel(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, b
 		num_sims += block_size
 
 		more.value = True
+		# Inform which queries have converged
+		for k, qindex in enumerate(which):
+			convergents[k] = qindex
+		convergents[len(which)] = -1
+
 		barrier.wait()
 
 	more.value = False
@@ -328,9 +351,9 @@ def qdata_to_dict(num_sims, qdata, program):
 	qdata_it = iter(qdata)
 	q = next(qdata_it, None)
 
-	for k, (fname, line, column, params) in enumerate(program.query_locations):
+	for k, query in enumerate(program.queries):
 		# For parametric queries, we return an array of values
-		if params:
+		if query.parameters:
 			mean, std, radius, count, discarded = [], [], [], [], []
 
 			while q and q.query == k:
@@ -342,13 +365,15 @@ def qdata_to_dict(num_sims, qdata, program):
 				q = next(qdata_it, None)
 
 			# We also write information about the parameter
-			param_info = {'params': [dict(name=params[0], start=params[1], step=params[2], stop=params[3])]}
+			param_info = {'params': [dict(zip(('name', 'start', 'step', 'stop'), query.parameters))]}
 
 		else:
 			mean, std, radius, count, discarded = q.mu, q.s, q.h, q.n, q.discarded
+			q = next(qdata_it, None)
 			param_info = {}
 
-		queries.append(dict(mean=mean, std=std, radius=radius, file=fname, line=line, column=column,
+		queries.append(dict(mean=mean, std=std, radius=radius,
+		                    file=query.filename, line=query.line, column=query.column,
 		                    nsims=count, discarded=discarded, **param_info))
 
 	return dict(nsims=num_sims, queries=queries)
@@ -370,9 +395,9 @@ def check(program, simulator, seed, alpha, delta, block, min_sim, max_sim, jobs,
 
 	# Each query maintains some data like the sum of the outcomes
 	# and the sum of their squares
-	qdata = [QueryData(k, delta, idict)
-	         for k, qinfo in enumerate(program.query_locations)
-	         for idict in make_parameter_dicts(qinfo[3])]
+	qdata = [QueryData(k, dt, idict)
+	         for k, qinfo in enumerate(program.queries)
+	         for idict, dt in make_parameter_dicts(qinfo, delta)]
 
 	# Run the simulations
 	if jobs == 1 and num_sims != 1:

{umaudemc-0.16.0.dist-info → umaudemc-0.17.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: umaudemc
-Version: 0.16.0
+Version: 0.17.1
 Summary: Unified Maude model-checking utility
 Author-email: ningit <ningit@users.noreply.github.com>
 License-Expression: GPL-3.0-or-later

{umaudemc-0.16.0.dist-info → umaudemc-0.17.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-umaudemc/__init__.py,sha256=ZkVXSbnNkhhpmMRr5ur6FqBcUYuqHyK0KUV5Je_XFn8,23
-umaudemc/__main__.py,sha256=zmgS0amNTdNZ4i2fhg860uLechFnBthvPNFBbFgUSJc,15039
+umaudemc/__init__.py,sha256=ctD9pjqBvASXR0DHHzalDZFaQsnMJWDpTalYrvY3e_Y,23
+umaudemc/__main__.py,sha256=LgKeZWi1JRrEclPS3asyZziErEJyldQvlZTtTt_tcyc,15063
 umaudemc/api.py,sha256=naZ5edEbvx-S-NU29yAAJtqglfYnSAYVS2RJNyxJMQQ,19893
 umaudemc/backends.py,sha256=mzJkALYwcKPInT0lBiRsCxJSewKvx5j_akQsqWN1Ezo,4590
 umaudemc/common.py,sha256=UcIf7hTpP2qjcT9u_9-UcYR0nNeosx1xRZW7wsuT2bE,7305
 umaudemc/counterprint.py,sha256=vVqM_UjGRk_xeftFxBGI5m6cQXV7mf8KvbQ_fvAvSQk,9226
-umaudemc/distributed.py,sha256=CljCg0VzLG7pDsDb_q1Lc95OVVjrU02cadkHRz9O8qY,9112
+umaudemc/distributed.py,sha256=jUxVUHtPRefwxNYZmU0ErePre6FTmH5S8RX6ADBL1vA,10611
 umaudemc/formatter.py,sha256=nbQlIsR5Xv18OEcpJdnTDGqO9xGL_amvBGFMU2OmheU,6026
 umaudemc/formulae.py,sha256=jZPPDhjgsb7cs5rWvitiQoO0fd8JIlK98at2SN-LzVE,12156
 umaudemc/grapher.py,sha256=K1chKNNlEzQvfOsiFmRPJmd9OpxRIrg6OyiMW6gqOCU,4348
@@ -15,10 +15,10 @@ umaudemc/mproc.py,sha256=9X5pTb3Z3XHcdOo8ynH7I5RZQpjzm9xr4IBbEtaglUE,11766
 umaudemc/opsem.py,sha256=Xfdi9QGy-vcpmQ9ni8lBDAlKNw-fCRzYr6wnPbv6m1s,9448
 umaudemc/probabilistic.py,sha256=MNvFeEd84-OYedSnyksZB87UckPfwizVNJepCItgRy8,29306
 umaudemc/pyslang.py,sha256=ABSXYUQO2TmDq8EZ3EpVZV8NecZ0p0gERlSvLUIVAm8,87970
-umaudemc/quatex.py,sha256=Je5g16Tzb1t9NtHPSww0W6wUTIrHPdQCOJN-bTliOnQ,23888
+umaudemc/quatex.py,sha256=7n7ugusjFUyO5jqKeb6-O8hdH4vj2fgnc-V_Z41w-40,27271
 umaudemc/resources.py,sha256=qKqvgLYTJVtsQHQMXFObyCLTo6-fssQeu_mG7tvVyD0,932
-umaudemc/simulators.py,sha256=ZGDpQjFj2Sv4GLq-NGVBMH78cFiG45KFPKfAfH1ds9w,13283
-umaudemc/statistical.py,sha256=FY3yXvv9NRiwYOQdwLDRf4WTXG1QupGJU8KwdHQhJyo,10534
+umaudemc/simulators.py,sha256=1_DKaO2JYxSQHcbTE2wbB_lgd_kFBi40PPjOMvqOgaE,14341
+umaudemc/statistical.py,sha256=I_C1ymz-ue-XaX0zF7lyQUce57-BdEWhctKg6yG2c_A,11371
 umaudemc/terminal.py,sha256=B4GWLyW4Sdymgoavj418y4TI4MnWqNu3JS4BBoSYeTc,1037
 umaudemc/usermsgs.py,sha256=h4VPxljyKidEI8vpPcToKJA6mcLu9PtMkIh6vH3rDuA,719
 umaudemc/webui.py,sha256=XlDV87tOOdcclHp2_oerrvHwRmCZdqAR4PppqeZm47A,11072
@@ -40,8 +40,8 @@ umaudemc/command/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 umaudemc/command/check.py,sha256=PyaPDMw5OnPxSIZ10U4we0b5tTrjnYKAtAeQkJh2uLE,12031
 umaudemc/command/graph.py,sha256=JqGzESC2sn-LBh2sqctrij03ItzwDO808s2qkNKUle0,6112
 umaudemc/command/pcheck.py,sha256=eV4e4GcOHanP4hcIhMKd5Js22_ONac6kYj70FXun3mY,7274
-umaudemc/command/scheck.py,sha256=wByVmANax4-Jw3S6MHbXevYDiVP81HIhMk1M7yZwuMs,6205
-umaudemc/command/sworker.py,sha256=rTfGbIRvXV7cVEmlTwkKrP9tfZN0ESNJKtVLnIVCOMs,4654
+umaudemc/command/scheck.py,sha256=mmAzCdGdIHgKbsyEi0uW-jcj9X0MSc-EEkEPR-EiB8U,6208
+umaudemc/command/sworker.py,sha256=uxw8gmacghUMvM0MUqM-AXX-w9xOA-10Mj-ExPWoNUI,5196
 umaudemc/command/test.py,sha256=Ru21JXNF61F5N5jayjwxp8okIjOAvuZuAlV_5ltQ-GU,37088
 umaudemc/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 umaudemc/data/opsem.maude,sha256=geDP3_RMgtS1rRmYOybJDCXn_-dyHHxg0JxfYg1ftv0,27929
@@ -52,9 +52,9 @@ umaudemc/data/smcgraph.js,sha256=iCNQNmsuGdL_GLnqVhGDisediFtedxw3C24rxSiQwx8,667
 umaudemc/data/smcview.css,sha256=ExFqrMkSeaf8VxFrJXflyCsRW3FTwbv78q0Hoo2UVrM,3833
 umaudemc/data/smcview.js,sha256=_fHum1DRU1mhco-9-c6KqTLgiC5u_cCUf61jIK7wcIQ,14509
 umaudemc/data/templog.maude,sha256=TZ-66hVWoG6gp7gJpS6FsQn7dpBTLrr76bKo-UfHGcA,9161
-umaudemc-0.16.0.dist-info/licenses/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
-umaudemc-0.16.0.dist-info/METADATA,sha256=53-pCZwFfBsUPOyA_ocXL1TauD09WrY6NL574Sf1LbQ,1654
-umaudemc-0.16.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-umaudemc-0.16.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
-umaudemc-0.16.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
-umaudemc-0.16.0.dist-info/RECORD,,
+umaudemc-0.17.1.dist-info/licenses/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
+umaudemc-0.17.1.dist-info/METADATA,sha256=bW8k2ctMQZPpFsXIHJ9wiBc2HoDwqw3VZHNyPgx75qk,1654
+umaudemc-0.17.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+umaudemc-0.17.1.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
+umaudemc-0.17.1.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
+umaudemc-0.17.1.dist-info/RECORD,,

{umaudemc-0.16.0.dist-info → umaudemc-0.17.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any