Merge pull request #6 from imaginationtech/rand_length_basic

Basic implementation of random length for list variables
* Add `rand_length` as an arg to `add_rand_var`
* Basic unit tests

Author: will-keen

constrainedrandom/internal/randvar.py

@@ -60,8 +60,11 @@ class RandVar:
         specified.
     :param constraints: List or tuple of constraints that apply to this random variable.
         Each of these apply across the values in the list, if a length is specified.
-    :param length: Specify a length > 0 to turn this variable into a list of random
-        values. A value of 0 means a scalar value. A value >= 1 means a list of that length.
+    :param length: Specify a length >= 0 to turn this variable into a list of random
+        values. A value >= 0 means a list of that length. A zero-length list is just
+        an empty list. A value of ``None`` (default) means a scalar value.
+    :param rand_length: Specify the name of a random variable that defines the length
+        of this variable. The variable must have already been added to this instance.
     :param max_iterations: The maximum number of failed attempts to solve the randomization
         problem before giving up.
     :param max_domain_size: The maximum size of domain that a constraint satisfaction problem
@@ -82,7 +85,8 @@ def __init__(self,
         args: Optional[tuple]=None,
         constraints: Optional[Iterable[utils.Constraint]]=None,
         list_constraints: Optional[Iterable[utils.Constraint]]=None,
-        length: int,
+        length: Optional[int]=None,
+        rand_length: Optional[str]=None,
         max_iterations: int,
         max_domain_size: int,
         disable_naive_list_solver: bool,
@@ -91,9 +95,14 @@ def __init__(self,
         self.name = name
         self.order = order
         self.length = length
+        self.rand_length = rand_length
+        self.rand_length_val = None
+        assert not ((length is not None) and (rand_length is not None)), \
+            "length and rand_length are mutually-exclusive, but both were specified"
         self.max_iterations = max_iterations
         self.max_domain_size = max_domain_size
-        assert  ((domain is not None) != (fn is not None)) != (bits is not None), "Must specify exactly one of fn, domain or bits"
+        assert ((domain is not None) != (fn is not None)) != (bits is not None), \
+            "Must specify exactly one of fn, domain or bits"
         if fn is None:
             assert args is None, "args has no effect without fn"
         self.domain = domain
@@ -219,7 +228,8 @@ def add_constraint(self, constr: utils.Constraint) -> None:
 
         :param constr: Constraint to add.
         '''
-        if self.length > 0:
+        length = self.get_length()
+        if length is not None:
             # Treat all additional constraints as list constraints,
             # although this is a little less performant.
             self.list_constraints.append(constr)
@@ -230,6 +240,35 @@ def add_constraint(self, constr: utils.Constraint) -> None:
             self.check_constraints = True
             self.randomizer = self.create_randomizer()
 
+    def get_length(self) -> int:
+        '''
+        Function to get the length of the random list.
+
+        :return: The length of the list.
+        '''
+        if self.rand_length is None:
+            return self.length
+        if self.rand_length_val is None:
+            raise RuntimeError("RandVar was marked as having a random length," \
+                " but none was given when get_length was called.")
+        return self.rand_length_val
+
+    def set_rand_length(self, length: int) -> None:
+        '''
+        Function to set the random length.
+
+        Should only be used when this ``RandVar``
+        instance is indicated to have a random length
+        that depends on another variable.
+
+        :raises RuntimeError: If this variable instance is not
+            marked as one with a random length.
+        '''
+        if self.rand_length is None:
+            raise RuntimeError("RandVar was not marked as having a random length," \
+                " but set_rand_length was called.")
+        self.rand_length_val = length
+
     def _get_random(self) -> random.Random:
         '''
         Internal function to get the appropriate randomization object.
@@ -254,14 +293,20 @@ def get_domain_size(self) -> int:
             # of this variable. Return 1.
             return 1
         else:
-            # length == 0 implies a scalar variable, 1 is a list of length 1
-            if self.length == 0 or self.length == 1:
+            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) ** self.length
+                return len(self.domain) ** length
 
     def can_use_with_constraint(self) -> bool:
         '''
@@ -284,18 +329,22 @@ def get_constraint_domain(self) -> utils.Domain:
         :return: the variable's domain in a format that will work
             with the ``constraint`` package.
         '''
-        if self.length == 0:
+        length = self.get_length()
+        if length is None:
             # Straightforward, scalar
             return self.domain
-        elif self.length == 1:
+        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=self.length)]
+            return [list(x) for x in product(self.domain, repeat=length)]
 
     def randomize_once(self, constraints: Iterable[utils.Constraint], check_constraints: bool, debug: bool) -> Any:
         '''
@@ -381,7 +430,7 @@ def randomize_list_naive(
         constraints: Iterable[utils.Constraint],
         check_constraints: bool,
         list_constraints: Iterable[utils.Constraint],
-        debug : bool,
+        debug: bool,
         debug_fail: Optional[RandomizationFail],
     ):
         '''
