Merge pull request #8 from imaginationtech/rand_len_next

Pass random length list tests with sparse/thorough solver

Author: will-keen

constrainedrandom/internal/multivar.py

@@ -1,14 +1,13 @@
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2023 Imagination Technologies Ltd. All Rights Reserved
 
-import constraint
 from collections import defaultdict
-from typing import Any, Dict, Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Any, Dict, Iterable, List, Optional, TYPE_CHECKING, Union
 
 from .vargroup import VarGroup
 
 from .. import utils
-from ..debug import RandomizationDebugInfo, RandomizationFail
+from ..debug import RandomizationDebugInfo
 
 if TYPE_CHECKING:
     from ..randobj import RandObj
@@ -138,74 +137,65 @@ def solve_groups(
         '''
         constraints = self.constraints
         sparse_solver = solutions_per_group is not None
-        solutions = []
-        solved_vars = []
+        solutions : List[Dict[str, Any]] = []
+        solved_vars : List[str] = []
 
-        # Respect assigned temporary values
+        # Respect assigned temporary values.
         if len(with_values) > 0:
             for var_name in with_values.keys():
                 solved_vars.append(var_name)
             solutions.append(with_values)
 
-        # If solving sparsely, we'll create a new problem for each group.
-        # If not solving sparsely, just create one big problem that we add to
-        # as we go along.
-        if not sparse_solver:
-            problem = constraint.Problem()
-            for var_name, value in with_values.items():
-                problem.addVariable(var_name, (value,))
-
+        # For each group, construct a problem and solve it.
         for group in groups:
-            if sparse_solver:
-                # Construct one problem per group, add solved variables from previous groups.
-                problem = constraint.Problem()
-            # Construct the appropriate group variable problem
-            group_problem = VarGroup(
-                group,
-                solved_vars,
-                problem,
-                constraints,
-                self.max_domain_size,
-                self.debug,
-            )
-
             group_solutions = None
+            group_problem = None
             attempts = 0
             while group_solutions is None or len(group_solutions) == 0:
+                # Early loop exit cases
                 if attempts >= max_iterations:
                     # We have failed, give up
                     return None
                 if attempts > 0 and not group_problem.can_retry():
                     # Not worth retrying - the same result will be obtained.
                     return None
-                if sparse_solver:
-                    if len(solutions) > 0:
-                        # Respect a proportion of the solution space, determined
-                        # by the sparsity/solutions_per_group.
+
+                # Determine what the starting state space for this group
+                # should be.
+                if sparse_solver and len(solutions) > 0:
+                    # Respect a proportion of the solution space, determined
+                    # by the sparsity/solutions_per_group.
+                        # Start by choosing a subset of the possible solutions.
                         if solutions_per_group >= len(solutions):
-                            solution_subset = solutions
+                            solution_subset = list(solutions)
                         else:
                             solution_subset = self.parent._get_random().choices(
                                 solutions,
                                 k=solutions_per_group
                             )
-                        if solutions_per_group == 1:
-                            for var_name, value in solution_subset[0].items():
-                                if var_name in problem._variables:
-                                    del problem._variables[var_name]
-                                problem.addVariable(var_name, (value,))
-                        else:
-                            solution_space = defaultdict(list)
-                            for soln in solution_subset:
-                                for var_name, value in soln.items():
-                                    # 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, values)
+                else:
+                    # If not sparse, maintain the entire list of possible solutions.
+                    solution_subset = list(solutions)
+
+                # Translate this subset into a dictionary of the
+                # possible values for each variable.
+                solution_space = defaultdict(list)
+                for soln in solution_subset:
+                    for var_name, value in soln.items():
+                        # 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)
+
+                # Construct the appropriate group variable problem.
+                # Must be done after selecting the solution space.
+                group_problem = VarGroup(
+                    group,
+                    solution_space,
+                    constraints,
+                    self.max_domain_size,
+                    self.debug,
+                )
 
                 # Attempt to solve the group
                 group_solutions = group_problem.solve(

constrainedrandom/internal/randvar.py

@@ -253,6 +253,14 @@ def get_length(self) -> int:
                 " but none was given when get_length was called.")
         return self.rand_length_val
 
+    def is_list(self) -> bool:
+        '''
+        Returns ``True`` if this is a list variable.
+
+        :return: ``True`` if this is a list variable, otherwise ``False``.
+        '''
+        return self.length is not None or self.rand_length is not None
+
     def set_rand_length(self, length: int) -> None:
         '''
         Function to set the random length.
@@ -282,31 +290,48 @@ def _get_random(self) -> random.Random:
             return random
         return self._random
 
-    def get_domain_size(self) -> int:
+    def get_domain_size(self, possible_lengths: Optional[List[int]]=None) -> int:
         '''
         Return total domain size, accounting for length of this random variable.
 
+        :param possible_lengths: Optional, when there is more than one possiblity
+            for the value of the random length, specifies a list of the
+            possibilities.
         :return: domain size, integer.
         '''
         if self.domain is None:
             # If there's no domain, it means we can't estimate the complexity
             # of this variable. Return 1.
             return 1
         else:
-            length = self.get_length()
-            if length is None:
-                # length is None implies a scalar variable.
-                return len(self.domain)
-            elif length == 0:
-                # This is a zero-length list, adding no complexity.
-                return 1
-            elif length == 1:
-                return len(self.domain)
+            # possible_lengths is used when the variable has a random
+            # length and that length is not yet fully determined.
+            if possible_lengths is None:
+                # Normal, fixed length of some description.
+                length = self.get_length()
+                if length is None:
+                    # length is None implies a scalar variable.
+                    return len(self.domain)
+                elif length == 0:
+                    # This is a zero-length list, adding no complexity.
+                    return 1
+                elif length == 1:
+                    return len(self.domain)
+                else:
+                    # In this case it is effectively cartesian product, i.e.
+                    # n ** k, where n is the size of the domain and k is the length
+                    # of the list.
+                    return len(self.domain) ** length
             else:
-                # In this case it is effectively cartesian product, i.e.
-                # n ** k, where n is the size of the domain and k is the length
-                # of the list.
-                return len(self.domain) ** length
+                # Random length which could be one of a number of values.
+                assert self.rand_length is not None, "Cannot use possible_lengths " \
+                    "for a variable with non-random length."
+                # For each possible length, the domain is the cartesian
+                # product as above, but added together.
+                total = 0
+                for poss_len in possible_lengths:
+                    total += len(self.domain) ** poss_len
+                return total
 
     def can_use_with_constraint(self) -> bool:
         '''
@@ -321,30 +346,42 @@ def can_use_with_constraint(self) -> bool:
         # and the domain isn't a dictionary.
         return self.domain is not None and not isinstance(self.domain, dict)
 
-    def get_constraint_domain(self) -> utils.Domain:
+    def get_constraint_domain(self, possible_lengths: Optional[List[int]]=None) -> utils.Domain:
         '''
         Get a ``constraint`` package friendly version of the domain
         of this random variable.
 
+        :param possible_lengths: Optional, when there is more than one possiblity
+            for the value of the random length, specifies a list of the
+            possibilities.
         :return: the variable's domain in a format that will work
             with the ``constraint`` package.
         '''
-        length = self.get_length()
-        if length is None:
-            # Straightforward, scalar
-            return self.domain
-        elif length == 0:
-            # List of length zero - an empty list is only correct choice.
-            return [[]]
-        elif length == 1:
-            # List of length one
-            return [[x] for x in self.domain]
+        if possible_lengths is None:
+            length = self.get_length()
+            if length is None:
+                # Straightforward, scalar
+                return self.domain
+            elif length == 0:
+                # List of length zero - an empty list is only correct choice.
+                return [[]]
+            elif length == 1:
+                # List of length one
+                return [[x] for x in self.domain]
+            else:
+                # List of greater length, cartesian product.
+                # Beware that this may be an extremely large domain.
+                # Ensure each element is of type list, which is what
+                # we want to return.
+                return [list(x) for x in product(self.domain, repeat=length)]
         else:
-            # List of greater length, cartesian product.
-            # Beware that this may be an extremely large domain.
-            # Ensure each element is of type list, which is what
-            # we want to return.
-            return [list(x) for x in product(self.domain, repeat=length)]
+            # For each possible length, return the possible domains.
+            # This can get extremely large, even more so than
+            # the regular product.
+            result = []
+            for poss_len in possible_lengths:
+                result += [list(x) for x in product(self.domain, repeat=poss_len)]
+            return result
 
     def randomize_once(self, constraints: Iterable[utils.Constraint], check_constraints: bool, debug: bool) -> Any:
         '''