umaudemc 0.16.0__py3-none-any.whl → 0.17.0__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,8 +96,8 @@ 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)]
 
 		sums = array('d', [0.0] * len(qdata))
 		sum_sq = array('d', [0.0] * len(qdata))

umaudemc/distributed.py

@@ -277,9 +277,9 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, constants,
 		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
 

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"""
 
@@ -279,8 +315,8 @@ class PMaudeSimulator(BaseSimulator):
 		self.state.rewrite()
 
 		# 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 +509,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
 
 
@@ -148,14 +148,18 @@ 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
@@ -328,9 +332,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 +346,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 +376,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.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: umaudemc
-Version: 0.16.0
+Version: 0.17.0
 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.0.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=aCvU1TaM5SZhAtWahclyANc1I0YXj8SuPXO_VjaqDdo,9115
 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=K8NFgwvvTgj1lueksnWOSc-7bo6VxS1_CA9g-6l5umc,14367
+umaudemc/statistical.py,sha256=aogqx2JCur9Lw9ZfOI6jaggwLcVTflDSs_Mn7yCmOGE,10815
 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=1icakFDO_qSr4ga-5Cu6eDfLirjLPJLNtO7OkbwTUQQ,4651
 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.0.dist-info/licenses/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
+umaudemc-0.17.0.dist-info/METADATA,sha256=HMhQv0StUz5ODf2H8vanIt_FnkK6p7BDZd-nkc8o0Fg,1654
+umaudemc-0.17.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+umaudemc-0.17.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
+umaudemc-0.17.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
+umaudemc-0.17.0.dist-info/RECORD,,

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

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