@@ -398,11 +447,13 @@ def randomize_list_naive(
             all debug info along the way and not just the final failure.
         :param debug_fail: :class:`RandomizationFail` containing debug info,
             if in debug mode, else ``None``.
+
         :return: A random list of values for the variable, respecting
             the constraints.
         '''
+        length = self.get_length()
         values = [self.randomize_once(constraints, check_constraints, debug) \
-            for _ in range(self.length)]
+            for _ in range(length)]
         values_valid = len(list_constraints) == 0
         iterations = 0
         max_iterations = self.max_iterations
@@ -421,7 +472,7 @@ def randomize_list_naive(
                     debug_fail.add_values(iterations, {self.name: values})
                 iterations += 1
                 values = [self.randomize_once(constraints, check_constraints, debug) \
-                    for _ in range(self.length)]
+                    for _ in range(length)]
         return values
 
     def randomize_list_subset(
@@ -451,13 +502,14 @@ def randomize_list_subset(
         :raises RandomizationError: When the problem cannot be solved in fewer than
             the allowed number of iterations.
         '''
+        length = self.get_length()
         values = [self.randomize_once(constraints, check_constraints, debug) \
-            for _ in range(self.length)]
+            for _ in range(length)]
         values_valid = len(list_constraints) == 0
         iterations = 0
         # Allow more attempts at a list, as it may be computationally hard.
         # Assume it's linearly harder.
-        max_iterations = self.max_iterations * self.length
+        max_iterations = self.max_iterations * length
         checked = []
         while not values_valid:
             iterations += 1
