Unify implementatiion of some_tuples and tester.some_elements; improve implementation for large repeat

Author: roed314

src/sage/misc/misc.py

@@ -1174,11 +1174,30 @@ def random_sublist(X, s):
     return [a for a in X if random.random() <= s]
 
 
-def some_tuples(elements, repeat, bound):
+def some_tuples(elements, repeat, bound, max_samples=None):
     r"""
     Return an iterator over at most ``bound`` number of ``repeat``-tuples of
     ``elements``.
 
+    INPUT:
+
+    - ``elements`` -- an iterable
+    - ``repeat`` -- integer (default ``None``), the length of the tuples to be returned.
+      If ``None``, just returns entries from ``elements``.
+    - ``bound`` -- the maximum number of tuples returned (ignored if ``max_samples`` given)
+    - ``max_samples`` -- non-negative integer (default ``None``).  If given,
+      then a sample of the possible tuples will be returned,
+      instead of the first few in the standard order.
+
+    OUTPUT:
+
+    If ``max_samples`` is not provided, an iterator over the first
+    ``bound`` tuples of length ``repeat``, in the standard nested-for-loop order.
+
+    If ``max_samples is provided, a list of at most ``max_samples`` tuples,
+    sampled uniformly from the possibilities.  In this case, ``elements``
+    must be finite.
+
     TESTS::
 
         sage: from sage.misc.misc import some_tuples
@@ -1192,15 +1211,44 @@ def some_tuples(elements, repeat, bound):
         sage: len(list(l))
         10
 
-    .. TODO::
+        sage: l = some_tuples(range(3), 2, None, max_samples=10)
+        sage: len(list(l))
+        9
+    """
+    if max_samples is None:
+        from itertools import islice, product
+        P = elements if repeat is None else product(elements, repeat=repeat)
+        return islice(P, bound)
+    else:
+        if not (hasattr(elements, '__len__') and hasattr(elements, '__getitem__')):
+            elements = list(elements)
+        n = len(elements)
+        N = n if repeat is None else n**repeat
+        if N <= max_samples:
+            from itertools import product
+            return elements if repeat is None else product(elements, repeat=repeat)
+        return _some_tuples_sampling(elements, repeat, max_samples, n)
 
-        Currently, this only return an iterator over the first element of the
-        Cartesian product. It would be smarter to return something more
-        "random like" as it is used in tests. However, this should remain
-        deterministic.
+def _some_tuples_sampling(elements, repeat, max_samples, n):
     """
-    from itertools import islice, product
-    return islice(product(elements, repeat=repeat), bound)
+    Internal function for :func:`some_tuples`.
+
+    TESTS::
+
+        sage: from sage.misc.misc import _some_tuples_sampling
+        sage: list(_some_tuples_sampling(range(3), 3, 2, 3))
+        [(0, 1, 0), (1, 1, 1)]
+        sage: list(_some_tuples_sampling(range(20), None, 4, 20))
+        [0, 6, 9, 3]
+    """
+    from sage.rings.integer import Integer
+    N = n if repeat is None else n**repeat
+    # We sample on range(N) and create tuples manually since we don't want to create the list of all possible tuples in memory
+    for a in random.sample(range(N), max_samples):
+        if repeat is None:
+            yield elements[a]
+        else:
+            yield tuple(elements[j] for j in Integer(a).digits(n, padto=repeat))
 
 def powerset(X):
     r"""

src/sage/misc/sage_unittest.py

@@ -450,7 +450,7 @@ def __repr__(self):
         return "Testing utilities for %s"%self._instance
 
 
-    def some_elements(self, S=None, repeat=1):
+    def some_elements(self, S=None, repeat=None):
         """
         Returns a list (or iterable) of elements of the instance on which
         the tests should be run. This is only meaningful for container
@@ -463,7 +463,7 @@ def some_elements(self, S=None, repeat=1):
           time, or the result of :meth:`.some_elements` if no elements
           were specified.
 
-        - ``repeat`` -- integer (default: 1).  If given, instead returns
+        - ``repeat`` -- integer (default: None).  If given, instead returns
           a list of tuples of length ``repeat`` from ``S``.
 
         OUTPUT:
@@ -528,14 +528,16 @@ def some_elements(self, S=None, repeat=1):
 
         The ``repeat`` keyword can give pairs or triples from ``S``::
 
-            sage: list(tester.some_elements(repeat=2)
+            sage: list(tester.some_elements(repeat=2))
             [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1)]
 
         You can use ``max_samples`` to sample at random, instead of in order::
 
-            sage: tester = InstanceTester(ZZ, elements = srange(8), max_samples = 3)
+            sage: tester = InstanceTester(ZZ, elements = srange(8), max_samples = 4)
             sage: list(tester.some_elements())
-            [2, 1, 4]
+            [0, 3, 7, 1]
+            sage: list(tester.some_elements(repeat=2))
+            [(1, 4), (3, 1), (4, 5), (5, 0)]
 
         Test for :trac:`15919`, :trac:`16244`::
 
@@ -555,19 +557,9 @@ def some_elements(self, S=None, repeat=1):
             sage: list(tester.some_elements())
             [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3)]
         """
-        if S is None:
-            if self._elements is None:
-                S = self._instance.some_elements()
-            else:
-                S = self._elements
-        import itertools
-        if repeat != 1:
-            S = itertools.product(S, repeat=repeat)
-        if self._max_samples is None:
-            return list(itertools.islice(S, self._max_runs))
-        else:
-            return list(random.sample(S, self._max_samples))
-
+        S = S or self._elements or self._instance.some_elements()
+        from sage.misc.misc import some_tuples
+        return list(some_tuples(S, repeat, self._max_runs, self._max_samples))
 
 class PythonObjectWithTests(object):
     """