Bug fixes and improvements to list randomization

- Fix bug where randomized list would cause a TypeError
  when trying to add it for a set in the sparse solver.
- Fix quality of results for sum to zero. This was badly
  affected by constructing lists one element at a time.
- Split random list solvers into naive and progressive.
  Naive just randomizes and checks. Progressive tries to
  save state as it goes, saving as much as possible each
  time to minimize over-constraining the problem.
- Add benchmarking vs pyvsc for random lists.

Author: will-keen

benchmarks/__main__.py

@@ -15,6 +15,8 @@
 from benchmarks.pyvsc.basic import vsc_basic, cr_basic
 from benchmarks.pyvsc.in_keyword import vsc_in, cr_in, cr_in_order
 from benchmarks.pyvsc.ldinstr import vsc_ldinstr
+from benchmarks.pyvsc.randlist import vscRandListSumZero, \
+    crRandListSumZero, vscRandListUnique, crRandListUnique
 from examples.ldinstr import ldInstr
 
 
@@ -113,6 +115,38 @@ def check(results):
             self.assertGreater(speedup, 10, "Performance has degraded!")
         self.run_benchmark(randobjs, 100, check)
 
+    def test_randlist_sumzero(self):
+        '''
+        Test random list example where the list must sum to zero.
+        '''
+        randobjs = {
+            'vsc': vscRandListSumZero(),
+            'cr': crRandListSumZero(Random(0)),
+        }
+        def check(results):
+            self.assertGreater(results['cr'][1], results['vsc'][1])
+            # This testcase is typically 20x faster, which may vary depending
+            # on machine. Ensure it doesn't fall below 15x.
+            speedup = results['cr'][1] / results['vsc'][1]
+            self.assertGreater(speedup, 15, "Performance has degraded!")
+        self.run_benchmark(randobjs, 100, check)
+
+    def test_randlist_unique(self):
+        '''
+        Test random list example where the list must be unique.
+        '''
+        randobjs = {
+            'vsc': vscRandListUnique(),
+            'cr': crRandListUnique(Random(0)),
+        }
+        def check(results):
+            self.assertGreater(results['cr'][1], results['vsc'][1])
+            # This testcase is typically 10-13x faster, which may vary depending
+            # on machine. Ensure it doesn't fall below 10x.
+            speedup = results['cr'][1] / results['vsc'][1]
+            self.assertGreater(speedup, 10, "Performance has degraded!")
+        self.run_benchmark(randobjs, 100, check)
+
 
 def parse_args():
     parser = ArgumentParser(description='Run unit tests for constrainedrandom library')

benchmarks/pyvsc/randlist.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2023 Imagination Technologies Ltd. All Rights Reserved
+
+'''
+Random list examples where constrainedrandom has previously struggled.
+'''
+
+from constrainedrandom import RandObj
+from constrainedrandom.utils import unique
+import vsc
+
+
+@vsc.randobj
+class vscRandListSumZero(object):
+
+    def __init__(self):
+        self.listvar = vsc.rand_list_t(vsc.int8_t(), 10)
+
+    @vsc.constraint
+    def listvar_c(self):
+        with vsc.foreach(self.listvar) as l:
+            l >= -10
+            l < 11
+
+    @vsc.constraint
+    def listvar_sum_c(self):
+        sum(self.listvar) == 0
+
+
+class crRandListSumZero(RandObj):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.add_rand_var('listvar', domain=range(-10, 11), length=10)
+        def sum_0(listvar):
+            return sum(listvar) == 0
+        self.add_constraint(sum_0, ('listvar',))
+
+
+@vsc.randobj
+class vscRandListUnique(object):
+
+    def __init__(self):
+        self.listvar = vsc.rand_list_t(vsc.uint8_t(), 10)
+
+    @vsc.constraint
+    def listvar_c(self):
+        with vsc.foreach(self.listvar) as l:
+            l >= 0
+            l < 10
+
+    @vsc.constraint
+    def listvar_unique_c(self):
+        vsc.unique(self.listvar)
+
+
+class crRandListUnique(RandObj):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.add_rand_var('listvar', domain=range(10), length=10, list_constraints=[unique])

constrainedrandom/internal/multivar.py

@@ -196,14 +196,17 @@ def solve_groups(
                                     del problem._variables[var_name]
                                 problem.addVariable(var_name, (value,))
                         else:
-                            solution_space = defaultdict(set)
+                            solution_space = defaultdict(list)
                             for soln in solution_subset:
                                 for var_name, value in soln.items():
-                                    solution_space[var_name].add(value)
+                                    # List is ~2x slower than set for 'in',
+                                    # but variables might be non-hashable.
+                                    if value not in solution_space[var_name]:
+                                        solution_space[var_name].append(value)
                             for var_name, values in solution_space.items():
                                 if var_name in problem._variables:
                                     del problem._variables[var_name]
-                                problem.addVariable(var_name, list(values))
+                                problem.addVariable(var_name, values)
 
                 # Attempt to solve the group
                 group_solutions = group_problem.solve(