@@ -473,7 +525,7 @@ def randomize_list_subset(
                 raise utils.RandomizationError("Too many iterations, can't solve problem", debug_info)
             # Keep a subset of the answer, to try to ensure forward progress.
             min_group_size = len(checked) + 1
-            for idx in range(min_group_size, self.length):
+            for idx in range(min_group_size, length):
                 tmp_values = values[:idx]
                 problem = constraint.Problem()
                 problem.addVariable(self.name, (tmp_values,))
@@ -493,7 +545,7 @@ def randomize_list_subset(
                     # degrees of freedom.
                     checked = tmp_values
             values = checked + [self.randomize_once(constraints, check_constraints, debug) \
-                for _ in range(self.length - len(checked))]
+                for _ in range(length - len(checked))]
             problem = constraint.Problem()
             problem.addVariable(self.name, (values,))
             for con in list_constraints:
@@ -507,7 +559,7 @@ def randomize_list_subset(
     def randomize(
         self,
         temp_constraints: Optional[Iterable[utils.Constraint]]=None,
-        debug: bool=False
+        debug: bool=False,
     ) -> Any:
         '''
         Returns a random value based on the definition of this random variable.
@@ -525,7 +577,8 @@ def randomize(
         # adding any temporary ones in.
         constraints = list(self.constraints)
         using_temp_constraints = temp_constraints is not None and len(temp_constraints) > 0
-        if self.length == 0:
+        length = self.get_length()
+        if length is None:
             # Interpret temporary constraints as scalar constraints
             if using_temp_constraints:
                 check_constraints = True

constrainedrandom/randobj.py

@@ -61,6 +61,7 @@ def __init__(
         # Prefix 'internal use' variables with '_', as randomized results are populated to the class
         self._random = _random
         self._random_vars = {}
+        self._rand_lengths = defaultdict(list)
         self._constraints : List[utils.ConstraintAndVars] = []
         self._constrained_vars = set()
         self._max_iterations = max_iterations
@@ -133,7 +134,8 @@ def add_rand_var(
         args: Optional[tuple]=None,
         constraints: Optional[Iterable[utils.Constraint]]=None,
         list_constraints: Optional[Iterable[utils.Constraint]]=None,
-        length: int=0,
+        length: Optional[int]=None,
+        rand_length: Optional[str]=None,
         order: int=0,
         initial: Any=None,
         disable_naive_list_solver: bool=False,
@@ -160,8 +162,13 @@ def add_rand_var(
             specified.
         :param constraints: List or tuple of constraints that apply to this random variable.
             Each of these apply across the values in the list, if a length is specified.
-        :param length: Specify a length > 0 to turn this variable into a list of random
-            values. A value of 0 means a scalar value. A value >= 1 means a list of that length.
+        :param length: Specify a length >= 0 to turn this variable into a list of random
+            values. A value >= 0 means a list of that length. A zero-length list is just
+            an empty list. A value of ``None`` (default) means a scalar value.
+            Mutually exclusive with ``rand_length``.
+        :param rand_length: Specify the name of a random variable that defines the length
+            of this variable. The variable must have already been added to this instance.
+            Mutually exclusive with ``length``.
         :param order: The solution order for this variable with respect to other variables.
         :param initial: Initial value to assign to the variable prior to randomizing.
         :param disable_naive_list_solver: Attempt to use a faster algorithm for solving
@@ -197,8 +204,24 @@ def my_fn(factor):
             rand_obj.add_rand_var('fn_based_with_args', fn=my_fn, args=(2,))
         '''
         # Check this is a valid name
-        assert name not in self.__dict__, f"random variable name {name} is not valid, already exists in object"
-        assert name not in self._random_vars, f"random variable name {name} is not valid, already exists in random variables"
+        assert name not in self.__dict__, f"random variable name '{name}' is not valid, already exists in object"
+        assert name not in self._random_vars, f"random variable name '{name}' is not valid, already exists in random variables"
+        # rand_length and length are mutually-exclusive.
+        assert not ((length is not None) and (rand_length is not None)), \
+            "length and rand_length are mutually-exclusive, but both were specified"
+        if rand_length is not None:
+            # Indicates the length of the RandVar depends on another random variable.
+            assert rand_length in self._random_vars, f"random variable length '{name}' is not valid," \
+                " it must be a fixed integer value or the name of an existing random variable."
+            assert self._random_vars[rand_length].length is None, f"random length '{name}' must be a scalar random" \
+                " variable, but is itself a random list."
+            # Track that this variable depends on another for its length.
+            self._rand_lengths[rand_length].append(name)
+            # Ensure the order used for this variable is greater than
+            # the one we depend on.
+            # Ignore the user if they're wrong rather than raising an error.
+            if order < self._random_vars[rand_length].order:
+                order = self._random_vars[rand_length].order + 1
         self._random_vars[name] = RandVar(
             name=name,
             _random=self._random,
@@ -210,10 +233,16 @@ def my_fn(factor):
             constraints=constraints,
             list_constraints=list_constraints,
             length=length,
+            rand_length=rand_length,
             max_iterations=self._max_iterations,
             max_domain_size=self._max_domain_size,
             disable_naive_list_solver=disable_naive_list_solver,
         )
+        if rand_length is not None:
+            # If rand_length is constrained by other vars,
+            # so must the variable whose length it controls.
+            if rand_length in self._constrained_vars:
+                self._constrained_vars.add(name)
         self._problem_changed = True
         self.__dict__[name] = initial
 
@@ -331,11 +360,26 @@ def randomize(
         constrained_vars = sorted(constrained_vars)
         # Don't allow non-determinism when iterating over a dict
         random_vars = sorted(self._random_vars.items())
+        list_length_vars = sorted(self._rand_lengths.items())
 
         # Process concrete values - use these preferentially
         with_values = with_values if with_values is not None else {}
 
+        # Randomize list length vars first
+        for name, dependent_var_list in list_length_vars:
+            if name in with_values:
+                length_result = with_values[name]
+            else:
+                tmp_constraints = tmp_single_var_constraints.get(name, [])
+                length_result = self._random_vars[name].randomize(tmp_constraints, debug)
+            result[name] = length_result
+            for dependent_var_name in dependent_var_list:
+                self._random_vars[dependent_var_name].set_rand_length(length_result)
+
+        # Randomize all remaining variables once
         for name, random_var in random_vars:
+            if name in self._rand_lengths:
+                continue
             if name in with_values:
                 result[name] = with_values[name]
             else:
@@ -365,13 +409,33 @@ def randomize(
                     result.update(solution)
                 else:
                     # No solution found, re-randomize and try again
+                    # List length variables first
+                    for name, dependent_var_list in list_length_vars:
+                        # If the length-defining variable is constrained,
+                        # re-randomize it and all its dependent vars.
+                        if name not in with_values and name in constrained_vars:
+                            tmp_constraints = tmp_single_var_constraints.get(name, [])
+                            length_result = self._random_vars[name].randomize(tmp_constraints, debug)
+                            result[name] = length_result
+                            # Need to re-randomize all dependent vars as their
+                            # length has changed.
+                            for dependent_var_name in dependent_var_list:
+                                self._random_vars[dependent_var_name].set_rand_length(length_result)
+                                tmp_constraints = tmp_single_var_constraints.get(dependent_var_name, [])
+                                result[dependent_var_name] = self._random_vars[dependent_var_name].randomize(tmp_constraints, debug)
                     for var in constrained_vars:
                         # Don't re-randomize if we've specified a concrete value
                         if var in with_values:
                             continue
-                        else:
-                            tmp_constraints = tmp_single_var_constraints.get(var, [])
-                            result[var] = self._random_vars[var].randomize(tmp_constraints, debug)
+                        # Don't re-randomize list-length vars, those have been dealt with.
+                        if var in self._rand_lengths:
+                            continue
+                        # Don't re-randomize list vars which have been re-randomized once already.
+                        rand_length = self._random_vars[var].rand_length
+                        if rand_length is not None and rand_length in constrained_vars:
+                            continue
+                        tmp_constraints = tmp_single_var_constraints.get(var, [])
+                        result[var] = self._random_vars[var].randomize(tmp_constraints, debug)
                     attempts += 1
 
         # If constraints are still not satisfied by this point, construct a multi-variable