Merge branch 't/21325/sequences/k-regular-subseq' into t/21319/sequences/rec-hash

* t/21325/sequences/k-regular-subseq:
  Trac #21318: rmul/lmul preserve identity for multiplying by 1
  Trac #21325: fixup test .subsequence being identity
  Trac #21318: rmul/lmul preserve identity for multiplying by 1
  Trac #21325: use (new) decorator minimize_result
  Trac #21325: remove empty lines, fix punctuation
  Trac #21325: remove iteritems
  Trac #21318: fix rmul/lmul issues
  Trac #21318: use "correct" 1
  Trac #21318: use tensor_product in method hadamard_product
  Trac #21318: use is_trivial_zero in doctest of _neg_
  Trac #21318: use (new) .linear_representation in doctests
  Trac #21318: fix empty lines and punctuation
  Trac #21318: decorator minimize_result
  Trac #21203 review issue 10: use "raise ... from None" where approriate

Author: dkrenn

src/sage/combinat/k_regular_sequence.py

@@ -96,6 +96,7 @@
 
 from .recognizable_series import RecognizableSeries
 from .recognizable_series import RecognizableSeriesSpace
+from .recognizable_series import minimize_result
 from sage.misc.cachefunc import cached_method
 
 
@@ -106,15 +107,15 @@ def pad_right(T, length, zero=0):
 
     INPUT:
 
-    - ``T`` -- A tuple, list or other iterable.
+    - ``T`` -- A tuple, list or other iterable
 
-    - ``length`` -- a nonnegative integer.
+    - ``length`` -- a nonnegative integer
 
-    - ``zero`` -- (default: ``0``) the elements to pad with.
+    - ``zero`` -- (default: ``0``) the elements to pad with
 
     OUTPUT:
 
-    An object of the same type as ``T``.
+    An object of the same type as ``T``
 
     EXAMPLES::
 
@@ -276,28 +277,30 @@ def __iter__(self):
         from itertools import count
         return iter(self[n] for n in count())
 
-
-    def subsequence(self, a, b, minimize=True):
+    @minimize_result
+    def subsequence(self, a, b):
         r"""
         Return the subsequence with indices `an+b` of this
         `k`-regular sequence.
 
         INPUT:
 
-        - ``a`` -- a nonnegative integer.
+        - ``a`` -- a nonnegative integer
 
-        - ``b`` -- an integer.
+        - ``b`` -- an integer
 
           Alternatively, this is allowed to be a dictionary
           `b_j \mapsto c_j`. If so, the result will be the sum
           of all `c_j(an+b_j)`.
 
-        - ``minimize`` -- (default: ``True``) a boolean. If set, then
-          :meth:`minimized` is called after the operation.
+        - ``minimize`` -- (default: ``None``) a boolean or ``None``.
+          If ``True``, then :meth:`minimized` is called after the operation,
+          if ``False``, then not. If this argument is ``None``, then
+          the default specified by the parent's ``minimize_results`` is used.
 
         OUTPUT:
 
-        A :class:`kRegularSequence`.
+        A :class:`kRegularSequence`
 
         .. NOTE::
 
@@ -349,7 +352,10 @@ def subsequence(self, a, b, minimize=True):
 
             sage: C.subsequence(0, 4)
             2-regular sequence 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, ...
-            sage: C.subsequence(1, 0) is C
+
+        ::
+
+            sage: C.subsequence(1, 0, minimize=False) is C
             True
 
         The following test that the range for `c` in the code
@@ -461,11 +467,7 @@ def mu_line(r, i, c):
                         if c >= 0 else dim*(zero,)
                         for c in kernel), tuple())))
 
-        if minimize:
-            return result.minimized()
-        else:
-            return result
-
+        return result
 
     def backward_differences(self, **kwds):
         r"""
@@ -474,12 +476,14 @@ def backward_differences(self, **kwds):
 
         INPUT:
 
-        - ``minimize`` -- (default: ``True``) a boolean. If set, then
-          :meth:`minimized` is called after the operation.
+        - ``minimize`` -- (default: ``None``) a boolean or ``None``.
+          If ``True``, then :meth:`minimized` is called after the operation,
+          if ``False``, then not. If this argument is ``None``, then
+          the default specified by the parent's ``minimize_results`` is used.
 
         OUTPUT:
 
-        A :class:`kRegularSequence`.
+        A :class:`kRegularSequence`
 
         .. NOTE::
 
@@ -506,20 +510,21 @@ def backward_differences(self, **kwds):
         """
         return self.subsequence(1, {0: 1, -1: -1}, **kwds)
 
-
     def forward_differences(self, **kwds):
         r"""
         Return the sequence of forward differences of this
         `k`-regular sequence.
 
         INPUT:
 
-        - ``minimize`` -- (default: ``True``) a boolean. If set, then
-          :meth:`minimized` is called after the operation.
+        - ``minimize`` -- (default: ``None``) a boolean or ``None``.
+          If ``True``, then :meth:`minimized` is called after the operation,
+          if ``False``, then not. If this argument is ``None``, then
+          the default specified by the parent's ``minimize_results`` is used.
 
         OUTPUT:
 
-        A :class:`kRegularSequence`.
+        A :class:`kRegularSequence`
 
         EXAMPLES::
 
@@ -542,8 +547,8 @@ def forward_differences(self, **kwds):
         """
         return self.subsequence(1, {1: 1, 0: -1}, **kwds)
 
-
-    def partial_sums(self, include_n=False, minimize=True):
+    @minimize_result
+    def partial_sums(self, include_n=False):
         r"""
         Return the sequence of partial sums of this
         `k`-regular sequence. That is, the `n`th entry of the result
@@ -555,12 +560,14 @@ def partial_sums(self, include_n=False, minimize=True):
           the `n`th entry of the result is the sum of the entries up
           to index `n` (included).
 
-        - ``minimize`` -- (default: ``True``) a boolean. If set, then
-          :meth:`minimized` is called after the operation.
+        - ``minimize`` -- (default: ``None``) a boolean or ``None``.
+          If ``True``, then :meth:`minimized` is called after the operation,
+          if ``False``, then not. If this argument is ``None``, then
+          the default specified by the parent's ``minimize_results`` is used.
 
         OUTPUT:
 
-        A :class:`kRegularSequence`.
+        A :class:`kRegularSequence`
 
         EXAMPLES::
 
@@ -624,10 +631,7 @@ def partial_sums(self, include_n=False, minimize=True):
                    (dim*(0,) if include_n else tuple(-self.left))),
             vector(2*tuple(self.right)))
 
-        if minimize:
-            return result.minimized()
-        else:
-            return result
+        return result
 
 
 def _pickle_kRegularSequenceSpace(k, coefficients, category):
@@ -808,4 +812,4 @@ def _n_to_index_(self, n):
         try:
             return W(n.digits(self.k))
         except OverflowError:
-            raise ValueError('value {} of index is negative'.format(n))
+            raise ValueError('value {} of index is negative'.format(n)) from None